1、接口可以多实现：一个实现类可以同时实现多个接口
package com.qf.demo02_interface;
//定义一种规则：
interface A{
public void testA();//
public void fun();
}
//定义另一种规则
interface B{
public void testB();
public void fun();
}
//实现类，实现接口A。满足接口的规则：其实就是要实现接口中所有的抽象方法。
class DemoA implements A,B{
@Override
public void testA() {
System.out.println("DemoA类，满足接口A的规则。。。");
}
@Override
public void testB() {
System.out.println("DemoA类，也满足接口B的规则。。。");
}
@Override
public void fun() {
System.out.println("DemoA类，实现类fun方法。。。");
}
}
public class Test1Interface {
public static void main(String[] args) {
A a = new DemoA();
a.testA();
a.fun();
B b = new DemoA();
b.testB();
b.fun();
DemoA demoA = new DemoA();
demoA.testA();
demoA.testB();
}
}
2、接口可以多继承
类中的方法：有声明有实现的方法。
接口中方法：有声明，没有实现。将功能的描述，和功能的实现，分离开。
package com.qf.demo03_interface;
//一种规则
interface C{
public void testC();
}
//另一种规则
interface D{
public void testD();
}
//接口可以继承多个父接口
interface E extends C,D{
public void testE();
}
//实现类，实现接口E
class DemoB implements E{
@Override
public void testC() {
System.out.println("C协议。。");
}
@Override
public void testD() {
System.out.println("D协议。。");
}
@Override
public void testE() {
System.out.println("E协议。。。");
}
}
public class Test3Interface {
public static void main(String[] args) {
C c = new DemoB();
c.testC();
D d = new DemoB();
d.testD();
E e = new DemoB();
e.testC();
e.testD();
e.testE();
}
}
3、一个类如果实现接口了，还能继承其他的父类吗？可以的
意味着，一个类继承了一个父类：那么就可以直接使用父类的非私有化的属性和方法。
同时，还实现接口某个接口规则。
这个类即作为一个父类的子类，又作为了一个接口的实现类。
package com.qf.demo04_interface;
//表示一种协议，一种规则
interface H{
public void testH();
public void fun();
}
//继承？is - a，子类是一个特殊的父类
class M{
public void testM(){
System.out.println("我是M类的方法。。");
}
public void fun(){
System.out.println("M类中的fun方法。。。");
}
}
//定义一个类：N
//继承了父类M：意味着N这个类可以直接使用父类的非私有化的属性和方法。
//同时实现接口H：意味着满足接口H中的所有规则：抽象方法。。
class N extends M implements H{
@Override
public void testH() {
System.out.println("满足了接口H的协议规则。。");
}
//父类的fun方法，一旦存在继承关系，相当于子类也有一份。
// public void fun(){
// System.out.println("M类中的fun方法。。。");
// }
}
public class Test4 {
public static void main(String[] args) {
//课间思考题：一个类可以继承父类的同时，再实现接口吗？
M m = new N();//父类引用，指向子类的对象：一种对象的多态
m.testM();
m.fun();
System.out.println("-----------------");
H h = new N();//接口引用，指向实现类对象：一种接口的多态
h.testH();
h.fun();
}
}
4、如果一个类没有实现接口中的所有的方法，那么它是抽象的
一个实现类可以实现接口，但是如果没有实现全部的方法， 那么该类是抽象的。等待子类继承，并且实现抽象方法。
package com.qf.demo05_interface;
interface K{
public void test1();
public void test2();
}
abstract class KImpl implements K{
@Override
public void test1() {
}
}
class L extends KImpl{
@Override
public void test2() {
}
}
public class Test5 {
public static void main(String[] args) {
}
}
5、接口中的两个特殊的方法
1、静态方法：
2、默认的方法：jdk1.8版本出现的新特性。
目的：不强制一定要实现某个功能。