JAVA学习(多态，内部类）

一、多态

多态是同一个行为具有多个不同表现形式或形态的能力。

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

 

特点：

1.成员变量：

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

运行时：参考引用型变量所属的类中是否有调用的成员变量，并允许该所属类的成员变量

（编译，运行都看左边）

2.成员函数：

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

运行时：参考的时对象所属的类中是否有调用的函数。

（编译看左边，运行看右边）

3.静态函数：

编译时：参考引用型变量所属的类中是否有调用的静态方法。

运行时：参考引用型变量所属的类中是否有调用的静态方法。

（编译和运行都看左边）

例如：

public abstract class Animal {
    abstract void eat();
}

public class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

public class Dog extends Animal{
    public void eat(){
        System.out.println("吃肉");
    }
    public void seeHome(){
        System.out.println("看家");
    }
}

public class DuoTaiDemo {
    public static void method(Animal a){
        a.eat();
    }

    public static void main(String[] args) {
        method(new Cat());   //Animal a = new Cat();
　　　　　//
    }
}

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

多态的前提：

(1).类与类之间必须存在关联，继承或者实现关系

(2).要有覆盖关系。

 

2.转型

向上转型：

当使用Animal a = new Ca(); 时，猫的对象提升为动物类型，但是猫类的特有功能无法访问

其作用就是限制对特有功能的访问。也称为向上转型。

向下转型：

当需要使用猫类的特有功能时，需要进行向下转型

Cat c =  (Cat)a;

 

public class DuoTaiDemo {
    public static void method(Animal a){
        a.eat();
    }

    public static void main(String[] args) {
        method(new Cat());
        Animal a = new Cat();
        Cat c = (Cat)a;      //向下转型
        c.catchMouse();
    }
}

 可以再其中添加类型判断instanceof，用于判断是否输入某个类型

例如：

public static void method(Animal a){
        a.eat();
       if(a instanceof Cat){ //添加类型判断
          Cat c = (Cat)a;
          c.catchMouse();
       }
    }

 二、内部类

特点：

1.内部类可以直接访问外部类的成员。

因为内部类持有外部类的引用。  外部类名.this

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

一般用于类的设计：

分析事物时，发现该事物的描述中还有事物，而且这个事物还在访问被描述事物的内容，这是就将该事物定义为上一个事物的内部类。

例如：

public class Outer {
    public int id = 9;
    class Inner{
        void show(){
            System.out.println(id);
        }
    }
}


public class InnerClassDemo {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();   //内部类未私有时，直接访问外部类中内部类的成员
        //如果内部类是静态的，说明外部类加载时，内部类就已经存在了，可以直接调用
　　　　　Outer.Inner in = new Outer.Inner();  //记得对类的成员进行静态修饰
        in.show();
    }
}

1.局部内部类：

内部类可以存放在局部位置上

public class Outer {
    public int id = 9;
    void method(){
        class Inner{
            void show(){
                 System.out.println(id);        
             }
        }
    Inner in = new Inner();
    in.show();
    }
}


public class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method();  
    }
}                    

2.匿名内部类

当函数参数是接口类型的时候，而且接口中的方法不超过三个，

可以用匿名内部类作为实际参数传递

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

public abstract class Demo {
    abstract void show();
}

public class Outer {
    public int id = 9;
    void method(){
        new Demo(){     //匿名内部类  其实是一个子类对象
            void show(){
                System.out.println(id);
            }
        }.show();       //该子类对象调用了覆盖后的show方法
    }
}

public class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method();
    }
}