1.抽象类和接口

参考文章

1.示例代码

/**
 * 抽象类：顾名思义是类
 * 抽象类中可以有 普通成员变量、普通的成员方法、抽象方法
 * 抽象类不能实例化
 */
public abstract class Animal {
    // 抽象类中可以有普通成员变量
    private int var1 = 10;
    protected String var2 = "this is var2";
    public boolean var3 = true;
    // 抽象类中可以有普通的成员方法
    void func1() {
        System.out.println("func1:我是普通的成员方法，可以写方法体实现！");
    }

    /**
     * 抽象类中一般有抽象方法
     * 抽象方法必须是public或protected(默认为public)不能使用private修饰 因为定义抽象类目的是为了让子类继承的
     * 抽象方法不能有方法体实现
     */
    abstract void func2(String str);
}
/**
 * Class 'Dog' must either be declared abstract or implement abstract method 'func2()' in 'Animal'
 * 继承抽象类必须实现抽象类里面的抽象方法，如果不实现则该类必须定义为抽象类，
 * 如下面的Cat类不实现Animal的抽象方法func2 则必须定义Cat类为abstract类
 */
class Dog extends Animal {
    @Override
    void func2(String str) {
        System.out.println(str);
    }
}
/**
 * Pig类继承抽象类Animal，实现抽象接口Action,
 * 必须实现抽象类里的抽象方法和接口里的抽象方法，不实现则必须定义该类为抽象类
 */
class Pig extends Animal implements Action {
    @Override
    void func2(String str) {
        System.out.println(str);
    }
    @Override
    public void eat(String food) {
        System.out.println("pig eat:" + food);
    }
}
/**
 * 继承抽象类如果不实现抽象方法，则也要定义为抽象类
 */
abstract class Cat extends Animal {
    public int var4 = 20;
    void func3() {
        System.out.println("this is func3");
    }
    abstract void func4(String str);
}

/**
 * FatCat 继承抽象类Cat,抽象类Cat又继承Animal，所以FatCat必须同时实现Cat与Animal里面的抽象类
 */
class FatCat extends Cat {
    @Override
    void func2(String str) {
        System.out.println(str);
    }
    @Override
    void func4(String f4) {
        System.out.println(f4);
    }
}

/**
 * 接口中可以含有 成员变量和抽象方法
 */
public abstract interface Action {
     /**
      * 接口中的变量会被隐式地指定为public static final变量
      * 并且只能是public static final变量，用private修饰会报编译错误
      */
     int var1 = 1;
     /**
      * 接口方法会被隐式地指定为public abstract方法且只能是public abstract方法
      * 用其他关键字，比如private、protected、static、 final等修饰会报编译错误
      */
     void eat(String food);
     
      // jdk8后可以有default方法
    default void say(){
        System.out.println("say");
    }

    // jdk8后可以有static方法
     static void eat(){
        System.out.println("eat");
    }
}

public class Test {
    public static void main(String args[]){
        /**
         * Dog类继承抽象类Animal
         */
        System.out.println("======================测试Dog========================");
        Dog dog = new Dog();
        // System.out.println(dog.var1); //访问不到继承类private定义的变量
        System.out.println(dog.var2);
        dog.func1();
        dog.func2("func2:hello world");

        /**
         * Pig extends Animal implements Action
         */
        System.out.println("======================测试Pig========================");
        Pig pig = new Pig();
        pig.func2("调用抽象类中的方法");
        System.out.println("访问接口中的public static final变量varl = " + pig.var1);
        pig.eat("糠粮");

        /**
         *  FatCat继承自抽象类Cat，抽象类Cat继承自抽象类Animal
         */
        System.out.println("======================测试FatCat========================");
        FatCat fatCat = new FatCat();
        System.out.println(fatCat.var2);
        System.out.println(fatCat.var3);
        System.out.println(fatCat.var4);
        fatCat.func1();
        fatCat.func2("func2:hello world");
        fatCat.func3();
        fatCat.func4("func4:hello world");
    }
}

2.总结

抽象类总结：
[public] abstract class ClassName {
    abstract void fun();
}
1：抽象类中可以有 普通成员变量、普通的成员方法、抽象方法。
抽象类要有抽象方法，如果一个抽象类不包含任何抽象方法，为何还要设计为抽象类？
抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类。
2：如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
3：抽象类不能实例化

接口总结：
[public] interface InterfaceName {
}
1：接口中可以含有 成员变量和抽象方法、jdk8后可以有default、static方法
接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误）
2：接口方法会被隐式地指定为public abstract方法且只能是public abstract方法，用其他关键字，比如private、protected、static、 final等修饰会报编译错误
3：不能像抽象类那样定义普通的成员方法

3.抽象类和接口的区别

1.语法层面上的区别
　　1）抽象类可以提供成员方法的实现细节（可定义普通的成员方法），而接口中只能存在public abstract 方法(jdk8后可以有default、static方法)；
　　2）抽象类中的成员变量可以是各种类型的（private,protected,public），而接口中的成员变量只能是public static final类型的；
　　3）一个类只能继承一个抽象类，而一个类却可以实现多个接口。
　　class ClassName extends Animal implements Interface1,Interface2,[....]{
}