Java_抽象类和接口（一）

爱塔居

已于 2022-11-19 10:28:54 修改

阅读量333

点赞数 3

分类专栏： JavaSE 文章标签： java

于 2022-11-19 10:28:37 首次发布

本文链接：https://blog.csdn.net/m0_65683419/article/details/127923633

版权

JavaSE 专栏收录该内容

13 篇文章 23 订阅

订阅专栏

作者：爱塔居的博客_CSDN博客-JavaSE领域博主

专栏：JavaSE

作者简介：大三学生，希望跟大家一起进步！

文章目录

一、抽象类

1.1 抽象类概念

抽象类：一个类中没有包含足够的信息来描绘一个具体的对象。

class Shape{
    public void shape(){
        System.out.println("画图形");
    }
}
class Star extends Shape{
    @Override
    public void shape() {
        System.out.println("⭐");
    }
}
class Heart extends Shape{
    @Override
    public void shape() {
        System.out.println("❤");
    }
}
class Sun extends Shape{
    @Override
    public void shape() {
        System.out.println("☀");
    }
}
class Main{
    public static void main(String[] args) {
Shape shape=new Star();
shape.shape();
    }
}

比如这个代码中的，Shape类。虽然Shape类中也存在shape的方法，但是Shape类不是具体的图形，因此其内部的shape方法实际是无法实现的，因此可以被设计为“抽象类”。

1.2 抽象类语句

🎊在java中，一个类如果被abstract修饰称为抽象类。抽象类中被abstract修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

abstract class Shape{//抽象类
   public abstract void shape();//抽象方法
}
class Star extends Shape{
    @Override
    public void shape() {
        System.out.println("⭐");
    }
}
class Heart extends Shape{
    @Override
    public void shape() {
        System.out.println("❤");
    }
}
class Sun extends Shape{
    @Override
    public void shape() {
        System.out.println("☀");
    }
}
class Main{
    public static void main(String[] args) {
    Shape shape=new Star();
    shape.shape();
    }
}

1.3 抽象类特性

🎀1.抽象类使用abstract修饰类

2.抽象类不能被实例化

abstract class Shape{//抽象类
   public abstract void shape();//抽象方法
}

class Main{
    public static void main(String[] args) {
    Shape shape=new Shape();//实例化抽象类
    }
}

编译错误：

3.在抽象类当中，可以有抽象方法或者非抽象方法。抽象类当中不一定有抽象方法。

4.抽象方法：一个方法被abstract修饰，没有具体的实现。只要包含抽象方法，这个类必须是抽象类

5.当一个普通类继承了这个抽象类，必须重写类当中的抽象方法。当一个子类没有重写抽象的父类的方法，可以把当前子类变成abstract修饰。

abstract class Shape{
public abstract void shape();
}
abstract class Star extends Shape{
//public void shape(){
//    System.out.println("⭐");
//}
}
class C extends Star{
    public void shape(){
        System.out.println("⭐");
    }
}
class Main{
    public static void main(String[] args) {
     Shape star=new C();
     star.shape();
    }
}

6.抽象类存在的最大意义是为了被继承。

7.抽象方法不能被private，final，static修饰，否则无法被重写

abstract class Shape{
   private abstract void shape();
}
class Star extends Shape{
    @Override
    public void shape() {
        System.out.println("⭐");
    }
}

class Main{
    public static void main(String[] args) {
    Shape shape=new Star();
    }
}

编译错误：

8.抽象类中可以有构造方法。

1.4 抽象类和普通类的区别

🍓1.抽象类不能实例化，普通类可以

2.抽象类当中，可以包含非抽象类方法和抽象类方法。而普通类只能包含非抽象方法

1.5 抽象类的作用

抽象类本身不能被实例化 , 要想使用 , 只能创建该抽象类的子类 . 然后让子类重写抽象类中的抽象方法。所以，使用抽象类相当于多了一重编译器的校验。🍏实际工作不应该由父类来完成，而应由子类完成。如果不小心误用成父类了 , 使用普通类编译器是不会报错的。但是父类是抽象类就会在实例化的时候提示错误 , 让我们尽早发现问题。

二、接口

2.1 接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB接口，电源插座等。

电脑的USB接口上，可以插:U盘、鼠标、键盘……所有符合USB协议的设备

电源插座插孔上，可以查：电脑、电视机、电饭煲……等所有符合规范的设备

通过上述例子可以看出：接口就是公共的行为规范标准。大家在实现时，只要符合规范标准，就可以通用。

🍰在java中，接口可以看成是多个类的公共规范，是一种引用数据类型。

2.2 语法规则

interface 接口名称{

//抽象方法

public abstract void method1();//public abstract 是固定搭配，可以不写

public void method2();

abstract void method3();

void method4();

//注意：在接口中上述写法都是抽象方法，更推荐mothod4，代码更简洁
}

🌮注意：

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

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

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

2.3 接口使用

class 类名称 implement 接口名称{

……

}

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

interface USB{//建立接口
    void openDevice();//抽象方法
    void closeDevice();
}
 class Mouse implements USB{//使用接口
    @Override//重写USB类中的抽象方法
    public void openDevice() {
        System.out.println("开机");
    }
     public void closeDevice() {
         System.out.println("关机");
     }
}
public class Computer {//测试接口
    public static void control(USB usb){
        usb.openDevice();
        usb.closeDevice();
    }
    public static void main(String[] args) {
    USB usb=new Mouse();
    control(usb);
    }
}

2.3 接口特性

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

interface USB{//建立接口
    void openDevice();//抽象方法
    void closeDevice();
}
 class Mouse implements USB{//使用接口
    @Override//重写USB类中的抽象方法
    public void openDevice() {
        System.out.println("开机");
    }
     public void closeDevice() {
         System.out.println("关机");
     }
}
public class Computer {//测试接口
    public static void control(USB usb){
        usb.openDevice();
        usb.closeDevice();
    }
    public static void main(String[] args) {
    USB usb=new USB();
    }
}

编译错误：

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

我们可以看到第二行的代码，我多写了public abstract ，然后它变灰色的，这就说明已经默认接口中的方法是public abstract修饰的。

第三行代码，我把public 改成了protect,然后编译错误。

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

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

interface USB{//建立接口
   int a=1;
   void openDevice();//抽象方法
    void closeDevice();
}
 class Mouse implements USB{//使用接口
    @Override//重写USB类中的抽象方法
    public void openDevice() {
        System.out.println("开机");
    }
     public void closeDevice() {
         System.out.println("关机");
     }
}
public class Computer {//测试接口
    public static void control(USB usb){
        usb.openDevice();
        usb.closeDevice();
    }
    public static void main(String[] args) {
    USB usb=new Mouse();
    USB.a=3;
    }
}

编译错误：

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

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

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

8.在jdk8中，接口中还可以包含default方法

这个样子，接口中的方法，写了内容也不会报错了。

2.5 实现多个接口

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

class Animal{
 String name;
    public Animal(String name) {
        this.name = name;
    }
    public void fly(){
        System.out.println(name+"会飞");
    }
    public void run(){
        System.out.println(name+"会跑");
    }
}
interface Irunning{
    void run();
}
interface Iflying{
    void fly();
}
interface Isiwmming{
    void swim();
}
class Bird extends Animal implements Iflying {
    public Bird(String name) {
        super(name);
    }
 public void fly(){
     System.out.println(name+"会飞");
 }
}
class Rabbit extends Animal implements Irunning {
    public Rabbit(String name) {
        super(name);
    }
    public void run(){
    System.out.println(name+"会跑");
}
}
class Flog extends Animal implements Irunning,Isiwmming{
    public Flog(String name) {
        super(name);
    }
    public void run(){
        System.out.println(name+"会跑");
    }
    public void swim(){
        System.out.println(name+"会游泳");
    }
}
public class Test {
    public static void fly(Bird bird){
        bird.fly();
    }
    public static void run(Rabbit rabbit){
        rabbit.run();
    }
    public static void run(Flog flog){
        flog.run();
    }
    public static void swim(Flog flog){
        flog.swim();
    }
    public static void main(String[] args) {
Bird bird=new Bird("小鸟");
fly(bird);
Rabbit rabbit=new Rabbit("小兔子");
run(rabbit);
Flog flog=new Flog("小青蛙");
run(flog);
swim(flog);
    }
}

输出结果：

三、抽象类和接口的区别

抽象类和接口都是 Java 中多态的常见使用方式 . 都需要重点掌握 . 同时又要认清两者的区别 ( 重要 !!! 常见面试题 ).

🍝

核心区别 : 抽象类中可以包含普通方法和普通字段 , 这样的普通方法和字段可以被子类直接使用 ( 不必重写 ), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法

总结

爱塔居

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java_抽象类和接口（一）

抽象类：一个类中没有包含足够的信息来描绘一个具体的对象。比如这个代码中的，Shape类。虽然Shape类中也存在shape的方法，但是Shape类不是具体的图形，因此其内部的shape方法实际是无法实现的，因此可以被设计为“抽象类”。🎊在java中，一个类如果被abstract修饰称为抽象类。抽象类中被abstract修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。1.3 抽象类特性编译错误： 4.抽象方法：一个方法被abstract修饰，没有具体的实现。只要包含抽象方法，这
复制链接

扫一扫