一分钟带你掌握Java中的抽象类与接口那些事

 

目录

什么是抽象类

抽象类知识归纳   

什么是接口

【面试考察重点】抽象类和接口的区别

使用重写的场景：

 

---

 

🥰🥰🥰各位读者们，今天我将带领大家来聊一聊Java中的抽象类与接口那些事，哈哈哈，且听我娓娓道来

 

什么是抽象类

🍑🍑🍑🍑🍑🍑🍑🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌼🌼🌼🌷🌷🌷🥦🥦🥦

       可能有人会问了什么是抽象类，它在Java语言中有啥作用，能起到什么作用？哈哈，大家不要着急，存在即合理，且听我慢慢道来👻👻👻

       有人看见抽象类，在字面上可能就会理解它就是一个抽象的东西，不是具体存在的，哈哈哈😙😙😙😙😙你猜对了，抽象类就是一个抽象的，不是一个具体的。

        抽象类可以理解为不干啥实际工作，它都是让它自己内部的类去干活。用专业术语来说，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。因此我们就可以正大光明的把这种类称为抽象类。抽象类中没有实际工作的方法, 我们可以把它设计成一个抽象方法

       聊到这里，大家对抽象类的定义是不是有了一定的理解了，接下来我给大家举个🌰子来帮助你们加深印象🍬

  // 使用abstract 来修饰的类叫做抽象类
public abstract class Test {
  //使用abstract 来修饰的方法叫做抽象方法
 abstract void eat();  //在抽象类内部，抽象方法没有方法体

  public int num(){  // 抽象类也是类，也可以增加普通方法和属性
     return num;
   }
}

      大家看到这里是不是觉得抽象类怎么啥也没干，而且内部的唯一抽象方法竟然没有方法体，通过这个小🌰🌰子，我们可以得到这样的结论：

像这样的类没有包含足够的信息来描述一个对象，因此抽象类自然不能通过new实例化对象

这里我们可以写一段代码来验证确认我们的结论

        哈哈哈哈，各位看到这里是不是对抽象类不能实例化对象可以理解了，毕竟抽象类和其内部抽象方法啥都没干，那么这里就可以延伸出一个问题：如果我们想要使用抽象类，那该怎么办呢👀👀👀

       这个问题也很好解决，我们如果想要使用抽象类，可以通过创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法，这样就可以使用抽象方法了😁大家看到这不禁就会想到这不就是让子类继承抽象类去调用父类重写方法，实现了多态思想。哈哈哈哈，又让大家猜到了🍗🍗🍗

 

🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴   

      既然要使用抽象类，在这里给大家补充一下抽象类的特性。

       1、因为抽象类使用就必须被子类重写方法调用父类方法，所以抽象类的方法就不能被private、final和static所修饰

       2、使用抽象类就必须被子类继承，重写抽象类方法；若创建子类为抽象类，如果不想重写父类抽象方法 就必须使用abstract修饰方法

3、抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

 

4、抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

 

🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴🌴

 

      对抽象类特性进行了补充，我相信大家对抽象类特性有了充分的理解。那我们重归主体，接着和大家聊聊如何使用抽象类问题😘😘😘

问题：如果我们想要使用抽象类，那该怎么办呢👀👀👀

回答：这个问题也很好解决，我们如果想要使用抽象类，可以通过创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法，这样就可以使用抽象方法了

 

接下来我们通过一段代码展示抽象类是如何使用的😊

abstract  class Animal {
    String name="小红";
    abstract public void eat();
    abstract void run();
}
 class Dog extends Animal {
    String name="小白";
     @Override
     public void eat() {
         System.out.println("正在吃饭");
     }
     @Override
      void run() {
          System.out.println("正在跑步");
     }
     public void swim() {  //子类Dog 独有的方法swim
         System.out.println("正在游泳");
     }
 }
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog(); //父类的引用指向子类的对象 向上转型，多态思想
        animal.eat(); //调用重写后的父类方法 输出结果：正在吃饭
        animal.run();  //输出结果：正在跑步
        System.out.println(animal.name); //输出结果：小红  
         //原因：抽象类被继承后只能访问父类的方法和属性，不能访问子类所独有的属性和方法
    }
}

       大家看完理解这段代码后是不是对使用抽象类很明白了，哈哈哈哈🥰🥰🥰 那通过这段代码我给大家讲解一下使用抽象类的注意细节知识点。

🍓  父类被子类继承，重写父类方法后，父类只能调用父类与子类共有的方法，不能调用子类所独有的方法

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog(); //父类的引用指向子类的对象 向上转型，多态思想
        animal.eat(); //调用重写后的父类方法 输出结果：正在吃饭
        animal.run();  //输出结果：正在跑步
        animal.swim();  //编译报错 不能访问子类独有的方法
        System.out.println(animal.name); //输出结果：小红  原因：抽象类被继承后只能访问父类的方法和属性，不能访问子类所独有的属性和方法
    }
}

 

🍓🍓父类只能访问自己独有的属性，无法访问子类独有的属性

abstract  class Animal {
   int a =10;
}
 class Dog extends Animal {
    String name="小白";
    int b = 20;
 }
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
    System.out.println(animal.a); //编译成功，输出10
    System.out.println(animal.b); //编译失败，无法访问子类独有属性
    System.out.println(animal.name); //编译失败，无法访问子类独有属性
  }
}

 

抽象类知识归纳   

🌷🌷🌷🌷🌷到这里抽象类的知识点就讲解完了，我给大家来归纳一下抽象类的知识点帮助大家来理清思维

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

2️⃣一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法没有方法体

3️⃣抽象类由于是抽象的，不能直接实例化对象

4️⃣抽象方法要被子类重写，不能被private、final和static修饰

5️⃣使用抽象类就必须被子类继承，重写抽象类方法；若创建子类为抽象类，如果不想重写父类抽象方法 就必须使用abstract修饰方法

6️⃣抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

7️⃣抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

8️⃣父类被子类继承，重写父类方法后，父类只能调用父类与子类共有的方法，不能调用子类所独有的方法

9️⃣父类只能访问自己独有的属性，无法访问子类独有的属性

 

 

什么是接口

 

        对于Java语言中的接口大家第一次可能有点陌生，那生活中大家有没有见过手机充电口的接口，电脑各种样式的接口和平常电器的接口，我相信大家对这些接口肯定很熟悉了。这些接口里面是不是包含了各种功能的电路板或者一些功能程序，它只露出了外在接口供我们去使用这些接口。

        😎各位看官们看到这里是不是对接口的定义和功能有一定的了解了，那么Java语言中的接口作用与我们平时看到的接口有点类似。那这里我用通俗易懂的话来说明接口的定义：

  在Java中，接口就是由内部包含全局变量和公共的抽象方法组成，供其他类去使用实现接口。 

        😜😜😜其实接口可以当做是一种特殊的引用类型，在用法上与抽象类类似，但不完全相同。下面我将详细介绍接口的创建与使用方法😊🌴🌴

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

public interface A { //interface 创建一个接口A
    //接口中定义变量时必须赋值，否则编译失败
 [public] [static] [final] String name = "小明"; //public static final为隐式，可以不写
  [public] [static] [final] int age = 10;
 [public] [abstract] void eat(); // public abstract 是固定搭配，可以不写
                     void run();
}

一般在接口中定义变量和方法时，更推荐不写这些固定搭配，因为这样可以让代码看起来更简洁，看起来是不是更舒服呢😎

         接口已经创建好了，接下来我们就要去学会如何去使用它。在这里我们需要注意的是：

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

 

这时候就需要使用到关键字 implements 来实现接口，下面我给大家写一段代码来展示接口的使用

 

 

public interface A { //创建接口A
   void eat(); //在接口中方法没有方法体
   void run();
}
public class B implements A { //类B实现接口A
    //重写接口A的方法
   public void eat() {  
      System.out.println("正在吃饭");
    }
   public void run() {  
      System.out.println("正在跑步");
    }
}

🍑🍑🍑🍑大家看懂这段代码是不是可以熟练掌握引用的使用了。在这里我们需要注意的是：

1️⃣接口不能实例化对象 ，接口类型是一种引用类型，无法通过new来实例化对象

2️⃣接口中的方法是不能在接口中实现的，只能由 实现接口的类来实现

 

3️⃣重写接口中的方法时，访问权限要大于等于接口的访问权限，否则编译报错

 

 

4️⃣接口中每一个方法都会被隐式的指定为 public abstract

 

5️⃣接口中的变量会被隐式地指定为 public static final 变量（并且只能是 public static final变量，用 private 修饰会报编译错误）

 

6️⃣接口里面不能有构造方法和静态代码块

public interface A {
   // 编译失败
   public A(){
  }
    {} // 编译失败
  void eat();
  void run();
}

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

 

 

 

 

【面试考察重点】抽象类和接口的区别

 

       各位老铁们看到这里，是不是对接口的概念和创建以及接口特性注意点有没有一种茅塞顿开的感觉，哈哈哈哈😎😎。接下来我将为大家继续讲解接口的其他语法😉

         大家理解完接口的特性后，有没有一种感觉，接口与抽象类在特性上有一些类似共同点，是的，我也有这种感觉。那接下来我就为大家讲解接口与抽象类的一些相同点和区别点。

 

🍊🍊🍊🍊🍊🍊🍊🍊🍊🍊🍊🍊🍊🍊🍊  

 

📃相同点：

1、接口和抽象类都不能实例化对象，

2、在接口和抽象类中都可以包含抽象方法，在实现接口的类中或者继承抽象类的普通子类都必须实现这些抽象方法 

📃区别点：     

1、在抽象类中，一个子类只能继承一个父类，而一个类可以实现多个接口

class Person {
    public String name ; //普通属性name

    public Person(String name) {
        this.name = name;
    }

    void fun(){
         System.out.println("1111");
    }
}
interface IA { //创建接口A
    void run();
}
interface IB { //创建接口B
    void wsa();
}
interface IC { //创建接口C
    void eat();
}
class Teenage extends Person implements IA,IB,IC{//子类Teenage 继承父类Person 实现多个接口
    public Teenage(String name) { // name属性在任何子类中都是存在的
        super(name);
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在跑");
    }
    @Override
    public void wsa() {
        System.out.println(this.name+"正在笑");
    }
    @Override
    public void eat() {
        System.out.println(this.name+"正在吃饭");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Teenage teenage = new Teenage("小红");
        teenage.eat();
        teenage.wsa();
        teenage.run();
    }
}

 

2、抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的，并且必须赋值，否则编译不通过

3、抽象类可以有静态代码块和静态方法，而接口中不能含有静态代码块以及静态方法

 

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中的方法都是被 public abstract修饰,都是抽象方法，所以接口中不能包含普通方法，子类必须重写所有的抽象方法。接口中的普通变量会被隐式地指定为 public static final 修饰的变量 ，不能被类访问。

 

 

🖐个🌰子帮助大家加深印象：

       

        在Person中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的Person只能作为一个抽象类, 而不应该成为一个接口

class Person {
   protected String name; //普通方法name
   public Animal(String name) {
      this.name = name;
   }
}

 

        各位铁子们，抽象类与接口的区别是十分重要的，在Java基础知识中，也是占有了一个比较重要的知识点，对于找工作的铁子们，面试官也是可能比较喜欢考察重点的一个地方。一起加油把抽象类和接口掌握牢固。

     

 

 

 

 

 🍑🍑🍑 基础不牢，地动山摇🍑🍑🍑

 

 

 

 

在这里补充上篇文章 封装、继承和多态中关于 重写的额外补充，加深印象，哈哈哈哈

 

 

使用重写的场景：

（1）继承和多态：当子类与父类发生多态时，子类必须重写父类的方法（当父类的某个方法，子类有不同的实现，那么就可以重写该方法）

（2）抽象类和接口：

1. 子类继承抽象类时，必须重写抽象类方法
2. 接口中的方法都是抽象类，所以一个类实现接口时，必须重写抽象方法

 

对于抽象类与接口的那些事，我们先聊到这里哈哈哈🥰🥰🥰。如果我有哪些表述错误的地方，欢迎各位铁汁们在评论中指正，我及时进行纠正🤣🤣🤣