JAVA内部类梳理

根据定义位置分类

定义在外部类的局部位置上

（1）局部内部类 （有类名）

局部内部类定义在外部类的局部位置上 ，通常在方法

不能添加访问修饰符，但可以使用final 修饰

作用域 ：仅在它作用的方法或者代码块中

局部内部类可以直接访问外部类的成员

外部类在方法中可以创建 局部内部类实例 调用其方法
代码实现

class Outer {
		private int n1 = 100 ;
		private void m2 (){
		System.out.println("m2被调用");
		}
		public void m1(){
		
		final class Inner1 (){//局部内部类
		
		public void f1() {
				System.out.println("调用局部内部类方法");
				
				m2() ; //在局部内部类调用外部类方法
				
				}
		}
		Inner1 inner1 = new Inner1(); //在外部类实例化 局部内部类 
		
		inner1.f1() ; // 在外部类调用 局部内部类方法

		}		
				 

（2）匿名内部类 （没有类名）

为什么使用匿名内部类？

需求 是 类只是用一次，后面不再使用 ，可以用匿名内部类用来简化开发
匿名内部类 是系统分发类名 

规范：
外部类名+$+编号 ；----->可用getClass() 来获取运行类型

匿名内部类本质还是一个类 但该类没有名字 同时它也是一个对象

基本语法 :

new 类或接口 （参数列表）{
--------类体----------
}

基于类和抽象类的匿名内部类

	public class Hello {
    /*
    匿名内部类的演示
     */
    public static void main(String[] args) {

        Father jack = new Father("jack"){
            @Override   //匿名内部类重写 tast 方法
            public void test() {
                System.out.println("tast重写");
            }
        };
        System.out.println("jack 的运行类型"+ jack.getClass());

        Animal animal = new Animal(){
            @Override
            void eat() {
                System.out.println("重写抽象类 eat方法");
            }
        };

        //输出 animal 运行类型
        System.out.println("animal 运行类型是 "+animal.getClass());

    }
}


class Father{
    public Father(String name){
        super();
    }


    public void test()  {

    }
}

abstract class Animal  {
    //基于抽象类的 匿名内部类
    abstract void eat();
}

定义在外部类的成员位置上

（1）成员内部类

1.可以使用所有访问修饰符修饰 —>本质上来说属于外部类的一个成员
2.可以访问外部类的所有成员 ，包括私有
3.作用域 和其他外部类的成员一样 ，为整个类体

成员内部类 ----访问 ----外部类成员 —（直接访问）
外部类—访问----成员内部类 访问方式 ：创建对象 ，再访问
外部其他类 ---- 访问 ----成员内部类 三种方式
外部类.成员内部类 变量名 = new 变量名.成员内部类
在外部类中写一个方法 返回成员内部类的一个实例

7 ，如果外部类成员名 和内部类成员名重名时 遵循就近原则

 可以通过 外部类名.this.属性 来访问外部类属性

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

        Outer outer = new Outer(); //实例化外部类

        Outer.Inner01 inner01 = outer.getInner01(); //实例化 成员内部类
        inner01.f1();  //调用 成员内部类 f1() 方法
        
        inner01.f2(3); //调用 成员内部类 f2() 方法
        
    }
}

class Outer {
    private int n1 = 100 ;

    Inner01 inner01 =new Inner01(); //在外部类 中实例化 成员内部类

    public Inner01 getInner01() {
        //该方法返回一个 成员内部类实例
        return inner01;
    }

    public class Inner01{  //定义 成员内部类

        public void f1(){ //定义成员内部类方法1

            System.out.println("调用成员内部类");

        }

        public void f2(int i){ //定义成员内部类方法2    该方法使用外部类 私有属性 n1
            System.out.println(i+n1);

        }
    }
    
}

（2）静态内部类

定义位置 定义在外部类的成员位置上 用static 修饰

可以访问外部类的所有静态成员 包括私有 但不能访问非私有成员

可以使用所有访问修饰符 ----->本质还是外部类的一个成员

作用域和其他外部类成员一样为整个类体

访问形式 ：

静态内部类—访问----外部类静态成员 ----直接访问

外部类—访问—>静态内部类 创建对象

外部其他类 ---- 访问 ----成员静态内部类

代码实现 ：

public class test03 {
    public static void main(String[] args) {
        int n2 = Outer2.Inner01.n2;
        System.out.println(n2); //输出 静态内部类 中静态属性

        Outer2.Inner01.fi(); //调用 静态内部类方法

    }
}


class Outer2 {
    public  static int n1 = 100 ;


    public static class Inner01{

        static int n2 =11 ; //静态内部类 中 静态属性
        int n3 = 22 ;  //静态内部类 中 普通属性

        static void fi(){ // 静态内部类 中 静态方法
            System.out.println("调用fi方法"+(n1+n2));

        }
        public void fz(){ //静态内部类 中 普通方法
            System.out.println(n3);

        }
    }

}