第十章 面向对象编程（高级）

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

1. 类变量

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

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

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

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

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

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

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

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

2. 类方法

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

二、理解 main 方法（P383）

public static void main(String[] args) {    }

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

public class Hello {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("无参");
        }
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

三、代码块（P386）

1. 基本介绍

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

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

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）继承关系的调用顺序：

1️⃣父类的静态代码块和静态属性
2️⃣子类的静态代码块和静态属性
3️⃣父类的普通代码块和普通属性初始化

4️⃣父类的构造方法

5️⃣子类的普通代码块和普通属性初始化

6️⃣子类的构造方法

（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）外部其他类---访问---->静态内部类文章来源地址https://www.toymoban.com/news/detail-455927.html

// 外部其他类
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();
    }
}

到了这里，关于第十章 面向对象编程（高级）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！