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

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一多态： 

1多态的概述：

某一类事物的多种存在的多种形态。 


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

<span style="font-family:SimSun;font-size:14px;">class Object1
{
	public static void main(String[] args)
	{
		//将子类对象复制给父类的引用
		func(new Cat());
	}
	public static void func(Animal a)
	{
		a.eat();
		if(a instanceof Cat)//判断是不是属于Cat
		{
			Cat c=(Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)//判断是不是属于Dog
		{
			Dog d=(Dog)a;
			d.kanJia();
		}
	}
}
abstract class Animal
{
	public abstract 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("看家");
	}
}</span>

2成员的特点： 

1，成员变量。 

编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。 
运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。 

简单总结：编译和运行都参考等号的左边。哦了。

 

2，成员函数(非静态)。 
编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。 
运行时：参考的是对象所属的类中是否有调用的函数。 
简单总结：编译看左边，运行看右边。因为成员函数存在覆盖特性。  

3，静态函数。 
编译时：参考引用型变量所属的类中的是否有调用的静态方法。 
运行时：参考引用型变量所属的类中的是否有调用的静态方法。 
其实对于静态方法，是不需要对象的。直接用类名调用即可。

4多态在程序代码中的特点

<span style="font-family:SimSun;font-size:14px;">class Object1
{
	public static void main(String[] args)
	{
		
		Fu f=new Zi();
		z.method1();
		//z.method3();报错
		z.method2();
	}
}
class Fu
{
	void method1()
	{
		System.out.println("Fu method1");
	}
	void method2()
	{
		System.out.println("Fu method2");
	}
}
class Zi extends Fu
{
	void method1()
	{
		System.out.println("Zi method1");
	}
	void method3()
	{
		System.out.println("Zi method3");
	}
}</span>

练习：电脑运行基于主板

<span style="font-family:SimSun;font-size:14px;">class Object1
{
	public static void main(String[] args)
	{
		Mainboard mb=new Maiaboard();
		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)
	{
		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");
	}

}</span>

<h2><span style="font-family:SimSun;font-size:14px;">二内部类： </span></h2><span style="font-family:SimSun;font-size:14px;">1将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。 
简单的说就是类中还有一个类，就是内部类。 
字节码文件名：外部类名$内部类名.class </span>

2内部类定义在成员变量上：

<pre name="code" class="java"><span style="font-family:SimSun;font-size:14px;">class Object1
{
	public static void main(String[] args)
	{
		Outer out=new Outer();
		out.getInter();
	}
}
class Outer
{
	int x=0;
	class Inter
	{
		public void show()
		{
			System.out.println(x);
		}
	}
	public void getInter()
	{
		Inter it=new Inter();
		it.show();
	}
}
</span>

3内部类定义在局部上：

<pre name="code" class="java"><span style="font-family:SimSun;font-size:14px;">class Object1
{
	public static void main(String[] args)
	{
		Outer out=new Outer();
		out.run();
	}
}
abstract class AbsDemo
{
	public abstract  void show();
}
class Outer
{
	int x=8;
	public void run()
	{
		
		class Inter extends AbsDemo
		{
			public void show()
			{
				System.out.println(x);
			}
		}
		new Inter().show();
	}
	

}
</span>

内部类访问特点： 

1，内部类可以直接访问外部类中的成员，包括私有成员。 
2，而外部类要访问内部类中的成员必须要建立内部类的对象。 
一般用于类的设计。 
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。 这时就是还有的事物定义成内部类来描述。 直接访问外部类中的内部类中的成员。 
外部类名.内部类名 = new 外部类对象.new 内部类对象; 
Outer.Innerin = new Outer().new Inner(); in.method(); 
如果内部类是静态的。 相当于一个外部类 外部类名.内部类名 = new 外部类对象.内部类; 

Outer.Inner in = new Outer.Inner(); in.method(); 
如果内部类是静态的，成员是静态的。 
外部类名.内部类名.静态函数名; 
Outer.Inner.function(); 
注：如果内部类中定义了静态成员，该内部类也必须是静态的。 为什么内部类能直接访问外部类中成员呢？ 那是因为内部类持有了外部类的引用。  外部类名.this 内部类可以存放在局部位置上。（也就是定义在外部类的成员函数里面，主函数也是函数哦）
内部类在局部位置上只能访问局部中被final修饰的局部变量。
 

匿名内部类： 

匿名内部类。就是内部类的简写格式。 其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，也可以理解为，带内容的对象。 必须有前提：内部类必须继承或者实现一个外部类或者接口。（因为内部类是用父类的名字创建对象） 匿名内部类：其实就是一个匿名子类对象。 

匿名内部类格式：new 父类或者(or)接口(){子类成员} 

举例：

<span style="font-family:SimSun;font-size:14px;">class Object1
{
	public static void main(String[] args)
	{
		Outer out=new Outer();
		out.run();
	}
}
abstract class AbsDemo
{
	public abstract  void show();
}
class Outer
{
	int x=8;
	public void run()
	{
		
		new AbsDemo(){
			public void show()
			{
				System.out.println(x);
			}
		}.show();
	}
	

}
</span>