多态和内部类

一、多态

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

多态在代码中的体现：父类或接口的引用指向其子类的对象。

/*对象的多态性*/
class  动物
{}

class 猫 extends 动物
{}

class 狗 extends 动物
{}

猫 x=new 猫();
动物 y=new 猫();

　　猫这类事物既具有猫的形态，又具有动物的形态，这就是对象的多态性。简单的说，就是一个对象对应着不同的类型。

多态的好处：提高了代码的扩展性，前期的代码可以使用后期的内容。

多态的弊端：前期的代码不能使用后期子类特有的内容。

多态的前提：

　　1.要有关系，继承、实现。

　　2.要有覆盖。

父类和子类可以互相转换：

     Animal  a=new Cat();

    Cat c=(Cat)a;

可用

    if (c instanceof Cat)

　{ }

来判断一个对象是否是某类型。

class Fu
{
     void  show()
    {
         System.out.println("Fu Show");
    }
    static void method()
    {
        System.out.println("Fu method");
    }
}

class Zi  extends Fu
{
     void  show()
    {
         System.out.println("Zi Show");
    }
   static void method()
   {

        System.out.println("Zi method");
    }

} 
class demo { 
   public static void main(String[] args) 
   { 
       Fu f=new Zi(); 
       f.show();
       f.method();
    }
}

　　打印结果为"Zi Show"和"Fu method"。因为普能成员函数是由对象调用的（this），而静态成员函数是由类调用的。其实静态函数可以直接用类名调用。

多态时，成员的特点：

1. 成员变量

    编译和运行都看等号的左边。

2. 成员函数（非静态）

   编译看左边，运行看右边。

3. 静态函数

   编译和运行都看等号的左边。

二、内部类

一个类定义在另一个类里面，里面的类就称为内部类。

1.内部类可以直接访问外部类中的成员，包括私有成员。

2.外部类要访问内部类的成员，必须建立内部类的对象。

直接访问外部类的内部类成员：

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

 in.show();

如果内部类是静态的，相当于一个外部类：

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

  in.show();

如果内部类是静态的，成员函数也是静态的：（如果有成员函数是静态的，内部类必须是静态的）

 Outer.Inner.show();

为什么内部类能直接使用外部类的成员变量呢？是因为内部类持有了外部类的引用。 即"外部类名.this"。

内部类在局部位置上只能访问局部中被final修饰的局部变量。

例如：

 abstract class Demo
  {
     abstract void show1();
     abstract void show1();
  }
 
class Outer
  {
       int num=4;
        public void method()
       {
              Demo d=new Demo()   //多态
              {
                    void show()
                   {
                         System.out.println("show....."+num);
                    }
              };
              d.show1();
              d.show2();
        }
 }

匿名内部类就是一个内部类的简写形式，匿名内部类其实就是一个匿名子类对象。

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

如果匿名内部类有多个成员函数，则需要定义父类变量来处理。