标签：部类 内部 静态 void public class

我们把一个类放在另一个类的内部定义，称为内部类(inner class)。

内部类的两个要点：

• 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
• 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

【示例】内部类的定义和使用

/**外部类 Outer*/
class Outer {
    private int age = 10;
    public void show() {
            System.out.println(age); //10
        }
        /**内部类 Inner*/
    public class Inner {
        //内部类中可以声明与外部类同名的属性与方法
        private int age = 20;
        public void show() {
            System.out.println(age); //20
        }
    }
}

编译后会产生两个不同的字节码文件，如图所示：

内部类的分类

非静态内部类

非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）

1. 非静态内部类对象必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
3. 非静态内部类不能有静态方法、静态属性和静态初始化块。
4. 成员变量访问要点：
   1. 内部类属性：this.变量名。
   2. 外部类属性：外部类名.this.变量名。

【示例】内部类中访问成员变量

/**外部类 Outer1*/
class Outer1 {
    private int age = 10;
    public void show() {
            System.out.println(age); //10
        }
        /**内部类 Inner*/
    public class Inner1 {
        //内部类中可以声明与外部类同名的属性与方法
        private int age = 20;
        public void show() {
            System.out.println(age); //20
            System.out.println(Outer1.this.age); //10 访问外部类的普通属性
        }
    }
}

内部类的访问：

1. 外部类中定义内部类：new Inner()。
2. 外部类以外的地方使用非静态内部类：
   Outer.Inner varname = new Outer().new Inner()。

【示例】内部类的访问

/**
 * 测试非静态内部类
 */
public class TestInnerClass1 {
    public static void main(String[] args) {
        //先创建外部类实例，然后使用该外部类实例创建内部类实例
        Outer1.Inner1 inner = new Outer1().new Inner1();
        inner.show();
    }
}

静态内部类

定义方式：

static class ClassName {
    //类体
}

使用要点：

1. 静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。
2. 静态内部类看做外部类的一个静态成员。

【示例】静态内部类的访问

/*
测试静态内部类
*/
class Outer2 {
    private int a = 10;
    private static int b = 20;
    //相当于外部类的一个静态成员
    static class Inner2 {
        public void test() {
            // System.out.println(a); //静态内部类不能访问外部类的普通属性
            System.out.println(b); //静态内部类可以访问外部类的静态属性
        }
    }
}
public class TestStaticInnerClass {
    public static void main(String[] args) {
        //通过 new 外部类名.内部类名() 来创建内部类对象
        Outer2.Inner2 inner = new Outer2.Inner2();
        inner.test();
    }
}

匿名内部类

适合那种只需要使用一次的类。比如：键盘监听操作等等。在安卓开发、awt、swing开发中常见。

语法：

/**
 * 测试匿名内部类
 */
public class TestAnonymousInnerClass {
    public void test1(A a) {
        a.run();
    }
    public static void main(String[] args) {
            TestAnonymousInnerClass tac = new
            TestAnonymousInnerClass();
            tac.test1(new A() {@
                    Override
                    public void run() {
                        System.out.println("匿名内部类测试! 我是新定义的第一个匿名内部类！ ");
                        }
                    }); tac.test1(new A() {@
                        Override
                        public void run() {
                            System.out.println("我是新定义的第二个匿名内部类");
                            }
                        });
                }
            }
            interface A {
                void run();
            }

注意

• 匿名内部类没有访问修饰符。
• 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

局部内部类

定义在方法内部的，作用域只限于本方法，称为局部内部类。

局部内部类在实际开发中应用很少。

【示例】方法中的内部类

/**
 * 测试局部内部类
 */
public class TestLocalInnerClass {
    public void show() {
        //作用域仅限于该方法
        class Inner3 {
            public void fun() {
                System.out.println("helloworld");
            }
        }
        new Inner3().fun();
    }
    public static void main(String[] args) {
        new TestLocalInnerClass().show();
    }
}

标签：部类,内部,静态,void,public,class
From： https://www.cnblogs.com/nylgwn/p/16919163.html