Java的抽象类和接口

🎉🎉🎉哈喽！！！大家好，这里是   我不是小明同学

🎆欢迎各位小伙伴关注➕点赞➕留言➕收藏

🎆我坚信努力奔跑才能与幸运不期而遇。

🎆🎉🎉🎉作者知识水平有限，若有什么错误或者需改进之处希望大家指出，若是你有更好的代码希望能给博主留言，博主希望能在CSDN与各位一起进步。

目录

抽象类

抽象类语法

抽象类特性

接口

语法规则

接口使用

接口的特性

实现多个接口

接口间的继承

---

抽象类

在解决实际问题时，我们一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。

在Java中使用abstract关键字定义的类成为抽象类，使用abstract关键字定义的方法称为抽象方法。

抽象类语法

// 抽象类：被abstract修饰的类
public abstract class Shape {
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
    return area;
}
protected double area; // 面积
}

抽象类特性

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

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

2.抽象方法不能是private的，抽象方法在没有加访问限定符时，默认是public

abstract class Shape {
    abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

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

public abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
}
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static

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

// 矩形类
public class Rect extends Shape {
    private double length;
    private double width;
    Rect(double length, double width){
        this.length = length;
        this.width = width;
    }
    public void draw(){
        System.out.println("矩形: length= "+length+" width= " + width);
    }
    public void calcArea(){
        area = length * width;
    }
}

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

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

接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。

语法规则

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

public interface 接口名称{
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();
    // 注意：在接口中上述写法都是抽象方法，更推荐方式4，代码更简洁
}

 注意：

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

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

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

接口使用

接口不能直接使用，需要通过类来“实现”接口，实现接口中的所有抽象方法。

 public class 类名称 implements 接口名称{

        // ...

}

 注意：子类和父类之间是 extends 继承关系，类与接口之间是 implements 实现关系

接口的特性

1.接口类型是一种引用类型，但是不能直接 new 接口的对象

public class TestUSB {
    public static void main(String[] args) {
        USB usb = new USB();
    }
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

2.接口中每一个方法都是 public 的抽象方法，即接口中的方法会被隐式的指定为public abstract（无法被其他修饰符修饰）

public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
}

3.接口中的方法不能在接口中实现，只能由实现接口的类来实现

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

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

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

    // ...
}

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

5.接口中可以含有变量，但是接口中的变量会被隐式的指定为public stati final变量

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

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

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

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

实现多个接口

Java中不允许出现多继承，但是使用接口就可以实现类似于“多继承”的效果。一个类可以同时实现多个接口，因此可以将所有需要继承的接口放置在 implements 关键字后并使用逗号隔开。实现多个接口的语法如下：

class 类名 implements 接口1，接口2，...，接口n

接下来我们看一个例子：

 我们先定义一个动物类

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }
}

然后我们再提供一组接口，分别表示 "会飞的", "会跑的", "会游泳的".

interface IFlying {
    void fly();
}

interface IRunning {
    void run();
}

interface ISwimming {
    void swim();
}

接下来我们创建几个具体的小动物

例如狗，会跑会游泳

class Dog extends Animal implements IRunning,ISwimming {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(name+"正在用四条腿跑");
    }

    @Override
    public void swim() {
        System.out.println(name+"正在用四条腿狗刨");
    }
}
public class Test {

    public static void main(String[] args) {
        Dog dog=new Dog("狗子");
        dog.run();
        dog.swim();
    }
}
//执行结果
狗子正在用四条腿跑
狗子正在用四条腿狗刨

鸭子不仅会跑，会游泳而且会飞

abstract class Animal {
    public String name;

    public Animal(String name) {
        this.name = name;
    }
}
interface IRunning {
    void run();
}

interface ISwimming {
    void swim();
}

interface IFly {
    void fly();
}
class Duck extends Animal implements IRunning,ISwimming,IFly {
    public Duck(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(name+"正在用两条腿跑");
    }

    @Override
    public void swim() {
        System.out.println(name+"正在用大脚掌游泳");
    }

    @Override
    public void fly() {
        System.out.println(name+"正在飞");
    }
}
public class Test {

    public static void main(String[] args) {
        Duck duck=new Duck("鸭子");
        duck.fly();
        duck.run();
        duck.swim();
    }
}
//执行结果
鸭子正在飞
鸭子正在用两条腿跑
鸭子正在用大脚掌游泳

有人可能会说干嘛用接口，我直接在父类Animal中实现fly、run、swimming这些属性，
然后不同的动物子类再继承父类这些方法不行吗？ 但问题是，鸭子会fly、swimming，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了，只要一个子类有这种行为，他就可以实现相对应的接口，接口是更加灵活的。

接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到 多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}

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

}

class Frog implements IAmphibious {
    ...
}