Java-面向对象（多态）

面向对象（多态）

第一部分

1、多态的概念

某一类事物的多种存在形态。

2、多态的举例

人：男人，女人

动物：猫，狗

3、多态的体现

3.1、父类的引用指向了自己的子类对象；

3.2、父类的引用也可以接收自己的子类对象；

4、多态的前提

4.1、必须类与类要有继承关系，要么继承，要么实现；

4.2、通常情况下还要存在覆盖；

5、多态的好处

多态的出现大大的提高了代码的扩展性；

6、多态的弊端

提高了代码的扩展姓，但是只能使用父类的引用访问父类中的成员(成员函数和成员变量)；

7、多态的初相在代码中的特点（多态使用的注意事项）

千万不要出现这样的操作，就是将父类对象转成子类类型，我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升也可以被强制转换，多态自始至终都是子类对象在做着变化；

//这是是不正确的，

Animal a = new Animal();

Cat c = (Cat)a;

8.图形展现

9、多态的举例理解

8.1、向上转型：毕老师和毕姥爷，毕老师的父亲是毕姥爷，毕姥爷讲的是工商管理，毕老师讲的是java，这是毕老师就覆盖了父类建立了自己的行为，讲的是java；现在有人要来找毕姥爷去讲课，但是现在毕姥爷不在家，但是毕老师在家，这时毕老师就化妆为毕姥爷，注意这是一个向上转型的过程，毕老师就提升了；

毕老师 x = new 毕老师();-->向上转型；

x.讲课();//但是毕老师脱口而出的是java；复写了父亲的功能建立了自己的特有的功能；运行的结果是子类的结果，

8.2、向下转型：现在毕老师的朋友来了，找毕老师去看电影，推门一进屋，看见是毕姥爷，但是现在的毕姥爷是毕老师化妆的，不知道这是毕老师，这时就向下转型，毕姥爷就卸妆成毕老师；

毕老师 y = (毕老师)x；-->向下转型；

x.看电影();

8.3、在向上转型和向下转型至始至终都是毕老师一个人在变化，只有毕老师一个人在变化；多态至始至终都是子类在做着变化；

10.多态的异常

类型转换异常：java.lang.ClassCastException:

11.代码体现

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) 
	{
//		Cat c = new	Cat();
//		c.eat();
//		c.catchMouse();
//		Dog d = new Dog();
//		d.eat();
//		d.kanJia();
//		Cat c = new Cat();
//		method(c);

//		function(new Dog());
//		function(new Pig());
//		function(new Cat());
//		Animal a = new Cat();//类型的提升；
//		Cat c = (Cat) a;//父类引用转成子类对象
//		c.catchMouse();

		function(new Dog());
		function(new Cat());
		function(new Pig());
	}
	public static void function(Animal a)
	{
		a.eat();
		if(a instanceof Cat)//这是引用数据类型的判断，用instanceof判断，这是一个关键字，基本数据类型用的是==
		{
			Cat c = (Cat)a;//将动物这个类型转换成猫，向下转型
			c.catchMouse();//调用子类特有的功能
		}
		else if (a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.kanJia();
		}
		else
		{
			Pig p = (Pig)a;
			p.gongDi();
		}
	}
}

12、运行的结果

第二部分

1、多态特点的体现

把事物不断的向上抽取，都是可以找到共同点的，只要找到了对象的共同所属类型，那么就可以指挥一批对象去做事情；

2、举例说明

需求：

基础班学生：

学习，睡觉

就业班学生：

学习，睡觉

可以将这两类事物进行抽取；

代码体现

<span style="font-family:SimSun;font-size:14px;">//将基础班和高级班的学生两类事物进行抽取
abstract class Student
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("躺着睡");
	}
}
//分离出来一个单独的对象，单独抽取出来
//建立工具类，由工具类来完成那些调用的动作，主函数只要来找这个工具类就可以了
class DoStudent 
{
	public void function(Student s)
	{
		s.study();
		s.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");
	}
	public void sleep()
	{
		System.out.println("躺着睡");
	}
}
class DuoTaiDemo3 
{
	public static void main(String[] args) 
	{
		DoStudent ds = new DoStudent();
		ds.function(new BaseStudent());
		ds.function(new AdvStudent());
	}
}</span><strong style="font-size:18px;">
</strong>

3、运行后的结果

4、在非静态多态中成员函数的特点

这边指的是在多态中，也就是说就是在父类引用指向子类对象的时候才具备的特点；

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

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

5、在非静态多态中成员变量的特点

在多态中，成员变量：无论是编译还是运行，都是参考左边（引用型变量所属的类）；

6、在多态中，静态成员函数的特点

无论编译和运行，都是参考左边（包括静态成员变量）；

7、多态的扩展示例

需求：数据库的操作

数据是：用户信息

1、连接数据库

2、操作数据

3、关闭数据库

代码体现

interface UserInfoDao
{
	public void add();
	public void delect();
}
class UserInfoByJDBC implements UserInfoDao
{
	public void add()
	{
	
	}
	public void delect()
	{
	
	}
}
class UserInfoByHibernate implements UserInfoDao
{
	public void add()
	{
	
	}
	public void delect(){}
}
class DBOperate 
{
	public static void main(String[] args) 
	{
		UserInfoDao ui = new UserInfoByJDBC;//利用里多态的
		ui.add();
		ui.delect();

	}
}

第三部分

我的总结

1、要想有多态的出现，那么类与类之间必须要么有继承关系，要么有实现关系；

2、多态的出现既可以将子类向下转型又可以向上转型；

3、在多态的过程中，自始自终都是子类在做着变化；

4、注意多态在静态和非静态中的成员函数和成员变量分别在编译时期和运行时期的操作；

5、多态的出现大大的提高了代码的复用性；