抽象类，内部类，匿名类

一：抽象类

1：抽象方法

（1）抽象方法的语法格式

[访问修饰符]abstract<返回类型><方法名>([参数列表])

（2）普通方法和抽象方法区别：

抽象方法需要用abstract修饰，普通方法不需要

抽象方法没有方法体，普通方法有方法体。

2：抽象类

（1）语法格式：

abstract class<类名>{
​
}

（2）与普通类的区别

抽象类可以有抽象方法；

抽象类不可以被实例化；

3：定义一个抽象类：

public abstract class 类名{
修饰符 数据类型 变量名;
修饰符 abstract 返回值类型 方法名称(参数列表);
修饰符 返回值类型 方法名称(参数列表){
}
}

4：注意事项

抽象类不能用final来声明；
抽象方法不能用private修饰
抽象类实则是定义了一个规范
abstract修饰的抽象方法没有方法体；
抽象类不能被直接实例化，但有构造方法
子类如果不是抽象类，则子类必须重写抽象类中的全部抽象方法。
abstract修饰符和final修饰符不能一起使用。

二：内部类

1：类的成员：

字段、方法、成员类/接口

2：成员类（内部类）

在类的里面声明的类为成员类， 可以被继承

定义一个内部类：创建对象，以及成员的调用

public static void main(String[] args) {
        /*
        创建内部类对象的格式
        外部类名.内部类名 对象名 = new 外部对象().new 内部对象();
         */
        Outer.Innter i = new Outer().new Innter();  //创建对象
        System.out.println(i.num);  //调用里面的成员
        i.show();   //调用里面的方法。
    }
}
class Outer{
    class Innter{
        int num = 10;
        public void show(){
            System.out.println("Inner .. show");
        }
    }

3：外部类和内部类的访问修饰符

外部类的访问修饰符只能是： public / package-access

成员类的访问修饰符可以是所有的访问修饰符

可以使用 final static abstract 等修饰符修饰成员类

4：创建对象的时候如何使用：

（1）成员内部类

内部类可以直接使用外部类中的成员（包括私有的）。

外部类要访问内部类的成员，必须创建对象。

public static void main(String[] args) {
        /*
        创建内部类对象的格式
        外部类名.内部类名 对象名 = new 外部对象().new 内部对象();
         */
        Outer.Innter i = new Outer().new Innter();  //创建对象
        System.out.println(i.num);  //调用里面的成员
        i.show();   //调用里面的方法。
    }
}
class Outer{
    int a = 10;
    class Innter{
        int num = 10;
        public void show(){
            System.out.println("Inner .. show");
            //内部类访问外部成员可以直接访问，包括私有
            System.out.println(a);
        }
    }

（3）static 成员类

使用 类名. 调用. 使用 new 外部类.内部类();

A.B b = new A.B(); //new A.B();

（4）实例成员类

使用外部类的对象来调用. 使用 对象.new 内部类();

public static void main(String[] args) {
        //外部类
        A a = new A();
        //使用实例成员类
        A.C c = a.new C();  // 等同于 new A().new C();
        A.C c1 = new A().new C();//依赖于外部类的对象,先实例化外部类，在实例化内部类
    }

在实例成员类中可以使用 外部类.this 表示外部类对象 (实例成员类是由外部类对象创建的)

成员类中的 this 表示的是成员类

外部类可以直接调用成员类的静态成员，实例成员需要创建成员类的对象来调用

成员类属于类的成员，所以可以调用外部类的 private 成员

外部类可以访问成员类的 private 成员

(5)私有成员内部类：

如果一个成员内部类被private私有化。如果外部类想再次访问，就只能在内部类所在的外部类中直接创建对象进行访问。

 public static void main(String[] args) {
        //Outer1.Inner1 oi = new Outer().new Innter1();  //错误原因是因为Innner1已经被私有化了。
        Outer1 o = new Outer1();
        o.method();
    }
}
class Outer1{
    private class Inner1{   //没报错说明成员内部类是可以被private修饰的
        public void show(){
            System.out.println("inner .. show");
        }
    }
    public void method(){
        Inner1 i = new Inner1();   //在自己的类里面调用没问题。
        i.show();
    }

（6）静态成员内部类的创建格式：

（外部类名.内部类名 对象名 = new 外部类名.内部类名() );

public static void main(String[] args) {
        //创建格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer2.Inner2 oi = new Outer2.Inner2();
        oi.show();
​
        Outer2.Inner2.method();  //调用静态内部类的静态方法
    }
}
class Outer2{
    static class Inner2{
        public void show(){
            System.out.println("inner ... show");
        }
        public static void method(){   //静态内部类
            System.out.println("method");
        }
    }

5：内部类和外部类的区别

访问修饰符： 外部类只能有两种访问权限： public 以及 package-access 内部类可以有四种访问权限： public / protected / package-access / private static 修饰： 外部类不可以使用 static 修饰类，内部类可以 使用：外部类可以直接被使用，内部类的使用则依赖于外部类

三：匿名类

1：定义

匿名类是没有明确的名称的类。

2：格式

new类名或者是接口名（）{
重写方法；
}

优势：

匿名内部类直接实现了接口，重写方法，创建了实现类对象，调用方法步骤都完成了。

3：注意事项

匿名类不能使用修饰符，在方法的内部，对外隐藏。不能是 static ，隐式 final类。

匿名类没有类名，没有构造方法。

匿名类不能定义接口，不能定义静态块，静态方法，静态变量

匿名类可以访问类中的成员，不能访问方法中的变量，除非是 final 的。

匿名类一般是实现接口、继承抽象类，实现了重写。相当于实现、继承了这个接口/类。

public abstract class Pet {
public abstract void cry();
}
//匿名类
Pet p = new Pet() {  
    @Override
    public void cry() {
    System.out.println("喵 喵 喵");
    }
};  //后面还可以调用方法
//等同于
public class 类名 extends Pet{
    @Override
    public void cry() {
    System.out.println("喵 喵 喵");
    }
}