java复习——内部类

内部类

在一个完整的类中，嵌套一个类，而这个嵌套的类就叫内部类

内部类的分类

在外部类的局部位置（在方法内）

0. 局部内部类（有类名）
1. 匿名内部类（没有类名）

在外部类的属性位置

0. 成员内部类（没用static）
1. 静态内部类（用static）

1.局部内部类

定义在外部类的局部位置（方法）

0. 局部内部类可以访问外部类的所有成员
1. 不能添加访问修饰符，只能用final修饰
2. 作用域：只能在局部位置内使用（方法体/代码块）
3. 外部类可以直接new内部类后使用
4. 其他外部类无法访问局部内部类
5. 当外部类和局部内部类中有重名事，局部内部类可以使用：类名.this.属性（访问遵循就近原则）

//外部类
class out{
    private Integer n1 = 100;
    //方法体
    public void getN1(){
        //局部内部类,只能用final修饰
        final class inner1{
            //内部类属性
            private Integer n1 = 200;
            //可以直接访问外部类的所有成员
            System.out.println("n1 =" + n1 + ",外部类n1 = " + out.this.n1);//这里会输出n1 = 200,,外部类n1 = 100;
        }
        //外部类可以直接new内部类
        inner2 in = nwe inner2();
    }
    //代码块
    {
        //局部内部类,只能用final修饰
        final class inner2{
            //可以直接访问外部类的所有成员
            System.out.println("n1 =" + n1);//这里会输出n1 = 100;
        }
    } 
}

2.匿名内部类

本质上是一个类，没有类名。

场景：一般该类只使用一次时，就可以用匿名内部类

//基本语法
new 类/接口{
    @Override
    //方法
}

//外部类
class out{
    public static void main(String[] args){
        //基于接口的匿名内部类
        IO io = new IO(){
            @Overrifde
            public void getIo(){
                System.out.println("基于接口的匿名内部类");
            }
        };
        //基于类的匿名内部类
        boy b = new boy(){
            @Overrifde
            public void test(){
                System.out.println("基于类的匿名内部类");
            };
        };
        //基于抽象类的匿名内部类
        chou c = new chou(){
            @Overrifde
            public void getChou(){
                System.out.println("基于抽象类的匿名内部类");
            }
        };
    }
}
//接口
interface IO{
    void getIO();
}
//类
class boy{
    //无参构造器
    public boy(){};
    //方法
    public void test(){};
}
//抽象类
abstract chou{
    abstract void getChou();
}

3.成员内部类

成员内部类定义在外部类的成员位置。

0. 成员内部类没有static修饰
1. 成员内部类可以访问外部类的所有成员
2. 成员内部类可以用访问修饰符，public、private、protected来修饰
3. 作用域：整个外部类类体
4. 成员内部类——>访问——>外部类【直接访问】
5. 外部类——>访问——>成员内部类【先new，在访问】
6. 外部其他类——>访问——>成员内部类【两种方式】

//外部其他类
class dome{
    //外部其他类——>访问——>成员内部类
    //【两种方式】
    //1.先new外部类，再用外部类new内部类
    out out = new out();
    out inner = out.nwe inner();
    inner.getName();
    //2.在外部类中提供一个方法用来new内部类，之后其他外部类调用方法
    out out = new out();
    out inner = out.newInner();
    inner.getName();   
    
}
//外部类
class out{
    private String name = "外部类";
    //成员内部类,写在成员位置
    public class inner{
        public void getName(){
            System.out.println("外部类name=" + name)
        }
    } 
    //该方法用来创建内部类实例
    public inner newInner(){
        //创建内部类
        inner inner = new inner();
        //返回
        return inner;
    }
}

4.静态内部类

静态内部类定义在外部类的成员位置

0. 静态内部类，只能访问外部类的所有静态成员，但不能访问非静态成员。
1. 静态内部类可以用访问修饰符，public、private、protected来修饰
2. 作用域：整个外部类类体
3. 静态内部类——>访问——>外部类的静态成员【直接访问】
4. 外部类——>访问——>静态内部类【先new，在访问】
5. 外部其他类——>访问——>静态内部类【三种方式】

//外部其他类
class dome{
    //外部其他类——>访问——>成员内部类
    //【三种方式】
    //1.在new外部类的同时点出内部类
    out.inner inner = new out().inner();
    inner.getName();
    //2.在外部类中提供一个方法用来new内部类，之后其他外部类调用方法
    out out = new out();
    out inner = out.newInner01();
    inner.getName();
    //3.在外部类中提供一个静态方法用来new内部类(推荐)
    out out = new out();
    out inner = out.newInner02;
    inner.getName();
}
//外部类
class out{
    private String name = "外部类";
    //成员内部类,写在成员位置
    //加static修饰为静态资源
    public static class inner{
        public void getName(){
            System.out.println("外部类name=" + name)
        }
    } 
    //该方法用来创建内部类实例
    public inner newInner01(){
        //创建内部类
        inner inner = new inner();
        //返回
        return inner;
    }
    //静态方法创建内部类实例(推荐)
    public static inner newInner02(){
        //创建内部类
        inner inner = new inner();
        //返回
        return inner;
    }
}