java中的抽象类和接口

最新推荐文章于 2024-09-17 11:50:15 发布

有幸相识

最新推荐文章于 2024-09-17 11:50:15 发布

阅读量69

点赞数 9

分类专栏： javase 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_53029014/article/details/134489859

版权

javase 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

在前面的章节我们分别学习了面对对象的三大特性：封装、继承、多态。接下来我将为大家讲解java中的抽象类和接口。

文章目录

1. 抽象类

1.1 抽象类概念

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

abstract class Shape{
    abstract public void draw();
}
class Rect extends Shape{

    @Override
    public void draw() {
        System.out.println("画矩形");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("画圆圈");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("画❀");
    }
}

public class Test {
    public static void func(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
       func(new Cycle());
       func(new Rect());
       func(new Flower());
    }
}

在上述代码中，把shape定义为抽象类，当我们想要抽象类当中的方法没有具体的实现，我们就可以把这个方法用abstract修饰。以后我们可以这种没有实际工作的方法设计成一个抽象方法，包含抽象方法的类叫做抽象类。

1.2抽象类的特性

1、抽象类不能直接进行实例化对象。
2、抽象方法不能是private的。
3、抽象方法不能被final和static修饰，因为抽象方法要被子类重写。
4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰。
5. 抽象类当中可以有和普通类当中一样的成员变量和成员方法。
6. 被abstract修饰的方法叫做抽象方法，没有具体的实现。
7. 如果一个类包含了这个抽象方法，此时这个类也必须得用abstract修饰，此时这个类叫做抽象类。
注意：抽象类当中可以包含构造方法，这个构造方法并不是在这个实例化这个抽象类的时候使用，因为他不能够被实例化，那么这个构造方法主要用于子类是在子类当中让子类调用，帮助父类进行初始化。

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Student extends Person {
    public Student() {
        super("沸羊羊",10);
    }
}

1.3抽象类和普通类

1、都有成员变量和成员方法。
2、抽象类多了抽象方法。
3、抽象类不能被实例化。

2.接口

2.1接口的概念

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

2.2接口的特性

1、定义接口的时候使用关键字interface来定义
2、接口当中的方法如果没有被实现，那么他就默认是一个抽象方法
3、接口当中的方法，不能有具体的实现
4、如果要有具体的实现，那么必须是有default修饰或者是由是static修饰
5、接口当只定义成员边变量，默认都是public static final修饰的
6、接口当中的抽象方法默认都是public abstract修饰的
7、接口不能被实例化
8、类和接口之间的关系可以用implement来关联
9、接口也是可以产生字节码文件的
10、一个类可以继承一个抽象类/普通类，同时可以实现这个接口

3.3接口的使用

package demo3;

public interface IUSB {
    void openDevice();
    void closeDevice();
}

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

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

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

public class Computer {
    public void poweron(){
        System.out.println("打开笔记本电脑");
    }
    public  void poweroff(){
        System.out.println("关闭笔记本电脑");
    }
    public void useDevice(IUSB iusb){
        iusb.openDevice();
        if (iusb instanceof Mouse){
            Mouse mouse = (Mouse)iusb;
            mouse.click();
        } else if (iusb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) iusb;
            keyBoard.inPut();
        }
        iusb.closeDevice();
    }
}

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.poweron();

        computer.useDevice(new Mouse());
        computer.useDevice(new KeyBoard());
        computer.poweroff();
    }
}

以上代码就是接口的基本使用方法，我们首先可以创建一个IUSB接口，然后分别创建一个鼠标类和键盘类去实现这个接口，我们还可以创建一个笔记本电脑类，用于使用usb设备，然后我们可以创建有个Test类进行测试。
注意：在useDevice当中，有的方法是键盘类和鼠标类自己独有的方法，不能由父类引用去直接访问，所以此时我们应该进行判断。（具体请看上节所讲的多态）

3.4实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。
如下代码:

public abstract class Animal {
    public String name;

    public Animal(String name) {
        this.name = name;
    }
    //
    public abstract void eat();
}

public interface IFly {
    void fly();
}

public interface IRun {
    void run();
}

public interface ISwim {
    void swim();
}

public class Bird extends Animal implements IRun,IFly{
    public Bird(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃鸟粮");
    }

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

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

public class Dog extends Animal implements IRun,ISwim {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃狗粮");
    }

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

    @Override
    public void swim() {
        System.out.println(this.name+"正在狗爬式游泳");
    }
}

public class Test {
    public static void func1(Animal animal) {
        animal.eat();
    }

    public static void testFly(IFly iFly) {
        iFly.fly();
    }

    public static void testRun(IRun iRun) {
        iRun.run();
    }

    public static void testSwim(ISwim iSwim) {
        iSwim.swim();
    }

    public static void main(String[] args) {
        testRun(new Bird("百灵"));
        testSwim(new Dog("旺财"));
    }
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.
这样的设计可以让我们时刻牢记多态的好处，还可以让我们忘记类型有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.

3.5接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

public interface IAmphibious extends IRun,ISwim{
 void test1();
}

public class Frog extends Animal implements IAmphibious{
    public Frog(String name) {
        super(name);
    }

    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void swim() {

    }

    @Override
    public void test1() {

    }
}