悟抽象类和接口

最新推荐文章于 2025-12-01 18:34:47 发布

原创最新推荐文章于 2025-12-01 18:34:47 发布 · 120 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

日升时奋斗，日落时自省

一、抽象类

1.抽象类解释

如果一个类中没有包含足够的信息来描绘一个具体的对象，就是抽象类

下面来代码解释：

每段代码后上已经注释了方法

（1）抽象类中，可以有抽象方法也可以没有抽象方法

（2）抽象类中，可以有普通方法

（3）抽象类中，也可以有抽象的成员变量

以上注意都是不会报错的，抽象方法与普通方法也没有差个啥，就是多了个abstract修饰，有区别，之后应用请看下面哈

2.抽象类的实例化

首先看图呢，抽象类是不能实例化的，这下我们就要想别的办法了

这里采用继承

（4）这里的继承又为什么会报错呢，这里就需要注意了，在我们继承抽象类时，需要把抽象方法进行重写（继承了就要被重写）

这样就好了

抽象类继承的一个使用例：

/**
 * Created with IntelliJ IDEA.
 * Description:
 * user: TR
 * Date: 2022-08-09
 * Time: 11:04
 */
abstract class Shape{   //抽象类  就是   普通类前面加一个abstract

    public static String name="list";  //抽象的成员变量

    public  abstract void func1();    //抽象方法

    public void func2(){     //普通方法

    }
}
class  Pig extends  Shape{    //继承抽象类

    @Override
    public void func1() {    //需要重写继承抽象类的方法
        System.out.println("小猪猪");
    }
}
class Dog extends Shape{

    @Override
    public void func1() {
        System.out.println("小狗狗");
    }
}
class Tiger extends  Shape{

    @Override
    public void func1() {
        System.out.println("小老虎");
    }
}

public class Test {
    public static  void practice(Shape shape){
        shape.func1();
    }
    public static void main(String[] args) {
        Shape Dog=new Dog();
        practice(Dog);    //可以调用实例化引用
        practice(new Dog());    //也可以直接使用匿名对象    在这里结果都是一样的

        practice(new Pig());
        practice(new Tiger());

    }
}

运行结果：

这里我们就使用了抽象类，做一个转接，继承之后，我们每次都是找到我们需要的类和方法，那普通类也可以继承，同样也可以重写，你说是不是抽象类就是一无是处

（5）其实不然：抽象类能够直接通过java编译，检查到你有没有进行重写，而普通类就不会，如果出现问题，也不容易发现，所以抽象类也是为了避免bug，直接让编译器就解决了

3.抽象类的特点

（6）抽象类是不能用private访问的

抽象类是要拿来继承的，所以懂哈..........用private访问之后，普通类就不能访问了，默认是public权限访问，要满足重写的规则

（7）注意：static，final是不能和abstract写在一起，是矛盾的

4.抽象类继承抽象类

二、接口

1.接口语法

接口解释：它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

简单点说：多个类的公共规范，是一种引用数据类型

（1）接口修饰：interface

（2）接口的成员方法，不能具体实现

（3）接口的固定修饰（如下代码）

（4）这里提及到了方法的使用有一个报错的

解释这个报错：这里方法上能看到吧，是有一点点的区别的，default修饰的才能在接口中正常使用该方法哈

2.接口使用

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

简单的使用一个使用例：

这里有个新的东西就是implement这个修饰，是实现用来实现接口的，这里接口处都有在用

interface Control{    //接口
    void openDevice();    //接口的方法  记得继承的时候要重写哈
    void closeDevice();
}
class Refrigeration implements Control{   //制冷接口
    public void openDevice(){     // 重写接口的方法
        System.out.println("打开制冷");
    }
    public void closeDevice(){
        System.out.println("关闭制冷");
    }
    public void cold(){
        System.out.println("送风制冷");
    }
}
class Timing implements Control{   //空调定时接口

    @Override
    public void openDevice() {     //重写接口的方法
        System.out.println("打开定时");
    }

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

    public void timingLength(){
        System.out.println("定时时长");
    }
}
class AirConditioner{     //空调控制接口
    public void poweropen(){                
        System.out.println("打开空调");
    }
    public void poweroff(){
        System.out.println("关闭空调");
    }
    public void controlDevice(Control control){
        control.openDevice();
        //我们使用该类，就要确定control是否在Refrigeration类下
        if(control instanceof Refrigeration){             
            //强制转换的就是Refrigeration中有一个自己的方法是不能通过control调用的  如：cold方法
            Refrigeration refrigeration=(Refrigeration) control;
            ((Refrigeration) control).cold();
        }else if(control instanceof Timing){   //同上
            Timing timing=(Timing) control;
            ((Timing) control).timingLength();
        }
        control.closeDevice();
    }
}
public class Test {    //测试类
    public static void main(String[] args) {
        AirConditioner airConditioner=new AirConditioner();
        airConditioner.poweropen();    

        airConditioner.controlDevice(new Refrigeration());

        airConditioner.poweroff();
    }
}

上面的东西就靠注释解释啦，可以尝试一下