JAVA 抽象类 和 接口

一、抽象

1. 使用 abstract 修饰
2. abstract 修饰类 抽象类
3. abstract 修饰方法 抽象方法
4. 抽象方法，没有实现的部分
   注意：
   抽象类中的抽象方法，强制子类去重写
   抽象类不能实例化对象（不能创建对象）

抽象类中：

1. 成员变量，可以有成员变量，也可以有常量。
2. 成员方法，可以有抽象方法，也可以有成员方法
3. 构造方法，有构造方法。
   注意：
   抽象类中不一定有抽象方法，但是抽象方法一定存在抽象类中。
   抽象类的子类，一定要重写父类的所有抽象方法。

举例public class Demo01{    public static void main（String[] args）{        //父类的引用 指向 子类的对象        Animal animal = new Cat();        animal.eat();               // 打印猫吃鱼        animal.fun();               // 打印 我是成员方法    }}abstract class Animal{    final int num1 = 5;         // 可以定义常量    int num2 = 10;              // 可以定义变量    public Animal(){            //  无参构造方法            System.out.println("我是父类的抽象方法")    }    public void fun(){            //  我是成员方法            System.out.println("我是成员方法")    }    public abstract void eat();// 定义一个抽象方法 eat（）}class Cat extends Animal{    public Cat(){        super();    }    public void eat(){    //方法的重写        System.out.println(猫吃鱼);    }}//  最后的打印结果//  我是父类的抽象方法//  猫吃鱼//  我是成员方法

1.一个类就算没有抽象方法，也可以定义成一个抽象类，作用是禁止创建抽象类的对象出来，只能使用其子类。
2.abstract 和 哪些关键字不能共同使用
abstract 和 static
static 修饰方法 用法 用类名区调用，abstract 修饰抽象方向，没有方法的实现，没有实现部分的方法，只能是方法的生命，无法直接调用，所以不能共存。
abstract 和 final
final 修饰方法 不能被重写。而abstract 修饰方法 就是为了让子类重写方法，所以不能共存。
abstract 和 private
private 修饰方法，只能本类访问，子类无法访问，没有办法重写。

二、接口

1. 狭义的接口：interface 关键词修饰的 叫做接口
2. 广义的接口：规则

定义接口的写法：
interface 接口名{}

接口特点：

1. 接口中，只能声明抽象方法
2. 如果你不写 public abstract 关键词修饰 接口中 声明的方法。那么系统会默认帮你添加。
3. 接口也不能实例化对象（谁要用接口，就谁要去实现接口中的方法。）可以使用多台的方式创建子类（实现类的对象）
4. 接口的实现，使用implement关键词

接口注意：

1. 成员变量 ：只能有常量， public static final 常量名 = 初值，当你在接口中声明变量时，系统默认回事public static final 修饰变量。
2. 成员方法：只有抽象方法，没有成员方法
3. 构造方法：没有构造方法。

类和类的关系：

类和类 之间 是继承关系 单继承和多层继承

类和接口的关系：

类和接口 是实现的关系，可以单实现，也可以多实现。

接口和接口的关系：

接口和接口的关系，可以多继承也可以单继承

举例public static Demo02{    public static void main（String[] args）{        InterA a = new Person();      //        a.print();                    //打印 我是人类的打印        InterZ z = new Car;        z.fun();        z.fun1();    }}// 定义一个接口 interfaceinterface InterA{    // 定义一个抽象方法    public abstract void print();}class Person implements InterA{    //  实现这个方法    public void print(){        System.out.println("我是人打印的")    }}interface InterX{    public abstract void fun();}interface InterY{    public abstract void fun1(){    }}inter face InterZ extends InterX, InterY{}class Car implements InterZ{                    //  接口的多继承    public void fun(){        System.out.println("我是fun")    }    public void fun1(){        System.out.println（"我是fun1"）    }}//最终的打印结果  //  我是人类的打印//  我是fun//  我是fun1

JDK 1.8之后进行了优化。

优化之后可以写成员方法：静态的方法， 默认的方法

1. 不能直接调用默认方法，因为接口不能创建对象
2. 必须使用该接口的实现类的对象去调用
3. 默认方法在实现类中不强制你重写。

抽象类 和 接口的区别
成员变量

抽象类：可以有成员变量，也可以有常量
接口： 只可以有常量

成员方法

抽象类：可以有成员方法，也可以由抽象方法
接口： 可以有静态成员方法，可以有默认成员方法，可以有抽象方法

构造方法

抽象类：有构造方法
接口：没有构造方法

举例public class Demo03{    public static void main(String[] args){        // 接口中的静态成员方法可以使用接口名直接调用        InterA.staticSayHi();        // 接口的引用指向 实现类的对象        InterA aimp = new InterAImp();        // aimp调用sayHi（）方法        aimp.sayHi();        // aimp调用defaultSayHi（）方法        aimp.defaultSayHi();    }}interface InterA{    public abstract sayHi()；    // 接口中的抽象方法，实现类中必须重写    public static void staticSayHi(){        System.out.println("我是接口中的静态成员方法")   // 接口中的静态成员方法    }    public default void defaultSayHi(){        System.out.println("我是接口中的默认成员方法")   //  接口中的默认成员方法    }}class InterAImp implements InterA{    public void sayHi(){        System.out.println("我是重写之后的接口中的抽象方法")； // 强制重写    }    public void defaultSayHi(){        InterA.super.defaultSayHi();  // 可以直接用interA.super.直接调用在实现类中        System.out.println("我是重写之后的接口的默认成员方法")  // 接口中的默认成员方法重写    }}