多态与内部类的简易笔记

多态

多态的前提

1. 要有（继承/实现）关系

2. 要有方法重写

3. 要有父类引用，指向子类对象

多态的成员访问特点

1. 成员变量：编译看左边（父类），运行看左边（父类）；

2. 成员方法：编译看左边（父类），运行看右边（子类）；

多态的好处和弊端

1. 多态的好处：提高了程序的扩展性

   具体体现：定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的任意子类对象；

2. 多态的弊端：不能使用子类的特有成员；

多态中的转型

1. 向上转型（属于隐式转换）

   从子到父

   父类引用指向子类对象

2. 向下转型

   从父到子

   父类引用转为子类对象（多态的情况下得使用强制转换）

多态中的转型存在的风险：

概述：如果被赚的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现ClassCasException

避免强转出现的问题

关键字：instanceof；

使用格式：变量名 instanceof 类型

通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

内部类

内部类的访问特点

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

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

成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式

1. 在类的成员位置：成员内部类；

2. 在类的局部位置：局部内部类；

成员内部类，外界如何创建对象使用，如下

1. 格式：外部类名.内部类名 对象名 = new外部类对象().new 内部类对象

2. 范例：Outer.Inner ion = new Outer().new Inner();

   代码实例：

   public class InClass {
       public static void main(String[] args) {
           //调用内部类的方式
           Outer.Inner inClass = new Outer().new Inner();
           inClass.methor();
       }
   }
   ​
   class Outer{
       class Inner {
           public void methor(){
               System.out.println("内部类");
           }
       }
   }

成员内部类，也属于（成员），既然是成员就可以背一下修饰符所修饰

1. private

   私有成员内部类访问：在自己所在的外部类中创建对象访问

   public class InClass {
       public static void main(String[] args) {
          //私有成员内部类演示
          Outer out = new Outer();
          out.matter();
       }
   }
   class Outer{
       private int a = 100;
   ​
       private class Inner {
           public void methor(){
               System.out.println(a);
           }
       }
       public void matter(){
           Inner in = new Inner();
           in.methor();
       }
   }

2. static

   静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

   代码示例：

   public class InClass {
       public static void main(String[] args) {
          //静态成员内部类演示
           Outer.Inner in = new Outer.Inner();
           in.methor();
           //调用静态内部类的静态方法
           Outer.Inner.math();
       }
   }
   class Outer{
       static class Inner {
           public void methor(){
               System.out.println("methor-----static");
           }
   ​
           public static  void math(){
               System.out.println("math------2");
           }
       }
   }

匿名内部类

概述：匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）

前提：需要存在一个接口或类

 

 

理解：匿名内部类是将（继承\实现）（方法重写）（创建对象）三个步骤，放在了一步进行；

实例代码：

public class MyClassDemo {
    public static void main(String[] args) {
​
        new inter(){
​
            @Override
            public void show() {
                System.out.println("这是匿名方法中的show方法");
            }
        }.show();
​
        System.out.println("--------------------------")
         intrer2 inte = new intrer2(){
​
            @Override
            public void show1() {
                System.out.println("匿名中多方法实现的show1方法");
            }
​
            @Override
            public void show2() {
                System.out.println("匿名中多方法实现的show2方法");
            }
        };
        inte.show1();
        inte.show2();
    }
​
}
​
interface  intrer2{
    void show1();
    void show2();
}
​
interface inter{
    void show();
}
class Inter1 implements inter{
​
    @Override
    public void show() {
        System.out.println("这是实现类中的show方法");
    }
}