黑马程序员——接口和多态

黑马程序员--接口和多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

接口

一、定义

接口（interface）：当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类；interface 用于定义接口。

二、格式：interface{}

1，接口定义内容：常量，抽象方法。
2，接口中的成员都有固定修饰符(默认，但是为了阅读性，写全很重要)。
   成员常量：public static final
   成员方法：public abctract
3，接口中的成员都是public。（抽象类中可以自己设置权限）

注意：接口不可以创建对象，因为抽象方法需要被子类实现，当子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。

三、抽象类和接口

相同点：都是被抽取的共性内容。

不同点：

1、抽象类需要被继承，但只能但继承； 接口需要被实现，而且可以多实现。

2、抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以使用非抽象方法；

接口中只能定义抽象方法，必须由子类去实现。

3、抽象类的继承是所属关系（is a），定义该体系的基本共性内容；

接口的实现是相似关系（like a），它用于扩展体系内容。

四、特点

因为接口是抽象类，没有方法体，它具有如下特点：
1、接口是对外暴露的规则；
2、接口是程序的功能扩展；
3、接口可以用来多实现；
4、类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；
5、接口与接口之间可以有继承关系；

[java] view plain copy print ?

1. interface A  
2. {  
3.     public void show();  
4. }  
5. interface B  
6. {  
7.     public void show();  
8. }  
9. class Q  
10. {  
11.     public void show()  
12.     {  
13.     }  
14.   
15. }  
16. abstract class P extends Q implements A,B  
17. {  
18. }  

interface A
{
	public void show();
}
interface B
{
	public void show();
}
class Q
{
	public void show()
	{
	}

}
abstract class P extends Q implements A,B
{
}

PS:

1、耦合性：事物间紧密程度。

2、基本功能定义在类中，体系外的扩展内容定义在接口中。

多态

一、定义

事物存在的多种体现形态，可理解为身份的转换。它不仅体现在对象上，如函数（重载和覆盖）。

二、原理

1、向上转型：通过将事物的概念进一步抽象，扩大可调用对象的范围，以方便对象的调用，提高代码的扩展性。

例：Animal a = new Cat(); 其中将动物等价于猫，扩展了对象猫的应用范围。

2、 向下转型：强制将父类的引用转换成子类类型，这种做法弥补了多态的父类的功能的局限性。

例：Cat c = (Cat)a;  其中c是子类对象，a为之前创建的父类对象。

3、多态自始至终都是子类在变化。

三、特点

1、 多态的前提： a.类与类之间必须有关系。要么继承，要么实现；b.存在覆盖。 
2、 多态的表现：父类的引用指向了自己的子类对象，即父类的引用也可以接收自己的子类对象。

3、 多态的优缺点：

优：提高了程序的扩展性； 便于程序维护。

缺：只能使用父类的引用访问父类中的成员。

4、代码的特点：
a.非静态成员函数：
编译时期：参阅引用型变量所属的类中是否有调用方法。（看父类）

运行时期：参阅对象所属的类中是否有调用的方法（重写特性）。（看子类）

[java] view plain copy print ?

1. class Fu  
2. {  
3.     public void run()  
4.     {  
5.         System.out.println("fu run");  
6.     }  
7. }  
8. class Zi extends Fu  
9. {  
10.     public void run()  
11.     {  
12.         System.out.println("zi .... run");  
13.     }  
14. }  
15. class  UnStaticMethod  
16. {  
17.     public static void main(String[] args)   
18.     {  
19.         Fu f = new Zi();  
20.         f.run();  
21.     }  
22. }  

class Fu
{
	public void run()
	{
		System.out.println("fu run");
	}
}
class Zi extends Fu
{
	public void run()
	{
		System.out.println("zi .... run");
	}
}
class  UnStaticMethod
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		f.run();
	}
}

输出结果：

b.成员变量：

无论编译和运行，都参考引用型变量所属的类。（看左边）

[java] view plain copy print ?

1. class Fu  
2. {  
3.     int num = 8;  
4. }  
5. class Zi extends Fu  
6. {  
7.     int num = 6;  
8. }  
9. class DuoTaiDemo   
10. {  
11.     public static void main(String[] args)   
12.     {  
13.         Fu f1 = new Zi();  
14.         System.out.println(f1.num);  
15.         Zi f2 = new Zi();  
16.         System.out.println(f2.num);  
17.     }  
18. }  

class Fu
{
	int num = 8;
}
class Zi extends Fu
{
	int num = 6;
}
class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		Fu f1 = new Zi();
		System.out.println(f1.num);
		Zi f2 = new Zi();
		System.out.println(f2.num);
	}
}

输出结果：

c.静态成员函数：

无论编译和运行，都参考引用型变量所属的类。（看左边）

[java] view plain copy print ?

1. class Fu  
2. {  
3.     public static void run()  
4.     {  
5.         System.out.println("fu run");  
6.     }  
7. }  
8. class Zi extends Fu  
9. {  
10.     public static void run()  
11.     {  
12.         System.out.println("zi .... run");  
13.     }  
14. }  
15. class  StaticMethod  
16. {  
17.     public static void main(String[] args)   
18.     {  
19.         Fu f = new Zi();  
20.         f.run();  
21.         Fu.run();  
22.     }  
23. }  

class Fu
{
	public static void run()
	{
		System.out.println("fu run");
	}
}
class Zi extends Fu
{
	public static void run()
	{
		System.out.println("zi .... run");
	}
}
class  StaticMethod
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		f.run();
		Fu.run();
	}
}

输出结果：

原因：静态属于公共项，优先于对象加载。引用时，静态必被调用。

接口和多态的应用

[java] view plain copy print ?

1. /* 
2. 接口和多态的应用 
3.  
4. 需求： 
5. 电脑运行实例 
6. 电脑运行基于主板 
7.  
8. 程序编码一点要考虑功能的扩展性，主板实现功能扩展可以加入接口。 
9. */  
10. //定义接口   
11. interface PCI  
12. {  
13.     public void open();  
14.     public void close();  
15. }  
16. class MainBoard  
17. {  
18.     public void run()  
19.     {  
20.         System.out.println("mainboard run");  
21.     }  
22.       
23.     //PCI p = new NetCard() 多态 接口型引用指向自己的子类对象。   
24.     public void usePCI(PCI p)   
25.     {  
26.         //检测接口是否正常   
27.         if(p!=null)   
28.         {  
29.             p.open();  
30.             p.close();  
31.         }  
32.     }     
33. }    
34.  //实现接口   
35. class NetCard implements PCI   
36. {  
37.     public void open()  
38.     {  
39.         System.out.println("netcard open");  
40.     }  
41.     public void close()  
42.     {  
43.         System.out.println("netcard close");  
44.     }  
45. }  
46. class AppDemo  
47. {  
48.     public static void main(String[] args)  
49.     {  
50.         MainBoard mb = new MainBoard();  
51.         mb.run();  
52.         mb.usePCI(null);  
53.         mb.usePCI(new NetCard());  
54.     }  
55. }  

/*
接口和多态的应用

需求：
电脑运行实例
电脑运行基于主板

程序编码一点要考虑功能的扩展性，主板实现功能扩展可以加入接口。
*/
//定义接口
interface PCI
{
	public void open();
	public void close();
}
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	
	//PCI p = new NetCard() 多态 接口型引用指向自己的子类对象。
	public void usePCI(PCI p) 
	{
		//检测接口是否正常
		if(p!=null) 
		{
			p.open();
			p.close();
		}
	}	
}  
 //实现接口
class NetCard implements PCI 
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
class AppDemo
{
	public static void main(String[] args)
	{
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
	}
}

输出结果：