Java_内部类

内部类

内部类: 成员内部类, 匿名内部类, 局部内部类
成员内部类: 非静态内部类, 静态内部类

类中定义的内部类特点
内部类作为外部类的成员, 可以直接访问外部类的成员(包括private成员), 反之则不行
内部类作为外部类成员, 可以声明为private, 默认, protected, public
内部类成员只有在内部类的方位之内是有效的
用内部类定义在外部类中不可访问的属性. 这样就在外部类中实现了比外部类private还要小的访问权限
编译后生成两个类: OuterClass.class和OuterClass$InnerClass.class

成员内部类可以用private, default, protected, public任意进行修饰

非静态内部

1.非静态内部类必须存在一个外部类对象里. 因此, 如果有一个非静态内部类对象, 那么一定存在一个对应的外部类对象, 非静态内部类对象单独属于外部类的某个对象
2.非静态内部类可以直接访问外部类的成员, 但是外部类不能直接访问非静态内部类成员
3.非静态内部类不能有静态方法, 静态属性, 静态初始化块
4.外部类的静态方法, 静态代码块不能访问非静态内部类, 包括不能使用非静态内部类定义的变量, 创建实例
5.成员变量访问要点
　　内部类中方法的局部变量: 变量名 　　内部类属性: this.变量名 　　外部类属性: 外部类名.this.变量名

public class TestInnerClass {
    public static void main(String[] args) {
        // 直接创建内部类实例
        Outer.Inner inner = new Outer().new Inner();
        
        inner.show();
        System.out.println("###########分隔符#############");
        
        // 先创建外部类实例, 然后使用该外部类实例创建内部类实例
        Outer outer = new Outer();
        Outer.Inner inn = outer.new Inner();
        
        outer.test();
        System.out.println("###########分隔符#############");
        inn.show();
    }
}

class Outer {
    private int age = 10;

    // 在Outer类中, 可在方法test()中创建内部类Inner对象
    void test() {
        Inner in = new Inner();
        
        in.show();
        System.out.println(in.age);
    }
    
    class Inner {
        int age = 20;
        
        public void show() {
            int age = 30;
            System.out.println("外部类的成员变量age: " + Outer.this.age);
            System.out.println("内部类的成员变量age: " + this.age);
            System.out.println("局部变量age: " + age);
        }
    }
}

/*
外部类的成员变量age: 10
内部类的成员变量age: 20
局部变量age: 30
###########分隔符#############
外部类的成员变量age: 10
内部类的成员变量age: 20
局部变量age: 30
20
###########分隔符#############
外部类的成员变量age: 10
内部类的成员变量age: 20
局部变量age: 30
*/

静态内部类

定义方式: static class ClassName{Code...;}

使用要点:

一个静态内部类对象存在, 对应的外部类对象可以不存在. 因此, 静态内部类的实例方法不能直接访问外部类的实例方法
静态内部类看成是外部类的一个静态成员. 因此, 外部类的方法中可以通过静态内部类.名字的方式访问静态内部类的静态成员, 通过new 静态内部类()创建静态内部类的实例

public class TestStaticInnerClass {
    public static void main(String[] args) {
        // 通过 new 外部类名.内部类名() 来创建内部类对象
        Outer2.Inner2 inner2 = new Outer2.Inner2();
        
    }
}

class Outer2 {
    // 相当于外部类的一个静态成员
    static class Inner2{
        
    }
}

匿名内部类--------->待解决

可以实现一个接口, 或者继承一个父类
只能实现一个借口
适合创建那种只需要一次使用的类, 不能重复使用. 比较常见的是在图形界面GUI里用得到
匿名内部类没有访问修饰符
匿名内部类没有构造方法. 由于他连名字都没有, 所以没有构造方法
匿名内部类要使用外部类的局部变量, 必须使用final修饰该局部变量

方法内部类

定义在方法内部, 作用域只限于本方法

局部内部类的使用主要是用来解决比较复杂的问题, 想创建一个类来辅助解决方案, 而又不希望这个类公共可用, 所以就产生了局部内部类. 局部内部类和成员内部类一样被编译, 只是他的作用域发生了改变, 他只能在该方法中被使用, 出了该方法就会失效

public class TestInnerClass {
    public static void main(String[] args) {
        new TestMethodClass().show();
    }
}

class TestMethodClass {
    public void show() {
        // 作用域仅限该方法
        class Inner {
            public void fun() {
                System.out.println("Just For Fun~~~");
            } 
        }
        new Inner().fun();
    }
}
/*
Just For Fun~~~
*/

转载于:https://www.cnblogs.com/hesper/p/9711356.html