一、内部类简介

类的五大成员：属性、方法、构造器、代码块、内部类

package com.hspedu.innerclass;

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

    }
}
class Outer{//外部类
    private int n1 = 100;//属性
    public Outer(int n1) {//构造器
        this.n1 = n1;
    }
    public void m1() {//方法
        System.out.println("m1()");
    }
    {//代码块
        System.out.println("代码块...");
    }
    class Inner{//内部类

    }
}

二、内部类的分类

三、局部内部类

第一点

局部内部类是定义在外部类的局部位置,通常在方法

package com.hspedu.innerclass;

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

    }
}
class Outer02{//外部类
    private int n1 = 100;
    private void m2(){
        System.out.println("外部类Outer02的private方法m2()");
    }
    public void m1(){
        //局部内部类：定义在外部类的局部位置，通常是方法
    
        class Inner02{//局部内部类

          

        }
    }
}

第二点

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

package com.hspedu.innerclass;

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

    }
}
class Outer02{//外部类
    private int n1 = 100;
    private void m2(){
        System.out.println("外部类Outer02的private方法m2()");
    }
    public void m1(){
        //1.局部内部类：定义在外部类的局部位置，通常是方法
        
        class Inner02{//局部内部类
            //2.可以直接访问外部类的所有成员，包括private成员
       
            public void f1(){
                System.out.println("n1=" + n1);
                m2();
            }

        }
    }
}

第三点

3.不能添加访问修饰符,但是可以使用 final 修饰

可以用final来修饰，这样局部内部类Inner03就不可以被继承

第四点

4.作用域:仅仅在定义它的方法或代码块中,类Inner02的作用域仅仅在方法m1()中

    public void m1(){
        //1.局部内部类：定义在外部类的局部位置，通常是方法

        //3.不能添加访问修饰符，但是可以用final修饰
        //用final修饰之后，该类就不能被继承
        //4.作用域:仅仅在定义它的方法或代码块中,类Inner02的作用域仅仅在方法m1()中
         final class Inner02{//局部内部类(本质仍然是一个类)
             //2.可以直接访问外部类的所有成员，包括private成员
            public void f1(){
                
                System.out.println("n1=" + n1);
                m2();
            }
        }
    }

如果在类的代码块中定义一个局部内部类，那么这个局部内部类的作用域就在这个代码块中

 //代码块
    {
        //在代码块中写一个局部内部类,Inner03的作用域仅限于这个代码块
        class Inner04{

        }
    }

第五点

5. 局部内部类可以直接访问外部类的成员， 比如 下面 直接访问外部类 n1 和 m2()

class Outer02{//外部类
    private int n1 = 100;
    private void m2(){
        System.out.println("外部类Outer02的private方法m2()");
    }
    public void m1(){
        //1.局部内部类：定义在外部类的局部位置，通常是方法

        //3.不能添加访问修饰符，但是可以用final修饰
        //用final修饰之后，该类就不能被继承
        //4.作用域:仅仅在定义它的方法或代码块中,类Inner02的作用域仅仅在方法m1()中
         final class Inner02{//局部内部类(本质仍然是一个类)
             //2.可以直接访问外部类的所有成员，包括private成员
            public void f1(){
                //5. 局部内部类可以直接访问外部类的成员， 比如 下面 直接访问外部类 n1 和 m2()
                System.out.println("n1=" + n1);
                m2();
            }
        }
        
    }

   
}

第六点

6. 外部类访问内部类的成员: 在方法m1()中， 可以创建 Inner02 对象， 然后调用方法即可

package com.hspedu.innerclass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
class Outer02{//外部类
    private int n1 = 100;
    private void m2(){
        System.out.println("外部类Outer02的private方法m2()");
    }
    public void m1(){
        
         final class Inner02{//局部内部类(本质仍然是一个类)
           
            public void f1(){
                
                System.out.println("n1=" + n1);
                m2();
            }
        }

        //6. 外部类访问内部类的成员: 在方法m1()中， 可以创建 Inner02 对象， 然后调用方法即可
        Inner02 inner02 = new Inner02();
         inner02.f1();
    }


   
}

1.在方法m1()（作用域）中创建局部内部类Inner02的对象实例inner02

2.然后调用局部内部类的方法f1()

3.在main方法中创建外部类Outer02的对象实例outer02

4.调用外部类Outer02中的方法m1()

第七点

7.外部其他类不能访问局部内部类

第八点

如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
使用外部类名.this.成员去访问

package com.hspedu.innerclass;

public class LocalInnerClass {//外部其他类
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02的hashCode()=" + outer02);
        //7.外部其他类不能访问局部内部类
        //Inner02 inner021 = new Inner02();
    }
}
class Outer02{//外部类
    private int n1 = 100;
    private void m2(){
        System.out.println("外部类Outer02的private方法m2()");
    }

    public void m1(){
        
         final class Inner02{//局部内部类(本质仍然是一个类)
             private int n1 = 200;
             //2.可以直接访问外部类的所有成员，包括private成员
            public void f1(){
                
                //8.如果外部类和局部内部类的成员重名时， 默认遵循就近原则， 如果想访问外部类的成        员，
                // 使用 外部类名.this.成员  去访问
                //分析:Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象

                // Outer02.this指的是外部类Outer02的对象，
                // 在这个例子中对象outer02在main方法中调用了m1()方法
                //所以Outer02.this和对象outer02的hashCode值是一样的

                System.out.println("Inner02的n1=" + n1 + "\tOuter02的n1" +     Outer02.this.n1);
                m2();
                System.out.println("Outer02.this的hashCode()=" + Outer02.this);
            }
        }



        //6. 外部类访问内部类的成员: 在方法m1()中， 可以创建 Inner02 对象， 然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }

  
}

Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象

1)Outer02.this指的是外部类Outer02的对象，
2)在这个例子中对象outer02在main方法中调用了m1()方法
3)所以Outer02.this和对象outer02的hashCode值是一样的

运行结果如下: