多态和object

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

public static void main(String[] args) {
//		Animal a = new Cat();//类型提升，向上转型。
//		a.eat();
//		Cat c = (Cat)a;//如何调用猫特有的方法时，强制将父类的引用，转换成子类类型，向下转型。
//		c.CatchMouse();
		//Animal a = new Animal;
		//Cat c = (Cat)a;是不允许出现的  不能把父类对象转成子类类型。
		//能转换的是父类应用指向自己的子类对象时，该引应用可以被提升，也可以强制转换。
		//多态自始至终都是子类对象在做着变化。
		function(new Dog());
		function(new Cat());
	}
	public static void function(Animal a) {
		a.eat();
		if(a instanceof Cat) {
			Cat c = new Cat();
			c.CatchMouse();
		}
		else if(a instanceof Dog){
			Dog d = new Dog();
			d.KanJia();
		}
	}
}
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("看门");	
	}
}

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

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

public static void main(String[] args) {
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
		
	}
}
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");
	}
}

object是所有对象的直接后者间接父类，该类中定义的肯定是所有对象都具备的功能。

只要沿袭父类中的功能，建立自己特有的功能，这就是覆盖。

public static void main(String[] args) {	
		Demo d1= new Demo(4);
		Demo d2=new Demo(5);
		System.out.println(d1.equals(d2));
	}
}
class Demo{
	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;
	}
}