【黑马程序员】面向对象（四） 第八天

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------

知识点

01）多态

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

从几个方法学习多态：

1：多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接受自己的子类对象。

2：多态的前提

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

通常还存在一个前提：要有覆盖，否则毫无意思。

3：多态的好处

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

4：多态的弊端

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

5：多态的应用

6：多态的出现在代码汇总的特点（多态使用的注意事项）

02）多态—扩展性（体现）

1：多态的体现

public class DuoTaiDemmo {
	public static void main(String[] args) {
		Animal c = new Cat();//c可以是Cat类型，也是Aniaml类型。
		function(c);//通过子类的引用调用函数。
		function(new Dog());
		function(new Pig());
	}
	public static void function(Animal a){//Cat、Dog和Pig类都是继承Animal类的。
		a.eat();
	}
}

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 kanMeng(){
		System.out.println("看门");
	}
}

class Pig extends Animal{
	public void eat(){
		System.out.println("吃饲料");
	}
	public void gongDi(){
		System.out.println("拱地");
	}
}

运行结果如下所示：

吃鱼
吃骨头
吃饲料

03）多态—转型

public class DuoTaiDemmo_2 {
	public static void main(String[] args) {
		Animal_2 a = new Cat_2();//类型提升，向上转型。
		a.eat();
		//如果要调用Cat的特有方法。那么需要将父类的引用，强制转换成子类类型。
		Cat_2 c = (Cat_2)a;//向下转型
		c.catchMouse();
		System.out.println("----------");
		function(new Dog_2());
		System.out.println("----------");
		function(new Pig_2());
	}
	public static void function(Animal_2 a){//Cat、Dog和Pig类都是继承Animal类的。
		a.eat();
		if (a instanceof Cat_2){//判断传入的参数是否为Cat_2类型。
			Cat_2 c = (Cat_2)a;
			c.catchMouse();
		}else if (a instanceof Dog_2){//判断传入的参数是否为Dog_2类型。
			Dog_2 d = (Dog_2)a;
			d.kanMeng();
		}else if(a instanceof Pig_2){//判断传入的参数是否为Pig_2类型。
			Pig_2 p = (Pig_2)a;
			p.gongDi();
		}
	}
}

abstract class Animal_2{
	public abstract void eat();
}

class Cat_2 extends Animal_2{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog_2 extends Animal_2{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void kanMeng(){
		System.out.println("看门");
	}
}

class Pig_2 extends Animal_2{
	public void eat(){
		System.out.println("吃饲料");
	}
	public void gongDi(){
		System.out.println("拱地");
	}
}

运行结果如下图所示：

04）多态—示例

多态将对象调用这件事情变简单了，以前是指挥每一个对象做事情，现在是可以指挥一批对象做事情，那是因为找到了这些对象共同所属类型。

public class DuoTiDemo_3 {
	public static void main(String[] args) {
		DoSome d = new DoSome();
		d.doSome(new BaseStudent());
		System.out.println("----------");
		d.doSome(new AdvStudent());
	}

}
abstract class Student{
	public abstract void study();
	public void sleep(){
		System.out.println("躺着睡");
	}
}
class DoSome{//工具类
	public void doSome(Student s){
		s.study();
		s.sleep();
	}
}
class BaseStudent extends Student{
	public void study(){
		System.out.println("Base study");
	}
}
class AdvStudent extends Student{
	public void study(){
		System.out.println("Adv study");
	}
	public void sleep(){
		System.out.println("坐着睡");
	}
}

运行结果如下：

Base study
躺着睡
----------
Adv study
坐着睡

05）多态中成员的特点

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

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

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

public class DuoTiDemo_4 {
	public static void main(String[] args) {
		Fu f = new Zi();
		f.method1();//调用的是子类中的method11()方法。
		f.method2();//调用的是子类从父类继承过来的method12()方法。
		//f.method3();//编译不通过：因为对象所属的类中没有method3()方法。
	}
}
class Fu{
	void method1(){
		System.out.println("Fu method1");
	}
	void method2(){
		System.out.println("Fu method2");
	}
}
class Zi extends Fu{
	void method1(){//子类覆盖父类中的method1()方法。
		System.out.println("Zi method1");
	}
	void method3(){
		System.out.println("Zi method3");
	}
}

运行结果如下：

Zi method1
Fu method2

06）多态的主板示例

/*
 * 需求：
 * 电脑运行实例。
 * 电脑运行基于主板。
 */
public class DuoTiDemo_5 {
	public static void main(String[] args) {
		MainBoard m = new MainBoard();
		m.run();
		m.usePCI(null);
		System.out.println("-----------");
		m.usePCI(new NewCard());
		System.out.println("-----------");
		m.usePCI(new SoundCard());
	}
}

interface PCI{//PCI接口。
	public void open();//打开
	public void close();//关闭
}
class MainBoard{//主板
	public void run(){//运行主板
		System.out.println("MainBoard run");
	}
	public void usePCI(PCI p){//使用PCI接口。接口型引用指向自己的子类对象。
		if (p != null){
			p.open();
			p.close();
		}
	}
}
class NewCard implements PCI{//网卡，实现PCI接口。
	public void open(){
		System.out.println("NewCard open");
	}
	public void close(){
		System.out.println("NewCard close");
	}
}
class SoundCard implements PCI{//声卡，实现PCI接口。
	public void open(){
		System.out.println("NewCard open");
	}
	public void close(){
		System.out.println("NewCard close");
	}
}

运行结果如下图所示：

07）Object-equals()

Object：是所有对象的直接或间接父类，就是传说中的对象。

该类中定义的肯定是所有对象都具备的功能。

public class ObjectDemo {
	public static void main(String[] args) {
		Demo d1 = new Demo(5);
		Demo d2 = new Demo(6);
		Demo d3 = new Demo(6);
		System.out.println(d1.equals(d2));//比较d1和d2的值。
		System.out.println(d2.equals(d3));//比较d2和d3的值。
	}
}
class Demo{
	private int num;
	Demo(int num){
		this.num = num;
	}
	public boolean equals(Object obj){
		if (!(obj instanceof Demo))//如果Demo不是Object类型，那么
			return false;//返回false
		Demo d = (Demo)obj;//如果是，那么强制转换为Demo
		return this.num == d.num;
	}
}

运行结果如下：

false
true

附言：我是Java新人，如有错误的地方请指出。

每天学习一点点，纠错一点点，进步很大点。

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------