🐵本篇文章将对抽象类和接口相关知识进行讲解
一、抽象类
先来看下面的代码：
class Shape {public void draw() {System.out.println("画");}
}
class Cycle extends Shape {public void draw() {System.out.println("圆形");}
}
public class Test2 {public static void main(String[] args) {Shape shape = new Cycle(); shape.draw();}
}在上述代码中，Shape类中的draw方法，因为有动态绑定而始终没有被实现，且Shape类不能描绘某个具体的对象，我们可以将这样不能描绘某个具体对象的类设为抽象类，具体操作是：使用abstract关键字修饰这个类，此时这个类被称为抽象类，可以将抽象类中被重写的方法也用abstract修饰，此时这个方法就叫抽象方法，抽象方法不能有具体实现
abstract class Shape {public abstract void draw();
}
class Cycle extends Shape {public void draw() {System.out.println("圆形");}
}二、抽象类相关总结
1. 抽象方法所在类必须是抽象类，抽象类不一定包含抽象方法
2. 抽象类中可以有和非抽象成员变量和成员方法（和普通类一样）
3. 抽象类不能被实例化
abstract class Shape {public abstract void draw();
}
class Cycle extends Shape {public void draw() {System.out.println("圆形");}
}
public class Test2 {public static void main(String[] args) {Shape shape = new Shape();//编译报错：抽象类不能被实例化}
}
4. 抽象类必须被继承，普通类继承抽象类后，必须重写抽象类中的抽象方法，（如果抽象类中没有抽象方法则可以不用重写）如果继承抽象类的也是抽象类则不用重写
5. 抽象方法不能被private、final和static修饰
6. 在多层继承关系下，子类必须继承所有父类的抽象方法
abstract class A {public abstract void print();
}
abstract class B extends A {public abstract void test();
}
class C extends B {//必须重写print和test方法，否则编译报错public void print() {}public void test() {}
}
7. 抽象类也有构造方法，只不过是被子类调用并帮助其初始化（因为抽象类不能实例化对象）
abstract class A {public abstract void print();public A() {}
}
class B extends A {public B() {super();}public void print() {}
}
三、接口
3.1 创建接口
创建一个接口需要用到interface关键字
interface 接口名 {
}
3.2 接口的使用
类和接口之间的关系是实现，即类实现接口，具体操作是使用implements关键字实现
类名 implements 接口名 {
}
下面举一个实例：
interface IUsb {void openDevice(); //默认为抽象方法void closeDevice();
}class Mouse implements IUsb {public void openDevice() {System.out.println("打开鼠标");}public void closeDevice() {System.out.println("关闭鼠标");}public void clink() {System.out.println("点击鼠标");}
}class Keyboard implements IUsb {@Overridepublic void openDevice() {System.out.println("打开键盘");}@Overridepublic void closeDevice() {System.out.println("关闭键盘");}public void inPut() {System.out.println("键盘输入");}
}class Computer {public void powerOn() {System.out.println("开机");}public void powerOff() {System.out.println("关机");}public void useDevice(IUsb iUsb) {iUsb.openDevice(); //这里实现了多态if (iUsb instanceof Mouse) { //判断iUsb是否引用Mouse对象Mouse mouse = new Mouse(); //向下转型mouse.clink();} else if (iUsb instanceof Keyboard) {Keyboard keyboard = new Keyboard(); //向下转型keyboard.inPut();}iUsb.closeDevice();}
}public class Test {public static void main(String[] args) {Computer computer = new Computer();computer.powerOn();computer.useDevice(new Mouse()); //向上转型computer.useDevice(new Keyboard()); //向上转型computer.powerOff();}
}
3.3 接口相关总结
1. 接口中定义的成员变量默认被public static final修饰，定义的成员方法默认被public abstract修饰
2. 接口中的方法如果没有具体实现则默认为抽象方法
3. 接口中的方法一般不能具体实现（没有方法块）如果要具体实现，应由default或static修饰
interface IUsb {default void method() {System.out.println("实现method方法");}static void method1() {System.out.println("实现method1方法");}
}4. 接口不能被实例化
interface IShape {
}
public class Test1 {public static void main(String[] args) {IShape iShape = new IShape();//编译报错：接口不能被实例化对象}
}5. 一个类可以继承一个普通类/抽象类，同时还可以实现接口
interface A {}
class B {}
class C extends B implements A { //必须先继承在实现
}6. 一个类实现一个接口后，必须重写其内部的方法
四、实现多接口
在Java中不支持多继承，但可以实现多接口，即一个类可以实现多个接口
class 类名 implements 接口名,接口名, ... {
}实际上多接口就是为了解决Java中不能多继承的问题，下面举一个例子：
interface IRun {void run();
}interface ISwim {void swim();
}class Dog implements IRun, ISwim {
//实现这两个接口后，要重写接口中的抽象方法public void run() {System.out.println("跑");}public void swim() {System.out.println("游");}
}
将run()和swim()两个方法分别写到两个接口中而不是直接将这两个方法写到一个Animal类中让Dog类来继承的原因是：将来如果有其它类比如一个Bird类要继承Animal类，那就会直接将Animal类中所有的方法全部继承，但是“鸟不能游泳”所以这样写不符合逻辑
五、接口间的继承
Java中类和类之间不支持多继承，但接口和接口之间是支持多继承的
interface IJump {void jump();
}interface ISing {void sing();
}interface IRap extends IJump, ISing { }class Student implements IRap{@Overridepublic void jump() {}@Overridepublic void sing() {}
}
接口间的继承的意义就是将多个接口合并为一个接口
六、Object类
object类是所有类的父类
class Person {public String name;public Person(String name) {this.name = name;}
}public static void main(String[] args) {public static void func(Object obj) { System.out.println(obj); //这里会调用Object类中toString中的方法，打印obj所指对象的地址}public static void main(String[] args) {func(new Person("Sans")); //向上转型}
} 调用Object类中toString方法的源码顺序：
public void println(Object x) { String s = String.valueOf(x); //调用valueof方法synchronized (this) {print(s);newLine();}}public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); //若obj指向某个对象则调用toString方法}public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());} //返回对象的地址
6.1 equals方法
equals方法是Object类中的成员方法，在此之前先来回顾一下“==”
如果==左右两侧是基本类型变量，比较的是变量中值是否相同
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
equals的源码如下：
public boolean equals(Object obj) {return (this == obj);
}
下面举一个实例：
class Person {public String name;public Person(String name) {this.name = name;}
}public class Test {public static void main(String[] args) {func(new Person("Sans"));Person person1 = new Person("Sans");Person person2 = new Person("Sans");System.out.println(person1.equals(person2));//由于person1和person2指向不同对象，所以它们的地址不同
}如果要使用equals方法比较对象的内容，则需要在Person类中重写equals方法，
class Person {public String name;public Person(String name) {this.name = name;}public boolean equals(Object obj) {Person per = (Person) obj;return per.name.equals(this.name); //name是String类型，String类继承了object类同时也重写了equals方法//所以这里是调用了String类的方法}}public class Test {public static void main(String[] args) {Person person1 = new Person("Sans");Person person2 = new Person("Sans");System.out.println(person1.equals(person2));//Person类继承了object类并重写了equals方法，所以这里//发生动态绑定，调用子类即Person类的equals方法
}
