黑马程序员——第8天——（面向对象）多态，Object类

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

人：男人，女人
动物：猫，狗。
猫 x = new 猫();
动物 x = new 动物();

1，多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2，多态的前提
必须是类与类之间有关系，要么继承，要么实现。
通常还有一个前提：存在覆盖。
3，多态的好处
多台的出现大大提高了代码的拓展性。
4，多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5，多态的应用

第二个问题：如何使用子类特有的方法。

动物，
猫，狗。

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) 
	{
		Animal a = new Cat();//类型提升。向上转型。
		a.eat();

		//如果想要调用猫的特有方法时，如何操作？
		//强制将父类的引用，转成子类类型。向下转型。
		Cat c = (Cat)a;
		c.cathMouse();

//		千万不要出现这样的操作，就是将父类的对象转成子类类型。
//		我们能转换的是父类的引用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
//		多态自始至终都是子类对象在做着变化。
//		Animal a = new Animal();
//		Cat c = (Cat)a;
	}

	public static void function(Animal a)//Animal a new Cat();
	{	
		a.eat();
		/*
		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 c = (Dog)a;
			c.kanjia();
		}
	}
}

多态Demo3

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

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

多态将对象调用变简单了，找到了这些对象的共同所属类型。

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

class DoStudent
{
	public void dosmoe(Student stu)
	{
		stu.study();
		stu.sleep();
	}
}

class BaseStudent extends Student
{
	public void study()
	{
		System.oout.println("base study");
	}
	public void sleep()
	{
		System.out.println("坐着睡");
	}
}

class AdvStudent extends Student
{
	public static study()
	{
		System.out.println("adv study");
	}
	public static sleep()
	{
		System.out.println("躺着睡")；
	}
}

class DuoTaiDemo3
{
	public static void main(String[] args) 
	{
		DoStudent ds = new DoStudent();
		ds.doSome(new BaseStudent());
		ds.sleep(new AdvStudent());
		
		
//		BaseStudent bs = new BaseStudent();
//		bs.study();
//		bs.sleep();
//		AdvStudent as = new AdvStudent();
//		sa.study();
//		as.sleep();
	}
}

多态Demo4

class Fu
{
	int num = 5 ;//面试题 1，子，父中成员变量定义不同值
	void method1()
	{
		System.out.println("fu method_1");
	}
	void method2()
	{
		System.out.println("fu method_2");
	}
	static method4()//面试题2，多加一个静态
	{
		System.out.println("fu method_4");
	}
}

class Zi extends Fu
{
	int num = 8;//面试题 1.
	void method1()
	{
		System.out.println("zi metohd_1");
	}
	void method3()
	{
		System.out.println("zi method_3");
	}
	static method4()//面试题2，
	{
		System.out.println("zi method_4");
	}
}

class DuoTaiDemo4 
{
	public static void main(String[] args)
	{
		Fu f = new Zi();
		System.out.println(f.num)//面试题 1

		Zi z = new Zi();//面试题  1
		System.out.println(z.num);//面试题 1

		//f.method1();
		//f.method2();
		//f.method3();
		Fu f = new Zi();//面试题2
		f.method4();

		Zi z = new Zi();
		z.method4();
/*
在多态中成员函数（非静态的，非静态有重写特性）的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败、
在运行时期：参阅对象所属的类中是否有调用方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。


面试题1：
在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用变量所属的类）。

面试题 2：
在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

静态成员变量，看父类。

静态绑定是静态绑定，非静态绑定是动态绑定。
*/

//		Zi z = new Zi();
//		z.method1();
//		z.method2();
//		z.method3();
	}
}

多态Demo5

/*
需求：
电脑运行实例，
电脑运行基于主板。
*/
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();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
	}
}

多态Demo6

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

Object类

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

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

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

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

	public boolean equals(Object obj)//Object obj = 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();
		Demo d2 = new Demo();
		Demo d3 = d1;
		//System.out.println(p1.equals(d1));//健壮性判断

		System.out.println(di.equals(d3));
		System.out.println(d1==d2);
		System.out.println(d1==d3);
	}
}