目录

抽象方法和抽象类

示例

使用要点

接口(interface)

作用

定义及使用

声明格式

定义接口的详细说明

要点

示例

接口中定义静态方法和默认方法(JDK8及以后)

默认方法

示例

静态方法

接口的多继承

示例

---

抽象方法和抽象类

• 抽象方法

  • 使用abstract修饰的方法，没有方法体，只有声明

  • 定义的是一种"规范"，就是告诉子类必须要给抽象方法提供具体的实现

• 抽象类

  • 包含抽象方法的类就是抽象类

  • 通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用

示例

package AbstarctLearn;
​
public abstract class Test01 {
​int age;public abstract void rest();public abstract void play();public abstract void learn();
​public void shout(){System.out.println("啊啊啊啊啊啊啊");}
}
​
class zhang extends Test01{// 子类必须实现父类的抽象方法@Overridepublic void rest(){System.out.println("该休息咯~");System.out.println("zhang.rest");}
​@Overridepublic void play(){System.out.println("该玩耍咯~");System.out.println("zhang.play");}
​@Overridepublic void learn() {System.out.println("该学习咯~");System.out.println("zhang.learn");}
}
​
class san extends Test01{
​// 子类必须实现父类的抽象方法@Overridepublic void rest() {System.out.println("san.rest");}
​@Overridepublic void play() {System.out.println("san.play");}
​@Overridepublic void learn() {System.out.println("san.learn");}
}

使用要点

• 有抽象方法的类只能定义成抽象类

• 抽象类不能实例化，即不能用new来实例化抽象类

• 抽象类可包含属性、方法、构造方法，但构造方法不能用new来实例，只能用来被子类调用

• 抽象类只能用来被继承

• 抽象方法必须被子类实现

接口(interface)

一组规范，所有实现类都要遵守

作用

• 更加规范的对子类进行约束，全面且专业的实现了：规范和具体实现的分离

• 接口是两个模块之间通信的标准，通信的规范

• 接口和实现类不是父子关系，是实现规则的关系

定义及使用

声明格式

[访问修饰符] interface 接口名 [extends 父接口1，父接口2...]{

常量定义；

方法定义；

}

定义接口的详细说明

• 访问修饰符：只能是pubic或默认

• 接口名：和类名采用相同命名机制

• extends：接口可以多继承

• 常量：接口中的属性只能是常量，总是：public static final修饰，不写也是

• 方法：接口中的方法只能是：public abstract，省略也是

要点

• 子类通过implements实现接口中的规范

• 接口不能创建实例，但可用于声明引用变量类型

• 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的

• JDK1.8(不含8以前)，接口中只能包含静态变量，抽象方法，不能有普通方法、构造方法、普通方法

• JDK1.8（不含8）后，接口中包含普通的静态方法，默认方法

示例

package InterfaceLearn;
​
public interface Volant {
​/* (public static final 自动写) */int h = 100;/* (public abstract 自动写)*/void Fly();
}
​
//定义好人接口
interface Honest{void helpOther();
}
​
class GoodMan implements Honest{@Overridepublic void helpOther() {System.out.println("你真是个好人！");}
}
​
class BirdMan implements Volant{@Overridepublic void Fly(){System.out.println("你真是个鸟人啊！");}
}
​
class Angel implements Volant,Honest{@Overridepublic void Fly(){System.out.println("你是个天使哎");}@Overridepublic void helpOther(){System.out.println("天使实锤！");}
}

package InterfaceLearn;
​
import duotaiLearn.Animal;
​
public class TestVolant {public static void main(String[] args) {GoodMan g = new GoodMan();BirdMan b = new BirdMan();Angel a = new Angel();g.helpOther();  // 你真是个好人！b.Fly();        // 你真是个鸟人啊！a.Fly();        // 你是个天使哎a.helpOther();  // 天使实锤！System.out.println(Volant.h); // 通过类名可访问常量 : 100}
}

接口中定义静态方法和默认方法(JDK8及以后)

默认方法

• 允许给接口添加一个非抽象的方法实现，只需要使用default关键字即可，这个特征叫做默认方法(扩展方法)

• 默认方法和抽象方法的区别：抽象方法必须被实现，默认方法不是。作为替代方式，接口可以提供默认方法的实现，所有这个接口的实现类都可得到默认方法

示例

package InterfaceLearn;
​
public interface TestDefault {void printInfo();
​default void printDefault(){System.out.println("哈哈哈哈~管不着我~！");}
}
​
class TestDefault01 implements TestDefault{@Overridepublic void printInfo(){System.out.println("哦莫，我必须在！");}
}

package InterfaceLearn;
​
public class Test01 {public static void main(String[] args) {TestDefault t = new TestDefault01();t.printInfo();       // 哦莫，我必须在！t.printDefault();    // 哈哈哈哈~管不着我~！}}

静态方法

• 如果子类定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于子类，可通过子类名直接调用

• 可在接口中直接定义静态方法的实现，这个静态方法直接从事与接口，可通过接口名调用

package InterfaceLearn;
​
public interface TestStatic {public static void teststatic01(){System.out.println("我是静态方法哟~");}
}
​
class static02 implements TestStatic{public static void teststatic01(){System.out.println("hi hi hi hi");}
}

package InterfaceLearn;
​
public class TestStatic01 {public static void main(String[] args) {
​// 一个属于接口，一个属于子类，完全独立，不是实现的关系TestStatic.teststatic01();  // 我是静态方法哟~static02.teststatic01();    // hi hi hi hi}
}

注意：默认方法中可以调用静态方法，但反之不行

接口的多继承

接口支持多继承，与类的继承类似，子接口extends父接口，会获得父接口中的一切

示例

package InterfaceLearn;
​
public interface DuojichengInterface {public static void main(String[] args) {C c = new C01();c.testC();      // C小子是抽象得，还得重写本身非默认方法！c.testA();      // C继承了本A,所以C你得重写本Ac.testB();      // C继承了本B,所以C你还得重写本B}
}
​
interface A{void testA();
}
​
interface B{void testB();
}
​
interface C extends A,B{void testC();
}
​
class C01 implements C{@Overridepublic void testA() {System.out.println("C继承了本A,所以C你得重写本A");}
​@Overridepublic void testB() {System.out.println("C继承了本B,所以C你还得重写本B");}
​@Overridepublic void testC() {System.out.println("C小子是抽象得，还得重写本身非默认方法！");}
}