学习笔记_毕向东 Java_多态 2014.7.14

1、代码：DuoTaiDemo2.java

/*
5、多态的应用
	
6，多态的出现代码中的特点(多态使用的注意事项)

*/

/*
动物，
猫，狗。
*/

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();  //捉老鼠
		
		//千万不要出现这样的操作，就是将父类对象转成子类类型。
		//我们能转换的是父类引用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
		//多态自始至终都是子类对象在做着变化。（如：猫一会变成动物，一会又变成猫。）
		//Animal b = new Animal();  不能将Animal强转成Cat。因为先有的Animal。
		//Cat d = (Cat)b;
		
		/*
		毕姥爷 x = new 毕老师();  //毕老师一会是毕姥爷     （向上转型）
		x.讲课();
		毕老师 y = (毕老师)x;  //毕老师一会是他自己       （向下转型）
		y.看电影();
		*/   //自始自终只有子类对象（毕老师）在做对象。先了毕姥爷，再有的毕老师，所以不能把毕姥爷变成毕老师。
		
		//function(new Cat());  //得 吃鱼 捉老鼠
		function(new Dog());  //得 吃骨头 看家
	}
	
	public static void function(Animal a)
	{
		a.eat();
		/*  //不要这么写，不然就得不到捉老鼠，看家了。都得haha了
		if(a instanceof Animal)
		{
			System.out.println("haha");
		}
		else 
		*/
		if(a instanceof Cat)
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.kanJia();
		}
	}

		/*
		instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)  
		*/

}

代码：DuoTaiDemo3.java

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

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

*/

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());  //得base study 坐着睡
		ds.doSome(new AdvStudent());  //得adv study 躺着睡

		/*
		BaseStudent bs = new BaseStudent();
		bs.study();  //得base study
		bs.sleep();  //得坐着睡
		AdvStudent as = new AdvStudent();
		as.study();  //得adv study
		as.sleep();  //得躺着睡
		*/
	}

}

代码：DuoTaiDemo4.java

class Fu
{
	static 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)
	{
		//f.method1();  //得zi method_1
		//f.method2();  //得fu method_2
		//f.method3();  //编译通不过，因为Fu中没有没method3方法
		/*
		在多态中成员函数（非静态的）的特点：        （开发中多见，因为有覆盖操作）
		在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
		在运行时期：参阅对象所属的类中是否有调用的方法。
		简单总结就是：成员函数在多态调用时，编译看左边，运行看右边
		*/

		/*	
		Fu f = new Zi();
		System.out.println(f.num);  //得5  （开发中遇不到，面试会遇到）

		Zi z = new Zi();
		System.out.println(z.num);  //得8
		*/
		/*
		在多态中，成员变量的特点：
		无论编译和运行，都参考左边(引用型变量所属的类)。
		*/

		/*
		Fu f = new Zi();  
		f.method4();  //得fu method_4  开发一般不会出现这种情况，没人会去覆盖静态  （面试题）
		Zi z = new Zi();
		z.method4();  //得zi method_4
		*/
		/*
		在多态中，静态成员函数的特点：
		无论编译和运行，都参考做左边。
		*/

		/*
		Zi z = new Zi();
		z.method1();  //得zi method_1  覆盖
		z.method2();  //得fu method_2  继承
		z.method3();  //得zi method_3
		*/
	}
}

 

代码：DuoTaiDemo5.java

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

class MainBoard
{
	public void run()
	{
		System.out.println("mainbord 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();  //得mainbord run
		mb.useNetCard(new NetCard());  //得netcard open   netcard close
	}
}

代码：DuoTaiDemo5.java

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

//接口：降低了耦合性，提高了扩展性 
//多态

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");
	}
}

class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("SoundCard open");
	}
	public void close()
	{
		System.out.println("SoundCard close");
	}
}

class DuoTaiDemo5
{
	public static void main(String[] args)
	{
		MainBoard mb = new MainBoard();
		mb.run();  //得mainboard run
		mb.usePCI(null);  //没有设备，就传null嘛。
		mb.usePCI(new NetCard());  //得netcard open    netcard close
		mb.usePCI(new SoundCard());  //得SoundCard open     SoundCard close
	}
}

2、代码：DBoperate.java

/*
需求：数据库的操作。
数据是：用户信息。
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 UserInfoDao
{
	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();
		ui.delete();
	}
}

 

3、Object类

1、代码：ObjectDemo.java

/*   equals
Object:是所有对象的直接后者间接父类，传说中的上帝。
该类中定义的肯定是所有对象都具备的功能。

Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
*/

class Demo  //extends Object
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}

	public boolean equals(Object obj)  //Object d = new Demo();  多态
	{
		if(!(obj instanceof Demo))
			return false;  //这里也可以抛出异常
		Demo d = (Demo)obj;
		return this.num == d.num;
	}

	/*
	public boolean compare(Demo d)
	{
		return this.num == d.num;
	}
	*/
}

class Person
{
}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		Demo d2 = new Demo(4);
		Demo d3 = d1;
		/*
		System.out.println(d1.equals(d2));  //得false  比较地址值？不是比较值是否相等吗？
		System.out.println(d1.equals(d3));  //得true 
		System.out.println(d1 == d2);  //得false
		System.out.println(d1 == d3);  //得true
		*/

		System.out.println(d1.equals(d2));  //得true 4和4，值相等

		Person p = new Person();
		System.out.println(d1.equals(p));  //得false
	}
}

代码：ObjectDemo.java
 

/*   
toString
*/

class Demo  //extends Object
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	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.getClass());  //得class Demo
		Class c = d1.getClass();
		System.out.println(c.getName());  //得Demo
		System.out.println(d1.hashCode());  //得2691004
		System.out.println(Integer.toHexString(d1.hashCode()));  //得290fbc
		System.out.println(d1.toString());  //得Demo@290fbc  得Demo:4
	}
}