abstract抽象类、interface接口、匿名内部类

一、abstract 抽象类

（1）抽象类定义规则

1. 抽象类和抽象方法必须用关键字abstract修饰；
2. 抽象类不能直接实例化，我们不能new一个抽象类对象；
3. 抽象类定义时可以只给出声明，而不需强制实现；
4. 含有抽象方法的类必须声明为抽象类，子类继承抽象类必须实现抽象类的所有方法后才能被实例化，否则该子类必须为抽象类；
5. 抽象类可以有构造方法，但是构造方法必须在子类中被调用，无法在外部抽象类的实例化
   举例如下：

abstract class Book{

    private String title = "java开发";

    public Book(String title) {     //可以定义构造方法
        this.title = title;
    }

    public void show(){     //可以给出定义
        System.out.println(title);
    }
    public abstract void add();     //也可以不给出定义直接声明
}

（2）抽象类使用

抽象类只能通过子类继承父类（父类是抽象类，子类不是抽象类）来使用，子类可以在构造函数中必须调用父类的构造方法：

public class Java extends Book{

    public Java(String title) {     //子类调用父类抽象类的构造方法
        super(title);		//必须明确调用，改行代码不可省略
    }
    @Override
    public void add() {
        System.out.println("add方法");
    }
}

（3）注意事项

1. 抽象类不能使用final关键字修饰：因为使用final定义的类不能有子类而抽象类必须有子类；
2. static 在外部抽象类上不能使用static声明，但是内部抽象类可以使用static定义，使用static定义的内部抽象类（只要是内部类即可，不一定是要抽象的）就表示是一个外部类；
   举例如下：

abstract class Person{

    static abstract class man{      //静态内部抽象类类，相当于一个外部抽象类
        public abstract void isMan();       //抽象方法
    }
}
class test extends Person.man {     //注意调用方式使用成员运算符.进行调用
    @Override
    public void isMan() {
        System.out.println("isMan方法");
    }
}

二、interface 接口

（1）接口定义规则

1. 使用interface关键字定义接口；
2. 接口中所有成员访问类型默认为public abstract，该修饰的方法，不能在接口中给出方法体；
3. 接口中可以有私有方法、静态方法默认方法，这些方法必须在接口中给出定义体；

（2）接口中私有方法注意事项

1. 接口中private方法不能是abstract抽象方法。因为abstract抽象方法是公开的用于给接口实现类实现的方法，所以不能是private。
2. 接口中私有方法只能在接口内部的方法里面被调用。
3. 接口中私有静态方法可以在其他静态和非静态接口方法中使用。
4. 接口中私有非静态方法不能在私有静态方法内部使用。

interface CustomInterface {

    public abstract void abstractMethod();  //抽象方法不能是私有的

    public default void defaultMethod() {
        privateMethod(); //可以调用接口中的私有方法
        privateStaticMethod(); //可以调用接口中的私有静态方法
        System.out.println("普通方法被调用");
    }

    public static void staticMethod() {
        privateStaticMethod(); //public静态方法可以调用private静态方法
        System.out.println("静态方法被调用");
    }

    private void privateMethod() {
        System.out.println("private私有方法被调用");
    }

    private static void privateStaticMethod() {
        System.out.println("private私有静态方法被调用");
    }
}

转自：https://www.cnblogs.com/zimug/archive/2020/10/13/13806592.html

三、匿名内部类

（1）匿名内部类的定义

官方例子：

 1 public class HelloWorldAnonymousClasses {
 2
 3     /**
 4      * 包含两个方法的HelloWorld接口
 5      */
 6     interface HelloWorld {
 7         public void greet();
 8         public void greetSomeone(String someone);
 9     }
10 
11     public void sayHello() {
12 
13         // 1、局部类EnglishGreeting实现了HelloWorld接口
14         class EnglishGreeting implements HelloWorld {
15             String name = "world";
16             public void greet() {
17                 greetSomeone("world");
18             }
19             public void greetSomeone(String someone) {
20                 name = someone;
21                 System.out.println("Hello " + name);
22             }
23         }
24 
25         HelloWorld englishGreeting = new EnglishGreeting();
26 
27         // 2、匿名类实现HelloWorld接口
28         HelloWorld frenchGreeting = new HelloWorld() {
29             String name = "tout le monde";
30             public void greet() {
31                 greetSomeone("tout le monde");
32             }
33             public void greetSomeone(String someone) {
34                 name = someone;
35                 System.out.println("Salut " + name);
36             }
37         };
38 
39         // 3、匿名类实现HelloWorld接口
40         HelloWorld spanishGreeting = new HelloWorld() {
41             String name = "mundo";
42             public void greet() {
43                 greetSomeone("mundo");
44             }
45             public void greetSomeone(String someone) {
46                 name = someone;
47                 System.out.println("Hola, " + name);
48             }
49         };   //注意此处有一个分号结尾
50         
51         englishGreeting.greet();
52         frenchGreeting.greetSomeone("Fred");
53         spanishGreeting.greet();
54     }
55 
56     public static void main(String... args) {
57         HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
58         myApp.sayHello();
59     }

（2）注意事项

匿名类可以在使用的时候直接给出该类的定义，如果创建的时候没有变量对它进行实例化引用，他只能被使用一次，该类的定义也会立即消失，匿名对象也与此同理。

---

仅限个人理解，如有错误，欢迎指正---------------------------------lensen明