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

目录

1、接口和抽象类区别

2、java8中接口的新特性

3、内部类

---

1、接口和抽象类区别

        1.1、抽象类可以存在普通成员函数，接口只能存在public abstract方法(省略系统会默认添加)

        1.2、抽象类中的成员变量可以是各种类型的，接口只能是public static final类型的(省略系统会默认添加)

        1.3、抽象类单继承，可以实现多个接口。接口多继承        

        1.4、抽象类不能被实例化，只能用来继承。抽象方法没有方法体，必须被子类实现

2、java8中接口的新特性

        除了定义全局变量和抽象方法外，还可以定义静态方法和默认方法

        2.1、接口中定义的静态方法(使用static修饰)只能通过接口来调用

        2.1、接口中定义的默认方法(使用default修饰)只能通过实现类的对象调用

3、内部类

        定义：将一个A声明在另一个类B中，类A称为内部类，类B称为外部类

        3.1、成员内部类(静态、非静态)，

                3.1.1、可以调用外部类的结构。调用外部类属性：B.this.属性名

                3.1.2、静态成员内部类创建：B.A a = new B.A();

                3.1.3、非静态成员内部类创建： B b = new B;        B.A a = b.new A();

        3.2、局部内部类(类在方法体、代码块内、构造器内)

                常见场景:

 方式一：
       public 接口  a() {
           class b implements 接口{
                 @Override
                       重写的方法;
        }
           retrun b;
}

方式二：匿名内部类写法
/*
注意接口是不能被new的，这里new 接口()时后面接了{},这种写法
实际上时new了一个实现接口的匿名内部类,
new 接口(){} === class 类名 implements 接口()
*/
        public 接口  a() {
             return  new 接口() {
                    @Override
                    重写的方法;
} 

        3.3、匿名内部类

                定义：没有名字的内部类，只能使用一次。

                前提条件：必须继承一个父类或者实现一个接口

                3.3.1、使用抽象类举例：不使用内部类用法

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p =new Child();
        p.eat();
    }
}

                3.3.2、使用匿名内部类写法(直接将抽象类Person中的方法在大括号中实现了)

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p =new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

                3.3.3、在接口上使用匿名内部类

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

                3.3.4、常见场景多线程Thread类或者Runable接口写法

                Thread类匿名内部类实现(因为继承thread类才能创建线程，符合匿名内部类前提条件)

public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

                  Runnable接口的匿名内部类实现(符合匿名内部类前提条件)

public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i =1; i <=5; i++) {
                    System.out.print(i +" ");
                }
            }
        };
        Thread t =new Thread(r);
        t.start();
    }
}