黑马程序员笔记——Java面向对象之多态

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

多态

什么是多态

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

多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接受自己的子类对象。

多态的前提

必须是类与类之间有关系。要么继承，要么实现

多态的好处

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

多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

多态的应用

*/

/*
动物，
猫，狗。
*/

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) 
	{
		//Cat c = new Cat();
		//c.eat();

		//Dog d = new Dog();
		//d.eat();
		//Cat c = new Cat();
		/*
		Cat c1 = new Cat();
		function(c1);

		function(new Dog());
		function(new Pig());
		*/

		//Animal c = new Cat();
		//c.eat();

		
		function(new Cat());
		function(new Dog());
		function(new Pig());
		

		
	}
	public static void function(Animal a)//Animal a = new Cat();
	{
		a.eat();
		//a.catchMouse();
	}
	/*
	public static void function(Cat c)//
	{
		c.eat();
	}
	public static void function(Dog d)
	{
		d.eat();
	}

	public static void function(Pig p)
	{
		p.eat();
	}
	*/

}

多态中的类型转换

instanceof : 用于判断对象的类型。 用法：对象 intanceof 类型(类类型 接口类型) a instanceof Animal

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 a = new Animal();
//		Cat c = (Cat)a;
		

		/*
		毕姥爷 x = new 毕老师();

		x.讲课();

		毕老师 y = (毕老师)x;


		y.看电影();
		*/
		function(new Dog());
		function(new Cat());


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


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


}

在多态中成员函数的特点：

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

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

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

在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边。

Object

Object :它是所有类的父类。

boolean equals(Object obj):比较两个对象是否相同，比较的是内存地址值。

String toString():将对象变成字符串。默认的是形式：类名@对象哈希值

Class getClass():返回该对象所属的类文件对象。Class类，可以通过类中的方法，获取类中定义的成员，如方法，变、量等。

int hashCode():返回对象的哈希值，哈希值就是对象在内存中存放位置。

void finalize():垃圾回收方法。可以通过System.gc()来运行垃圾回收器。

每一对象都有可能因为自身的特点而覆盖equals，或者toString等其他方法。

因为每一个都有这个功能，但是功能的体现内容是不同的。

内部类

内部类的访问规则：

1、内部类可以直接访问外部类的成员包括私有。

      子所以可以直接访问外部类中的成员，是因为内部类中持有了一个

      尾部类的引用，格式：类名.this

2、外部类访问内部类必须建立内部类对象格式: 

      外部类名.内部类名.变量名称=new外部类（）.内部类（） 例Outer.Inner in = new Outer().new Inner()

3、因为内部类处在外部类的成员位置上，可以被private修饰，是Java中唯一可以被private修饰的类。

4、当内部类定义在外部类的成员位置上，而且非私有可以在外部其他类中直接建立内部类对象。

      格式：外部类名.内部类名.变量名称=new外部类（）.内部类（）Outer.Inner in = new Outer().new Inner()

5、当内部类在成员位置上，就可以被成员修饰符所修饰。比如：private：将内部类在外部类中进行封装

       static:内部类就具备static的特性，当内部类被static修饰后，只能直接访问外部类的静态成员，出现了访问局限

      在外部其他类中，如何直接访问静态内部类的非静态成员：new  Outer.Inner().functaion()

      如何直接访问静态内部类的静态成员：Outer.Inner.functaion()

      注意：当内部类中定义了静态成员，该内部类必须是静态的。

      当外部类的静态方法访问内部类时，内部类也必须是静态的。

内部类的应用

当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容

内部类定义在函数的局部成员位置上时，内部类和内部函数不能被成员修饰符private、static等修饰

内部类定义在局部时不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量

匿名内部类

1、匿名内部类就是内部类的简写格式 

2、定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3、匿名内部类的格式：  new 父类或者接口(){定义子类的内容}

4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5、匿名内部类中定义的方法最好不要超过3个。

interface Inter
{
	void method();
}

class Test 
{
	//补足代码。通过匿名内部类。
	/*
	static class Inner implements Inter
	{
		public void method()
		{
			System.out.println("method run");
		}
	}
	*/

	static Inter function()
	{
		return new Inter()
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}

}



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

		//Test.function():Test类中有一个静态的方法function。
		//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
		//因为只有是Inter类型的对象，才可以调用method方法。


		Test.function().method();
		

//		Inter in = Test.function();
//		in.method();


		show(new Inter()
		{
			public void method()
			{
				System.out.println("method show run");
			}
		});

	}

	public static void show(Inter in)
	{
		in.method();
	}
}

class InnerTest
{

	public static void main(String[] args)
	{
		new Object()
		{
			public void function()
			{
				
			}
			
		}.function();


	}
}

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