黑马程序员------面向对象（No.6）(接口、多态)

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 

 

接口

格式：interface{ }

接口中的成员修饰符是固定的。

1.成员常量：public static final

2.成员函数：public abstract

接口的出现，将“多继承”通过另一种形式体现出来，即“多实现”。

 

接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全部重写后，子类才可以实例化。否则，子类是一个抽象类

/*
接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全部重写后，子类才可以实例化。
否则，子类是一个抽象类
*/
interface Inter{
	public static final int NUM = 3;
	public abstract void show();
}
class Test implements Inter{
	public void show(){}
}
class InterfaceDemo{
	public static void main(String[] args){
		Test t = new Test();
		System.out.println(t.NUM);//输出3
		System.out.println(Test.NUM);//输出3
		System.out.println(Inter.NUM);//输出3
	}
}

编译后产生三个.class文件：Inter.class、Test.class、InterfaceDemo.class

interface A{
	void methodA();
}
interface B{
	void methodB();
}
//可以多继承 只在接口与接口之间
interface C extends A,B{
	void methodC();
}
class D implements C{
	public void methodA(){}
	public void methodB(){}
	public void methodC(){}
}

接口的特点：

1.接口是对外暴露的规则。

2.接口是程序的功能扩展。

3.接口可以用来多实现。

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5.接口与接口之间可以有继承关系。

abstract class Student{
	//每个学生都有自己学习功能的实现，所以定义成抽象方法。由子类实现该功能
	abstract void study();
	//每个学生都有相同的sleep功能。
	void sleep(){
		System.out.println("sleep");
	}
}
//扩展功能要放在接口中，要扩展这个功能，就实现这个接口。
interface Smoking{
	void smoke();
}
//实现了Smoking接口。具有Smoking功能。
class ZhangSan extends Student implements Smoking{
	void study(){}
	public void smoke(){}
}
//没有实现Smoking功能。
class LiSi extends Student{
	void study(){}
}

 

多态

 

多态：可以理解为事物存在的多种体现形态。

人：男人、女人；

动物：猫、狗；

猫 x = new 猫( );

动物 x = new 猫( );

 

1.多态的体现

父类引用指向子类对象（父类的引用可以接收自己的子类对象）。

2.多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提，就是存在覆盖（重写）。

3.多态的好处

多态的出现大大的提高了程序的扩展性。

4.多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("啃骨头");
	}
	public void kanJia(){
		System.out.println("看家");
	}
}
class DuoTaiDemo{
	public static void main(String[] args){
		//父类引用指向子类对象（父类的引用可以接收自己的子类对象）（类型提升）（向上转型）
		Animal a = new Cat();
		a.eat();
		//如果想要调用猫的特有方法时，如何操作？
		//强制向下转型
		Cat c = (Cat)a;
		c.catchMouse();//输出  抓老鼠

		//这种方式错误，这种方式就是将父类对象转成子类类型。
		//我们能转换的是父类应用指向了自己的子类对象事，该应用可以被提升，也可以被强制转换。
		//多态自始自终都是子类对象在做着变化。
		//Animal a1 = new Animal();  同时抽象类也不能直接被实例化
		//Cat c1 = (Cat)a1;

		fun(new Dog());
		fun(new Cat());
	}
	public static void fun(Animal a){
		a.eat();
		if(a instanceof Cat){
			Cat c = (Cat)a;
			c.catchMouse();
		}
		if(a instanceof Dog){
			Dog d = (Dog)a;
			d.kanJia();
		}
	}
}

 

我们能转换的是父类应用指向了自己的子类对象事，该应用可以被提升，也可以被强制转换。多态自始自终都是子类对象在做着变化。

5.多态的应用

/*
基础班学生：
	学习、睡觉
高级版学生：
	学习、睡觉
*/
abstract class Student{
	public abstract void study();
	public void sleep(){
		System.out.println("躺着睡");
	}
}
//将操作Student的方法封装成类
class DoStudent
{
	public void doSome(Student stu){
		stu.study();
		stu.sleep();
	}
}
class BaseStudent extends Student{
	public void study(){
		System.out.println("base study");
	}
	public void sleep(){
		System.out.println("坐着睡");
	}
}
class AdvStudent extends Student{
	public void study(){
		System.out.println("adv study");
	}
}
class DuoTaiDemo{
	public static void main(String[] args){
		//BaseStudent bs = new BaseStudent();
		//bs.sleep();
		//bs.study();
		//AdvStudent as = new AdvStudent();
		//as.sleep();
		//as.study();
		DoStudent ds = new DoStudent();
		ds.doSome(new BaseStudent());
		ds.doSome(new AdvStudent());
	}
}

6.多态的出现代码中的特点（多态使用注意事项）

在编译时期，参阅引用型变量所属类中是否有调用的方法。如果有，编译通过，如果没有则编译失败。

在运行时期，参阅对象所属的类中是否有调用方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

 

在多态中，成员变量的特点：

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

 

在多态中，静态成员的特点：

无论编译和运行，都参考左边。

（视频出处：传智播客毕向东Java基础视频教程-day08-05-面向对象(多态中成员的特点).avi）

 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

详情请查看：http://edu.csdn.net