【JAVA |抽象类和接口】JAVA中的抽象类和接口 纯干货！！！

✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨ 
🎈🎈作者主页： 🎈丠丠64-CSDN博客🎈

✨✨ 帅哥美女们，我们共同加油！一起进步！✨✨ 

目录

目录

一、前言

二、抽象类

1.abstract

2.抽象的类特性

三、接口

1.interface

2.接口的使用

3.接口的特性

4.多接口

5.接口的继承

---

一、前言

接口提供了一种抽象的方法定义和类型规范，可以帮助我们实现代码的灵活性、可扩展性和可维护性，接口可以看作是一种合约或协议，规定了类应该实现哪些方法。

---

二、抽象类

在面对对象的这个概念中，所有的对象都是通过类来描述的，但是并不是所有的类都是用来描述对象的，如果一个类中没有包含足够多的信息来描述一个具体对象的话，这样的类就是抽象类，主要作用还是为了编译器的检验防止我们出错

---

就好比这个Animal动物的类，名字，年龄，睡觉，这是所有动物的共性，并不能描述具体对象，像这样的类，我们就可以设置为抽象类

class Animal{

    public String name;
    public int age;

    public void sleep(){
        System. out. println("睡觉”);
    }
}

---

1.abstract

抽象类也是类，内部不仅仅包含了构造方法，普通方法跟属性，同时也有独有的抽象方法；

抽象类中可能不包含抽象方法，但有抽象方法一定是抽象类。

我们把用被 abstract 关键字修饰的类或方法称为抽象类和抽象方法

就好比下述代码

//抽象类
abstract class Animal{

    public String name;
    public int age;

//抽象方法(没有方法体)
    abstract public void sleep();
}

用abstract 关键字修饰后的Animal类跟sleep方法就变成了抽象类和抽象方法

---

2.抽象的类特性

抽象类不能够实例化对象，当实例化一个抽象类对象的时候编译器会报错

public static void main(String[]args){

    Animal animal = new Animal();
}

---

抽象方法访问权限不能是private，同时不能被final跟static修饰，因为抽象方法必须被子类重写

abstract class Animal{
    public String name;
    public int age;

    abstract private void sleep1();

    abstract public final void sleep2();

    abstract public static void sleep2()

}

---

抽象类存在的意义必须被继承，继承的子类要重写父类中的方法，不然便会报错（可以给子类加private，意为子类也为抽象类）

abstract class Animal{
    public String name;
    public int age;

    abstract public void sleep();
}

class Dogl extends Animal{
}

class Dog2 extends Animal{

    @0verride
    public void sleep(){
    //重新方法
    }
}

abstract class Dog3 extenas An1mal{
}

Dog1方法中继承了父类但未重写于是报错，Dog2方法中对父类的抽象方法进行了重写正常编译，Dog3中加入了abstract 使得其也为抽象类。

---

三、接口

接口就是公共行为的行为规范标准，大家在实现它的时候只要符合规范标准，就可以一起使用，在JAVA中接口可以看成是：多个类的公共规范，是一种引用数据类型。  

---

1.interface

接口定义的方式与类相同，只不过把关键字class替换成了关键字interface，就定义了一个接口

就像下面这样我们定义了一个叫IUSB的接口

public interface IUSB{
    int key= 123;

    void openDevice();
    void closeDevice();
}

接口中的变量会被隐式指定为public static final，一般可以省略；接口中的方法会被隐式指定为public abstract，一般可以省略。

public interface IUSB{
    public static final int key= 123;

    public abstract void openDevice();
    public abstract void closeDevice();

}

---

2.接口的使用

方法不能够直接去使用，必须有一个实现类来实现该接口，接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

类与接口之间是 implements 实现关系

比如下面这个代码KeyBoard方法就是一个实现类，可以在类中实现自己的方法但必须重写接口的所有抽象类，不然会报错

public class KeyBoard implements IUSB{

}

这样就正常编译

public class KeyBoard implements IUSB {

    @Override
    public void openDevice(){
        System.out.println("打开键盘");
    }
    
    @0verride
    public void closeDevice(){
    System. out.println("关闭键盘");
    }
    
    public void inPut(){
    System.out.println("键盘输入")
    }
}

---

3.接口的特性

接口类型也是一种引用的数据类型，不能够实例化对象，当实例化一个抽象类对象的时候编译器会报错

public static void main(String[] args){
    IUSB usb = new IUSB();
}

---

在重写接口中的方法时必须使用public，因为实现类中访问权限要小于等于接口类，而接口默认的方法为public

我们可以看出来，在重写方法时不带访问权限或者带private均会报错，只能使用public

class A implements IUSB {

    @0verride
    private void openDevice(){
    }

    @0verride
    void openDevice(){
    }

    @0verride
    public void closeDevice(){
    }
}

 

---

接口中不能带有静态代码块跟构造方法，否则会报错

public interface IUSB{
    static{
        System.out.println("我是静态代码块");
    }

    public IUSB() {
        System. out.println("我是构造方法")
    }

        void openDevice();
        void closeDevice();
}

---

4.多接口

我们都知道在JAVA中的类不能实现多继承，但是一个类能实现多接口!

我们拿一段代码 举例子，首先构造出一个父类

public class Animal{
    protected String name;

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

再构造出几个接口

public interface ISwimming{
    void swim();
}

public interface IRunning {
    void run();
}

public interface IFlying{
    void fly();
}

构造一下实现类并且继承父类Animal

猫只能跑，所以用IRunning接口

public class Cat extends Animal implements IRunning{

    public Cat(String name){
        super(name);
    }

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

鱼只能游，所以用ISwimmin接口

public class Fish extends Animal implements ISwimming{

    public Fish(String name){
        super(name);
    }

    @Override
    public void swim(){
        System.out.println(this.name +"正在用鱼尾游");
    }
}

青蛙能游能跑，所以用ISwimmin接口和IRunning接口

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

    @0verride
    public void run(){
        System.out.println(this.name + "正在用蛙腿跑");
    }

    @Override
    public void swim(){
        System. out.println(this.name + "正在用蛙腿游");
    }
}

鸭子能游能跑能跳，所以用ISwimmin接口、IRunning接口和IFlying接口

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

    @Override
    public void fly(){
        System.out.println(this.name + "正在用鸭翅膀飞");
    }

    @0verride
    public void run(){
        System.out.println(this.name + "正在用鸭腿跑");
    }

    @0verride
    public void swim(){
        System.out.println(this.name + "正在用鸭腿游");
    }
}

当然也可以不继承父类的单独的一个类也是可以使用接口

机器人可以跑，所以用IRunning接口

public class Robot implements IRunning{
    private String name;

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

    @Override
    public void run(){
        System.out.println(this.name +"正在用机械腿跑”)
    }
}

我们来验证一下

public class Test{

    public static void run(IRunning name){
        name.run();
    }

    public static void swim(ISwimming name){
        name.swim();
    }

    public static void fly(IFlying name){
        name.fly();
    }

    public static void main(Stringl args){
        Cat cat = new Cat( name + "小喵");
        Duck duck = new Duck( name + "小鸭");
        Fish fish = new Fish( name + "小鱼");
        Frog frog = new Frog( name + "小蛙");
        Robot robot = new Robot( name + "机器人");

        run(cat):
        run(duck).
        run(frog);
        run(robot):

        swim(duck):
        swim(fish);
        swim(frog);

        fly(duck);
    }
}

验证通过

---

5.接口的继承

当然继承之间也是可以使用继承的

创建一个新接口IAmphibious，相当于把IRunning接口和ISwimmin接口合并在了一起

public interface IAmphibious extends ISwimming,IRunning{
}

---

希望对你有帮助