Java基础接口

接口：

1、接口也是一种“引用数据类型”。编译之后也是一个class字节码文件。

2、接口是完全抽象的。(抽象类是半抽象。)或者也可以说接口是特殊的抽象类。

3、接口怎么定义，语法是什么？

• [修饰符列表] interface 接口名{}

4、接口支持多继承，一个接口可以继承多个接口。

5、接口中只支持两部分内容，一部分是：常量。一部分是：抽象方法。接口中没有其它内容。

6、接口中所有的元素都是public修饰的。(都是公开的)。

7、接口中的抽象方法定义时：public abstract修饰符可以省略。

8、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。

9、接口中的常量的public static final 可以省略

总结一句话：三个字“解耦”
面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
接口的使用离不开多态机制。(接口+多态才可以达到降低耦合度。)

接口可以解耦合，解开的是谁和谁的耦合！！！
任何一个接口都有调用者和实现者
接口可以将调用者和实现者解耦合
调用者面向接口调用
实现者面向接口编写实现

示例代码：

public class InterfaceTest01{
	public static void main(String[] args){
		
		//输出常量
		System.out.println(MyMath.PI);
		
		//编译报错，无法为最终变量PI分配值
		//MyMath.PI = 15.2;
		System.out.println(MyMath.k);
		// MyMath.k = 111;
	}
}

//接口A
interface A{
	
}
//接口可以单继承
interface B extends A{
	
}
//接口可以多继承
interface c extends B,A{
	
}
//我的数学接口
interface MyMath{
	
	//常量
	public static final double PI = 3.1415926;
	
	//public static final 可以省略吗？[可以]
	//double PI = 3.1415926;//编译通过
	
	//k是不是常量？？？是
	//接口中随便写一个变量就是常量
	//常量：值不能发生改变的常量
	int k = 80;
	
	//抽象方法
	public abstract int sumInt(int a,int b);
	
	//public abstract 可以省略并且接口中的方法不能带有主体
    int sum(int x,int b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

接口的基础语法：
1、类和类之间叫做继承，类和接口之间叫做实现。
别多想：你仍然可以将"实现"看做“继承”。
继承使用extends关键字完成。
实现使用implements关键字完成。

2、五颗星：当一个非抽象的类实现接口的话，必须将接口中所有的
抽象方法全部实现（覆盖、重写）。

示例代码：

public class InterfaceTest02{
	
	public static void main(String[] args){
		
		//接口可以使用多态
		//父类型的引用指向子类型的对象
		MyMath mm = new MyMathImpl();
		//调用接口里面的方法(面向接口编程)
		int result1 = mm.sum(10,20);
		System.out.println(result1);
		
		int result2 = mm.sub(20,10);
		System.out.println(result2);
	}
}
	
//特殊的抽象类，完全抽象的，叫做接口
interface MyMath{
	double PI = 3.1415926;
	int sum(int a,int b);
	int sub(int a,int b);
}

// 这样没问题
/*
abstract class MyMathImpl implements MyMath {
}
*/

//编写一个类(这个类是一个“非抽象”的类)
//此类名字随意
//错误：MYMathImpl不是抽象的，并且未覆盖MyMath中的抽象方法sub（int，int）
//class MyMathImpl implements MyMath{}

class MyMathImpl implements MyMath{
	
	//错误：正在尝试分配更低的访问权限; 以前访问权限为public【访问权限控制符】
	/*
	int sum(int a, int b){
		return a + b;
	}
	*/
	
	// 重写/覆盖/实现 接口中的方法（通常叫做实现。）
	public int sum(int a,int b){
		return a + b;
	}
	
	public int sub(int a,int b){
		return a - b;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？

• 对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的…

重点（五颗星）：一个类可以同时实现多个接口。

这种机制弥补了java中的哪个缺陷？

• java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中存在多继承，java中的接口弥补了单继承带来的缺陷。

• 接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。编译器没意见。但是运行时可能出现：ClassCastException

之前有一个结论：

• 无论向上转型还是向下转型，两种类型之间必须要有继承关系，没有继承关系编译器会报错。（这句话不适用在接口方面。）最终实际上和之前还是一样，需要加：instanceof运算符进行判断。向下转型养成好习惯。转型之前先if+instanceof进行判断。

示例代码：

public class InterfaceTest03{
	
	public static void main(String[] args){
		
	   // 多态该怎么用呢？
	   // 都是父类型引用指向子类型对象
	   A a = new D();
	   B b = new D();
	   C c = new D();
	   
	   
	   //a.m2(); // 编译报错。A接口中没有m2()方法。
	   
	   // 这个编译没问题，运行也没问题。
	   // 调用其他接口中的方法，你需要转型（接口转型。）
	   B b2 = (B)a;
	   b2.m2();
	   
	   // 直接向下转型为D可以吗？可以
		D d = (D)a;
		d.m2();

	   
       m m = new e();
	   
	   // 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
	   // 但是一定要注意，运行时可能会出现ClassCastException异常。
	   // 编译没问题，运行有问题。
	   //k k = (k)m;
       if(m instanceof k){
		   k k = (k)m;
	   }	   
	}
}

interface X{
	
}

interface Y{
	
}

interface Z extends X,Y{ //接口和接口支持多继承。
}

interface k{
	
}

interface m{
	
}

class e implements m{
	
}

interface A{
	void m1();
}

interface B{
	void m2();
}

interface C{
	void m3();
}

// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{

    public void m1(){
		
	}

    public void m2(){
		System.out.println("m .....");
	} 
	
	public void m3(){
		
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

继承和实现都存在的话，代码应该怎么写？

• extends 关键字在前。implements 关键字在后。

示例代码：

public class InterfaceTest04{
	
	public static void main(String[] args){
		// 创建对象（表面看Animal类没起作用！）
		Flyable f = new Cat();//多态。
		f.fly();
		
		// 同一个接口
		Flyable f2 = new Fish();
		// 调用同一个fly()方法，最后的执行效果不同。
		f2.fly();
	}
}

// 动物类：父类
class Animal{
	
}

// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
	void fly();
}

// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
	
	public void fly(){
		System.out.println("我是一只猫，我在太空翱翔，我喜欢飞！");
	}
}

// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class snake extends Animal{
	
}

// 想飞就插翅膀这个接口。
// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{//没写extends，也是有的，默认继承Object。
	public void fly(){
		System.out.println("我是一只鱼，我学会了飞！(六眼飞鱼！)");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53