黑马程序员5.多态&Object类

最新推荐文章于 2015-08-15 07:23:40 发布

poiop221

最新推荐文章于 2015-08-15 07:23:40 发布

阅读量360

点赞数

文章标签：多态 Object类

本文链接：https://blog.csdn.net/poiop221/article/details/35582989

版权

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

今天学习了毕老师java基础第8天的内容，在这里总结一下。

一. 多态

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

例：动物中猫，狗。

猫这个对象对应的类型是猫类型。

猫 x = new 猫();

同时，猫也是动物的一种，也可以把猫称为动物。

动物 y = new 猫();

动物是猫和狗具体事物中抽取出来的父类型。父类型引用指向了子类对象。

多态：可以理解为事物存在的多种体现形态。
人：男人，女人
动物：猫，狗。
猫 x = new 猫();
动物 x = new 猫();(实体可以具备其它类型) (重载和覆盖是函数的多态体现)
这里重点讲对象的多态
1，多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2，多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。
3，多态的好处
多态的出现大大的提高程序的扩展性。
4，多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员。(不能访问子类中的成员，因为子类当时可能不存在)

1.多态的体现

abstract class Animal
{
	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) 
	{
		function(new Cat());//先养猫
		function(new Dog());//又养狗
		function(new Pig());//一年后养猪
		//没养一次新动物就得重新写一遍function()
		
	}
	public static void function(Cat c)//将eat()方法封装，提高复用性
	{
		c.eat();
	}
	public static void function(Dog d)
	{
		d.eat();
	}
	public static void function(Pig p)
	{
		p.eat();
	}
}

每添加一次动物，就得重新写一遍function().这样很麻烦。

应用多态：(一个对象具备多种形态)

Animal c = new Cat(); c既是Cat类型，又是Animal类型，父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象：

public static void function(Animal a)

{

a.eat()

}

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		function(new Cat());
	}
	public static void function(Animal a)//Animal a = new Cat();
	{
		a.eat();
	}
}<span style="color:#ff0000;">
</span>

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		function(new Cat());
		function(new Dog());
		function(new Pig());
	}
	public static void function(Animal a)
	{
		a.eat();
	}
}

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

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		function(new Cat());
	}
	public static void function(Animal a)
	{
		a.eat();
		a.catchMouse();
	}
}

运行结果：

原因：动物类中只有eat(),没有catchMouse()

Animal a = new Cat() 到底做了什么？

类型提升（byte b = 2; int x =b;b会被提升为int类型）

在这猫被提升为了动物，也称为向上转型

如果想要调用猫的特有方法时，如何操作？

强制将父类的引用，转成子类类型。向下转型

Cat c = (Cat)a;

c.catchMouse();

但是，

Animal a = new Animal();

Cat c = (Cat)a;

这是不允许的。

千万不要出现这样的操作，就是将父类对象转成子类类型。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。

多态自始至终都是子类对象在做着变化

强制转换例子：

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		function(new Cat());
	}
	public static void function(Animal a)
	{
		a.eat();
		Cat c = (Cat)a;
		c.catchMouse();
	}
}

但是问题也产生了,可以传狗,function(new Dog()):

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		function(new Dog());
	}
	public static void function(Animal a)
	{
		a.eat();
		Cat c = (Cat)a;
		c.catchMouse();
	}
}

编译是可以通过的。运行的时候（函数开始执行，在内存中开辟空间）失败：

类型转换异常。

解决方法（instanceof）

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		function(new Dog());
	}
	public static void function(Animal a)
	{
		a.eat();
		if(a instanceof Cat)//指向对象是不是猫类型的
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if (a instanceof Dog)
		{
			Dog c = (Dog)a;
			c.kanjia();
		}
		
	}
}

2.多态的应用

/*
基础班学生：
	学习，睡觉。
高级班学生：
	学习，睡觉。

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

*/

abstract class Student
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("躺着睡");
	}
}

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  DuoTaiDemo3
{
	public static void main(String[] args) 
	{
		DoStudent ds = new DoStudent();
		ds.doSome(new BaseStudent());
		ds.doSome(new AdvStudent());
	}
}

多态中成员特点

class Fu
{
	void method1()
	{
		System.out.println("fu method_1");
	}
	void method2()
	{
		System.out.println("fu method_2");
	}
}


class Zi extends Fu
{
	void method1()
	{
		System.out.println("zi method_1");
	}
	void method3()
	{
		System.out.println("zi method_3");
	}
}
class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.method1();
		z.method2();
		z.method3();
	}
}

运行结果：

class Fu
{
	void method1()
	{
		System.out.println("fu method_1");
	}
	void method2()
	{
		System.out.println("fu method_2");
	}
}


class Zi extends Fu
{
	void method1()
	{
		System.out.println("zi method_1");
	}
	void method3()
	{
		System.out.println("zi method_3");
	}
}
class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		f.method1();
		f.method2();
		f.method3();
	}
}

以上代码编译失败：

class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		f.method1();
		f.method2();
	}
}

运行结果：

在多态中（父类引用指向子类对象）成员函数（非静态）的特点：

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

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

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

class Fu
{
	int num = 5;
	void method1()
	{
		System.out.println("fu method_1");
	}
	void method2()
	{
		System.out.println("fu method_2");
	}
}


class Zi extends Fu
{
	int num = 8;
	void method1()
	{
		System.out.println("zi method_1");
	}
	void method3()
	{
		System.out.println("zi method_3");
	}
}
class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		System.out.println(f.num);

		Zi z = new Zi();
		System.out.println(z.num);
	}
}

运行结果：

为什么第一个是5？

在多态中，成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类)。

class Fu
{
	int num = 5;
	void method1()
	{
		System.out.println("fu method_1");
	}
	void method2()
	{
		System.out.println("fu method_2");
	}
	static void method4()
	{
		System.out.println("fu method_4");
	}

}


class Zi extends Fu
{
	int num = 8;
	void method1()
	{
		System.out.println("zi method_1");
	}
	void method3()
	{
		System.out.println("zi method_3");
	}
	static void method4()
	{
		System.out.println("zi method_4");
	}

}
class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		f.method4();
	}
}

运行结果：

在多态中，静态成员函数的特点：无论编译和运行，都参考做左边。
原因：静态方法不需要对象，父类引用指向子类对象的时候，只要引用还在，它找的就是父类中的静态方法。

动态绑定：this.method1(),静态绑定：Fu.method4()

多态的主板示例：

/*
需求：
电脑运行实例，
电脑运行基于主板。
*/


interface PCI
{
	public void open();
	public void close();
}

class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run ");
	}
	public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
	{
		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");
		method();
	}
	
}
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("SoundCard open");
	}
	public void close()
	{
		System.out.println("SoundCard close");
	}
}
/*
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void useNetCard(NetCard c)
	{
		c.open();
		c.close();
	}
}

class NetCard
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
*/

class DuoTaiDemo5 
{
	public static void main(String[] args) 
	{
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
		
	}
}

多态的扩展示例：

/*
需求：数据库的操作。
数据是：用户信息。
1，连接数据库。JDBC  Hibernate
2，操作数据库。
	c create r read  u update  d delete
3，关闭数据库连接。
*/

interface UserInfoDao
{
	public void add(User user);

	public void delete(User user);
}

class UserInfoByJDBC implements UserInofDao
{

	public void add(User user)
	{
		1,JDBC连接数据库。;
		2，使用sql添加语句添加数据。;
		3，关闭连接。
	}
	public void delete(User user)
	{
		1,JDBC连接数据库。;
		2，使用sql添加语句删除数据。;
		3，关闭连接。
	}
}

class UserInfoByHibernate implements UserInfoDao
{
	public void add(User user)
	{
		1,Hibernate连接数据库。;
		2，使用sql添加语句添加数据。;
		3，关闭连接。
	}
	public void delete(User user)
	{
		1,Hibernate连接数据库。;
		2，使用sql添加语句删除数据。;
		3，关闭连接。
	}
}

class  DBOperate
{
	public static void main(String[] args) 
	{
		//UserInfoByJDBC ui = new UserInfoByJDBC();
//		UserInfoByHibernate ui = new UserInfoByHibernate();
		UserInfoDao ui = new UserInfoByHibernate();
		ui.add(user);
		ui.delete(user);
	}
}

Object类

类Object是类层次结构的根类，每个类都使用object作为超类。所有对象（包括数组）

class Demo
{
}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo();
		Demo d3 = d1;

		System.out.println(d1.equals(d3));
	}	
}

运行结果为true.（比较的是地址）。

class Demo
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	public boolean compare(Demo d)
	{
		return this.num = d.num;
	}
}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		Demo d2 = new Demo(6);
		

		System.out.println(d1.comapre(d2));
	}	
}

运行结果：

比较的不再是地址了。

Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。

class Demo
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	public boolean equals(Object obj)//Object obj = d2;(Object obj = new Demo();)
	{
		return this.num = obj.num;
	}
}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		Demo d2 = new Demo(4);
		

		System.out.println(d1.equals(d2));
	}	
}

运行结果：

Object类中没有num变量。需要向下转型：

	public boolean equals(Object obj)
	{
		Demo d = (Demo)obj;
		return this.num = obj.num;
	}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		Demo d2 = new Demo(4);
		Person p = new Person();

		System.out.println(d1.equals(p));
	}	
}

运行结果：

类型转换异常。

解决办法：

	public boolean equals(Object obj)
	{
		if(!obj instanceof Demo)
			return false;
		Demo d = (Demo)obj;
		return this.num = obj.num;
	}

Object类toString()

class Demo
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	public boolean equals(Object obj)
	{
		if(!obj instanceof Demo)
			return false;
		Demo d = (Demo)obj;
		return this.num = obj.num;
	}
}
class Person
{
}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		System.out.println(d1.toString());
	}	
}

运行结果：

返回对象的地址。

Class c = d1.getClass();返回类文件

System.out.println(c.getName());打印class文件名称

System.out.println(c.getName()+"@"+Integer.toHexString(d1.hashCode()));

为了让字符串有意义，复写toString()方法：

public String toString()
{
	return "demo:"+num;
}

class Person 
{
}


class ObjectDemo 
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo(4);
		System.out.println(d1.toString());

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