Java day8 多态 object类 2019.7.17

• 多态
• 多态-转型
• 多态-实例
• 多态中成员的特点
• object类-equals
• object类-taString

多态

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

1.多态的体现
父类的引用指向了自己子类的对象
父类的引用也可以接受子类的对象

2.多态的前提
必须是类与类之间有关系，继承或者实现
通常还有一个前提：存在覆盖

3.多态的好处
大大的提高了程序的拓展性

4.多态的应用


5.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员
*/


abstract class Animal
{
	abstract public void eat();
}


class Cat extends Animal
{
	public void eat()
	{
		System.out.print("吃鱼");
	}
}

class Dog extends Animal
{
	public void eat()
	{
		System.out.print("吃骨头");
	}
}

class  DuoTai
{
	public static void main(String[] args) 
	{
		//Animal c=new Cat();//向上转型
		//c.eat();
		function(new Cat());
	}

	public static void function(Animal a)//如此只做不需要单独创建出一个符合对象的函数，可共用
	{
		a.eat();
	}
}

多态-转型

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


*/


abstract class Animal
{
	abstract public 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.print("吃骨头");
	}

	public void guide()
	{
		System.out.println("看家");
	}
}

class  DuoTai2
{
	public static void main(String[] args) 
	{

		/*Animal c=new Cat();//向上转型（把猫升级成父类动物）
		c.eat();
		Cat a=(Cat)c;//向下转型（把父类动物降级成子类猫）
		a.catchMouse();*/

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

		//Animal b=new Animal();//其实abstract类也不可以建立对象
		//Cat d=(Cat)b;

		function(new Dog());
	}

	public static void function(Animal a)//如此只做不需要单独创建出一个符合对象的函数，可共用
	{
		if(a instanceof Cat)//但是一般不使用instancesof，因为扩展性极差。当类有限时可以使用
		{
			Cat c=(Cat)a;
			c.eat();
			c.catchMouse();
		}
		else
		{
			Dog c=(Dog)a;
			c.guide();
			c.eat();
		}
	}
 
}

多态-实例

/*
以前时指挥一个对象，多态的出现是指挥一群对象
*/

abstract class Stu
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("SLEEP");
	}
}

class BaseStu extends Stu
{
	public void study()
	{
		System.out.println("base study");
	}
	public void sleep()
	{
		System.out.println("趴着睡");
	}
}

class AdvStu extends Stu
{
	public void study()
	{
		System.out.println("adv study");
	}
	public void sleep()
	{
		System.out.println("站着睡");
	}
}

class DoSome
{
	public void work(Stu a)
	{
		a.sleep();
		a.study();
	}
}

class  DuoTai3
{
	public static void main(String[] args) 
	{
		DoSome a=new DoSome();
		a.work(new BaseStu());
	}

}

多态中的成员特点

class Fu
{
	int num=5;
	public void method1()
	{
		System.out.println("fu1");
	}

	public void method2()
	{
		System.out.println("fu2");
	}

	public static void method4()
	{
		System.out.println("fu4");
	}
}

class Zi extends Fu
{
	int num=4;
	public void method1()
	{
		System.out.println("zi1");
	}

	public void method3()
	{
		System.out.println("zi3");
	}

	public static void method4()
	{
		System.out.println("zi4");
	}
}



class DuoTai4 
{
	public static void main(String[] args) 
	{
		Fu a=new Zi();//父类引用指向子类对象
		
		System.out.println(a.num);

		a.method1();
		a.method2();
		a.method4();
		//a.method3();

		/*
		在多态中成员函数(非静态)的特点：
		在编译时期：参阅引用变量所属的类中是否有调用的方法，有就编译通过
		在运行时期：参阅对象所属的类中是否有调用的方法
		
		简单说，编译时候参照FU，里面没有method3，所以编译失败
		运行时才会有

		在多态中成员变量和静态方法的特点：编译和运行都参照左边（引用型变量）
		*/
	}
}

object类-equals

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


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

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


class Demo
{
	int num;
    Demo(int num)
	{
		this.num=num;
	}

	public boolean  equals(Object obj)//直接复写
	{
		Demo a=(Demo)obj;
		return this.num==a.num;
	}
}


class ObjectDemo 
{
	public static void main(String[] args) 
	{
		/*Demo p1=new Demo();
		Demo p2=new Demo();
		Demo p3=p1;
		System.out.println(p1.equals(p3));//第一种方法：object，是比较两个对象地址的
		System.out.println(p1==p2);
		System.out.println(p1==p3);*/

		Demo a=new Demo(3);
		Demo b=new Demo(4);
		System.out.println(a.equals(b));
		
	}
}

object类-toString

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


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

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


class Demo
{
	int num;
    Demo(int num)
	{
		this.num=num;
	}

	public boolean  equals(Object obj)//直接复写
	{
		Demo a=(Demo)obj;
		return this.num==a.num;
	}
}


class ObjectDemo2
{
	public static void main(String[] args) 
	{
	

		Demo a=new Demo(3);

		Class c=a.getClass();//得到Class文件，注意是大写的Class
		System.out.println(c.getName());//getName（）方法必须是Class文件才能调用
		System.out.println(a.toString());//Demo@2a84aee7 @后面的是十六进制的哈希值
		System.out.println(Integer.toHexString(a.hashCode()));//2a84aee7
	}
}