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版本出现的新特性。

目的：不强制一定要实现某个功能。