-------------------------ASP.Net+Unity开发、.Net培训、期待与您交流！--------------------------
多态
1、含义：父类的引用指向了自己的子类对象。2、多态的好处：多态的出现大大的提高了代码的扩展性。
3、多态的前提
第一，类与类之间要有关系，要么继承，要么实现；
第二，一般还要有：存在覆盖
4、多态的弊端
虽然提高了扩展性，但是只能使用父类的引用的访问父类中的成员。
5、多态的转型
转型包括向上转型和向下转型
向上转型：Animal a=new Cat();为向上转型。即父类引用指向子类对象
向下转型：Cat c=(Cat)a;为向下转型。将父类引用转为子类引用
向下转型主要用于调用子类的特有方法。
例子：
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("看家");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
//function(new Cat());
//function(new Dog());
FunctionDemo fd=new FunctionDemo();
fd.function(new Cat());
fd.function(new Dog());
}
/*
public static void function(Animal a)
{
a.eat();
if (a instanceof Cat)
{
Cat c=(Cat)a;
c.catchMouse();
}
else if (a instanceof Dog)
{
Dog d=(Dog)a;
d.kanJia();
}
}
*/
}
//将上面注释掉的代码单独封装成了一个类，这样提高了代码的复用性
class FunctionDemo
{
public static void function(Animal a)
{
//由于大家都要访问吃的功能，所以为了不每次都调用此功能
//所以利用多态来调用此功能
a.eat();
if (a instanceof Cat)
{
//向下转型，来调用子类的特有方法
Cat c=(Cat)a;
c.catchMouse();
}
else if (a instanceof Dog)
{
Dog d=(Dog)a;
d.kanJia();
}
}
}内部类
当内部类定义在成员位置上时
1、定义
将一个类定义在另一个类里面，对里面的那个类就成为就成为内部类（内置类、嵌套类）
2、特点
第一，内部类可以直接访问外部类中的成员，包括私有。之所以可以访问外部类的成员
是因为内部类中持有了一个外部类的引用。
第二，外部类要访问内部类，必须建立内部类对象。
3、访问格式：
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他的类中，可以直接
建立内部类对象。
格式：Outer.Inner in=new Outer().new Inner();
4、当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private，static。当
被private修饰，则将内部类在外部类中进行封装；当被static所修饰时，内部类就
具备了static的特性。当内部类被static修饰后，只能直接访问外部类中的static
成员，出现了访问局限。
5、在外部其他类中，如何直接访问static内部类的非静态成员呢？
利用建立内部类对象来访问，
建立内部类对象格式为:new 外部类名.内部类名()
则也可直接建立了对象之后直接调用此方法：new 外部类名.内部类名().function();
即 new Outer.Inner().function();
6、在外部其他类中，如何直接访问static内部类的静态成员？
直接写成：Outer.Inner.function();
7、注意：
第一，当内部类定义了静态成员，该内部类也必须是static的；
第二，当外部类的静态方法访问内部类时，内部类也必须是静态的。
例子：
class Outer
{
private int x=3;
//内部类
class Inner
{
void function()
{
System.out.println("inner:"+x);//即本身是Outer.this.x即省略了Outer.this
}
}
void method()
{
Inner in=new Inner();//外部类要想访问内部类方法，则必须创建内部类对象。
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Outer ou=new Outer();
ou.method();//通过调用方法method来访问内部类的方法
}
}}特点：
第一，不可被成员修饰符修饰，eg private，static
第二，可以直接访问外部类中的成员，因为持有外部类中的引用。但是不可以访问
它所在的局部中的变量，只能访问被final修饰的局部变量。
例子：
class Outer
{
private int x=3;
//内部类
void method()
{
//内部类在局部位置上
class Inner
{
void function()
{
System.out.println("inner:"+x);//即本身是Outer.this.x即省略了Outer.this
}
}
new Inner().function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Outer ou=new Outer();
ou.method();//通过调用方法method来访问内部类的方法
}
}匿名内部类
特点:
第一，匿名内部类其实就是内部类的简写格式
第二，定义匿名内部类的前提：内部类必须是继承一个类或者实现一个接口
第三，匿名内部类的格式：new 父类或者接口(){定义子类内容}
第四，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，即带内容的对象
第五，匿名内部类中定义的方法最好不要超过三个。
例子：
需求：根据main函数中给的形式来写其他的程序代码。利用匿名内部类。
第一个方式：
interface Inner
{
public abstract void method();
}
class Test
{
public static Inner function()
{
//利用匿名内部类
return new Inner()
{
public void method()
{
System.out.println("内部类");
}
};
}
}
class InnerDemo
{
public static void main(String[] args)
{
Test.function().method();//看到此类直接调用的function()说明此方法为静态的
//而且又调用了方法method，则说明function方法返回一个对象
}
}
第二个方式
interface Inner
{
public abstract void method();
}
class B
{
public void show(Inner in)
{
in.method();
}
}
class InnerDemo
{
public static void main(String[] args)
{
B b=new B();
//利用匿名内部类来传入此参数。
b.show(new Inner()
{
public void method()
{
System.out.println("黑马程序员");
}
});
}
}
-------------------------ASP.Net+Unity开发、.Net培训、期待与您交流！--------------------------
详情请查看:http://edu.csdn.net