接口
a.所有版本:
静态常量
默认添加 public static final
Long.MAX_VALUE
Int.MAX_VALUE
抽象方法
接口的使用步骤
b.JDK1.8版本
静态方法
属于接口,通过接口名.方法名调用
默认方法
通常用来做接口功能的扩展,可以选择性的在实现类中重写(覆盖/实现)
c.JDK1.9版本
私有方法
普通私有:
为了给默认方法中的公共代码提取,实现代码的复用
静态私有:
给静态方法中公共代码提取
定义格式
public interface 接⼝名称 {
// 抽象⽅法
// 默认⽅法
// 静态⽅法
// 私有⽅法
}
接口的使用步骤
a.接口不能new 对象,需要一个实现类实现接口
b.实现类中必须重写接口中所有的抽象方法
c.通过实现类调用方法
public interface LiveAble {
public default void fly() {
System.out.println("天上⻜");
}
}
public class Animal implements LiveAble {
// 继承,什么都不⽤写,直接调⽤
}
public static void main(String[] args) {
// 创建⼦类对象
Animal a = new Animal();
// 调⽤默认⽅法
a.fly();
}
}
//输出结果:天上⻜
接口和类的关系:
类 和 类(单继承): 1 v 1 extends 继承
接口 和 类: 没有此关系
类 和 接口(多实现): 1 v n implements 实现
接口 和 接口(多继承): 1 v n extends 继承
public default void method() {
System.out.println("AAAAAAAAAAAAAAAAAAA");
}
}
interface B {
public default void method() {
System.out.println("BBBBBBBBBBBBBBBBBBB");
}
}
interface D extends A, B {
@Override
public default void method() {
System.out.println("DDDDDDDDDDDDDD");
}
}
多态
class Cat extends Animal {
public void eat() {
System.out.println("吃⻥");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃⻣头");
}
}
public class Test {
public static void main(String[] args) {
// 多态形式,创建对象
Cat c = new Cat();
Dog d = new Dog();
// 调⽤showCatEat
showCatEat(c);
// 调⽤showDogEat
showDogEat(d);
/*
* 以上两个⽅法,均可以被showAnimalEat(Animal a)⽅法所替代
* ⽽执⾏效果⼀致
*/
showAnimalEat(c);
showAnimalEat(d);
}
public static void showCatEat(Cat c) {
c.eat();
}
public static void showDogEat(Dog d) {
d.eat();
}
public static void showAnimalEat(Animal a) {
a.eat();
}
}
⽗类类型 变量名 = new ⼦类类型();
如:Animal a = new Cat();
⼦类类型 变量名 = (⼦类类型) ⽗类变量名;
如: Cat c =(Cat) a;
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃⻥");
}
public void catchMouse() {
System.out.println("抓⽼⿏");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃⻣头");
}
public void watchHouse() {
System.out.println("看家");
}
}
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调⽤的是 Cat 的 eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调⽤的是 Cat 的 catchMouse
}
}
多态出现的好处:类型统一,规范代码,代码的复用性