day14、接口

一、接口

相当于一种特殊的抽象类，定义方式、组成部分与抽象类类似

接口不关心具体的实现，只关心提供什么能力

微观概念：接口是一种能力和约定
宏观概念：接口是一种标准

• 接口的定义：代表某种能力
• 方法的定义：能力的具体要求

类与类之间是单继承，接口与实现类之间多实现关系，接口与接口是多继承关系

接口支持多实现，可为类扩充多种能力

1、接口的语法

关键字interface

//1.定义一个接口
public interface 接口名{
    //公开的静态的常量
	public static fianl String FIELD = "value"
    //只能是公开的抽象方法
	public abstract void method();
}
//2.需要实现类来实现接口：类比子类继承抽象类。
class 实现类 implements 接口名{
    //重写接口中的抽象方法
}
//3.创建实现类的对象

//可以不写，编译器会默认添加
public static fianl
public abstract

2、 接口注意点

• 0.接口不能实例化
• 1.接口不能有构造方法
• 2.接口中的变量是默认为，公开的静态常量 public static final来修饰
• 3.接口中的方法默认为，公开的抽象方法 public abstract来修饰
• 4.接口不可以实现接口，但是可以继承接口

3、 接口实现类的语法

命名规则
	1、I接口名
	2、接口名Impl
包，一般创建在接口所在的包的位置建立一个包，名称impl
	
语法：
    public class 实现类的类名 implements 接口名{}
	public class 实现类的类名 implements 接口名,接口名,接口名....{} 多实现的时候

4、接口的规范

• 任何类在实现接口时，必须实现接口中所以的抽象方法，否则此类为抽象类
• 实现接口中是抽象方法时，访问修饰符必须是public

5、接口的注意点

5.1、一个类还可以实现多个接口

//定义一种规则：
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 Test {
	public static void main(String[] args) {
		A a = new DemoA();
		a.testA();
		//实现接口A中的fun()
		a.fun();
		
		B b = new DemoA();
		b.testB();
		//实现接口B中的fun()
		b.fun();
		
		DemoA demoA = new DemoA();
		demoA.testA();
		demoA.testB();
		//实现实现类DemoA中的fun()
		demoA.fun();
	}
}

5.2、接口可以多继承

//一种规则
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 Test {

	public static void main(String[] args) {
		//C接口实现类
		C c = new DemoB();
		c.testC();
		//D接口实现类
		D d = new DemoB();
		d.testD();
		//E接口实现类
		E e = new DemoB();
		e.testC();
		e.testD();
		e.testE();
	}
}

5.3、如果一个类没有实现接口中的所有的方法，那么它是抽象的

//一个实现类可以实现接口，但是如果没有实现全部的方法， 那么该类是抽象的。等待子类继承，并且实现抽象方法。
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 Test {

	public static void main(String[] args) {
		L l = new L();
		l.test1();		
	}
}

5.4、一个类也可以继承父类，同时实现接口。

/**
 * 一个类继承了一个父类：那么就可以直接使用父类的非私有化的属性和方法。
 * 同时，还实现接口某个接口规则。
 * 这个类即作为一个父类的子类，又作为了一个接口的实现类。
 */
//表示一种协议，一种规则
interface H {
	void testH();
}
//继承？is - a，子类是一个特殊的父类
class M {
	public void testM() {
		
	}
}
/**
 * 定义一个类：N
 * 继承了父类M：意味着N这个类可以直接使用父类的非私有化的属性和方法。
 * 同时实现接口H：意味着满足接口H中的所有规则：抽象方法。。
 * @author asus
 * @Description:实现接口并继承父类
 */
class N extends M implements H {

	@Override
	public void testH() {
		System.out.println("满足了接口H的协议规则。。");
	}
	@Override
	public void testM(){
		System.out.println("重写父类中的testM方法。。。");
	}
}

public class Test {

	public static void main(String[] args) {
		// 父类引用，指向子类的对象：一种对象的多态
		M m = new N();
		m.testM();

		System.out.println("-----------------");
		// 接口引用，指向实现类对象：一种接口的多态
		H h = new N();
		h.testH();
	}
}

5.5、jdk 1.8 的新特性：default方法。

1、静态方法（语法级别上允许）
2、默认的方法：jdk1.8版本出现的新特性。
	目的：不强制一定要实现某个功能。

6、接口的引用

同父类一样，接口也可以声明为引用，并指向实现对象。其实就是一种接口的多态。

接口类型的引用 = new 实现类的对象

注意：

接口作为引用仅可调用接口所声明的方法，不可以调用实现类中独有的方法。可以强制转回实现类的类型，就可以调用新增的方法。

7、常量接口

将多个常用于表示状态或固定值的常量，以静态常量的形式定义在接口中统一管理，提供代码的可读性

8、接口的好处

程序的耦合度降低
更自然的使用多态
设计与实现完全分离
更容易更换具体实现
更容易搭建程序框架

9、接口回调

先有接口的使用者，再有接口的实现者

接口回调可以看做多态的一种应用

•  父类引用指向子类
  

•  接口引用指向实现类
  

首有个接口A，和接口A实现类。然后在另一个类B中，持有A的引用，那么在B类中可以调用接口A的方法。这就是一种回调。

二、接口与抽象类的异同

1.相同点

• 都可以写抽象方法
• 可以编译成字节码文件
• 不能创建对象
• 可以作为引用类型
• 具备Object类中所定义的方法

2.对比接口与抽象类

对比点	抽象类	接口
关键字	class	interface
概念	不能被实例化的类，可能包含抽象方法。理解“做父类”	定义标准，规则，规范，协议。
构成	构造方法，普通方法，静态方法，抽象方法，成员变量，静态属性，常量	公开的静态常量，公开的抽象方法
和子类关系	子类继承，与子类关系 is a	实现类实现接口的规则，与实现类关系 has a
关系	extends	implements
用法	抽象类作为父类，抽象方法，强制子类重写	要求实现类实现约定
特点	子类只能单继承父类	实现类可以实现多个接口

三、类和类的关系

1、继承关系

继承是指一个类继承另一个类。一个作为子类，另一个是父类。子类可以使用父类的内容，还可以扩展自己的内容。

public class Animal{}
public class Cat extends Animal{}

2、实现关系

实现是指一个类，实现接口中所有的抽象方法。一个类可以同时实现多个接口。

public interface A{}
public class AImple implements A{}

3、依赖关系

一个类依赖另一个类。两个类之间的耦合度不大。代码层面体现：一个类作为另一个类的方法的参数。

public class Pet{}
public class Girl{
    public void play(Pet pet){
        
    }
}

4、关联关系

两个类之间的依赖关系比较强。代码层面体现：一个类作为另一个类的属性。

public class Book{}
public class Person{
	Book book;
}

特殊的关联关系：聚合，组合…