【java】关键字、代码块、接口、枚举学习笔记（一）

public class Student {
    String name;
    int age;
    static String school;
    public void show() {
        System.out.println(name + "---" + age + "---" + school);
    }
}
/*
    static关键字的特点 :
        1 静态成员被该类的所有对象的进行共享
        2 静态成员可以通过类名调用 , 也可以通过对象进行调用 , 推荐使用类名
        3 静态成员随着类的加载而加载 , 优先于对象存在
 */
public class StudentTest {
    public static void main(String[] args) {
        Student.school = "清华大学";
        Student s = new Student();
        s.name = "张三";
        s.age = 23;
        s.show();
        Student s2 = new Student();
        s2.show();
    }
}

package com.itheima.final_demo;
/*
    final的特点
        final修饰的类 , 不能被继承, 也就是没有子类
        final修饰的方法 , 不能被重写
        final修饰的变量
            基本数据类型 : 值不可以发生改变
            引用数据类型 : 地址不可发生改变 , 对象的内容可以发生改变
        注意 :
            1 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
            2 final修饰成员变量需要注意初始化时机的问题
              1) 直接赋值
              2) 在构造方法执行完毕前赋值
 */
public class FinalDemo1 {
    public static void main(String[] args) {
        // final修饰的基本数据类型变量 , 值不能被修改
//        final int num = 10;
//        num = 20;
//        System.out.println(num);
        final int[] arr = {1, 2, 3, 4, 5};
        // final修饰的引用数据类型 , 地址不可改发生改变
        // arr = new int[3];
        // final修饰的引用数据类型 , 对象中的内容可以发生改变
        arr[0] = 100;
    }
}
// final修饰的类 , 不能被继承, 也就是没有子类
//final class Person {
//
//}
class Person {
    // final修饰的方法 , 不能被重写
    public final void eat() {
    }
}
class Student extends Person {
    // final修饰成员变量需要注意初始化时机的问题
    // 要么直接赋值 , 要么在构造方法执行完毕前赋值
    // final int num = 10;
    final int num;
    public Student() {
        num = 100;
    }
    //    @Override
//    public void eat() {
//        super.eat();
//    }
}

package com.itheima.permissions_demo1;
/*
    public -- protected -- 默认的 -- private
 */
public class Fu {
    public void method1() {
    }
    protected void method2() {
    }
    void method3() {
    }
    private void method4() {
    }
    // 同一个包中同一个类
    public void show(){
        method1();
        method2();
        method3();
        method4();
    }
}
===================================================
package com.itheima.permissions_demo1;
public class Test {
    // 同一个包中 , 无关类
    public void show(){
        Fu f = new Fu();
        f.method1();
        f.method2();
        f.method3();
        // f.method4();
    }
}
====================================================
package com.itheima.permissions_demo1;
public class Zi extends Fu {
    // 用一个包中 , 有子类父关系
    public void show(){
        method1();
        method2();
        method3();
        // method4();
    }
}

package com.itheima.permissions_demo2;
import com.itheima.permissions_demo1.Fu;
public class Test {
    // 不同包中 , 无关类
    public void show(){
        Fu f = new Fu();
        f.method1();
        // f.method2();
        // f.method3();
        // f.method4();
    }
}
======================================
package com.itheima.permissions_demo2;
import com.itheima.permissions_demo1.Fu;
public class Zi extends Fu {
    // 不同包中 , 有子类父关系
    public void show(){
        method1();
        method2();
        // method3();
        // method4();
    }
}

package com.itheima.code_block;
/*
    构造代码块
 */
public class Student {
    final int NUM;
    {
        NUM = 10;
        System.out.println("构造代码块...");
    }
    public Student() {
        System.out.println("空参构造...");
    }
    public Student(int a) {
        System.out.println("有参构造...");
    }
}
class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        Student s2 = new Student(10);
    }
}

package com.itheima.code_block.static_demo;
/*
  静态代码块 :
      1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外
      2 执行时机 ; 随着类的加载而执行, 只加载一次
      3 可以给类中的静态成员进行初始化数据
 */
public class Test {
  public static void main(String[] args) {
      new Student();
      new Student(10);
  }
}

class Student {
static {
System.out.println(“静态代码块”);
}
public Student() {
    System.out.println("空参构造");
}
public Student(int a) {
    System.out.println("有参构造");
}
}

### 2.3 局部代码块
- 成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
- 执行时机 : 正常执行(从上往下依次执行)
- 控制变量的局部变量的声明周期
​```java
package com.itheima.code_block.local_demo;
/*
  局部代码块 :
      1 位置 : 可以定义任何的局部的位置 , 方法中居多
      2 执行时机 : 正常执行(从上往下依次执行)
      3 作用 : 控制变量的生命周期 , 变量在使用完毕, 及时释放内存
*/
public class Test {
  public static void main(String[] args) {
      int num1 = 10;
      System.out.println(num1);
      // 局部代码块
      {
          int num2 = 20;
          System.out.println(num1);
          System.out.println(num2);
      }
      System.out.println(num1);
//        System.out.println(num2);// 作用域不够 , 报错
  }
}