JAVA抽象类和接口

类和对象：

1.封装

2.继承

3.多态

（1）向上转型

（2）子类父类有同名的覆盖方法，通过父类引用调用这个方法

（3）动态绑定

❤🧡💛💚💙💜🤎🖤🤍💔❣💕💞💓💗💖💘💝

抽象类：

1.使用abstract修饰的方法，叫做抽象方法。

2.包含抽象方法的类，必须设计为抽象类，使用abstract修饰此类

3.抽象类不能进行实例化

4.抽象类当中可以有和普通类一样的方法，成员。最突出的和普通类不一样的地方就是抽象类不能进行实例化。

5.抽象类可以被继承（抽象类的存在就是为了被继承）

6.当一个普通类继承这个抽象类之后，如果这个抽象类当中包含抽象方法，那么需要重写这个抽象方法，否则代码不能通过编译。

7.如果一个抽象类A继承另一个抽象类B，那么此时这个抽象类A可以不重写B当中的抽象方法。

8.抽象方法不能是private的、static的、final的。

🐵🐺🐶🐱🦁🐯🦒🦊🦝🐮🐷🐗🐭🐹🐰🐻

接口：

1.使用interface来修饰接口

2.接口当中的成员变量，默认都是public static final修饰的

3.接口当中的成员方法默认都是public abstract修饰的

4.接口当中的普通成员方法，是不能有具体实现的

5.接口当中的普通成员方法，如果要有具体的实现，必须加上default修饰【JDK8开始】

6.接口当中可以有静态的成员方法。但是不管是静态的方法还是default方法，都是public修饰的。

7.接口也是不能进行实例化的

8.类和接口的关系使用implements来关联的

9.一个接口可以引用 具体实现类的 向上转型

10.接口当中不能有静态 示例代码块 构造方法

11.一个抽象类实现一个接口，可以不重写这个抽象方法（但是不建议）

🧞‍♀️🧞‍♂️🤼‍♂️🤼‍♀️🤼‍♀️👯‍♂️👯‍♀️💑👩‍❤️‍👩👩‍❤️‍👩👨‍❤️‍👨💏👩‍❤️‍💋‍👩👨‍❤️‍💋‍👨👨‍❤️‍💋‍👨

1.抽象类

（1）抽象类概念

在面向对象的概念中，所有对象都是通过类来描述的，但是不是所有的类都是用来描述对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

 说明：

1.三角形圆形矩形都是图形，所以与shape类的关系是继承关系

2.shape类不是具体图形，其中的draw方法实际是没有办法实现的，因此可将shape类设计为“抽象类”

 说明：

1.Fruit类是水果类，每种水果都有生长环境，但Fruit不是一种具体的水果，因此内部的grow（）方法不能具体实现

2.Apple是苹果类，是一种水果，与fruit是继承关系，其次🍎是一种具体的水果，长在树上，其grow（）方法可以实现

3.grape是葡萄，是一种水果，与fruit是继承关系，其次🍇是一种具体的水果，长在架子上，其grow（）方法可以实现

4.因此：Fruit类可以设计为“抽象类”

在打印图形的例子中，我们发现，父类shape中的draw方法好像并没有什么实际工作，主要绘制图形都是由Shape的各种子类的draw方法来完成的。像这种没有实际工作的方法，我们可以把它设计成一个抽象方法，包含抽象方法的类叫做抽象类。

（2）抽象类语法

抽象方法不用给出具体的实现体

//抽象类：被abstract修饰的类
public abstract class Fruit{
    //抽象方法：被abstract修饰的方法，没有方法体
    abstract public void grow();
    abstract void color();


    //抽象类也是类，可以增加普通方法和属性
    public double Price(){
      return price;
    }


    protected double price;//价格
}

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

（3）抽象类特性

1.抽象类不能直接实例化对象

Shape shape = new Shape();


//编译出错
Error:(30,23)java:Shape是抽象的，无法实例化

2.抽象方法不能是private的

abstract class Fruit{
    abstract private void grow();
}


//编译出错：
Error:(4,27)java:非法的修饰组合：abstract和private

注意：抽象方法没有加访问限定符时，默认是public

3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape{
    abstract final void methodA();
    abstract public static void methodB();
}


//编译报错
//Error：(20,25)java:非法的修饰符组合:abstract和final
//Error：(21,35)java:非法的修饰符组合:abstract和static

4.抽象类必须被继承，并且子类要重写父类的抽象方法，否则子类也是抽象类，必须要使用abstract修饰

5.抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

6.抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

（4）抽象类的作用

普通类也可以被继承，普通方法也可以被重写，为什么非得用抽象类和抽象方法呢？

使用抽象类相当于多了一重编译器的校验

使用抽象类实际工作不应该由父类完成，而应由子类完成。那么此时如果不小心误用成父类了，使用普通编译器是不会报错的，但是父类是抽象类就会在实例化的时候提示错误，让我们尽早发现问题。

很多语法存在的意义都是为了“预防错误”，我们曾经使用的final也是类似，创建的变量不去修改，不就相当于常量吗？但是加上final能够在误修改的时候，让编译器及时提醒我们。

充分编译器的校验，在实际开发中是非常有意义的。

2.接口

（1）接口的概念

在java中，接口可以看成是：多个类的公共规范，是一种引用数据类型

（2）语法规则

接口定义形式与类定义形式基本相同，将class关键字换成interface关键字，就定义了一个接口。

public interface 接口名称{
    //接口方法
    public abstract void mathod1();//public abstract 是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();

    //注意：在接口中上述写法都是抽象方法，更推荐最后一种，代码更简洁
}

提示：

1.创建接口时，接口的命名一般以大写字母I开头

2.接口的命名一般使用“形容词”词性的单词

3.阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性

（3）接口使用

接口不能直接使用，必须需要有一个“实现类”来实现该接口，实现接口中所有的抽象方法

public class 类名 implements 接口名称{
    //.....
}

请实现笔记本电脑使用USB鼠标、USB键盘的例子
1.USB接口：包含打开设备，关闭设备功能
2.笔记本类：包含开机功能、关机功能、使用USB设备功能
3.鼠标类：使用USB接口，并具备点击功能
4.键盘类：使用USB接口，并具备输入功能

//USB接口
public interface USB {
    void openDevice();
    void closeDevice();
}

//鼠标类，实现USB接口
public class Mouse implements USB{
   @Override
    public void openDevice(){
       System.out.println("打开鼠标");
   }

   @Override
    public void closeDevice(){
       System.out.println("关闭鼠标");
   }

   public void click(){
       System.out.println("鼠标点击");
   }
}

//键盘类，实现USB接口
public class KeyBoard implements USB{
    @Override
    public void openDevice(){
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice(){
        System.out.println("关闭键盘");
    }

    public void inPut(){
        System.out.println("键盘输入");
    }
}

//笔记本类：使用USB设备
public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }

    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }

    public void useDevice(USB usb){
        usb.openDevice();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse)usb;
            mouse.click();
        }else if(usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }
}

//测试类
public class TestUSB {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();

        //使用鼠标设备
        computer.useDevice(new Mouse());

        //使用键盘设备
        computer.useDevice(new KeyBoard());

        computer.powerOff();
    }
}

 （4）接口特性

1.重写接口中方法时，不能使用default访问权限修饰

public interface USB{
    void openDevice();  //默认是public的
    void closeDevice(); //默认是public的
}

public class Mouse implements USB{
    @Override
    void openDevice(){
        System.out.println("打开鼠标");
}

//...
}


//编译报错，重写USB中openDevice方法时，不能使用默认修饰符
//正在尝试分配更低的访问权限;以前为public

2.接口中含有的变量会被隐式指定为public static final变量

public interface USB{
    double brand = 3.0;//默认被final public static修饰
    void openDevice();
    void closeDevice();
}

public class TestUSB{
    public static void main(String[] args){
        System.out.println(USB.brand);//可以直接通过接口名访问，说明是静态的
        

        //编译报错：Error:(12,12)java:无法为最终变量brand分配值
        USB.brand = 2.0;    //说明brand具有final属性
    }
}

3.接口中不能有静态代码块和构造方法

public interface USB{
    //编译失败
    public USB(){

    }


    {} //编译失败

    void openDevice();
    void closeDevice();
}

4.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8.如果类没有实现接口中的所有抽象方法，则类必须设置为抽象类

9.jdk8中：接口还可以包含default方法

（5）实现多个接口

在Java中，类与类之间是单继承的，一个类只能有一个父类，即java中不支持多继承，但是一个类可以实现多个接口。

class Frog extends Animal implements IRunning,ISwimming{
    //...



}

 注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类

提示：IDEA中使用ctrl+i快速实现接口

代码展示了java面向对象编程中最常见的用法：一个类继承一个父类，同时实现多重接口

继承表达的含义是is-a语义，而接口表达的含义是具有XXX特性

青蛙是一种动物，既能跑也能游泳

这样设计的好处，牢记多态的好处：让程序猿忘记类型。有了接口以后，类的使用者就不必关心具体类型，而只关注某个类是否具备某种能力

（6）接口间的继承

接口和接口之间可以多继承，即：用接口可以达到多继承的目的

接口可以继承一个借口，达到服用的效果，使用extends关键字

interface IRunning{
    void run();
}

interface ISwimming{
    void swim();
}

//两栖的动物，既能跑也能游泳
interface IAmphibious extends IRunning,Swimming{

}

class Frog implements IAmphibious{
...
}

接口的继承相当于把多个接口和并在一起