内部类与外部类之间的访问

目           录

1.内部类与外部类

2.内部类的特点：内部类可以直接访问外部类的成员(成员变量和成员方法)，包括私有成员。

3.内部类与外部类之间的访问

在测试类中调用成员内部类中的方法:

 外部类访问成员内部类中的成员:

静态的成员内部类,只能访问外部类的静态成员

私有的成员内部类，外界就无法直接创建其对象,可以通过外部类的方法访问

 局部内部类，在外界没有直接创建其对象的语法

局部内部类访问外部类的局部变量:

---

1.内部类与外部类

将一个类A 定义到另一个类B的内部，那么类A叫做内部类，类B叫做外部类。

根据内部类在外部类中定义的位置不同，分为 成员内部类，和局部内部类

• 成员内部类: 定义在外部类的成员位置。
• 局部内部类: 定义在外部类的局部位置，也就是外部类中的方法内部。

class B {           //B是外部类
   
    class A {       //A是成员内部类

    }

    public void show() {
        
        class C {    //C是局部内部类

        }
    }

}

2.内部类的特点：内部类可以直接访问外部类的成员(成员变量和成员方法)，包括私有成员。

package org.xingyun.interface1;

public class Wai {           //外部类
    int num = 20;
    private int a = 60;

    //成员内部类
    public class Nei {
        public void neiShow() {
            System.out.println("内部类的show方法");
            //内部类的特点：内部类可以直接访问外部类的成员，包括私有成员。
            System.out.println(num);              //外部类的成员变量
            System.out.println(a);                //外部类的私有变量
            waiShow();                            //外部类的成员方法
            hehe();                               //外部类的私有方法
        }
    }

    public void waiShow() {
        System.out.println("外部类的show方法");
    }

    private void hehe() {
        System.out.println("外部类的私有方法");
    }
    
}

如果外部类与内部类的成员有重名的话 ,可以这样拿到外部类的成员:外部类名.this.变量名(其中 Outer.this 表示外部类对象)

class Outer {
    //外部类的成员变量
    public int num = 10;

    class Inner {
        //内部的成员变量
        public int num = 20;

        public void show() {
            //局部变量
            int num = 30;
            System.out.println(num);      //30(就近原则)
            System.out.println(this.num); //20(内部类的变量)

            System.out.println(Inner.this.num); //20(内部类的变量,也可以这样取到)
           
            System.out.println(new Outer().num); //10(创建了一个外部类的对象去取变量)这样太繁琐了
            // 可以这样Outer.this.num .   (Outer.this 表示外部类对象)
            System.out.println(Outer.this.num);  //10
 
        }
    }
}

3.内部类与外部类之间的访问

在测试类中调用成员内部类中的方法:

需要先创建成员内部类的对象的语法格式:外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

 class Wai {       //外部类
     private int a=100;
    //成员内部类
    public class Nei {

        public void neiShow() {
            System.out.println("内部类的show方法" );
        }
    }

    public void waiShow() {
        System.out.println("外部类的show方法");
    }
}


public class Test {
    public static void main(String[] args) {
        //在测试类里面，调用内部类的方法
        //创建成员内部类的对象    外部类名.内部类名 对象名 = 外部类对象.内部类对象
        Wai.Nei nei = new Wai().new Nei();
        nei.neiShow();
        System.out.println("====================================");
        //内部类可以直接访问外部类的成员，包括私有成员。
        Wai wai = new Wai();
        wai.waiShow();
    }
}
//执行结果:
/*
内部类的show方法
====================================
外部类的show方法
 */

 外部类访问成员内部类中的成员:

需要先创建成员内部类的对象:     内部类名 对象名 =new 内部类名();

public class Wai {        //外部类

    //成员内部类
    public class Nei {
        //内部类的成员变量
        int n = 5;
        int x = 100;

        //内部类的成员方法
        public void neiShow() {
            System.out.println("内部类的show方法");
        }
    }

    public void waiShow() {
        System.out.println("外部类的show方法");
    }
    //外部类访问内部类的成员
    public void test() {
        //创建内部类对象
        Nei nei = new Nei();
        //访问内部类的成员变量
        System.out.println(nei.n);
        System.out.println(nei.x);
        //访问内部类的成员方法
        nei.neiShow();
        
        //直接访问外部类成员
        waiShow();
    }
}

静态的成员内部类,只能访问外部类的静态成员

静态的成员内部类，创建对象的语法: 外部类名.内部类名 对象名 = new 外部类名.内部类名();

public class Test {
    public static void main(String[] args) {
        //静态的成员内部类，创建对象的语法
        Wai.Nei nei = new Wai.Nei();
        nei.neiShow();
        //静态的成员内部类,只能访问外部类的静态成员。
    }
}


 class Wai{
    static int num = 100;

    //static 也可以修饰内部类
    public static class Nei {
        public void neiShow() {
            //静态的成员内部类,只能访问外部类的静态成员。
            System.out.println(num);
        }
    }
}

私有的成员内部类，外界就无法直接创建其对象,可以通过外部类的方法访问

public class privateNei {
    public static void main(String[] args) {
        //私有的成员内部类，外界就无法创建其对象了
        //通过外部类的方法访问
        Outer outer = new Outer();
        outer.waiShow();
    }
}

class Outer {     //外部类
    //内部类可以私有修饰
    private class Inner {        //成员内部类
        public void neiShow() {
            System.out.println("nei show");
        }
    }

    public void waiShow() {
        //可以外部类访问内部类,创建内部类对象
        Inner inner = new Inner();
        inner.neiShow();
    }
}

 局部内部类，在外界没有直接创建其对象的语法

public class Test {
    public static void main(String[] args) {
        //局部内部类，在外界没有直接创建其对象的语法。通过外部类方法访问
        Wai wai = new Wai();
        wai.waiShow();
    }
}

class Wai {
    int num = 20;
    private double a = 3.5;

    public void waiShow() {
        //局部内部类
        class Nei {
            int t = 50;

            public void neiShow() {
                System.out.println(num);
                System.out.println(a);
            }
        }
        //创建局部内部类对象
        Nei nei = new Nei();
        nei.neiShow();
    }
}

局部内部类访问外部类的局部变量:

局部内部类访问外部类的局部变量，局部变量必须用final修饰，使之成为常量.

为什么呢? 因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用final修饰，这样，在堆内存里面存储的其实是一个常量值。(JDK1.8之后，final会默认加上)

class Outer {
    public void waiShow(final int a) {
        //局部变量
        final int num = 20; 

        //定义局部内部类
        class Inner {
            public void neiShow() {
                //局部内部类，要访问外部类的局部变量，局部变量，必须用final修饰，使之成为常量
                System.out.println(num);    //20
                System.out.println(a);      //20
            }
        }
    }
}

(小编也在努力学习更多哟!以后会多多分享哒!)  

希望对友友们有所帮助!!!