Java 超详细讲解抽象类与接口的使用

一、抽象类

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

1、抽象类的语法

//抽象类：被abstract修饰的类
public abstract class Shape{
   //抽象方法：被abstract修饰的方法，没有方法体
   public abstract void drew();
   //抽象类中也可以增加普通方法和属性
   public double getArea(){
      return area;
   }
}

【注】抽象类也可以包括普通的方法和属性，甚至构造方法

2、抽象类的特性

抽象类不能直接实例化对象
抽象类不能被private、final和static修饰，因为抽象方法要被子类重写
抽象类中不一定包含抽象方法
抽象类必须被继承，如果被普通子类继承，继承后子类需要重写父类中的抽象方法
如果抽象类B继承抽象类A，B中可以不用重写A中抽象类，但其最后继承的子类需要重写所有的抽象方法。

3、抽象类的作用

抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类，然后通过子类重写抽象类中的抽象方法。使用抽象类相当于多了一层编译器的检验。

有些情况下实际工作不应该由父类完成，而应由子类完成，如果误用为父类，父类为抽象类时就会在实例化时报错。

二、接口

1、接口的概念

接口就是公共的行为规范标准，大家在实现的时候，只要符合规范标准，就可以通用。在Java中，接口可以看成：多个类的公共规范，是一种引用数据类型。使用关键字interface。

public interface 接口名称{
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();
// 注意：在接口中上述写法都是抽象方法，
}

【注】

创建接口时，命名一般以大写字母“I”口头
接口中和抽象方法默认public abstract
成员变量默认public static final

2、接口使用

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

public class 类名称 implements 接口名称{

//……

}

【注】子类与父类之间是extends继承关系，类与接口之间是implements实现关系

3、接口特性

接口中的类不能在接口中实现，只能在实现接口的类中实现
使用interface修饰
接口不能使用new直接实例化
接口中可以定义实现了的方法，使用default或者static修饰
default方法是接口的默认方法，也可以在实现类中重写这个方法
一个类可以实现过个接口，使用逗号隔开
接口中不能有构造方法和静态代码块

4、实现多个接口

Java中，类与类是单继承的关系，一个子类只能有一个父类，即Java不支持多继承。但是一个类可以实现多个接口。

class Animal{
    protected String name;
    public Animal(String name){
        this.name=name;
    }
}
interface IFlying{
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
class Duck extends Animal implements IFlying,IRunning,ISwimming{
    public Duck(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println("Duck正在飞！");
    }
    @Override
    public void run() {
        System.out.println("Duck正在跑！");
    }
    @Override
    public void swim() {
        System.out.println("Duck正在游泳！");
    }
}

【注】一个类可以实现多个接口，每个接口中的抽象方法都要实现。（使用ctrl+i快速实现接口）

5、接口间的继承

在Java中，类与类之间是单继承，一个类可以实现多个接口，接口与接口之间可以多继承。用接口可以达到多继承的的目的。

interface Animal extends IRunning,IFlying{
    //……
}

接口继承接口，达到复用的效果，使用关键字extends。

6、常用的接口

（1）Comparable接口

import java.util.Arrays;
class Student implements Comparable{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override  //重写toString方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override  //重写Comparable中的compareTo方法
    public int compareTo(Object o) {
        Student x=(Student)o;
        if(this.age>x.age){
            return -1;
        }if(this.age<x.age){
            return 1;
        }else{
            return 0;
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("zhangsan",18);
        students[1]=new Student("lisi",22);
        students[2]=new Student("liming",21);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

当我们对students进行排序时，编译器不能确定通过什么排序，此时会报错，需要重写Comparable接口中的compareTo方法。

（2）Cloneable接口

Object类中存在一个clone方法，掉哦用这个方法可以创建一个对象的拷贝。要想合法调用clone方法，必须先实现Cloneable接口。否则会抛出CloneNotSupportedException异常。

class Person implements Cloneable{
    private String name;
 
    public Person(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person("zhangsan");
        Person person2=(Person)person1.clone();
 
    }
}

Cloneable为空接口。空接口：标记接口。证明当前类是可以被克隆的。此时克隆的对象提供了副本，修改其中的信息不会对原信息产生影响。Cloneable拷贝出的对象是一份“浅拷贝”。

三、Object类

Object类是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认继承Object父类。如果要打印对象中的内容，可以直接重写Object类中的toString方法。

【注】使用Object可以接受所有类的对象

对象比较equals()方法

在Java中，==进行比较时：

如果==左右两侧是基本类型变量，比较的是变量中的值是否相等
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
如果要比较对象中的内容，必须重写Object中的equals方法，因为equald方法默认也是按照地址比较的

//Object类中的equals方法
public boolean equals(Object obj){
    return (this==obj);//使用引用中的地址直接来比较
}

【注】比较对象中内容是否相同时，一定要重写equals方法

频道导航