java基础<多态>

多态概念

一、概念

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

     人：男人，女人     动物：猫，狗

    猫 x=new 猫（）；  动物 x=new 猫（）；

从这4个方面来学习多态

1.多态的体现

父类的引用指向了自己的子类对象（即，父类的引用接收了自己的子类对象)

2.多态的前提

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

3.多态的利弊

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

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

4.多态的应用

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

多态的扩展性

一、代码

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 Pig extends Animal
{
	public void eat()
	{
		System.out.println("饲料");
	}
	
	public void gongDi()
	{
		System.out.println("拱地");
	}
}


--------------------------------------------------------

class DuoTaiDemo
{
	public static void main(String[] args) 
	{
		//Cat c=new Cat();
		//c.eat();
		//Dog d=new Dog();
		//d.eat();
		function1(new Cat());
		function1(new Dog());
		function1(new Pig());
	}
/*
	public static void function(Cat c)
	{
		c.eat();
	}

	public static void function(Dog d)
	{
		d.eat();
	}

	public static void function(Pig p)
	{
		p.eat();
	}
*/
	public static void function1(Animal a)
	{
		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 kanJia()
	{
		System.out.println("看家");
	}
}

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


--------------------------------------------------------

class DuoTaiDemo2
{
	public static void main(String[] args) 
	{
		Animal a=new Cat();//类型提升。(向上转型)
		a.eat();
		//如果想要调用猫的特有方法时，如何操作？
		Cat c=(Cat)a;//向下转型
		c.catchMouse();
		//千万不要出现：将父类对象转换成子类类型。
		//能转换的是：父类引用指向了自己的子类对象时，该引用可以向下转型
		//多态自始至终都是子类对象在做着变化。


		function(new Cat());
		function(new Dog());
	}

	public static void function(Animal a)
	{
		a.eat();

		if(a instanceof Cat)
			Cat c=(Cat)a;
			c.catchMouse();
	}
}

多态成员的特点

一、概述

在多态中，成员方法的特点：

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

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

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

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

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

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

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

二、代码

class Fu
{
	int num=6;

	void method1()
	{
		System.out.println("fu method1");
	}
	
	
	void method2()
	{
		System.out.println("fu method2");
	}

	static void method4()
	{
		System.out.println("fu method4");
	}


}

class Zi extends Fu
{
	int num=5;
	void method1()
	{
		System.out.println("Zi method1");
	}

	void method3()
	{
		System.out.println("Zi method3");
	}

	static void method4()
	{
		System.out.println("Zi method4");
	}


}

class DuoTaiDemo3
{
	public static void main(String[] args)
	{
		Fu f=new Zi();

		System.out.println(f.num);//输出6

		Zi z=new Zi();

		System.out.println(z.num);//输出5

		f.method1();
		f.method2();
		//f.method3();//会编译失败，因为Fu类中没有method3()方法。
		f.method4();//调用父类的静态方法。

	}
}

多态的示例

一、代码（主板示例）

interface PCI
{
	abstract void run();
	abstract void close();
}

class MainBord
{
	public void mainRun()
	{
		System.out.println("主板运行");
	}

	public void useCard(PCI p)
	{
		if(p!=null)
		{
			p.run();
			p.close();
		}
	}
}

class NetCard implements PCI
{
	public void run()
	{
		System.out.println("网卡运行");
	}

	public void close()
	{
		System.out.println("网卡关闭");
	}
}



class MainbordDuotaiDemo 
{
	public static void main(String[] args) 
	{
		MainBord mb=new MainBord();
		mb.mainRun();
		mb.useCard(new NetCard());
	}
}

二、读取数据库示例