内部类（成员类）-非静态成员类、静态成员类

内部类

也称成员类

非静态成员类

class Outer{
    private int x = 1;
    public void print(){
        Inner inner = new Inner();
        inner.display();
        System.out.println("=======================================");
        System.out.println("外部类访问内部类成员需要先进行实例化，y的值为"+inner.y);
    }

    class Inner{
        private int y = 2;
        public void display(){
            //在内部类中可直接访问外部类的所有成员，不需要进行实例化
            System.out.println("在内部类Inner中访问外部类x的数值："+x);
        }
    }
}

public class InterClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.print();
    }
}

输出结果：

在内部类Inner中访问外部类x的数值：1

外部类访问内部类成员需要先进行实例化，y的值为2

class Outer2{
    private int i = 0;
    public Outer2(){

    }
    public Outer2(int i){
        this.i = i;
    }
    public void print(){
        System.out.println("Outer2："+i);
    }

    class Inner2{
        private int j = 0;
        public Inner2(){

        }
        public Inner2(int j){
            this.j = j;
        }
        public void display(){
            System.out.println("Inner："+j+"\t"+"Outer："+i);
        }
    }
}

public class InnerClass02 {
    public static void main(String[] args) {
        //创建外围类对象outer2
        Outer2 outer2 = new Outer2(10);
        outer2.print();
        //必须先创建外围类对象，然后才可通过 该外围类对象 创建内部类对象，关键字new需要放在外围类对象之后
        Outer2.Inner2 inner2 = outer2.new Inner2(20);
        inner2.display();
    }
}

输出结果

Outer2：10
Inner：20 Outer：10

静态成员类

public class TestStaticClass {
    public class Inner{

    }
    public static class StaticInner{

    }

    public static void main(String[] args) {
        //实例化静态类时，new前不需要对象变量
        new StaticInner();
        TestStaticClass testStaticClass = new TestStaticClass();
        //必须先创建外围类对象，然后才可通过 该外围类对象 创建内部类对象，关键字new需要放在外围类对象之后
        TestStaticClass.Inner inner = testStaticClass.new Inner();

    }
}