Java内部类

Java内部类

刚学的知识，能力有限，暂时整理出这么多，简单的了解和使用

内部类的基本使用

概念：

​ 内部类就是在一个类中定义一个类，

格式：

public class 类名{
    public class 内部类名{
        
    }
}

内部类的访问：

• 内部类可以直接访问外部类的成员，包括私有属性、方法
• 外部类需要创建内部类对象，才能访问

成员内部类

成员内部类就是作为外部类的成员，也是最常见的内部类

• 可以直接使用外部类的所有成员和方法，即使是private
• 当内部类的成员属性或者方法也外部类同名时，会发生隐藏现象
  • 直接调用同名属性或方法，使用的是内部类中的
  • 使用 “ 外部类.this.成员变量/成员方法 ”才会使用外部的同名属性或者方法
• 成员内部类属于外部类的成员，如果想要访问成员内部类，需要先创建外部类
• 可以使用访问修饰符（public、protected、private都可以）

举例：

public class Test1 {
    public static void main(String[] args) {
        //先创建一个外部类对象   然后创建内部类对象
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        
        //也可以这样
        Outer.Inner inner1 = new Outer().new Inner();
        inner1.show();
    }
}
class Outer{
    private int num =10;
    public class Inner{
        public void show(){
            //直接使用外部类的num变量
            System.out.println(num);

            method();//调用的是内部类中的method方法

            Outer.this.method();//调用的是外部类中的method方法
        }
        public void method(){
            System.out.println("内部类中的方法");
        }
    }
    public void method(){
        System.out.println("外部类中的方法");
        Inner i = new Inner();
        i.show();
    }
}

局部内部类

就是在方法中定义的类，就叫做局部内部类

• 局部内部类只能在方法的作用域内使用，它所在的方法外无法使用
• 局部内部类的实例化也要在方法中进行。
• 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
• 局部内部类不能使用访问修饰符

举例：

class Outer{
    private int num1 =999;
    public void method(){
        int num2 = 10;
        class Inner{
            public void show(){
                //可以访问外部类的属性
                System.out.println(num1);
                //也可以访问方法中的变量
                System.out.println(num2);
            }
        }
        //局部变量的实例化也要在方法中
        Inner inner = new Inner();
        inner.show();
    }
}

匿名内部类

匿名内部类是不能有名称的内部类，所以没有办法引用，必须在创建时，作为new语句的一部分来声明。

• 匿名内部类不能有构造方法
• 匿名内部类不能定义任何静态成员、方法和类
• 只能创建匿名内部类的一个实例
• 一个匿名内部类定义时一定在new后面，生成一个对象引用
• 匿名内部类可以实现一个接口或者实现一个抽象类
• 匿名内部类属于局部内部类，所以局部内部类的所有限制都对其有效
• 内部类当中的this指的时匿名内部类本身，如果使用外部类中this则使用“外部类.this”
• 匿名内部类不能使用访问修饰符和static关键字

举例：

//创建一个抽象类
abstract class Abs{
    public abstract void absTest();
    public abstract void method();
}
//创建一个接口
interface Inter01{
    public void interTest();
}

public class Test5 {
    public static void main(String[] args) {
        //创建接口的匿名内部类
        new Inter01() {
            @Override
            public void interTest() {
                System.out.println("匿名内部类实现接口的方法");
            }
        }.interTest();//直接调用匿名内部类的方法

        Test5 test5 = new Test5();
        //当这个方法需要一个接口的对象作为参数时，就可以定义一个匿名内部类传给方法
        test5.display(new Inter01() {
            @Override
            public void interTest() {
                System.out.println();
            }
        });
    }
    public void display(Inter01 inter01){
        //调用接口中的方法
        inter01.interTest();
    }
    
    
    //当一个方法需要一个抽象类的返回值，匿名内部类也可以作为返回值
    public Abs returnTest(){
        return new Abs() {
            @Override
            public void absTest() {

            }
            @Override
            public void method() {

            }
        };
    }


    //创建一个和抽象类中重名的方法
    public void method(){
        System.out.println("和抽象类中方法重名的方法");
    }
    //创建一个方法   测试匿名内部类中this的使用
    public void thisTest(){
        //创建抽象类的匿名内部类
        new Abs() {
            @Override
            public void absTest() {
                System.out.println("匿名内部类实现抽象类的方法");
                //这两个调用的是匿名内部类中的method方法
                method();
                this.method();
                //这种写法调用的是外部类中的method方法
                Test5.this.method();
            }

            @Override
            public void method() {
                System.out.println("匿名内部类中的一个普通方法");
            }
        }.absTest();
    }
}

静态内部类

使用static修饰的成员内部类

• 静态内部类不需要依赖于外部类的存在
• 静态内部类不能使用外部类中非静态的成员变量或方法

public class Test3 {
    public static void main(String[] args) {
        //可以直接访问内部类中的静态属性和方法，不依赖于外部类
        System.out.println(Outer.Inner.str);
    }
}

class Outer{
    static int num =100;

    static class Inner{
        static String str = "静态变量";
        public void method(){
            //只能访问外部类中的静态变量和方法
            System.out.println(num);
        }
    }
}