抽象类和接口

抽象类和接口的区别：

抽象类：
1.抽象类是一个类
2.定义抽象类时，使用abstract关键字修饰，继承抽象类时，使用extends
3.只能继承一个抽象类
4.抽象类中可以有抽象方法，也可以没有抽象方法，抽象类中可以有具体的方法

接口：
1.接口不是一个类
2.定义接口时使用interface，实现接口时使用implements
3.可以实现多个接口
4.jdk1.8之前接口中的方法都是抽象方法，jdk1.8之后接口中可以有非抽象方法、静态方法

抽象类和接口的相同点：

1.都不可以实例化，即不能使用new关键字来实例化对象
2.子类/实现类需要实现抽象类父类/要实现的接口中的所有抽象方法，如果没有实现它们中的全部抽象方法，子类/实现类需要定义成抽象类
3.可以引用抽象类/接口，指向子类/实现类---》形成多态

抽象方法：只有方法体，没有具体实现。eg:

public abstract void a();

jdk1.8之前和jdk1.8之后，接口区别：

jdk1.8之前接口中有：1.常量 2.抽象方法
jdk1.8之后接口中有：1.常量 2.抽象方法 3.非抽象方法 4.静态方法

常量：public static final
抽象方法：public abstract
非抽象方法：public default
静态方法：public static

注意：接口中的静态方法不能被继承。实现类实现接口时，重写接口中的的非抽象方法不可以带关键字default

抽象类：

abstract public class Person {
    int age;
    String name;

    public void eat(){
        System.out.println("能吃是福");
    }

    public abstract void sleep();
}

jdk1.8之前接口：

public interface TestInterface01 {
    //常量
    public static final int NUM = 10;
    //抽象方法：
    public abstract void a();
    public abstract void b(int num);
    public abstract int c(String name);
}

interface TestInterface02{
    public abstract void e();
    public abstract void f();
}

继承父类、实现接口：

class Student extends Person implements TestInterface01, TestInterface02{
    @Override
    public void a() {
        System.out.println("------aaa");
    }

    @Override
    public void b(int num) {
        System.out.println("------bbb");
    }

    @Override
    public int c(String name) {
        return 110;
    }

    @Override
    public void e() {
        System.out.println("--------eee");
    }

    @Override
    public void f() {
        System.out.println("-------fff");
    }

    @Override
    public void sleep() {
        System.out.println("我喜欢睡硬板床");
    }
}

class Test{
    //这是一个main方法，程序的入口
    public static void main(String[] args) {
        //10.接口不能创建对象：
        //TestInterface02 t = new TestInterface02();
        //抽象类不能创建对象
        //Person p = new Person();
        Person p = new Student();   //  父类指向子类---》多态
        TestInterface02 t = new Student();  //接口指向实现类---》多态

        //11.接口中常量如何访问：
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);
    }
}

jdk1.8之后接口：

package com.test12;

/**
 * jdk1.8之后，除了常量，抽象方法，还新增了非抽象方法、静态方法
 * 常量：public static final
 * 抽象方法：public abstract
 * 非抽象方法：public default
 * 静态方法：public static
 */
public interface TestInterface {
    //常量
    public static final int NUM = 10;

    //抽象方法
    public abstract void a();

    //非抽象方法
    public default void b(){
        System.out.println("-----TestInterface---b()---");
    }

    //静态方法
    public static void c(){
        System.out.println("这是TestInterface的静态方法c()");
    }
}

package com.test12;

public class Demo implements TestInterface{
    @Override
    public void a() {
        System.out.println("Demo重写接口TestInterface的a()方法");
        b();
        //调用接口中的方法
        TestInterface.super.b();
    }

    @Override
    public void b() {
        System.out.println("Demo重写接口TestInterface中的b()方法");
    }

    public static void c(){
        System.out.println("Demo中的静态方法c()");
    }
}

class TestDemo{
    //这是一个main方法，程序的入口
    public static void main(String[] args) {
        Demo d = new Demo();
        d.a();
        Demo.c();
        TestInterface.c();
    }
}

打印结果：

Demo重写接口TestInterface的a()方法
Demo重写接口TestInterface中的b()方法
-----TestInterface---b()---
Demo中的静态方法c()
这是TestInterface的静态方法c()