08内部类

内部类

一般内部类

• 内部类概述

  • 在类中定义的类内部类叫做内部类

• 内部类访问特点

  • 内部类可以直接访问外部成员，包括私有
  • 外部类要访问内部类的成员，必须创建对象
  • 外部类名.内部类名 对象名 = 外部类对象.内部类对象

public class Main {
    public static void main(String[] args) {
        // 创建内部类对象： 外部类名.内部类名  对象名 = 外部类对象.内部类对象
        Ouer.Inner oi = new Ouer().new Inner(); 
        // 外部类要访问内部类的成员，必须创建对象
        oi.method(); // 方法执行了！！！.
    }
}

class Ouer { // 外部类
    private int num = 10;
    class Inner { // 内部类
        public void method() {
            System.out.println("方法执行了！！！");
            System.out.println(num); // 内部类可以直接访问外部成员，包括私有
        }
    }
}

---

成员内部类私有使用

• 内部类被私有，外部是无法通过 外部类.内部类 的方法访问，可以在本类添加访问方法即可

// 私有内部类不能像上面那种创建对象的方式访问，别的类不能访问但是可以在本类中访问，本类添加访问方法即可
public class Main {
    public static void main(String[] args) {
        Ouer o = new Ouer(); // 调用方式
        o.print();
    }
}

class Ouer {
    private class Inner { // 内部类私有
        public void method() {
            System.out.println("方法执行了！！！");
        }
    }

    public void print() { // 本类中添加共有方法访问私有类
        Inner i = new Inner();
        i.method();
    }
}

---

静态成员内部类

外部类名.内部类名 对象名 = 外部类名.内部类对象

public class Main {
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = 外部类名.内部类对象  Outer.new Inner  可以写成new Outer.Inner,要知道new Inner是在一起的
      Outer.Inner oi  = new Outer.Inner();
        oi.method();
    }
}

class Outer {
    static class Inner { // 静态成员内部类
        public void method() {
            System.out.println("方法执行了！！！");
        }
    }
}

---

成员内部类访问案例

• 内部类之所以能够获取到外部类的成员，是因为它能获取到外部类的引用：外部类名.this

public class Main {
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = 外部类名.内部类对象  Outer.new Inner  可以写成new Outer.Inner,要知道new Inner是在一起的
      Outer.Inner oi  = new Outer().new Inner();
        oi.method();
    }
}
/*
* 要求：使用已知的变量，在控制台输出30/20/10
* */
class Outer {
    public int num = 10;
    class Inner { // 静态成员内部类
        public int num = 20;
        public void method() {
            int num = 30;
            System.out.println(num); // 30
            System.out.println(this.num); // 20 
            System.out.println(Outer.this.num); //10  获取外部类的引用Outer.this所以可以获取 Outer下面的num
        }
    }
}

---

局部内部类

• 局部内部类
  • 在方法中定义的内部类(实际开发中极少会用，面试有可能会遇到吧)

public class Main {
    public static void main(String[] args) {
        Outer ot  = new Outer();
        ot.method();
    }
}
/*
* 局部内部类，和局部变量类似，只有在该方法中有效，如果需要创建局部类实例，只能在方法内实现
* */
class Outer {
   public void method() {
       class Inner {
           public void print() {
               System.out.println("print方法执行了");
           }
       }
       Inner i = new Inner();
       i.print(); //方法内创建实例并掉用print方法
   }
}

---

// 上面的调用没有问题的，但是如果此时在method里面加个变量 int num = 10;然后再print里面打印num此时会报错 即：
class Outer {
   public void method() {
       int num = 10;
       class Inner {
           public void print() {
               System.out.println(num); // 报错：从内部类中访问本地变量num，需要声明为最终类型
           }
       }
       Inner i = new Inner();
       i.print();
   }
}

---

final int num = 10; // 这里使用final修饰后就可以正常输出了

解释： 这里就先不画内存图，大致描述下（关于代码运行顺序及内存分配以及进栈弹栈，这块不懂的需要自己研究下）；

因为调用这个方法时，局部变量没有使用final修饰，他的生命周期和方法的生命周期是一样的，当方法弹栈，这个局部变量也会消失，那么如果局部类对象还没有马上消失，想用这个局部变量，就没有了、找不到了；如果用final修饰，会在类加载的时候进入常量池（方法区有个常量池），即使方法弹栈，常量池的常量还在，可以继续使用；

！！！但是！！！ j d k 1.8取消了这个事情（j d k 1.8可以不加final），姑且认为这是个bug吧；

---

匿名内部类的格式和理解

• 匿名内部类

  • 就是内部类的简化写法

• 前提：存在一个类或接口

  • 这里的类可以是具体类也可以是抽象类

• 格式：

  • new 类名或者接口 () {

    ​ 重写方法

    }

• 本质是什么

  • 是一个继承了该类或者是想了该接口的子类匿名对象

未完待续…