Java中的多态和内部类-学习笔记

悠悠 2023-03-14 05:25 195阅读 0赞

**目录**

多态

内部类

匿名内部类

--------------------

# 多态 #

什么是多态？

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

> 例如：动物中猫，狗。
> 
> 猫这个对象对应的类型是猫类型：猫 x = new 猫();
> 
> 同时猫也是动物中的一种，也可以把猫称为动物类型：动物 y = new 猫();
> 
> 我们发现：动物是猫和狗具体事物中抽取出来的父类型。  
> 也就是父类型引用指向了子类对象。

多态的体现：

父类或者接口的引用指向或者接收自己的子类对象 。

多态的作用：

多态的存在提高了程序的扩展性和后期可维护性。

多态的使用前提：

（1）需要存在继承或者实现关系，就是类与类之间要有关系。要么继承，要么实现；

（2）要有覆盖操作

多态的特点：

*   成员函数：

（1）编译时：要查看引用变量所属的类中是否有所调用的方法。如果有，编译通过，如果没有编译失败；

（2）在运行时：要查看对象所属的类中是否有所调用的方法.

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

*   成员变量

只看引用变量所属的类。

无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：  
无论编译和运行，都参考做左边。

例子：猫和狗的多态例子

//猫和狗的多态例子
    public class Demo {
    
      public static void main(String[] args) {
        Animal a=new Cat(); //类型提升。 向上转型。父类的引用指向了自己的子类对象
        Animal a1=new Dog();
        a.eat();
        a1.eat();
        //如果想要调用猫的特有方法时，如何操作？
        Cat c=(Cat)a; //强制将父类的引用转成子类类型。为向下转型。
        c.catchMouse();
    
      }
    }
    //将Animal定义为抽象类
    abstract class Animal
    {
      abstract void eat();  //抽象方法
    }
    class Cat extends Animal
    {
      //抽象方法的实现
      public void eat()
      {
        System.out.println("Fish");
      }
      public void catchMouse()
      {
        System.out.println("Catch Mouse");
      }
    }
    class Dog extends Animal
    {
      public void eat()
      {
        System.out.println("Bone");
      }
    }

![20200515225737675.png][]

例2：多态中成员函数的运行特点：

public class Demo {
    
      public static void main(String[] args) {
        Fu f=new Zi();
        //在多态中，静态成员函数的特点：无论编译和运行，都参考做左边。
        System.out.println(f.num);  //访问的是父类中的静态成员num,
        f.method1();  //因为method1是非静态函数，访问的是子类中的方法method1
        f.method2();  // method2是静态方法，访问的是父类中的方法method2
        Zi z=new Zi();
        z.method2();  //访问子类中的method2
      }
    }
    
    class Fu
    {
      static int num=5;
      void method1()
      {
        System.out.println("Fu method1");
      }
      static void method2()
      {
        System.out.println("Fu method2");
      }
    }
    class Zi extends Fu
    {
      static int num = 8;
      void method1()
      {
        System.out.println("Zi method1");
      }
      static void method2()
      {
        System.out.println("Zi method2");
      }
    }

![20200515232948846.png][]

例3：电脑运行实例，电脑运行基于主板。主板通过PCI来连接声卡，网卡。

public class Demo {
    
      public static void main(String[] args) {
        MainBoard m=new MainBoard();
        m.run();
        m.usePCI(new NetCard());
        m.usePCI(new SoundCard());
      }
    }
    //定义接口
    interface PCI
    {
      public void open();
      public void close();
    }
    class MainBoard
    {
      public void run()
      {
        System.out.println("MainBoard run");
      }
      public void usePCI(PCI p)   //接口型引用指向自己的子类对象。
      {
        if (p != null) {
          p.open();
          p.close();
        }
      }
    }
    //声卡实现接口
    class SoundCard implements PCI
    {
      public void open()
      {
        System.out.println("SoundCard open");
      }
      public void close()
      {
        System.out.println("SoundCard close");
      }
    }
    //网卡实现接口
    class NetCard implements PCI
    {
      public void open()
      {
        System.out.println("NetCard open");
      }
      public void close()
      {
        System.out.println("NetCard close");
      }
    }

![20200516123206730.png][]

# 内部类 #

定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）

> 内部类的访问特点：
> 
>  *   内部类可以直接访问外部类中的成员，包括私有成员；
> 
> 之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
> 
>  *   而外部类要访问内部类中的成员必须要建立内部类的对象
> 
> 内部类的位置：
> 
> 内部类定义在成员位置上：
> 
>  *   可以被private static成员修饰符修饰；
>  *   被static修饰的内部类只能访问外部类中的静态成员
> 
> 内部类定义在局部位置上：
> 
>  *   也可以直接访问外部类中的成员；
>  *   同时可以访问所在局部中的局部变量，但必须是被final修饰的

例子： 外部类访问内部类成员

public class Demo {
    
      public static void main(String[] args) {
        Outer otr=new Outer();
        otr.show();
      }
    }
    
    class Outer
    {
      private int i=3;
      //定义内部类
      class Inner
      {
        void method()
        {
          System.out.println("Inner:"+i);
          //访问的i值其实是Outer.this.i,内部类中持有了一个外部类的引用
        }
      }
      void show()
      {
        //外部类要访问内部类，必须建立内部类对象
        Inner ir=new Inner();
        ir.method();
      }
    }

![2020051612481831.png][]

例2：静态内部类的应用

>  *  当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
> 
> 格式:  
>           外部类名.内部类名  变量名 = 外部类对象.内部类对象;  
>           Outer.Inner in = new Outer().new Inner();
> 
>  *   当内部类在成员位置上，就可以被成员修饰符所修饰.比如，private：将内部类在外部类中进行封装。  static:内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
>  *   在外部其他类中，如何直接访问static内部类的非静态成员呢？                                                                                              new Outer.Inner().function();
>  *   在外部其他类中，如何直接访问static内部类的静态成员呢？
> 
>               Outer.Inner.function();

//内部类定义在外部类成员位置上
    public class Demo {
    
      public static void main(String[] args) {
        Outer ot=new Outer();
        ot.show();
      }
    }
    
    class Outer
    {
      private static int x=3;
      //定义静态内部类
      static class Inner
      {
        //当内部类中定义了静态成员，该内部类必须是static的
        static void method()
        {
          System.out.println("Inner:"+x);
          //访问的i值其实是Outer.this.i,内部类中持有了一个外部类的引用
        }
      }
      static class Inner2
      {
        void method2()
        {
          System.out.println("Inner2");
        }
      }
      public static void show()
      {
        //在外部其他类中，直接访问static内部类的非静态成员时：
        //格式：new Outer.Inner().function();
        new Outer.Inner2().method2();
        //在外部其他类中，直接访问static内部类的静态成员
        //格式：Outer.Inner.function();
        Outer.Inner.method();
      }
    }

![20200516130825809.png][]

例3：内部类定义在局部时的情形

> 当内部类定义在局部时：
> 
> 1.  内部类不可以被成员修饰符修饰 ；
> 2.  可以直接访问外部类中的成员，因为还持有外部类中的引用；
> 3.  不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

//内部类定义在局部时的情形
    public class Demo {
    
      public static void main(String[] args) {
        Outer ot=new Outer();
        ot.method();
      }
    }
    
    class Outer
    {
      int x = 3;
      void method()
      {
        final int y =5;
        class Inner
        {
          void function()
          {
            //只能访问被final修饰的局部变量
            System.out.println(y);
          }
        }
        new Inner().function();
      }
    }

![20200516141409380.png][]

# 匿名内部类 #

什么是匿名内部类？

就是内部类的简化写法。

> 匿名内部类的前提： 内部类可以继承或实现一个外部类或者接口。
> 
> 格式： new 外部类名或者接口名()\{覆盖类或者接口中的代码，(也可以自定义内容。)\}
> 
> 简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。

例1：内部类定义在

public class Demo {
    
      public static void main(String[] args) {
        new Outer().function();
      }
    }
    
    abstract class AbsDemo
    {
      abstract void show();
    }
    
    class Outer
    {
      int x=3;
      public void function()
      {
       //创建匿名内部类
        AbsDemo d=new AbsDemo()
        {
          int num=8;
          void show()
          {
            System.out.println("num="+num);
          }
        };  //不要忘了这个分号
        d.show();
      }
    }

![20200516142510270.png][]

public class Demo {
    
      public static void main(String[] args) {
        new Outer().function();
      }
    }
    
    abstract class AbsDemo
    {
      abstract void show();
    }
    
    class Outer
    {
      int x=3;
      public void function()
      {
        //匿名内部类
        new AbsDemo()
        {
          //实现父类的抽象方法
          int num=8;
          void show()
          {
            System.out.println("num="+num);
          }
        }.show();  //记住.前面的内容为匿名类对象，然而再调用自己的成员
      }
    }

![20200516145023970.png][]

[20200515225737675.png]: /images/20230312/4e122c5a2a0c4701b6baf35f4484af09.png
[20200515232948846.png]: /images/20230312/53a8ed9fe4c544e39d1e10bfbd6dc777.png
[20200516123206730.png]: /images/20230312/f3e6634459d44ddd84000d37b1ee18b7.png
[2020051612481831.png]: /images/20230312/f5756929c17f4fcfbaae9a62972e2f3e.png
[20200516130825809.png]: /images/20230312/d023f6de7e2a4f6994e558eb32a76efa.png
[20200516141409380.png]: /images/20230312/4215c1396c4a48858eec3d4d9926a0a1.png
[20200516142510270.png]: /images/20230312/921aa918ba0b4671b2af709f97bba503.png
[20200516145023970.png]: /images/20230312/4272d7965b024315ae4b237343894034.png