抽象类和接口(超重点!!)

一时失言乱红尘 2024-02-17 13:27 47阅读 0赞

**\[本节目标\]**

**1.抽象类**

**2.接口**

**3.Object类**

## **1.抽象类** ##

### **1.1 抽象类概念** ###

**在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 比如：**

![a23206343c4043269a628c641a120c53.png][]

说明:圆形,正方形,长方形都是图形,因此图形类和圆形和正方形还有长方形都是继承关系.

虽然图形中也存在draw(),但由于图形类不是具体的图形,因此内部的draw()方法实际是没有办法实现的.

由于图形类没有办法描述一个具体的图形,导致draw()方法无法具体实现,因此可以将图形类设计为"抽象类".

### 1.2 抽象类语法 ###

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

注意:抽象类也是类,内部可以包含普通方法和属性,甚至构造方法

### 1.3 抽象类特性 ###

1.抽象类不能直接实例化对象

![74cb2024ea0343e48dbe263f0f0842c1.png][]

2.抽象方法不能是private的

![1e20b40f6c424d94bc50b414a7e52281.png][]

3.抽象方法不能被final和static修饰,因为抽象方法要被子类重写

![fb08fe2c7d9d47589839920ef4a508b5.png][]

![5765fa3f60ea4eb99b1f305af0d01448.png][]

4.抽象类必须被继承,并且继承后子类要重写父类中的抽象方法.否则子类也是抽象类,必须使用abstract修饰.

public abstract class Shape {
    abstract public void draw();
    //抽象方法:被abstract修饰的方法,没有方法体
    abstract void calcArea();
    //抽象类也是类,也可以增加普通方法和属性
    public double getArea(){
        return area;
    }
    protected double area;  //面积
    
    }
    
    
    public class Rect extends Shape {
        private double length;
        private double width;
    
        public Rect(double length, double width) {
            this.length = length;
            this.width = width;
        }
        @Override
        public void draw(){
            System.out.println("矩形:length="+length+"width="+width);
        }
    
        @Override
        public void calcArea() {
            area = length*width;
        }
    
    
    }
    
    
    
    public class Cidcle extends Shape{
        private double r;
        final private static double Pi = 3.14;
    
        public Cidcle(double r) {
            this.r = r;
        }
        public void draw(){
            System.out.println("圆:r = "+r);
        }
        @Override
        public void calcArea(){
            area = Pi*r*r;
        }
    }
    
    
    
    public abstract class Triangle extends Shape{
        private double a;
        private double b;
        private double c;
        @Override
        public void draw(){
            System.out.println("三角形: a = "+a+"b="+b+"c="+c);
        }
    
    }

5.抽象类中不一定包含抽象方法,但是有抽象方法的类一定是抽象类

6.抽象类可以有构造方法,供子类创建对象时,初始化父类的成员变量

### 1.4 抽象类的作用 ###

**抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.**

有些朋友可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?

**确实如此. 但是使用抽象类相当于多了一重编译器的校验.**

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

很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.  
充分利用编译器的校验, 在实际开发中是非常有意义的.

## 2. 接口 ##

### 2.1 接口的概念 ###

在现实生活中,比如:笔记本上的usb口,电源插座等.

电脑的usb口上,可以插:电脑,电视机,电饭煲...所以符合规范的设备

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

###    2.2 语法规则 ###

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

public interface Usb {
        public abstract void method1();  // public abstract是固定搭配,可以不用写
        public void method2();
        abstract void method3();
        void method4();//上诉这些写法都是一样的
    }

上诉写法中,更推荐写法4,代码更简洁

**注意:**

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

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

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

### 2.3 接口的使用 ###

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

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

注意:子类和父亲之间是extends继承关系,类与接口之间是implement实现关系.

一些小例子:帮助大家更好的理解接口

public interface Usb {
       void openDevice();
       void cloceDevice();
    
    }
    
    
    public class Mouse implements Usb {
        @Override
        public void openDevice() {
            System.out.println("打开鼠标");
        }
    
        @Override
        public void cloceDevice() {
            System.out.println("关闭鼠标");
        }
        public void click(){
            System.out.println("点击鼠标");
        }
    }
    
    
    public class Keyboard implements Usb{
    
        @Override
        public void openDevice() {
            System.out.println("打开键盘");
        }
    
        @Override
        public void cloceDevice() {
            System.out.println("关闭键盘");
        }
        public void inPut(){
            System.out.println("键盘输入");
        }
    }
    
    
    public class Computer {
        public void powerOn(){
            System.out.println("打开笔记本电脑");
    
        }
        public void powerOff(){
            System.out.println("关闭笔记本电脑");
        }
        public void useDevice(Usb usb){
            usb.openDevice();
    
            if(usb instanceof Mouse){
               ((Mouse) usb).click();//写法不一样而已
               Mouse mouse = new Mouse();
               mouse.click();
            } else if (usb instanceof Keyboard) {
                Keyboard keyboard = (Keyboard) usb;
                keyboard.inPut();
            }
    usb.cloceDevice();
        }
    }
    
    
    //测试类
    public class Teat6 {
        public static void main(String[] args) {
         Computer computer = new Computer();
         computer.powerOn();
            //使用鼠标设备
            computer.useDevice(new Mouse());
            //使用键盘设备
            computer.useDevice(new Keyboard());
            computer.powerOff();
        }
    }

![a3904faa631a41a2be79578e37c0c545.png][]

不可以直接引用实现接口的方法,需要强制转换.

### 2.4 接口特性 ###

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

public class Test7 {
        public static void main(String[] args) {
            IUSB iusb = new IUSB() ;
        }
    }

2.接口每一个方法都是public的抽象方法,即接口中的方法被隐式的指定为public abstract(只能是publicabstract,其他的都会报错)

public interface IUSB {
    protected void method();
    }

![5387c35460734c21af304bbbb9d5e624.png][]3.接口中的方法是不能在接口中实现的,只能由实现接口的类来实现.

public interface IUSB {
    void open();
    void close(){
        System.out.println("关闭设备");
    }
    }

![7b5a754947d94626a20100ef3057a791.png][]

4.重写接口中方法时,不能使用默认的访问权限

public class Mouse implements Usb {
        @Override
     void openDevice() {
            System.out.println("打开鼠标");
        }
    
        @Override
        public void cloceDevice() {
            System.out.println("关闭鼠标");
        }
        public void click(){
            System.out.println("点击鼠标");
        }
    }

![d497b2c7f84f4975bec8137c4b5ffb75.png][]5.接口中可以含有变量,但是接口中的变量会被隐式的指定为public abstract final变量.

public interface Usb {
       int a = 1;
       void openDevice();
       void cloceDevice();
    
    }
    
    
    
    public class Teat6 {
        public static void main(String[] args) {
         
            System.out.println(Usb.a);
            Usb.a= 2;
        }
    }

![ab3b1725f8364d089211aeb5f67f5c13.png][]

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

public interface Usb {
       int a = 1;//必须有初始值
       public Usb(){
          
       }
       void openDevice();
       void cloceDevice();
    
    }

![7d1db3fa42b74c06a6dbd0643df49feb.png][]

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

8.如果类没有实现接口中的所以的抽象方法,则类必须设置为抽象类(和抽象类一样)

9.jdk8中:接口还可以包含default方法

### 2.5 实现多个接口 ###

在java中,类和类之间是单继承的,一个类只能有一个父类,即java中不支持多继承,但是一个类可以实现多个接口,下面通过一些类来表示一组动物.

public class Animal1 {
        protected String name;
    
        public Animal1(String name) {
            this.name = name;
        }
    }
    
    
    
    public interface IRunning {
        void run();
    }
    
    
    public interface IFlying {
        void fly();
    }
    
    
    
    public interface ISwimming {
    void swimming();
    }

接下来我们再创建几个具体的动物

猫,是会跑的

public class Cat1 extends Animal1 implements IRunning{
    
        public Cat1(String name) {
            super(name);
        }
        @Override
        public void run(){
            System.out.println(this.name+"猫在跑");
        }
    }

鱼,会游泳

public class Fish extends Animal1 implements ISwimming{
        public Fish(String name) {
            super(name);
        }
    @Override
        public void swimming(){
        System.out.println(this.name+"鱼儿在游泳");
    }
    }

青蛙,会跑,而且会游泳

public class Qing extends Animal1 implements ISwimming,IRunning{
        public Qing(String name) {
            super(name);
        }
        @Override
        public void run(){
            System.out.println(this.name+"青蛙在跑");
        }
        @Override
        public void swimming(){
            System.out.println(this.name+"青蛙在游泳");
        }
    }

注意:一个类实现多个接口时,每个接口中的抽象方法都要实现,否则类必须设置为抽象类

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

这样的设计有什么好处呢?时刻牢记多肽的好处,让程序员忘记类型,有了接口之后,类的使用者就不必关注具体类型,而只关注是否具备某种能力.

public class Test7 {
    public static void walk(IRunning running){
        System.out.println("我带着伙伴去散步");
        running.run();
    }
        public static void main(String[] args) {
    Cat1 cat1 = new Cat1("小猫");
    walk(cat1);
        }
    }

![8d7ddab618754782b6e89052d317aeaf.png][]

![f09655bde25a432ea19fb7fd0a5b69eb.png][]

因为在猫这个类里面重写过,所以可以直接调用.

### 2.6 接口间的继承 ###

在java中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承,即:用接口可以达到多继承的目的.

接口可以继承一个接口,达到复用的效果,使用extends.

![cf8545e6b33140fab22b7182165e4e5a.png][]

![1cd0459a552b4806822117991a9d7e6e.png][]

通过刚刚的代码改造

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的qing 类, 就继续要实现 run 方法, 也需要实现 swim 方法

**接口之间的继承,相当于把多个接口合并在一起**

### **2.7 接口使用实例** ###

**给对象数组排序**

import java.util.Arrays;
    import java.util.Objects;
    
    public class Student implements Comparable{
        private String name;
        private int score;
    
        public Student(String name, int score) {
            this.name = name;
            this.score = score;
        }
    
    
        @Override
        public String toString(){
            return "{"+this.name+":"+this.score+"}";
        }
    
        @Override
        public int compareTo(Object o){
            Student s = (Student) o;
            if (this.score>s.score){
                return -1;
            }else if(this.score<s.score){
                return 1;
            }
            return 0;
        }
    
    
    
    }
    
    
    import java.util.Arrays;
    
    public class Test7 {
        public static void main(String[] args) {
    
            Student[] students = new Student[]{
                    new Student("张三",95),
                    new Student("李四",96),
                    new Student("王五",97),
                    new Student("赵六",92),
            };
    Arrays.sort(students);
            System.out.println(Arrays.toString(students));
        }
    }

仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎么确定? 需要我们额外指定

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法即可.

### 2.8 抽象类和接口的区别 ###

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

class Animal{
    protected String name;
    public Animal(String name){
    this.name = name;
    }
    }

再次提醒:

抽象类存在的意义是为了让编译器更好的校验,像Animal这样的 类我们并不会直接使用,而是直接使用它的子类,万一不小心创建了Animal的实例.编译器会及时提醒我们

![12b86cb45cc945c09c55e3f00bb93cf4.png][]

通过对象比较equals方法

在java中,==进行比较时;

a.如果==左右两侧比较的是基本类型变量,比较的是变量中值是否相同

b.如果==左右两侧比较的是引用类型变量,比较的是引用变量地址是否相同

c.如果要比较对象中内容,必须重写object中的equals方法,因为默认按照地址比较

class Person{
    private String name ;
    private int age ;
    public Person(String name, int age) {
    }
    
    public class Test {
    public static void main(String[] args) {
    Person p1 = new Person("gaobo", 20) ;
    Person p2 = new Person("gaobo", 20) ;
        int a = 10;
        int b = 10;
        System.out.println(a == b);       // 输出true
    System.out.println(p1 == p2);      // 输出false
        System.out.println(p1.equals(p2));    // 输出false
    }
    }

person类重写equals方法后,然后比较:

class Person{
     ...
    @Override
    public boolean equals(Object obj) {
    if (obj == null) {
    return false ;
    }
    if(this == obj) {
    return true ;
    }
    // 不是Person类对象
    if (!(obj instanceof Person)) {
    return false ;
    }
       
    Person person = (Person) obj ; // 向下转型，比较属性值
    return this.name.equals(person.name) && this.age==person.age ;
    }
    }

结论：比较对象中内容是否全部相同的时候，一定要重写equals方法

[a23206343c4043269a628c641a120c53.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/8fb2bf320ed7489f9fc7c69364e548fb.png
[74cb2024ea0343e48dbe263f0f0842c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/8248abcf42444b1d92b0960a8a8faf9c.png
[1e20b40f6c424d94bc50b414a7e52281.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/d609548da18d498ea29cbc6214abc0e9.png
[fb08fe2c7d9d47589839920ef4a508b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/ddf24157306447e999c5681eda423388.png
[5765fa3f60ea4eb99b1f305af0d01448.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/a98af5ebe2e9454fa2575355eccb77d4.png
[a3904faa631a41a2be79578e37c0c545.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/fd4d93eeb6824542befb78df43fd8962.png
[5387c35460734c21af304bbbb9d5e624.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/cb42584b3a5b43d6af5e77687a1bcc5c.png
[7b5a754947d94626a20100ef3057a791.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/d314d2e1b81e46e7ac08ca265ab4f805.png
[d497b2c7f84f4975bec8137c4b5ffb75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/b4fd9188561944969082e02b6d1381c9.png
[ab3b1725f8364d089211aeb5f67f5c13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/615e56b918d541aaab5b70dc89dea6f9.png
[7d1db3fa42b74c06a6dbd0643df49feb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/0a7ba612c9d449b4853a25404061811a.png
[8d7ddab618754782b6e89052d317aeaf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/a9e53d2369884effb5fee381d91d22ee.png
[f09655bde25a432ea19fb7fd0a5b69eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/5229623de5f54431b2c221e619efd8ee.png
[cf8545e6b33140fab22b7182165e4e5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/2317475a17f84f73abdc8c6f8186f1c0.png
[1cd0459a552b4806822117991a9d7e6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/b362a866d491403bb6bb003d09a433a9.png
[12b86cb45cc945c09c55e3f00bb93cf4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/2735c3eeb15e461fb5caf5fb70dfdd1d.png