一、成员内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

1、什么是成员内部类

        作为外部类的一个成员存在，是定义在外部类的成员位置，并且没有static修饰，与外部类的属性、方法并列。内部类和外部类的实例变量可以共存。

2、访问方式

① 在内部类中访问实例变量：this.属性

        ② 在内部类访问外部类的实例变量：外部类名.this.属性

        ③ 在外部类的外部访问内部类，使用 out.inner.


Ⅱ使用细节 ☛♡☚

1、内部类作为外部类的成员，可以直接访问外部类的所有成员，包括私有的。

2、可以添加任意访问修饰符（public、protected、默认、private），因为成员内部类就相当于一个成员。

3、成员内部类不能定义静态成员，只能定义普通成员或非静态成员。

4、注意：

❶ 在外部类可以直接使用 inner s=new inner(); ，因为内部类是外部类的成员，所以可以生成对象。
        ❷ 而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后再生成一个内部类对象。如：
                Outer o=new Outer()；
                Outer.Inner in=o.new.Inner()；

5、创建成员内部类实例时，外部类的实例必须已经存在。

6、当内部类和外部类有同名的成员时，成员内部类可通过 外部类名.this.变量名 访问外部类成员。

Ⅲ代码实例演示 ☛♡☚

㈠创建简单的成员内部类
package com.Locally;

public class Member {
    public static void main(String[] args) {

        //new一个外部类AA对象
        AA aa = new AA();

        //调用外部类的t1()方法
        aa.t1();

    }
}
class AA{

    //外部类的成员属性
    private int n1 = 10;
    public String name = "sminth";

    //定义成员内部类
    class BB{//类名

        //成员内部类的成员方法
        public void play(){
            //调用外部类的成员属性
            System.out.println("n1=" + n1 + " name=" + name);
        }

    }

    //外部类的成员方法    
    public void t1(){
        
        //new一个成员内部类
        BB bb = new BB();
        //调用成员内部类的play()方法
        bb.play();
    }

}
㈡其他外部类的第一种访问方式
package com.Locally;

public class Member {
    public static void main(String[] args) {
       
        //new一个外部类AA对象
        AA aa = new AA();

        //外部类使用成员内部类的第一种方式:    
        AA.BB b1 = aa.new BB();
        //解析：
        //AA.BB 表示外部类AA的内部类BB
        //aa.new BB() 可以看做是通过外部类对象(前面new外部类对象)，去创建外部类中的内部类对象
        
        //然后直接调用内部类的play()方法
        b1.play();



    }
}
class AA{
    private int n1 = 10;
    public String name = "sminth";

    //定义成员内部类
    class BB{
        public void play(){
            System.out.println("n1=" + n1 + " name=" + name);
        }
    }

}
㈢其他外部类的第二种访问方式
package com.Locally;

public class Member {
    public static void main(String[] args) {
        //new一个AA对象
        AA aa = new AA();
        aa.t1();

        //外部类使用成员内部类的第二种方式
       
        AA.BB b2 = aa.retu();
        //解析：
        //AA.BB 是外部类AA中的内部类BB
        //aa.retu() 等价于 aa.new BB()

        //直接调用内部类的play()方法
        b2.play();


    }
}
class AA{
    private int n1 = 10;
    public String name = "sminth";

    //定义成员内部类
    class BB{
        public void play(){
            System.out.println("n1=" + n1 + " name=" + name);
        }
    }

    //第二种：
    //定义一个外部成员方法tetu(),返回值为 内部类对象类型
    public BB retu(){
        return new BB(); //返回 内部类的new BB() 对象
    }
}

二、静态内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

1、什么是静态内部类

静态类部类是定义在外部类的成员位置，与成员内部类相似。但是静态内部类有static 关键字修饰，并且静态内部类只能访问外部类的静态成员。

2、静态内部类与成员类部类的区别

        生成（new）一个静态内部类不需要外部类成员，静态内部类的对象可以直接生成，如：
                Outer.Inner in=new Outer.Inner();

        而不需要通过生成外部类对象来生成，并且可以定义私有静态内部类。


Ⅱ使用细节 ☛♡☚

1、可以直接访问外部类的所有静态成员，包含私有，但是不能直接访问非静态成员。

2、可以添加任意访问修饰符（public、protected、默认、private），因为成员内部类就相当于一个成员。和成员内部类一样。

3、静态内部类能定义静态成员，也能定义普通成员或非静态成员。

4、当静态内部类和外部类有同名的成员时，静态内部类可通过 外部类名.变量名 访问外部类成员。

Ⅲ代码实例演示 ☛♡☚

㈠其他外部类的第一种访问方式
package com.Locally;

public class static_inner {
    public static void main(String[] args) {

        //new 一个外部类Outer01 对象
        Outer01 outer01 = new Outer01();

        //外部类的第一种访问方式:直接访问静态内部类成员
        Outer01.Inner01 inner01 = new Outer01.Inner01();
        //解析：
        //Outer01.Inner01可以理解为创建外部类对象Outer01的内部类对象Inner01
        //Outer01.Inner01() 因为是静态的，所以直接访问

        //通过对象名，直接调用静态内部类成员
        inner01.cc();

        
    }
}
class Outer01{

    private static int n3 = 10;

    public void cpy(){
        System.out.println("这是cpy()方法");
    }
    
    //定义静态内部类
    static class Inner01{

        private int n2 = 33;
        
        public void cc(){
            System.out.println("n3=" + n3);

            //不能访问cpy()，因为它是普通成员，没有static 关键字修饰
        }
    }

    
}
㈡其他外部类的第二种访问方式
package com.Locally;

public class static_inner {
    public static void main(String[] args) {
        //定义外部类对象
        Outer01 outer01 = new Outer01();
        

        //其他外部类的第二种访问方式：
        //创建一个方法访问
        Outer01.Inner01 inner011 = outer01.n();
        //解析：
        //Outer01.Inner01 同上
        //outer01.n() 等价于 new Outer01.Inner01()

        //通过对象名直接访问静态内部类的成员
        inner011.cc();
    }
}
class Outer01{
    private static int n3 = 10;
    public void cpy(){
        System.out.println("这是cpy()方法");
    }
    
    //定义静态内部类
    static class Inner01{

        private int n2 = 33;

        public void cc(){
            System.out.println("n3=" + n3);
            
        }
    }

    //创建的方法
    //定义一个方法，返回值类型为 静态内部类对象
    public Inner01 n(){
        return new Inner01(); //返回 new了的静态内部类对象
    }
}

三、局部内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

什么是局部内部类：定义在一个类的成员方法或代码块中的类叫局部内部类。

代码解释：
class Outer{//外部类
    
    private int n1; //外部类属性
    public void m2(){} //外部类方法

    //外部类方法
    public void m1(){

        //方法中
        //局部内部类
        final class Inner{ //类名
            
            private int n1; //局部内部类属性

            public void f1(){ //局部内部类方法}
        }
    }

}
Ⅱ使用细节 ☛♡☚

1、局部内部类是定义在外部类的局部位置,通常在方法

2、可以直接访问外部类的所有成员，包含私有的

3、不能添加访问修饰符，因为它的地位就是一个局部变量，局部变量是不能其他使用修饰符的，但是可以使用 final 修饰。

4、作用域 : 仅仅在定义它的方法或代码块中

5、如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，使用 外部类名.this.成员名 去访问

6、外部类名.this 的本质就是外部类的对象

Ⅲ代码实例演示 ☛♡☚
package com.Locally;

public class locally {
    public static void main(String[] args) {
        
        //new 一个外部类对象
        Outer outer = new Outer();
        outer.m1();
    }
}

class Outer{
    
    private int n1 = 100;

    public void m2(){
        System.out.println("Outer m2()");
    }

    public void m1(){
        
        //局部内部类
        final class Inner{

            private int n1 = 800;
            public void f1(){

                //  Outer02.this 本质就是外部类的对象，使用 外部类名.this.成员 去访问
                System.out.println("n1= " + n1 + " Outer.this.n1=" + Outer.this.n1);
                
                调用外部类的m2()方法
                m2();
            }
        }

        //new 一个局部内部类对象
        Inner inner = new Inner();
        //调用局部内部类的方法
        inner.f1();
    }

}

四、匿名内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

什么是匿名内部类：

匿名内部类,其实就是匿名的子类而已,只不过它隐藏在.class文件里面你看不到,所以叫匿名内部类!

注意：

匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的的特征。

Ⅱ使用细节 ☛♡☚

1、可以直接访问外部类的所有成员，包含私有的

2、不能添加访问修饰符，因为它的地位就是一个局部变量

3、作用域 : 仅仅在定义它的方法或代码块中

4、如果外部类和匿名内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，使用 外部类名.this.成员名 去访问

Ⅲ代码实例演示 ☛♡☚
package com.Locally;

public class Anonymous {
    public static void main(String[] args) {

        //new 一个Cellphone的对象
        Cellphone cellphone = new Cellphone();
        
        //匿名内部类
        cellphone.alarmclock(new Bell(){
            @Override
            public void ring() {
                System.out.println("System.out.println(\"懒猪起床了.....\");");
            }
        });

    }
}

//接口
interface Bell{
    void ring();
}

//定义一个类
class Cellphone{
    
    public void alarmclock(Bell bell){//传一个接口类的参数
        bell.ring();//动态绑定
    }

}
匿名内部类：
        cellphone.alarmclock(new Bell(){
            @Override
            public void ring() {
                System.out.println("System.out.println(\"懒猪起床了.....\");");
            }
        });
解析匿名内部类，可以把它分成两个部分：

①先new一个Bell() 对象，同时实体化（就是在{大括号中写属性或方法}），
        Bell bell = new Bell(){
            @Override
            public void ring() {
                System.out.println("System.out.println(\"懒猪起床了.....\");");
            }
        }
②调用cellphone类的alarmclock方法，传一个参数bell
cellphone.alarmclock(bell);
③而匿名内部类就是把第一步直接放到第二步的参数位置

④ring()方法的调用则是在cellphone类的alarmclock方法中bell.ring()时被调用

（JAVA）:四种内部类的细节理解，文字+代码会更好理解----第三部分重点

一、成员内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

Ⅱ使用细节 ☛♡☚

Ⅲ代码实例演示 ☛♡☚

二、静态内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

Ⅱ使用细节 ☛♡☚

Ⅲ代码实例演示 ☛♡☚

三、局部内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

Ⅱ使用细节 ☛♡☚

Ⅲ代码实例演示 ☛♡☚

四、匿名内部类 ☞♥☜

Ⅰ基本介绍 ☛♡☚

Ⅱ使用细节 ☛♡☚

Ⅲ代码实例演示 ☛♡☚

猜你喜欢