黑马程序员-java基础-面向对象-多态和内部类

-------------------------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