[学习笔记]Java抽象类和接口

最新推荐文章于 2023-06-28 19:48:45 发布

jacobvv

最新推荐文章于 2023-06-28 19:48:45 发布

阅读量889

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/jacobvv/article/details/41809639

版权

Java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

抽象类

概述

抽象就是从多个事物中将共性的，本质的内容抽取出来。例如：猫和狗共性都是动物，动物就是抽象出来的概念。

定义

Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

由来

当多个类出现相同功能，但功能内容不同，这时也可以进行向上抽取，只抽取功能定义，不抽取功能内容。那么只有功能声明，没有功能主体的方法称为抽象方法。例如：猫和狗都有进食的方法，但是进食的内容是不一样的。所以抽象出来的动物虽然有进食功能，但是并不明确进食的细节。

特点

抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明，没有方法体，定义在抽象类中。
抽象类不可以被实例化，也就是不可以用new 创建对象。
因为：
1. 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。
2. 抽象类即使创建了对象，调用抽象方法也没有意义。例如：动物是个抽象的概念，只有猫和狗才是真正存在的。
抽象类通过其子类实例化，而子类需要重写掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
抽象方法一定在抽象类或接口中。
抽象类可以没有抽象方法，作用仅仅是不可以建立对象。

格式

抽象方法：

权限修饰符 abstract 返回值类型函数名 (参数列表);

抽象类：

权限修饰符 abstract 类名 {}

注意

抽象类有构造函数。
因为：抽象类必须被继承才能够使用，而子类创建对象必须运行父类的构造方法。
抽象关键字abstract不能与private、static和final关键字一起使用。
因为：
1. 抽象方法是要被子类中的方法覆盖重写，如果用private关键字修饰，而私有化后方法是不能被子类访问到的。
2. 用static关键字修饰后的方法，就是静态方法，不用创建对象，可以直接用类名调用方法，而调用抽象方法就毫无意义了。
3. 被final关键字修饰的方法不能被覆盖，而抽象方法就是要被其子类中的方法覆盖后才能使用。

示例

   
   
    
    
     
     class Person {
    
    
    
    
     
       private String name;
    
    
    
    
     
       private int age;
    
    
    
    
     
      
    
    
    
    
     
       Person(String name, int age) {
    
    
    
    
     
         this.name = name;
    
    
    
    
     
         this.age = age;
    
    
    
    
     
       }
    
    
    
    
     
      
    
    
    
    
     
       public void speak() {
    
    
    
    
     
         System.out.println("I'm a Person, I can speak!");
    
    
    
    
     
       }
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
     /**
    
    
    
    
     
      * Employee类是个抽象类，其中定义了抽象方法work()，必须由子类重写后才可使用。
    
    
    
    
     
      */
    
    
    
    
     
     abstract class Employee extends Person {
    
    
    
    
     
       private String id;
    
    
    
    
     
       private double salary;
    
    
    
    
     
      
    
    
    
    
     
       Employee(String name, int age, String id, double pay) {
    
    
    
    
     
         super(name, age);
    
    
    
    
     
         this.id = id;
    
    
    
    
     
         this.salary = pay;
    
    
    
    
     
       }
    
    
    
    
     
      
    
    
    
    
     
       public abstract void work();
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
     /**
    
    
    
    
     
      * Manager类继承自Employee类，重写了work()方法，并定义了经理工作具体的实现。
    
    
    
    
     
      */
    
    
    
    
     
     class Manager extends Employee {
    
    
    
    
     
       private double bonus;
    
    
    
    
     
      
    
    
    
    
     
       Manager(String name, int age, String id, double pay, double bonus) {
    
    
    
    
     
         super(name, age, id, pay);
    
    
    
    
     
         this.bonus = bonus;
    
    
    
    
     
       }
    
    
    
    
     
      
    
    
    
    
     
       public void work() {
    
    
    
    
     
         System.out.println("Manager work!");
    
    
    
    
     
       }
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
     /**
    
    
    
    
     
      * Staff类也继承自Employee类，重写了work()方法，并定义了职员工作具体的实现。
    
    
    
    
     
      */
    
    
    
    
     
     class Staff extends Employee {
    
    
    
    
     
       Staff(String name, int age, String id, double pay) {
    
    
    
    
     
         super(name, age, id, pay);
    
    
    
    
     
       }
    
    
    
    
     
      
    
    
    
    
     
       public void work() {
    
    
    
    
     
         System.out.println("Staff work!");
    
    
    
    
     
       }
    
    
    
    
     
     }

接口

概述

当抽象类中的方法都是抽象的，该类可以通过接口形式来表示。

格式

class用于定义类，interface用于定义接口。

interface name {}

interface只能被public或abstract修饰。
可以定义常量，抽象方法，静态方法。
接口中的成员都有固定修饰符，并且都有public修饰。

常量：public static final

方法：public abstract

静态方法：public static

特点

1. 接口是对外暴露的规则。

2. 接口是程序的功能扩展。

3. 接口可以多实现。

4. 类与接口之间是实现关系，而且类可以继承同一个类的同时实现多个接口。

5. 接口与接口之间可以有继承关系。

注意

1. 接口不可以创建对象，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都重写后才可以实例化，否则子类是一个抽象类。

2. 多继承或者多实现，不可以有同名不同返回值类型的函数。

示例

   
   
    
    
     
     interface Interface1 {
    
    
    
    
     
       // 接口中可以定义常量和抽象方法
    
    
    
    
     
       public static final int NUM = 3;
    
    
    
    
     
      
    
    
    
    
     
       public abstract void print();
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
      
    
    
    
    
     
     interface Interface2 {
    
    
    
    
     
       public abstract void print();
    
    
    
    
     
      
    
    
    
    
     
       public abstract void method();
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
      
    
    
    
    
     
     class ClassDemo {
    
    
    
    
     
       public void function() {}
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
      
    
    
    
    
     
     class Implement extends ClassDemo implements Interface1, Interface2 {
    
    
    
    
     
       public void print() {}
    
    
    
    
     
      
    
    
    
    
     
       public void method() {}
    
    
    
    
     
     }
    
    
    
    
     
      
    
    
    
    
     
      
    
    
    
    
     
     class InterfaceDemo {
    
    
    
    
     
       public static void main(String[] args) {
    
    
    
    
     
         Implement i = new Implement();
    
    
    
    
     
         System.out.println(i.NUM);
    
    
    
    
     
         System.out.println(Implement.NUM);
    
    
    
    
     
         System.out.println(Interface1.NUM);
    
    
    
    
     
       }
    
    
    
    
     
     }