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方法
