抽象类

abstract 声明的
抽象类不能够够实例化对象，例如 Person p = new Person(); //编译报错，只能通过子类去实例化
抽象类中可以没有抽象方法，有抽象方法一定是抽象类
抽象类中也可以有普通成员（成员变量、成员函数、代码块），除了可以有抽象方法，其他都是以一毛一样

抽象方法

抽象方法只有声明没有实现（没有代码块）
用abstract修饰的方法就是抽象方法，抽象方法不能有方法主主体
子类继承抽象父类，重写抽象方法，实现父类的抽象方法

//类里面携带 abstract 修饰符，那么就是抽象类
public  abstract class Person {
    String name;
    public void eat(){

    }

    public  Person() {
        System.out.println("person构造方法");
    }
    //抽象方法
   public abstract void a();


//    abstract 声明的
//    抽象类不能够够实例化对象，例如 Person p = new Person(); //编译报错，  只能通过子类去实例化
//    抽象类中可以没有抽象方法，有抽象方法一定是抽象类
//    抽象类中也可以有普通成员（成员变量、成员函数、代码块），除了可以有抽象方法，其他都是以一毛一样
    public static void main(String[] args) {
        Person p = new HuaJia();
    }
}

public class HuaJia extends Person{
    public HuaJia(){
        System.out.println("画家构造方法");
    }
    //Override 验证该方法是否是重写
    @Override
    public void a() {

    }
}

接口(interface)

在接口中定义的变量必须给予初始值，定义的变量相当于 static final int a = 10;
在接口给中所有的方法都是public修饰的，所以在实现类中实现的方法必须要用public修饰，否则编译出错。
接口可以继承多个接口 jdk1.8新特性，可以在类中声明一个default的函数

接口注意事项：
不能有构造函数
只能是有静态常量
每个方法都是public的，而且是抽象方法，不能被static修饰
接口可以继承多个接口，类只能继承单个类，类可以实现多个接口。

接口和抽象类的使用场景:

接口给是动作的抽象，抽象类是对根源的抽象
抽象类表示的是，这个对象是什么。接口给表示的是，这个对象能做什么，
比如有，男人，女人，这两个类（如果是类的话......），他们的抽象类是人，说明他们都是人。人可以吃东西，狗也可以吃东西，你可以把’吃东西‘定义成一个接口，然后让这些类去实现它。所以，在高级语言上，一个类只能继承一个类（抽象类）（正如人不可能同时是生物和非生物），但是可以实现多个接口（吃饭接口，走路接口等）

接口和抽象类的区别

抽象类可以有构造函数，但是接口不可有构造函数
抽象类可以有普通成员变量，接口中没有全局普通成员变量，只能有常量
抽象类中的方法可以被public,protected等修饰符修饰，接口中的方法全都是public abstract的方法，如果省略修饰符，则默认的也都是public abstract修饰
一个类只能继承一个抽象类，可以实现多个接口
抽线类中的方法可以被static修饰，接口中的方法不可以被static修饰（jdk1.8之前）
抽象类中可以有普通方法和抽象方法，接口中的方法全是抽象方法（jdk1.8之前）

public interface Elevator  extends Rise,Decline{

    //默认已经加上  static final        常量
    int a = 10;
    //默认已经加上   public abstract
      void a();

    static void hh() {

    }

    //jdk1.8才开始具备，可以在类中声明一个default的函数
    default void say(){
        System.out.println("这是我的方法");
    }

}

面向接口：

public interface ComputerInterface {

    //开机
    void open();
    //关机
    void close();
}

public class XiaoMiComputer implements ComputerInterface{
    private String pcName;

    public XiaoMiComputer(String pcName) {
        this.pcName = pcName;
    }

    public String getPcName() {
        return pcName;
    }

    public void setPcName(String pcName) {
        this.pcName = pcName;
    }

    @Override
    public void open() {
        System.out.println(pcName +"小米电脑开机");
    }

    @Override
    public void close() {
        System.out.println(pcName + "小米电脑关机");
    }
}

public class HuaSuoComputer implements ComputerInterface{
    private String name;

    private HuaSuoComputer(String name) {
        this.name = name;
    }
    public static HuaSuoComputer getIt(){
        return new HuaSuoComputer("GG15152");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void open() {
        System.out.println(name + "笔记本翻开机盖开机");
    }

    @Override
    public void close() {
        System.out.println(name + "长按关机");
    }
}

public class Teacher {
    private String name;
    //面向接口：你不知道这个接口的实现类有什么，但是知道该接口能够做什么
    public Teacher(String name) {
        this.name = name;
    }

    public void teach(ComputerInterface pc){

        pc.open();
        System.out.println(name + "教学");
    }
}

public class Test1 {

    //面向接口，就是面向对象的补充

    public static void main(String[] args) {
        Teacher teacher = new Teacher("伦哥");
        HuaSuoComputer huaSuoComputer = HuaSuoComputer.getIt();
        teacher.teach(huaSuoComputer);
        teacher.teach(new XiaoMiComputer("xiaomi"));
    }
}

内部类

类定义在一个类的内部则成为内部类。

public class Fruit {
}

public interface JJk {
    void sos();
}

/本类
public class Human {

    //1、普通内部类/成员内部类
    class Monkey{
        
    }
    //2、局部内部类       局部内部类因为在方法里，只能在方法里实例化，再通过方法返回值给予外面
    public Fruit do1(){
        class apple extends Fruit{
        }
        return new apple();
    }

    //3、匿名内部类   不需要声明一个类的名字就能够完成类的实例化
    public void do2(JJk jjk){
        jjk.sos();
    }


    //4、静态内部类
    static class  SuperMan{

    }
    public static void main(String[] args) {
        Human human = new Human();
        //成员内部类
        Monkey monkey = human.new Monkey();
        //局部内部类
        Fruit ap = human.do1();

        //实现和实例化一步到位        接接口“实例化”
        human.do2(new JJk() {
            @Override
            public void sos() {
                System.out.println("我是用匿名内部类实现的");
            }
        });

        //静态内部类
        SuperMan qq = new Human.SuperMan();
    }
}

参考：
Java内部类详解

Java抽象类、接口、内部类

抽象类

抽象方法

接口(interface)

接口和抽象类的使用场景:

接口和抽象类的区别

内部类