内部类和外部类之间的相互调用

内部类：

①静态内部类中可以有非静态的方法

②当内部类中有静态方法或者静态成员变量时，一定是静态内部类

 

一般内部类在外部类的成员变量位置，像这样：

public class Outer {
    class Inner{
        
    }
}

1、外部类访问内部类：

　　　内部类被static修饰：可以直接new

　　　　Inner in = new Inner();

　　　内部类没有被static修饰:得先new出来外部类的实例，再new内部类的

　　　　Inner in = new Outer().new Inner();

2、内部类访问外部类：（外部类.this.变量）

 

public class Outer {
    int x = 9;
    class Inner{
        int x = 8;
        public void test(){
            int x = 7;
            System.out.println(x);
            System.out.println(this.x);
            System.out.println(Outer.this.x);
            test1();
        }
    }
    
    private void test1(){
        System.out.println("test");
    }
    public static void main(String[] args) {
        Inner in = new Outer().new Inner();
        in.test();
    }
}

 

 

 

输出为：7，8，9，test

分析：第七行第八行相信大家都没有什么问题，第九行输出的是9，说明访问到了外部类的变量，而输出的test说明内部类访问到了外部类的test1方法

总结：

　　输出是9的原因：因为内部类持有一个外部类的引用，格式：外部类名.this

　　可以调用private方法原因是：因为他们在一个类Outer中所以可以调用

3、外部类和内部类中的方法相互访问：

①外部类的静态方法test和非静态内部类的非静态方法voice的相互访问：

   !  test----->voice       先new外类再new内类，再调方法

public class Outerclass {
    class Inner{
        public void voice(){
            System.out.println("voice()");
        }
    }
    public static void test(){
        new Outerclass().new Inner().voice();
    }
    public static void main(String[] args) {
　　　　　　//主函数调用test方法
       test();13     }
}

输出：voice();

   !!  voice----->test        外类.this.方法（持有的外部类的引用）

public class Outerclass {
    class Inner{
        public void voice(){
            Outerclass.this.test();
        }
    }
    public static void test(){
        System.out.println("test()");
    }
    public static void main(String[] args) {
　　　　//主函数调用voice()
        Inner in = new Outerclass().new Inner();
        in.voice();
    }
}

 输出：test();

  ②外部类的非静态方法test和静态内部类中的非静态方法voice之间的相互调用

　! voice------>test

public class Outerclass {
    static class Inner{
        public void voice(){
            new Outerclass().test();
        }
    }
    public void test(){
        System.out.println("test()");
    }
    public static void main(String[] args) {
　　　　//主函数调用voice()方法
        new Outerclass.Inner().voice();
    }
}

输出：test();

!!  test----->voice

public class Outerclass {
    static class Inner{
        public void voice(){
            System.out.println("voice()");
        }
    }
    public void test(){
　　　　　　//1、其他类访问外部类中的静态内部类的非静态方法
       // new Outerclass.Inner().voice();
　　　　　　//2、此处的Outerclass中的test方法访问静态内部类中的非静态方法
　　　　　　 new Inner().voice();
    }
    public static void main(String[] args) {
　　　　　　//主函数调用test方法
        new Outerclass().test();
    }
}

输出：voice();

 

4、总结：

外部类访问内部类：必须建立内部类的对象

内部类访问外部类：内部类可以直接访问外部类的成员包括私有成员，因为外部类持有内部类的引用

 

特例：内部类写在外部类的方法中(即局部变量的位置)

　　1、内部来外部类均可定义变量/常量

　　2、只能被final/abstract修饰

　　3、只能访问被final/abstract修饰的变量

　　4、可以直接访问外部类中的成员，因为还持有外部类的引用

　　

原文地址：https://www.cnblogs.com/rgever/p/8902758.html