Java中内部类概述和总结

内部类简述

内部类，将一个类定义到另一个类内部，我们称之为内部类；
在类A中，定义一个类B，那么这个类B我们称之为内部类，把A叫做外部类；
根据内部类的定义位置不同，我们将内部类分为：局部内部类和成员内部类；
成员内部类：将内部类定义到外部类的成员位置（类中方法外）；
局部内部类：将内部类定义到外部类局部位置（方法中）。

public class Neibulei {
    public static void main(String[] args) {
    }
}

class A{
    class B{}   //成员内部类

    public void show(){
        class C{}  //局部内部类
    }
}

成员内部类

调用内部类的方法，要创建内部类的对象
Outer.Inner inner = new Outer().new Inner();
外部类想要访问内部类的成员，得创建内部类的对象

public class MyTestNeibulei {
    public static void main(String[] args) {
        //调用内部类的方法，要创建内部类的对象
        Outer.Inner inner = new Outer().new Inner();
        inner.innerShow();
        Outer outer = new Outer();
        outer.test();

    }
}
class Outer{
    int num = 10;
    private int a = 20;
    //定义一个成员内部类
    class Inner{
        int aaa= 30;
        public void innerShow(){
            System.out.println("内部类的show方法");
            System.out.println(num);
            System.out.println(a);
            waiShow();
            waiTest();
            test();
        }
    }
    public void waiShow(){
        System.out.println("外部类的方法");
    }
    private void waiTest(){
        System.out.println("这是外部类的私有方法");
    }
    public void test(){
        //外部类想要访问内部类的成员，得创建内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.aaa);
    }
}

private和static修饰的成员内部类

private ：为了保证数据的安全性
static：为了方便访问数据
注意事项：
静态内部类访问外部类数据必须用静态修饰
成员方法可以是静态的 也可以是非静态的

//内部类可以用private修饰
//私有的内部类，外界不能创建其对象
//可以通过外部类来间接访问

public class MyTestNeibulei2 {
    public static void main(String[] args) {
       // new Wai().new Nei();   私有的内部类，外界不能创建其对象
        //可以通过外部类来间接访问
        new Wai().hehe();
        System.out.println(new Wai().show());
    }
}
class Wai{
    //内部类可以用private修饰
    //私有的内部类，外界不能创建其对象
    private class Nei{
        int a =100;
        public void test(){
            System.out.println("内部类的方法");
        }
    }
    public int show(){
        Nei nei = new Nei();
        return nei.a;
    }
    public void hehe(){
        Nei nei = new Nei();
        nei.test();
    }
}

    //未使用static修饰的内部类的创建对象的语法
    //WaiBu.NeiBu neiBu = new WaiBu().new NeiBu();
    //使用static修饰的内部类的创建对象的语法，相比而言更加简洁了
    //WaiBu.NeiBu bu = new WaiBu.NeiBu();

public class MyTestNeibulei3 {
    public static void main(String[] args) {
        //未使用static修饰的内部类的创建对象的语法
        //WaiBu.NeiBu neiBu = new WaiBu().new NeiBu();
        //使用static修饰的内部类的创建对象的语法，相比而言更加简洁了
        WaiBu.NeiBu bu = new WaiBu.NeiBu();
        System.out.println(bu.num);
        bu.neishow();
    }
}
class WaiBu{
     static int wai = 20;
     static class NeiBu{    //static可以修饰内部类型
        int num = 10;
        public void neishow(){
            System.out.println("静态内部类的方法");
            System.out.println(wai);
            waishow2();
        }
    }
    public void waishow(){

        System.out.println(new NeiBu().num);
    }
    public static void waishow2(){
        System.out.println(wai);
    }
}

局部内部类

    //局部内部类可以直接访问外部类的成员变量，包括私有的
    //局部内部类，外界内有直接创建其对象的方法

public class MyTestJubuNeibulei4 {
    public static void main(String[] args) {
       //局部内部类可以直接访问外部类的成员变量，包括私有的
        //局部内部类，外界内有直接创建其对象的方法
        Outer outer1 = new Outer();
        outer1.test();
    }
}
class Outer1 {
    int num = 10;
    private int a = 20;
    public void waiShow1(){
        //局部位置
        class Inner1{  //局部内部类
          int b =30;
          public void neiShow(){
              System.out.println(num);
              System.out.println(a);
              System.out.println("内部show方法");
              waiShow1();
              hehe();
          }
          public void test(){
              Inner1 inner1 = new Inner1();
              inner1.neiShow();
          }
        }
    }
    private void hehe(){
        System.out.println("外部私有方法");
    }
}

局部内部类访问局部变量的问题（final）

A: 可以直接访问外部类的成员
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

    //在局部内部类中，可以访问外部类的局部变量，但是无法赋值，因为他是final修饰的常量
    //在JDK1.8之前需要加上final，JDK1.8之后可以省略不写，但是它依然是常量
    // 因为在JDK1.8之后，默认有final

public class JubuniebuleiTest2 {
    public static void main(String[] args) {

    }
}
class Waibu{
    public void waishow(final int num){
        //在局部内部类中，可以访问外部类的局部变量，但是无法赋值，因为他是final修饰的常量
        //在JDK1.8之前需要加上final，JDK1.8之后可以省略不写，但是它依然是常量
        // 因为在JDK1.8之后，默认有final
       final int a = 10;   //外部类的局部变量
        class neibu{
            public void neishow(){
                System.out.println(a);
               // a=20;  报错
            }
        }
    }
}