Java中的抽象类和接口

• 抽象类
• 接口
• 抽象类和接口的区别

抽象类

抽象方法：没有实际工作的方法。abstract关键字定义。不能是privata（一定被重写）

abstract void f();

抽象类：包含抽象方法的类。不能加final（一定被继承）

ps：
1、抽象类和普通类最大的区别是抽象类包含抽象方法。
2、抽象类不能被实例化 new
3、存在的意义就是要被继承和提前检查代码的错误（向上转型--父类不能被new）（防止客户端程序员创建该类的对象）
4、抽象类一旦被继承，一定要重写抽象方法
5、一个类继承了抽象类，如果不想重写抽象方法。那么当前类必须也设置成抽象类(可重写也可不重写)

接口

接口：interface定义一个接口。接口中包含的方法都是抽象方法，字段都是静态常量。

ps：
1、定义的成员方法默认是 public abstract
2、定义的成员属性默认是 public static final
3、类和接口的关系是实现：implements; 接口和接口的关系是extend
4、实现了接口必须重写抽象方法
5、使用接口的核心原因：为了能够向上转型为多个基类型。还有一个原因是防止客户端程序员创建该类的对象。

接口不仅仅是一种更纯粹的抽象类，接口没有任何具体的实现，因此多个接口可以自由组合。组合多个类的接口的行为称为多重继承。

抽象类和接口的区别

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

no	区别	抽象类（abstract）	接口（interface）
1	结构组成	普通方法+抽象方法	抽象方法+全局变量
2	子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
3	关系	一个抽象类可以实现若干个接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
4	子类限制	一个子类只能继承一个接口	一个子类可以实现多个接口
5	权限	各种权限	public

=================================================

接口使用示例：

1、如果要排序自定义类型，需要手动实现comparable接口。
①该类实现(implements)comparable接口
②重写comparaTo方法

package com.test;

import java.util.Arrays;

public class Student implements Comparable<Student> {
    public String name;
    public int age;
    public double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public int compareTo(Student o) {
//        return this.age - o.age;
        return this.name.compareTo(o.name);
    }

    public static void main(String[] args) {
        Student[] student = new Student[2];
        student[0] = new Student("b",18,66.6);
        student[1] = new Student("a",16,33.3);
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

}

2、接口实现clone
①实现conleable接口
②重写object clone(); 方法
③如果当前类包含引用类型，在当前类（Person）的克隆方法内不仅要克隆自己本身还需要克隆引用类型 （Money）。

package com.test;

class Money implements Cloneable{
  double money = 12.5;

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

class Person implements Cloneable {
    public String name;
    public Money m;
    public Person() {
        this.m  = new Money();
    }


    @Override
    protected Object clone() throws CloneNotSupportedException {
       // return super.clone();
        Person per = (Person) super.clone();
        per.m = (Money)this.m.clone();
        return per;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        person.name = "caocao";
        Person person1 = (Person) person.clone();
        System.out.println(person.name);
        System.out.println(person1.name);
        person1.name = "hh";
        System.out.println(person.name);
        System.out.println(person1.name);
    }
}

(￣▽￣)~*