抽象类

• abstract修饰符（抽象类的关键字）可以用来修饰方法也可以修饰类，如果修饰方法，那该方法就是抽象方法，如果修饰类，那该类就是抽象类

• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

 

• 抽象类，不能使用new关键字来创建对象，他是用来让子类继承的。

• 抽象方法，只有方法的声明，没有方法的实现，他是让子类来实现的。（通过overwrite）

 

• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明抽象类。

• 抽象方法必须在抽象类中，抽象类中可以有普通方法。

public abstract class B {
    public abstract void a();
    public void b(){
        System.out.println("b");
    }
}

public class A extends B{
    @Override
    public void a() {
        System.out.println("a");
    }
}

public class Demo {
    public static void main(String[] args) {
        A s = new A();
        s.a();
        s.b();
    }
}
/*输出结果是
a
b
*/

接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范（抽象方法）

接口关键字：interface

public interface B {
    void speak(String name);
    void bite();
}

public interface C {
    void run(String name);
}

public class A implements B,C{
​
    @Override
    public void speak(String name) {
        System.out.println(name);
    }
​
    @Override
    public void bite() {
        System.out.println("you stop!");
    }
​
    @Override
    public void run(String name) {
        System.out.println(name + "run!");
    }
}

public class Demo {
    public static void main(String[] args) {
        A s = new A();
        s.speak("小狗");
        s.bite();
        s.run("小明");
    }
}
/*输出的是：
小狗
you stop!
小明run!
*/

 

内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类来说就是外部类了。

成员内部类

public class Outer {
    private int id = 20;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部的私有属性
        public void getId(){
            System.out.println(id);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }
}

静态内部类

public class Outer {
    private int id = 20;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部的私有属性
        public void getId(){
            System.out.println(id);//这里会报错，因为static创建早于私有属性
        }
    }
}

匿名内部类

public class Demo {
    public static void main(String[] args) {
        //没有名字初始化，不用将实例保存到变量中
        new Apple().eat("苹果");
    }
}
​
class Apple{
    public void eat(String name){
        System.out.println("eat"+name);
    }
}