黑马程序员 ---多态 内部类

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

多态

事物存在多种体现形态，覆盖和继承就是多态的体现。

1、多态的体现

父类引用指向子类对象，父类引用可以接收自己子类对象

2、多态的前提

必须是类与类之间有关系，继承或实现，并且存在覆盖。

3、多态好处

好处：提高程序扩张性

弊端：只能使用父类引用访问父类中成员

 

abstract class Animal//定义动物类，在类中定义吃的抽象方法
{
	abstract void eat();
}
class Cat extends Animal//cat继承动物类复写其中eat方法
{
	public void eat()
	{
		System.out.println("cat eat");
	}
	public void catchMouse()
	{
		System.out.println("catch mouse");
	}
}
class Dog extends Animal//dog继承动物类复写其中eat方法
{
	public void eat()
	{
		System.out.println("dog eat");
	}
	public void kanJia()
	{
		System.out.println("kanjia");
	}
}
class DuotaiDemo1
{
	public static void main(String[] args)
	{
		function(new Cat());
		function(new Dog());
		
	}
	public static void function(Animal a)
	{
		a.eat();
	}
}

多态——示例（将两类事物进行抽取）

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

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

*/

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());
		ds.doSome(new AdvStudent());

		
//		BaseStudent bs = new BaseStudent();
//		bs.study();
//		bs.sleep();
//		AdvStudent as = new AdvStudent();
//		as.study();
//		as.sleep();
	}

}

在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

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

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

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
{
	static 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) 
	{
		
//		Fu f = new Zi();
//
//		System.out.println(f.num);
//
//		Zi z = new Zi();
//		System.out.println(z.num);

		//f.method1();
		//f.method2();
		//f.method3();

		Fu f = new Zi();
		System.out.println(f.num);
		f.method4();

		Zi z = new Zi();
		z.method4();		


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

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


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");
		method();
	}
	
}
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("SoundCard open");
	}
	public void close()
	{
		System.out.println("SoundCard close");
	}
}
/*
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard 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();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
		
	}
}

内部类

将一个类定义在另一个类中，里面那个类叫做内部类。

内部类访问规则：内部类可以直接访问外部类成员包括被private修饰的成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this；外部类要访问内部类中成员必须建立内部类对象。

访问格式：

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

格式：外部类名。内部类名 变量名 = 外部类对象。内部类对象

       Outer.Inner        in  =  new Outer().new Inner();

静态内部类

内部类在成员位置上时可以被成员修饰符修饰

比如：private 将内部类在外部类中进行封装   

  static内部类具有了static属性，当内部类被static修饰后，只能直接访问外部类中static成员，出现了访问局限。

当不涉及特有数据时可以定义内部静态类，当内部类中定义了静态成员，该内部类必须定义为静态。当外部类中静态方法访问内部类时内部类也必须为静态。

内部类定义原则： 当一个事物内部包含另一事物时该事物用内部类描述， 当一个类需要直接访问另一个类中成员时定义在另一个类中。

匿名内部类

内部类可以定义在成员位置和局部位置。

当内部类定义在局部位置时：

1、不可以被成员修饰符修饰，因为不是成员，而是成员中的类；

2、可以直接访问外部类中成员，因为还持有外部类中引用。只能访问被final修饰的局部变量。

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

格式：

new 父类名或接口名 （）｛定义子类内容｝.函数名

匿名内部类中方法不要超过三个，匿名内部类其实就是一个匿名子类对象，可理解为带内容对象。