抽象类

什么是抽象类？

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

比如：在继承关系当中的父类，它并不描绘一个具体的对象，只是用来描绘所有子类对象的一些共性，因此它就可以被定义成抽象类。

抽象类语法

在Java中，如果一个类被abstract修饰称为抽象类，抽象类中被abstract修饰的方法称为抽象方法，抽象方法不用给出具体的实现。因为抽象类是必须要被继承才能使用的，在继承抽象类后必须重写抽象方法。

// 抽象类
abstract class Animal{
    // 抽象方法
    abstract public void eat();
    abstract public void sleep();

}

注： 抽象类也是类，也可以包含属性和普通方法，甚至是构造方法。

抽象类特性

1. 抽象类不能直接实例化对象，即不能直接new。
2. 抽象方法不能是private修饰的。
3. 抽象方法不能被final和static修饰。
4. 抽象类必须被继承使用，并且继承后子类要重写父类中的抽象方法；否则子类也是抽象类，必须用abstract修饰。
5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类—必须加abstract修饰。
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。
7. 使用抽象类是为了“预防出错”，防止不小心使用父类方法来完成原本应该子类方法完成的工作。

接口

什么是接口？

接口：就是公共的行为规范标准，大家只要符合规范标准就可以使用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

接口语法

public interface 接口名称{
    // 抽象方法
    public abstract void method();
    public void method1();
    abstract void method2();
    
    void method3();
}

注：

1. 接口中的方法默认被 public abstract修饰，public和abstract都可以省略，更推荐都省略掉。
2. 创建接口时，接口的名称一般以 大写字母‘I’开头。
3. 接口的命名一般使用“形容词”词性的单词。

接口使用

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

class 类名 implements 接口名{
    ......
}

接口特性

1. 接口是一种引用类型，但是不能直接new接口对象。
2. 接口中的每个方法都默认被public abstract修饰。
3. 接口中的方法不能在接口中实现只能在实现接口的类中实现。
4. 重写接口中的方法时以 public 访问权限修饰。
5. 接口中可以有变量，但是默认被 public static final 修饰。
6. 接口中不能有静态代码块和构造方法。
7. 接口虽然不是类，但是接口经过编译以后生成的字节码文件也是以 .class为后缀。
8. 如果类没有实现接口的所有抽象方法，则类必须设置为抽象类。

实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类。但是一个类可以实现多个接口。

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

interface IRun{
    void run();
}

interface IEat{
    void eat();
}

interface ISwim{
    void swim();
}

class Duck extends Animal implements IRun,IEat,ISwim{
    public Duck(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("鸭子跑");
    }

    @Override
    public void eat() {
        System.out.println("鸭子吃");
    }

    @Override
    public void swim() {
        System.out.println("鸭子游");
    }
}

注： 一个类实现多个接口时，每个接口中的抽象方法都要实现，否则该类必须设置为抽象类。

接口间的继承

在Java中，类和类之间是单继承的，但是接口和接口之间可以多继承。

interface IRun{
    void run();
}

interface ISwim{
    void swim();
}

interface IAmphibious extends ISwim,IRun{

}

class Frog implements IAmphibious{
    @Override
    public void run() {
        
    }

    @Override
    public void swim() {

    }
}

抽象类 VS 接口

抽象类和接口都是Java中多态的常见使用方式。

二者的核心区别是：
抽象类中包含普通方法和普通字段，这样的普通方法和普通字段可以被子类直接使用，不用重写。
接口中不能包含普通方法，子类必须重写所有的抽象方法。

Java中的 Clonable 接口

Object类中存在一个clone（）方法，调用这个方法可以创建对象的拷贝，但是想要合理调用clone（）方法，必须要实现Clonable接口，否则就会抛出 CloneNotSupportedException 异常。

class Animal implements Cloneable {
    public String name;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

注：拷贝出的对象是一份浅拷贝。

Java中的 Object 类

Object是Java默认提供的一个类，且它是所有类的父类。Java中，所有的类都默认继承Object类。

Object类中也存在一些定义好的方法：

1. toString（）方法：打印对象中的内容；

class Animal{
    public String name;

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                '}';
    }
} 

2. equals（）方法：
在Java中，使用 == 进行比较时：
1> 如果左右两侧是基本类型变量：比较的是变量中的值是否相等；
2> 如果左右两侧是引用类型变量：比较的是引用变量地址是否相等；
3> 如果要比较对象中的内容，必须重写Object中的equals（）方法，因为equals（）方法默认是按照地址比较的。

class Animal {
    public String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Animal animal = (Animal) o;
        return Objects.equals(name, animal.name);
    }

}

3. hashcode（）方法：用来确定对象在内存中的存储位置；

class Animal {
    public String name;
    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}