一、类变量和类方法（P374）

1. 类变量

定义语法：
访问修饰符        static        数据类型        变量名；

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

（1）当我们需要让某个类的所有对象都共享一个变量时，可以考虑使用类变量

（2）类变量是该类的所有对象共享的，而实例变量是每个对象独享的

（3）加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

（4）类变量可以通过类名.类变量名或者对象名.类变量名来访问

（5）类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了
就可以使用类变量了。

（6）类变量的生命周期是随类的加载开始，随着类消亡而销毁

2. 类方法

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

二、理解 main 方法（P383）

（1）main 方法是虚拟机调用
（2）java虚拟机需要调用类的 main() 方法，所以该方法的访问权限必须是public
（3）java虚拟机在执行 main() 方法时不必创建对象，所以该方法必须是static
（4）该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数 
（5）Java 执行的程序 参数1 参数2 参数3

三、代码块（P386）

1. 基本介绍

代码块又称为初始化块，属于类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过｛｝包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或
类显式调用，而是加载类时，或创建对象时隐式调用。

2. 基本语法

[ 修饰符 ]｛
        代码

｝；
注意：
（1）修饰符可选，要写的话，也只能写 static
（2）代码块分为两类，使用 static 修饰的叫静态代码块，没有 static 修饰的，叫普通代码块。
（3）逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）

3. 优点

（1）相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
（2）场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用
性

（3）代码块优先构造器执行

public class Movie {
    private String name;
    private String director;

    {
        System.out.println("电影开始了");
    }

    public Movie() {
    }

    public Movie(String name) {
        this.name = name;
    }

    public Movie(String name, String director) {
        this.name = name;
        this.director = director;
    }
}

4. 代码块使用注意事项和细节讨论

（1）static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。

（2）类什么时候被加载
1️⃣创建对象实例时（new）
2️⃣创建子类对象实例，父类也会被加载
3️⃣使用类的静态成员时（静态属性，静态方法）

（3）普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行

（4）构造器的最前面其实隐含了 super() 和调用普通代码块，新写一个类演示，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

class A{
    public A() {
        //(1) super();
        //(2) 调用普通代码块
        System.out.println("ok");
    }
}

（5）继承关系的调用顺序

① 父类的静态代码块和静态属性

② 子类的静态代码块和静态属性

③ 父类的普通代码块和普通属性初始化

④ 父类的构造方法

⑤ 子类的普通代码块和普通属性初始化

⑥ 子类的构造方法

（6）静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调
用任意成员。

四、final 关键字（P394）

1. 基本介绍

final 中文意思：最后的，最终的

final 可以修饰类、属性、方法和局部变量

使用到 final 的情况：

（1）当不希望类被继承时，可以用final修饰。

（2）当不希望父类的某个方法被子类覆盖/重写（override）时，可以用final关键字修饰。

（3）当不希望类的的某个属性的值被修改，可以用final修饰。

（4）当不希望某个局部变量被修改，可以使用final修饰。

2. final 使用注意事项和细节

（1）final修饰的属性又叫常量，一般用XX_XX_XX来命名

（2）final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一：

1️⃣定义时 
2️⃣在构造器中
3️⃣在代码块中

（3）如果 final 修饰的属性是静态的，则初始化的位置只能是

1️⃣定义时 
2️⃣在静态代码块
3️⃣不能在构造器中

（4）final类不能继承，但是可以实例化对象。

（5）如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

（6）一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

（7）final不能修饰构造方法（即构造器）

（8）final和static往往搭配使用，效率更高，底层编译器做了优化处理。

（9）包装类（Integer、Double、Float、Boolean等都是final类），String也是final类。

五、抽象类（P398）

当父类的一些方法不能确定时，可以用 abstract 关键字来修饰该方法，这个方法就是抽象方法，用 abstract 来修饰该类就是抽象类。

1. 抽象类的介绍

（1）用abstract关键字来修饰一个类时，这个类就叫抽象类

（2）用abstract关键字来修饰一个方法时，这个方法就是抽象方法

（3）抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类

2. 抽象类使用的注意事项和细节讨论

（1）抽象类不能被实例化

（2）抽象类可以没有抽象方法。

（3）有抽象方法的类一定是抽象类。

（4）abstract 只能修饰类和方法，不能修饰属性和其它的。

（5）抽象类可以有任意成员【因为抽象类本质还是类】，比如：非抽象方法、构造器、静态属性等等

（6）抽象方法不能有主体，即不能实现。

（7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为
抽象类。

（8）抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的。

抽象类最佳实践-模板设计模式

六、接口（P403）

1. 基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

语法：

interface  接口名｛

        //属性

        //抽象方法

｝

class 类名 implements 接口｛

                自己属性；
                自己方法：
                必须实现的接口的抽象方法

｝

接口是更加抽象的抽象类。

（1）在 Jdk7.0 前接口里的所有方法都没有方法体
（2）在 Jdk8.0 后接口类可以有静态方法（static）、默认方法（default），也就是说接口中可以有方法的具体实现。

2. 注意事项和细节

（1）接口不能被实例化

（2）接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰

（3）一个普通类实现接口，就必须将该接口的所有方法都实现

（4）抽象类实现接口，可以不用实现接口的方法

（5）一个类同时可以实现多个接口

（6）接口中的属性，只能是public static final 修饰符。

比如：int a=1；实际上是public static final int a = 1；（必须初始化）

（7）接口中属性的访问形式：接口名 . 属性名

（8）一个接口不能继承其它的类，但是可以继承多个别的接口

（9）接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

3. 实现接口vs继承类

接口和继承解决的问题不同

（1）继承的价值主要在于：解决代码的复用性和可维护性
（2）接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法。

接口比继承更加灵活：
继承是满足 is-a 的关系，而接口只需满足 like-a 的关系

七、内部类（P413）

1. 基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

2. 内部类的分类

定义在外部类局部位置上（比如方法内）：

（1）局部内部类（有类名）

（2）匿名内部类（没有类名，重点）

定义在外部类的成员位置上：

（1）成员内部类（没用static修饰）

（2）静态内部类（使用static修饰）

3. 局部内部类的使用

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名

（1）可以直接访问外部类的所有成员，包含私有的
（2）不能添加访问修饰符，但是可以使用final修饰
（3）作用域：仅仅在定义它的方法或代码块中

（4）外部类---访问---->局部内部类的成员
访问方式：创建对象，再访问（注意：必须在作用域内）

（5）外部其他类---不能访问----->局部内部类

（6）如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成
员，则可以使用（外部类名.this.成员）去访问。

4. 匿名内部类

说明：匿名内部类是定义在外部类的局部位置，并且没有类名。

（1）本质是类（2）内部类（3）该类没有名字（4）同时还是一个对象

传统方式：

public class Test {

    public static void main(String[] args) {
        A a = new A();
        a.m1();
    }
}

interface IA{
    void m1();
}

class A implements IA{

    @Override
    public void m1() {
        System.out.println("子类实现接口");
    }
}

匿名内部类方式：

public class Test {

    public static void main(String[] args) {
        IA a = new IA(){
            @Override
            public void m1() {
                System.out.println("匿名内部类实现接口");
            }
        };
        a.m1();
    }
}

interface IA{
    void m1();
}

匿名内部类使用细节：

（2）匿名内部类的语法比较奇特。因为匿名内部类既是一个类的定义，同时它本身也是一个对象。因此从语法上看，它既有定义类的特征，也有创建对象的特征

（3）可以直接访问外部类的所有成员，包含私有的

（4）不能添加访问修饰符，因为它的地位就是一个局部变量

（5）作用域：仅仅在定义它的方法或代码块中

（6）匿名内部类---访问---->外部类成员 [访问方式：直接访问]

（7）外部其他类---不能访问----->匿名内部类

（8）如果外部类和匿名内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成
员，则可以使用（外部类名.this.成员）去访问

匿名内部类的最佳实践：当做实参直接传递，简洁高效

public class Test {

    public static void main(String[] args) {
        f1(new IA() {
            @Override
            public void m1() {
                System.out.println("匿名内部类的最佳实践1");
            }
        });
        f1(new IA() {
            @Override
            public void m1() {
                System.out.println("匿名内部类的最佳实践2");
            }
        });
    }

    public static void f1(IA a){
        a.m1();
    }
}

interface IA{
    void m1();
}

5. 成员内部类

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

（1）可以直接访问外部类的所有成员，包含私有的。

（2）可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。

（3）作用域：和外部类的其他成员一样，为整个类体。在外部类的成员方法中创建成只内部类对象，再调用方法。

（4）成员内部类---访问---->外部类成员【访问方式：直接访问】

（5）外部类---访问------>成员内部类【访问方式：创建对象，再访问】

（6）外部其他类---访问---->成员内部类

// 外部其他类
public class Demo {
 
    public static void main(String[] args) {
 
        Waibu waibu = new Waibu();
        // 方式一
        Waibu.Neibu neibu1 = waibu.new Neibu();
        // 方式二
        Waibu.Neibu neibu2 = waibu.getNeibu();
    }
}
 
 
// 外部类
class Waibu{
 
    // 内部类
    class Neibu{}
 
    public Neibu getNeibu(){
        return new Neibu();
    }
}

6. 静态内部类

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

（1）可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
（2）可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是
一个成员。
（3）作用域：同其他的成员，为整个类体

（4）静态内部类---访问---->外部类 【访问方式：直接访问所有静态成员】
（5）外部类---访问------>静态内部类【访问方式：创建对象，再访问】

（6）外部其他类---访问---->静态内部类

// 外部其他类
public class Demo {
 
    public static void main(String[] args) {
 
        // 方式一
        Waibu.Neibu neibu = new Waibu.Neibu();
        // 方式二
        Waibu.Neibu neibu2 = Waibu.getNeibu();
    }
}
 
// 外部类
class Waibu{
 
    // 静态内部类
    public static class Neibu{}
 
    public static Neibu getNeibu(){
        return new Neibu();
    }
}