Java基础语法之抽象类和接口

发布时间:2023年12月17日

抽象类

什么是抽象类

并不是所有的类都是用来描述对象的,这样的类就是抽象类

例如,矩形,三角形都是图形,但图形类无法去描述具体图形,所以它的draw方法无法具体实现,这个方法就可以没设计成抽象方法,这个类就是抽象类

抽象类语法

被abstract修饰的类是抽象类,abstract修饰的方法是抽象方法,抽象方法不用给出具体的实现体?

如上,draw方法没有具体实现体,也就是不用写代码块

继承了抽象类的子类必须重写所有的抽象方法。如下:

如何使用该抽象类及其子类

这就是一种使用方法,在main函数中调用了Test中的静态方法draw(注意一定要是静态的,在静态方法中不可以调用非静态方法,因为非静态方法的调用依赖对象,而静态方法不依赖对象,所以静态方法默认没有this参数,也就无法调用非静态方法)

draw方法的参数是Shape类,而我们传参时传的是其子类,这里就发生了向上转型;

在draw方法中调用shape.draw()时,又会发生动态绑定;

总之这也是多态。

抽象类的特性

1.不能实例化本抽象类的对象

但是可以用它实例化一个子类对象,也就是可以发生向上转型

因为向上转型后,对象的本质还是其子类,只不过用父类来接收了,并不代表实例化了一个父类对象。

2.抽象方法不可以是private权限,也不可以被final,static修饰

首先,子类重写方法的访问权限要大于等于父类;

其次,final修饰的方法是静态方法,static修饰的方法在方法区;

总之,被private,final,static修饰的方法不可以被重写

3.继承抽象类的子类必须重写其方法,否则子类也要被abstract修饰,然后它的继承者要将其父类以及父类的父类中所有的抽象方法重写

4.抽象类中不一定有抽象方法,但由抽象方法的一定是抽象类

5.抽象类中也可以有普通方法和成员

但它里面的普通成员变量及方法只能通过子类对象来调用

其中,shape引用是发生了向上转型的,而reck就是一个子类的引用,由于有继承关系,所以可以通过子类引用来调用抽象类的方法

6.抽象类中可以有构造方法,供子类创建对象时初始化父类的成员变量,但注意,构造方法不能是抽象方法,因为构造方法不可以被重写

抽象类的作用

很多工作不应由父类完成,而应由子类来完成,但如果是一个普通类,用父类的引用去调用某些方法时就不会报错,而要是抽象类就会报错

就比如画图,你要是用父类shape来调用draw方法,如果不是抽象类就能正常编译,但由于图形有很多种,所以shape这个引用画不出具体的图形;而要是抽象类就会及时报错,提醒你调用具体的子类来画图

接口

什么是接口

接口就是公共的行为标准,大家在实现时,只要符号规范标准就可以通用。

具体点说,接口就是多个类的公共规范,是一种引用数据类型。

语法规则

接口要用interface关键字定义,内部是抽象方法;例如:

接口的使用

有了接口就必须要有具体的类来使用这就要用到implements关键字

public class 类名 implements 接口名{

}

如果这个类还和其他类由继承关系,则应该:

public class 类名 extends 父类名 implements 接口名{

}? ?表示该子类继承了某个类并且还有某个功能

既然都有继承关系了,为什么还要有接口呢?一个父类可以引出多个子类,它们都是由共性的,但也有特性,这些特性就不适合写在父类里面,这时就可以提供接口,有什么功能就使用什么接口

举例:

接口的特性

1.接口默认是被abstract修饰的,因为它里面有抽象方法

 interface USB等价于abstract interface USB

2.接口中的方法默认是被public abstract修饰的(也只能是这种权限,其他的都会报错)

void func();? 等价于public abstract void func();

这也好理解,接口是一种公共标准,一定得是公开的抽象的

3.接口是一种引用类型,但不能直接new一个接口对象

4.接口中可以有成员变量,但这些变量默认是public static final修饰的。既然默认被final修饰了,那么在定义的时候就必须初始化

首先? int a=10;等价于public static final int a=10;

其次,不可以直接int a;必须初始化

5.接口中一般不可以有普通方法,但被static default修饰的方法除外

但注意:static void func(){}等价于public?static void func(){},不可以改成除public的其他权限,default也一样

对于被static修饰的方法,可以直接用接口名调用,而default修饰的方法只能用子类对象调用或者被重写

例如:

package Demo2;
interface A{
    void Testa();
    static void Testb(){
        System.out.println("A 的static方法");
    }
    default void Testc(){
        System.out.println("A的default方法");
    }
}
class B implements A{
    @Override
    public void Testa() {
        System.out.println("B重写的testa方法");
    }

    @Override
    public void Testc() {
        A.super.Testc();
    }
}

public class Test {
    public static void main(String[] args) {
        A.Testb();
        B b=new B();
        b.Testa();
        b.Testc();
    }
}

用static修饰的方法可以在main中直接用接口名调用,但default方法要么被重写,要么用子类实例化的对象来调用

6.重写接口中的抽象方法时,只可以设置为public权限,因为接口中的抽象方法默认是public的,所以子类的方法权限要大于等于public

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

8.如果它的子类没有重写抽象方法,那这个类必须设置为抽象类

举例

abstract interface USB{
    void openDevice() ;

    void closeDevice();
}
class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }
    public void click(){
        System.out.println("疯狂点击鼠标");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
}
class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }
    public void input(){
        System.out.println("疯狂打字");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
}
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 Test {
    public static void main(String[] args) {
        Computer computer=new Computer();
        computer.powerOn();
        KeyBoard keyBoard=new KeyBoard();
        Mouse mouse=new Mouse();
        computer.useDevice(keyBoard);
        computer.useDevice(mouse);
        computer.powerOff();
    }
}

如上,电脑有usb接口,可以实现打开关闭键盘鼠标的操作

注意,电脑本身不需要usb接口来打开,所以电脑是一个独立的类,它通过自己的powerOn powerOff 方法来打开,然后它又有使用设备的方法,然后就是设备要通过usb接口来打开关闭,即usb.openDevice(); usb.closeDevice();但是在打开后,还要工作,可是只用USB类无法调用设备独有的功能,所以发生了向下转型,注意instanceof的判断和括号的类型强转

然后在main函数中,首先实例化一个电脑对象,将电脑打开,再实例化键盘和鼠标,然后就是电脑要开始使用设备了,调用useDevice函数(这里发生了向上转型,因为是用USB这个引用去接收各种需要USB的对象)。最后就关闭电脑

实现多个接口

在Java中,类和类之间只能单继承,一个类只能有一个父类,但是一个类可以有多个特殊的功能,即一个类可以有多个接口

class 类名 implements 接口1,接口2

例如:青蛙会跑也会游泳,鸭子会跑会游泳也会飞,如下

class Animal{
    String name;
    int age;
    public void eat(){
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
 interface Running{
    public abstract void run() ;
}
interface Swimming{
    public abstract void swim();
}
interface Flying{
    public abstract void fly();
}
class Dog extends Animal implements Running{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void run() {
        System.out.println("正在用囧囧跑步步");
    }

    @Override
    public void eat() {
        System.out.println("吃狗粮");
    }
}
class Flog extends Animal implements Running,Swimming{
    @Override
    public void run() {
        System.out.println("正在用俩只大脚掌跑步步");
    }
    @Override
    public void swim() {
        System.out.println("正在用那小手手游泳");
    }
    public Flog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃蛙粮");
    }
}
class Duck extends Animal implements Running,Flying,Swimming{
    @Override
    public void run() {
        System.out.println("正在小跑");
    }
    @Override
    public void swim(){
        System.out.println("正在划水");
    }
    @Override
    public void fly() {
        System.out.println("正在扇翅膀飞飞");
    }
    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("正在吃鸭粮");
    }
}

这就是一个典型的例子

那如何使用呢?

在main函数中可以调用这些static修饰的方法。在=========的上方,是多态的典型例子,将子类对象给到父类,再发生动态绑定,调用重写的方法,

在============的下方就是在使用接口了。注意public static void run(Running run),这个方法的参数是Running这个引用类型,当有此功能的对象给到这个引用类型时,就是发生了向上转型,所以在run.run()时,表面上是调用了接口的抽象方法,实际上是在调用子类的重写的方法

其实,只要是有这个功能的类,就可以实现这个接口

接口间的继承

在Java中,类和类之间是单继承的,但接口与接口可以多继承

package Demo4;
interface A {
    void testA();
}

interface B {
    void testB();
}
interface C extends A,B{
    void testC();
    void testA();
}
class TestDemo1 implements C {
    @Override
    public void testC() {

    }

    @Override
    public void testA() {

    }

    @Override
    public void testB() {

    }
}

public class Test {
}

接口举例

comparable

想要比较俩个学生的大小

单纯这样是不行的,我们要指定如何比较,拿什么比较,这就要用到comparable接口

这是一个接口,尖括号里面的T是要比较的数据的类型,如果要比较student,就在里面写student。这个接口里面有一个抽象方法,所以我们要重写这个抽象方法;以用年龄比较为例

注意,尖括号不能省略

但是,如果需求改变,又想用姓名比较,我们就又得把重写的方法改了,而不可以再写一个重写方法(抽象方法只可以被重写一份)很麻烦

所以就有了下面的比较器

comparator

它里面有很多抽象方法,但我们只用到了比较,所以重写比较即可

先看例子

这是年龄比较器,那要是名字比较器呢?不能直接返回o1.name-o2.name,因为name是String类型,不可以相加减。这时就需要用到String下面的compareTo方法

使用的时候就要实例化比较器这个对象

com

上面这个是String类下面的compareTo方法,其实是String类使用了comparable接口,所以重写了comepareTo方法

总结

comparable对类的侵入性比较强,是要比较哪个类,就要让哪个类implements它,是在类里面重写方法。一旦写死了,就只可以用这一种比较方法

comparator更加灵活,只要传入要比较的对象即可,只不过注意要实例化比较器对象因为comparator这是一个接口,里面的抽象方法无法调用,只有放到类里面才能发挥作用,需要我们按自己的意愿重写

再例如

我们可以这样对整型数组排序,那能否对学生数组排序呢?

显然是不可以的,来看一下源码

这里用到了Comparable接口,即将俩个对象强转为了comparable类型,所以要想成功排序,Student类就要使用这个接口,并且重写这个comepareTo方法

然后就可以正常排序了,但最好再自己重写一个toString方法,要不然就会出现上面的打印情况(上面这个最终是调用的object类的toString方法,而object类是所有子类的父类,所以当我们再Student类中重写了方法后就会调用我们自己的方法),如下

其实,sort有很多重载方法,比如下面这个:

它是有俩个参数,其中一个是要排序的数组,另一个就是Comparator这个接口(但不是说要传这个接口,而是要传实现这个接口的类型的引用)

那么我们就可以如下这种方式来排序

总结:

既然对于整型数组可以直接用arrays.sort排序,那就说明一个事实,Integer这个类一定implements了comparable这个接口,我们可以看一下源码:

自己写一个排序方法

因为排序不仅仅是为一个类提供,而是为多个类提供,所以参数要设置成Comparable类的数组,这样的话,只要是实现了这个接口的类,都可以用到这个排序方法。注意,里面的交换语句其实交换的是引用的指向(相当于C语言中指针的指向)。

文章来源:https://blog.csdn.net/zyh20050430/article/details/135028238
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。