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

抽象类

抽象类本质就是一种特殊的类
抽象类和普通类的 区别：
1 将普通类使用abstract修饰 之后的 类就是抽象类
2抽象类不能被实例化
3 抽象类是 用来被继承的
4 抽象类中可以存在抽象方法
5 抽象类不一定存在抽象方法 但是存在抽象方法 的类 一定是抽象类
抽象方法：就是使用abstract修饰 没有方法体的方法

接口
接口是一种规范
接口又是一种特殊的抽象类
接口的修饰符 interface 接口是用来被实现（implements）的
接口中只有 类常量（全局常量）和抽象方法
接口特点：
1 接口可以继承接口 而且接口 的继承是多继承

内部类
就是在类的内部 创建一个类 这个类就称为内部类
内部类分为成员内部类和局部内部类
包含内部类的类称为外部类

public class OuterClass {
     
    private int num =10;
    private int num1 = 20;
    //成员内部类
    public class InnerClass{
     
        private double a = 100.1;
        public  void print(){
     
            System.out.println(num +"---"+num1);
            show();
        }
    }

    public  void show(){
     
        System.out.println(num +"---"+num1);
    }

    public static void main(String[] args) {
     
        OuterClass oc = new OuterClass();
        System.out.println(oc.num);
        System.out.println(oc.num1);
        oc.show();
        // 调用内部类的成员方法、成员属性
        //1 需要创建内部类的对象 需要通过 外部类 的对象来创建内部类的对象  创建出来的对象是内部类类型
        InnerClass innerClass = new OuterClass().new InnerClass();
        System.out.println(innerClass.a);
        innerClass.print();
    }
}

包含有成员内部类的类 编译之后 会产生几个class文件？

在成员内部类中不能存在static修饰的 成员
如果在内部类中使用this此时的this代表的是内部类的当前对象

public class OuterClass {
     
    private int num =10;
    private int num1 = 20;
    //成员内部类
    private class InnerClass{
     
        private double a = 100.1;
         int i = 100;
         public  InnerClass(){
     

         }
         public InnerClass(int i){
     
             this.i = i;
         }
        public  void print(){
     
            System.out.println(num +"---"+num1);
            show();
        }
    }

    public  void show(){
     
        System.out.println(num +"---"+num1);
    }

    public static void main(String[] args) {
     
        OuterClass oc = new OuterClass();
        System.out.println(oc.num);
        System.out.println(oc.num1);
        oc.show();
        // 调用内部类的成员方法、成员属性
        //1 需要创建内部类的对象 需要通过 外部类 的对象来创建内部类的对象  创建出来的对象是内部类类型
        InnerClass innerClass = new OuterClass().new InnerClass();
        // 使用外部类已有的对象来创建外部类  同时可以使用他的重载的 构造方法
        InnerClass innerClass1 =oc.new InnerClass(100);
        System.out.println(innerClass.a);
        innerClass.print();
    }
}

局部内部类

public class OuterClass {
     
    private int num =10;
    private int num1 = 20;

    public  void show(){
     
        System.out.println(num +"---"+num1);
        // 局部内部类    相当于方法的一个局部变量 局部变量不能使用访问修饰符
         class  InnerClass{
     
            private  int i = 100;
            public void  print(){
     
                System.out.println(num +"--"+ num1+"--"+i);
            }
        }
        // 局部内部类的 声明周期和局部变量相同 仅限于当前方法中来使用  在方法的 外部是访问不到的
        //在方法中如果要访问局部内部类的成员  则需要创建局部内部类的 对象来访问
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.i);
    }

    public static void main(String[] args) {
     
        OuterClass oc = new OuterClass();
        oc.show();

    }
}

编译之后也是两个class文件

匿名内部类一般用于在方法的参数上，当方法的 参数是一个抽象类或者接口的时候，我们 可以采用匿名内部类的 形式来传入方法的实参

public interface InterDemo {
     
    void method();
}

public class ClassDemo {
     
    public  void  show(InterDemo interDemo){
     
        interDemo.method();
    }

    public static void main(String[] args) {
     
        ClassDemo demo = new ClassDemo();
        demo.show(new InterDemo() {
     
            @Override
            public void method() {
     
                System.out.println("这是使用匿名内部类来实现接口的");
            }
        });
    }
}