包，修饰符，访问修饰符

• 包(package)

  包提供了类的多层命名空间，可以解决类的命名冲突，类文件管理等问题；[类似于文件夹]

  访问其他包下的类(同一个包的类直接调用即可)：

// 默认方法(冲突情况下只能用这种方式)
com.study.part1.Bus bus = new com.study.part1.Bus();
// 1.包名.类名
import com.study.part1.Bus;
// 2.导入包
import com.study.part1.*;

• 访问修饰符

  成员访问权限：private→default→protected→public

  类的访问权限：default→public

  1.成员访问级别

修饰符	同一个类中	同一个包中	子类	全局范围内
private	√
	√	√
protected	√	√	√
public	√	√	√	√

// 局部变量和成员变量
public class Test {
    public static void main(String[] args) {
        int i = 1;
        Other other = new Other();
        System.out.println(other.j);
        System.out.println(j);// 报错,对象的成员变量的调用错误示范；
        System.out.println(other.run().k);// 报错，方法的局部变量不能调用；
        // 方法的局部变量是随着方法的使用和结束产生和消除的，不能够调用；
        // 类的成员变量初始化的时候已经产生，可以直接调用；

}

class Other {
    void run(){
        int k = 1;
    }
    int j =1;
}

2.类的访问级别

default：包范围；

public：全局范围；

• 初始化块（本质上就是一块初始化的代码)

  初始化块是对构造方法的补充，可用于处理那些与参数无关的、固定的初始化逻辑；

  执行顺序：

  1.初始化块总是在构造方法之前执行；

  2.多个初始化块之间按书写顺序执行；

  3.初始化块与成员变量的初始化，按照代码书写顺序执行；

public class Driver{
  private long no;
  private String name;
  private int age = 18;
  
  // 初始化块,不需要外界的输入
  no = System.currentTimeMillist();
    
  public Driver(String name, int age){
    this.name = name;
    this.age = age;
  }
  
  public long setNo(){
  }
    return this.no  
  public long getNo(){
  }
    this.no = no;
  
  public int getAge(){
    return this.age;
  }
  public int setAge(int age){
    this.age = age;
  }
  // 构造方法和set，get保证了私有成员变量的封装，不能够用Diver.age直接访问，对于age或者no进行
  // 修改或者访问必须用封装好的方法set，get，这是JVM默认的规则，在编写代码的时候可以直接用
  // generator生成构造器和访问修改方法；
]

• static关键字（关键区别：生命周期、调用方式）

  static修饰的成员是类的成员，该成员属于类，不属于单个对象；

  个人理解：在类初始化的时候静态变量就会存储在静态存储区，与之相关的方法在调用和退出后，该静态变量仍然是保存在静态存储区的，不会随着方法的结束而结束；静态变量的值是可变的，只有final修饰的常量的值是不可变的，只是静态变量不会在每个对象的初始化时也同时进行新的初始化；

  • 修饰：

    1.java类中可包含成员变量，方法，构造方法，初始化块，内部类；

    2.其中，static可以修饰的是成员变量，方法，初始化块，内部类（仅不能修饰构造方法）；

  • 类变量

    1.以static修饰的成员变量叫类变量（静态变量）；

    2.类变量属于类，它随类的信息存储在方法区（1份），并不随对象存储在堆中；

    3.类变量可以通过类名来访问，也可以通过对象名来访问，建议通过类名来访问它；

  • 类方法

    和类变量一样；静态方法不能够被重写，最好用类来调用；

  • 静态块

    静态块属于类，在类加载的时候被隐式调用一次，之后再也不会被调用；

static{}

• 静态块，初始化块，构造方法对比

  • 初始化块：构造方法

    **相同：**都是给对象进行初始化；

    **区别：**1.初始化块给所有对象进行统一初始化，构造方法只给对应对象初始化；

    应用:将所有构造方法所具有共性的东西定义在初始化块中；（先初始，再构造，初始化块中的成员是所有对象中都包含的）

  • 初始化块（非静态初始化块：静态初始化块（静态块））

    1.构造代码块用于初始化对象，每创建一个对象就会被执行一次；静态代码块用于初始化类，随着类的加载而执行，不管创建几个对象，都只执行一次。

    2.静态代码块优先于构造代码块的执行

  • 执行顺序：（静态块必在最前）

    • 父类的静态初始化块

    • 子类的静态初始化块

    • 父类的初始化块

    • 父类的构造函数

    • 子类的初始化块

    • 子类的构造函数

• final关键字

  final关键字可用于修饰类、方法、变量

  • final关键字修饰类

    final关键字修饰的类不能被继承；

public final class Father{
}

public class Son extends Father{
}
// 报错不能够继承final类;

• final关键字修饰的方法

  final关键字修饰的方法不能被重写；

public class Father{
  public final void call{
    System.out.println("I am F");
  }
}

public class Son extends Father{
  @override
  public void call{
    System.out.println("I am Son");
  }
}
// final方法不可以被子类重写；

• final关键字修饰的变量

  final关键字修饰的变量一经赋值，不可更改；

  • final修饰成员变量

// 类的成员变量final；
public class Demo{
  public static int a = 1;
  public static final b = 2;
  
  static{
    b = 3;// 报错，final常量不可再修改；
    a = 3;// 不会报错；
  }
}

// 对象实例的成员变量final；
public class Demo{
  public int a = 1;
  public final int b = 2;
  public final int c;
  
  c = 2;
  public Demo(){
    b =2;// 报错，final常量不可再修改；
  }
  
}

- **final修饰局部变量**

public class Demo{
  public static void main(String[] args){
  
    final int i = 1;
    i = 2；// 报错,局部常量也不可以进行修改；
  }
}

- **final修饰引用类型变量**

  1.引用类型变量，保存的仅仅是一个引用（地址）；

  2.final只保证这个引用类型变量所引用的地址不会改变，但这个对象的内容可以发生改变。

public class Test{

  public static void main(String[] args) {
    // 修改引用类型变量的数据√
    final int[] i = {1, 2, 3, 4, 5, 6};
    i[1] = 6;// 这是可以进行修改的;
    
    Arrays.sort(i);// 对数组进行排序也是可以的
    
    // 直接修改地址是不行的;
    i = null;
    i = new int[] {2, 3, 4, 5, 6};
    // 以上都是不行的,i只能够指向固定的内存地址
  }
}

• final变量的宏替换原则

  满足下述三个条件的变量相当于直接量：

  1.使用final关键字修饰；

  2.在声明变量的时候指定了初始值；

  3.该初始值可以在编译时被确定下来；

  编译时，编译器会把程序中所有用到该变量的地方直接替换成它的值；

final int i = 10;
final double d =3.14 * 5;
final String s = "Hello"
// 如下：d*3 = 3.14*5*3,直接进行替换；