JAVASE语法零基础——抽象类和接口

Java系列文章目录

---

Write once,Runanywhere.🔥🔥🔥

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

---

1.抽象类

抽象类概念：在面向对象的思想里，对象都是通过类来描绘的，但是反过来，不是所有的类都能用来描绘对象，当一个类包含的信息不足以描绘一个对象时，这样的类就是抽象类。
比如上一篇多态文章里最后那个画图形的代码：

因此父类Shape里的draw方法可以不用写得具体，因为draw方法实际上总是调用子类重写的draw方法，所以可以将draw方法设计成抽象方法：用abstract修饰的方法，没有具体的实现操作，让子类进行重写。而包含抽象方法的类就是抽象类，也得用abstract修饰。

//被abstract修饰的类为抽象类
abstract class Shape{
    //被abstract修饰的方法为抽象方法 抽象方法---一个方法没有具体的实现
    public abstract void draw();
}
//抽象类是用来被继承的，被继承的抽象类如果包含了抽象方法，那么抽象方法必须重写
class Flower extends Shape{
//重写抽象方法
    @Override
    public void draw() {
        System.out.println("💐");
    }
}

再看下面这张图，就可以很好的了解抽象类了：

2.抽象类语法

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。
1.抽象类也是类，内部可以包含普通方法、属性、构造方法。

//被abstract修饰的类为抽象类
abstract class Shape{
    //成员属性
    public int num;
//构造方法
    public Shape(int num) {
        this.num = num;
    }
    //普通方法
public void fun(){
    System.out.println("普通方法");
}
    //被abstract修饰的方法为抽象方法 抽象方法---一个方法没有具体的实现
    public abstract void draw();
}
//抽象类是用来被继承的，被继承的抽象类如果包含了抽象方法，那么抽象方法必须重写
class Flower extends Shape{
    public Flower(int num) {
        super(num);
    }

    //重写抽象方法
    @Override
    public void draw() {
        System.out.println("💐");
    }
}

public class demo1 {

}

2.抽象类不能实例化对象，抽象类必须用来被继承并且继承后子类要重写父类中的抽象方法。

3.如果子类也是抽象类，子类必须要使用 abstract 修饰,并且可以不用重写父类的抽象方法。

//被abstract修饰的类为抽象类
abstract class Shape{
    //成员属性
    public int num;
//构造方法
    public Shape(int num) {
        this.num = num;
    }
    //普通方法
public void fun(){
    System.out.println("普通方法");
}
    //被abstract修饰的方法为抽象方法 抽象方法---一个方法没有具体的实现
    public abstract void draw();
}
abstract class Smile extends Shape{
    public Smile(int num) {
        super(num);
    }
//不用重写抽象方法
}
}

3.如果是多个抽象类多被重继承之后再被非抽象类继承，则需要重写所有继承的抽象类的所有抽象方法。

//被abstract修饰的类为抽象类
abstract class Shape{
    //成员属性
    public int num;
//构造方法
    public Shape(int num) {
        this.num = num;
    }
    //普通方法
public void fun(){
    System.out.println("普通方法");
}
    //被abstract修饰的方法为抽象方法 抽象方法---一个方法没有具体的实现
    public abstract void draw();
}
abstract class Smile extends Shape{
    public Smile(int num) {
        super(num);
    }
    abstract public void draw1();

}
class Star extends Smile{
    public Star(int num) {
        super(num);
    }

    @Override
    public void draw() {
        System.out.println("😊");
    }

    @Override
    public void draw1() {
        System.out.println("🎇");

    }
}

4.抽象方法不能被 private、final、static修饰，因为被这些关键字修饰的方法不能被重写。注意：抽象方法没有加修饰访问限定符，默认是public。
5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

使用抽象类来实现多态的代码：

//被abstract修饰的类为抽象类
abstract class Shape{
    //成员属性
    public int num;
//构造方法
    public Shape(int num) {
        this.num = num;
    }
    //普通方法
public void fun(){
    System.out.println("普通方法");
}
    //被abstract修饰的方法为抽象方法 抽象方法---一个方法没有具体的实现
    public abstract void draw();
}
class Flower extends Shape{
    public Flower(int num) {
        super(num);
    }

    //重写抽象方法
    @Override
    public void draw() {
        System.out.println("💐");
    }
}

public class demo1 {
    public static void drawMap(Shape shape){//向上转型
        shape.draw();
    }
    public static void main(String[] args) {
        Flower flower = new Flower(1);
        drawMap(flower);

    }

运行结果：

3.抽象类的作用

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。
有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
确实如此， 但是使用抽象类相当于多了一重编译器的校验。

使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的。但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。

4.接口

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
接口比抽象类还要抽象(接口没有实例代码、静态代码块、构造方法)，接口也不能实例化对象，也是通过其他类来实现接口然后重写接口里的抽象方法。

5.接口语法

分为三类：

1.结构实现方面

1.1.接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

interface IShape{
void draw();
}

提示:

1. 创建接口时， 接口的命名一般以大写字母 I 开头。
2. 阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性。

1.2.接口不能直接使用，必须要有一个"实现类"来"实现"该接口(通过关键字implements)，实现接口中的所有抽象方法。

public class 类名称 implements 接口名称{ // ...
}

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
1.3. 接口类型是一种引用类型，但是不能直接new接口的对象

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

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

再被普通类继承则需要重写上面抽象类和接口的抽象方法：

1.6.一个接口可以引用具体实现类，向上转型。

interface IShape{

    int a = 10;
    public static final int b = 10;//成员变量默认
void draw();
//    void fun();
//    public abstract  void fun1();//抽象方法默认

    default public void fun2(){//default 方法 可以有具体实现，可以不被重写

    }
    static public void fun3(){//static方法可以有具体实现，不能被重写

    }
}
abstract class T implements IShape{
    //抽象类可以不重写接口里的抽象方法
    abstract public void t();
}
class A extends T{

    @Override
    public void draw() {

    }

    @Override
    public void t() {

    }
}

class Flower implements IShape{
    @Override
    public void fun2(){

    }
    @Override
    public void draw() {
        System.out.println("💐");
    }
}
public class Test {
    public static void drawMap(IShape shape){//向上转型
        shape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Flower());
    }
}

2.方法方面

2.1.接口中每一个方法默认都是public的抽象方法不能有具体的实现, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)。
2.2. 重写接口中方法时，因为接口里的抽象方法是public abstract修饰，所以实现接口类里重写抽象方法时不能使用default访问权限修饰(因为重写的方法访问修饰限定符大于等于被重写的修试限定访问符)
2.3. 如果要想接口里的方法有具体实现类，则用default修饰(jdk8以以后才有)、static修饰，default修饰的方法可以不重写，而被static修饰的方法不能被重写。

3.成员属性方面

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

5.实现多个接口

在java中类和类之间是单继承的，一个类只能继承一个父类，即java中不支持多继承，但是一个类可以实现多个接口。
只能先继承然后再实现多个接口
下面通过一动物来掩饰：

//抽象类
abstract class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public abstract void eat();
}
//跑
interface IRuning{
    void run();
}
//飞
interface IFlying{
    void fly();
}
//游泳
interface ISwimming{
    void swimming();
}
class Dog extends Animal implements IRuning,ISwimming{
    public Dog(String name, int age) {
        super(name, age);
    }

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

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

    @Override
    public void swimming() {
        System.out.println(name+"正在狗刨");

    }
}
class Bird extends Animal implements IRuning,IFlying{
    public Bird(String name, int age) {
        super(name, age);
    }

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

    }

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

    @Override
    public void fly() {
        System.out.println(name+"两只小翅膀正在飞");

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

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

    @Override
    public void run() {
        System.out.println(name+"两只大脚掌正在跑");
    }

    @Override
    public void fly() {
        System.out.println(name+"两只大翅膀在飞");
    }

    @Override
    public void swimming() {
        System.out.println(name+"两只大脚掌在游泳");

    }
}
public class Test {
   //抽象类引用
    public static void eat(Animal animal){
        animal.eat();
    }
    //接口类引用
    public static void run(IRuning iRuning){
        iRuning.run();
    }
    public static void fly(IFlying iFlying){
        iFlying.fly();
    }
    public static void swim(ISwimming iSwimming){
      iSwimming.swimming();
    }
    public static void main(String[] args) {
        eat(new Dog("边牧",4));
        eat(new Bird("鹦鹉",1) );
        eat(new Duck("唐老鸭",15));
        System.out.println("======================");
        run(new Dog("边牧",4));
        run(new Bird("鹦鹉",1) );
        run(new Duck("唐老鸭",15));
        System.out.println("======================");
        fly(new Bird("鹦鹉",1) );
        fly(new Duck("唐老鸭",15));
        System.out.println("=======================");
        swim(new Dog("边牧",4));
        swim(new Duck("唐老鸭",15));
    }
}

运行结果：

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口。
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性

鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序员忘记类型.。有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力。
比如狗、鸟、鸭子都能跑。

6.接口的继承

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

interface IA{
    void func1();
}
interface IB{
    void func2();
}
//接口间的继承----拓展接口功能
interface IC extends IA , IB {接口相当于有了接口IA和接口IB的功能
    void func3();
}
class T implements IC{
    @Override
    public void func1() {
        System.out.println("重写接口IA里的抽象方法");
    }

    @Override
    public void func2() {
        System.out.println("重写接口IB里的抽象方法");

    }

    @Override
    public void func3() {
        System.out.println("重写接口IC里的抽象方法");

    }
}
public class Test0 {
}

7.抽象类与接口的区别

抽象类和接口都是 Java 中多态的常见使用方式，都需要重点掌握.，同时又要认清两者的区别(重要!!! 常见面试题)。
核心区别：抽象类里包含普通方法和普通字段，这些普通方法和普通字段是可以被子类继承使用的，而接口里不包含普通方法和普通字段，子类必须重写所有的抽象方法。

区别	抽象类	接口
结构组成	普通类+抽象方法	抽象方法+全局常量
	是类，有普通字段和方法子类可以继承使用	是一种公共规范标准，没有普通字段和方法
	构造方法、代码块都有	没有构造方法、代码块
继承方式	不能被多继承	接口可以实现多继承
实现方式	不能直接实例化对象，而是子类继承，然后重写抽象方法	类通过implements继承然后重写抽象方法
关系	一个抽象类可以实现多个接口	接口不能继承抽象类，但是接口可以使用关键字extends继承多个父类接口
子类限制	一个子类只能继承一个抽象父类	一个子类可以实现多个接口

如之前写的 Animal 例子，此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口。
再次提醒:
抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔