一、多态性
1、多态性的体现
方法的重载与重写
对象的转型
2、对象的多态性
向上转型：自动完成
父类 父类对象=子类实例；
向下转型：强制类型转换
子类 子类对象=（子类）父类实例；
二、内部类
1、内部类的共性
(1)、内部类仍是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前冠以外部类的类名和$符号；
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。
(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。
2、内部类的区分
(1)、成员内部类
class MemberInner
{
private int d = 1;
private int a = 2;
// 定义一个成员内部类
public class Inner
{
private int a = 8;
public void doSomething()
{
// 直接访问外部类对象
System.out.println(d);
// 直接访问a，则访问的是内部类里的a
System.out.println(a);
// 如何访问到外部类里的a呢？
System.out.println(MemberInner.this.a);
}
}
}
public class Test
{
public static void main(String[] args)
{
// 创建成员内部类的对象
// 需要先创建外部类的实例
MemberInner.Inner inner = new MemberInner().new Inner();
inner.doSomething();
}
}
成员内部类也是定义在另一个类中，但是定义时不用static修饰。成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。成员内部类就像一个实例变量。它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。
在外部类里面创建成员内部类的实例：
this.new Innerclass();
在外部类之外创建内部类的实例：
(new Outerclass()).new Innerclass();
在内部类里访问外部类的成员：
Outerclass.this.member
(2)、静态内部类
class StaticInner
{
private static int a = 4;
// 静态内部类
public static class Inner
{
public void test()
{
// 静态内部类可以访问外部类的静态成员
// 并且它只能访问静态的
System.out.println(a);
}
}
}
public class Test
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}
最简单的内部类形式。类定义时加上static关键字。不能和外部类有相同的名字。被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。生成静态内部类对象的方式为：
OuterClass.InnerClass inner = new OuterClass.InnerClass()；
(3)、方法内部
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定义一个局部内部类
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以访问非final的局部变量
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以访问final变量
System.out.println(c);
}
}
// 创建局部内部类的实例并调用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 创建外部类对象
LocalInner inner = new LocalInner();
// 调用外部类的方法
inner.doSomething();
}
}
局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。像局部变量一样，不能被public, protected, private和static修饰。只能访问方法中定义的final类型的局部变量。局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。
(4)、匿名内部类
interface Product
{
public double getPrice();
public String getName();
}
public class AnonymousTest
{
public void test(Product p)
{
System.out.println("购买了一个" + p.getName()
+ "，花掉了" + p.getPrice());
}
public static void main(String[] args)
{
AnonymousTest ta = new AnonymousTest();
//调用test方法时，需要传入一个Product参数，
//此处传入其匿名实现类的实例
ta.test(new Product()
{
public double getPrice()
{
return 567.8;
}
public String getName()
{
return "AGP显卡";
}
});
}
}
匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。匿名内部类隐式地继承了一个父类或者实现了一个接口。