Java基础篇：内部类详解

目录：

一、内部类的好处：

二、成员内部类：

内部类：可以将一个类的定义放在另一个类的定义内部，这就是内部类。

内部类是一个编译时概念，编译后外部类及其内部类会生成两个独立的class文件： OuterClass.class和OuterClass$InnerClass.class。

在Java中内部类主要分为四种：成员内部类、局部内部类、匿名内部类、静态内部类。

一、内部类的好处：

《Thinking in Java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都是没有影响的。

1、使用内部类最大的优点就是可以实现多重继承问题：

Java中只能继承一个类，多重继承在没有内部类之前是使用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了，它可以使我们的类继承多个具体类或抽象类。

2、可以解决同时继承类和实现接口的时候，类和接口中出现同名方法的情况：

3、内部类提供了更好的封装和隐藏，除了外部类，其他类都不能访问内部类。而且，一般外部类，是不允许有private和protected权限的，但是内部类可以。

4、内部类中的属性和方法，即使是外部类也不能直接访问，相反，内部类拥有外部类所有元素的访问权限，可以直接访问外部类的属性和方法，即便是private。

5、内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外部类对象的信息相互独立。

6、在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类，不受外部类是否继承接口影响。

7、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。

8、有利于回调函数的编写。

二、成员内部类：

（1）成员内部类作为外部类的一个成员存在，与外部类的属性、方法并列，可以无限制的访问外部类的所有成员，即使是private的也可以访问。但是外部类要访问内部类的成员属性和方法则要通过内部类实例来访问。

（2）成员内部类不能存在任何static的静态变量和方法；

（3）成员内部类是依附于外部类的，所以只有先创建了外部类才能够创建内部类。

（4）用内部类定义在外部类中不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限。

public class OuterClass {
    private String str;
    
    public void outerDisplay(){
        System.out.println("outerClass...");
    }
    
    public class InnerClass{
        public void innerDisplay(){
            //使用外部类的属性
            str = "chenssy...";
            System.out.println(str);
            //使用外部类的方法
            outerDisplay();
        }
    }
    
    /*推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */
    public InnerClass getInnerClass(){
        return new InnerClass();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.getInnerClass();
        inner.innerDisplay();
    }
}
--------------------
chenssy...
outerClass...

三、局部内部类：

（1）即在方法中或者作用域中定义的内部类，局部内部类与成员内部类基本一致，只是他们的作用域不同，局部内部类只能在该方法中被使用，出了该方法就会失效。

（2）局部内部类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，但又不希望这个类是公共可用的，所以就产生了局部内部类。

（3）与局部变量相似，在局部内部类前面不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和 abstract修饰。

（4）局部内部类中不可定义static静态变量，static方法中定义的内部类可以访问外部类定义的static成员。

（5）局部内部类可以访问外部类的局部变量（即方法内的变量），但是变量必须是final。

（6）在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时，需要生成对象，对象调用方法，在方法中才能调用局部内部类。

//定义在方法中：
public class Parcel5 {
    public Destionation destionation(String str){
        class PDestionation implements Destionation{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new PDestionation(str);
    }
    
    public static void main(String[] args) {
        Parcel5 parcel5 = new Parcel5();
        Destionation d = parcel5.destionation("chenssy");
    }
}

//定义在作用域中：
public class Parcel6 {
    private void internalTracking(boolean b){
        if(b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s) {
                    id = s;
                }
                String getSlip(){
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("chenssy");
            String string = ts.getSlip();
        }
    }
    
    public void track(){
        internalTracking(true);
    }
    
    public static void main(String[] args) {
        Parcel6 parcel6 = new Parcel6();
        parcel6.track();
    }
}

四、静态内部类：

（1）静态内部类定义在类中、任何方法外，用static修饰，在静态内部类中可以定义静态或者非静态的成员。

（2）静态内部类与非晶体啊内部类之间存在一个最大的区别：非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外部类，但是静态内部类去没有。

（3）静态内部类的创建不依赖外部类，可以直接创建，而不需要通过生成外部类对象来生成。

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

（4）静态内部类可以定义静态或者非静态的成员，但是不可以访问外部类的非static成员变量和方法，而内部类则都可以；

（5）静态内部类可以用public,protected,private修饰。

public class OuterClass {
    private String sex;
    public static String name = "chenssy";
    
    /**
     *静态内部类
     */
    static class InnerClass1{
        /* 在静态内部类中可以存在静态成员 */
        public static String _name1 = "chenssy_static";
        
        public void display(){
            /* 
             * 静态内部类只能访问外部类的静态成员变量和方法
             * 不能访问外围类的非静态成员变量和方法
             */
            System.out.println("OutClass name :" + name);
        }
    }
    
    /**
     * 非静态内部类
     */
    class InnerClass2{
        /* 非静态内部类中不能存在静态成员 */
        public String _name2 = "chenssy_inner";
        /* 非静态内部类中可以调用外部类的任何成员,不管是静态的还是非静态的 */
        public void display(){
            System.out.println("OuterClass name：" + name);
        }
    }
    
    /**
     * @desc 外部类方法
     * @return void
     */
    public void display(){
        /* 外部类访问静态内部类：内部类. */
        System.out.println(InnerClass1._name1);
        /* 静态内部类 可以直接创建实例不需要依赖于外围类 */
        new InnerClass1().display();
        
        /* 非静态内部的创建需要依赖于外围类 */
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        /* 访问非静态内部类的成员需要使用非静态内部类的实例 */
        System.out.println(inner2._name2);
        inner2.display();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}
----------------
Output:
chenssy_static
OutClass name :chenssy
chenssy_inner
OuterClass name：chenssy

五、匿名内部类：

1、定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类的创建放到一起完成，或者说在定义类的同时就创建一个类。以这种方法定义的没有名字的类称为匿名内部类。

（1）匿名内部类是没有访问修饰符的；

（2）匿名内部类所在方法的形参需要被匿名内部类使用时，这个形参必须是final；

（3）匿名内部类是没有构造方法的，因为他没有类名。由于不知道类名，也不能使用关键字来创建该类的实例。实际上匿名内部类的定义、构造、和第一次使用都发生在同样一个地方。

（4）匿名内部类中不能存在任何静态变量和方法；

（5）匿名内部类必须继承一个抽象类或者实现一个接口，一般隐式的继承某一个父类或者实现某一个接口，不需要使用extends和implements关键字。但不能同时继承类和实现接口。

（6）一个匿名内部类一定是在new的后面，用其隐含地实现一个接口或者实现一个类，没有类名，根据多态，我们使用其父类名。因为他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。

（7）大部分匿名内部类是用于接口回调用的，匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

（8）匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

public class OuterClass {
    public InnerClass getInnerClass(final int num,String str2){
        return new InnerClass(){
            int number = num + 3;
            public int getNumber(){
                return number;
            }
        };        /* 注意：分号不能省 */
    }
    
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        InnerClass inner = out.getInnerClass(2, "chenssy");
        System.out.println(inner.getNumber());
    }
}
 
interface InnerClass {
    int getNumber();
}
 
----------------
Output:
5

2、当方法中的参数需要被匿名内部类使用时，为什么使用要使用final？

https://blog.csdn.net/chenssy/article/details/13170015

在内部类编译成功后，他会产生一个class文件，该class文件与外部类并不是同一个class文件，仅仅保留对外部类的引用。当外部类传入的参数需要被内部类调用时，从java程序角度来看是直接被调用：

public class OuterClass {
    public void display(final String name,String age){
        class InnerClass{
            void display(){
                System.out.println(name);
            }
        }
    }
}

从上面代码中看，好像参数应该是被内部类直接调用？其实不然，在Java编译之后，实际操作如下：

public class OuterClass$InnerClass {
    public InnerClass(String name,String age){
        this.InnerClass$name = name;
        this.InnerClass$age = age;
    }
    
    
    public void display(){
        System.out.println(this.InnerClass$name + "----" + this.InnerClass$age );
    }
}

从上面代码来看，内部类并不是直接调用方法传递的参数，而是利用自身的构造器对传入的参数进行备份，自己内部方法调用的实际是自己的属性而不是外部方法传递进来的参数。

直到这里还没有解释为什么是final？在内部类中的属性和外部方法的参数两者从外表上看是同一个东西，但实际上却不是，所以他们两者是可以任意变化的，也就是说在内部类中我对属性的改变并不会影响到外部的形参，而然这从程序员的角度来看这是不可行的，毕竟站在程序的角度来看这两个根本就是同一个，如果内部类该变了，而外部方法的形参却没有改变这是难以理解和不可接受的，所以为了保持参数的一致性，就规定使用final来避免形参的不改变。

简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

故如果定义了一个匿名内部类，并且希望它使用一个其外部定义的参数，那么编译器会要求该参数引用是final的。

3、匿名内部类的初始化：

我们一般都是利用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！那怎么来初始化匿名内部类呢？使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果。

public class OutClass {
    public InnerClass getInnerClass(final int age,final String name){
        return new InnerClass() {
            int age_ ;
            String name_;
            //构造代码块完成初始化工作
            {
                if(0 > age && age < 200){
                    age_ = age;
                    name_ = name;
                }
            }
            public String getName() {
                return name_;
            }
            
            public int getAge() {
                return age_;
            }
        };
    }
    
    public static void main(String[] args) {
        OutClass out = new OutClass();
        
        InnerClass inner_1 = out.getInnerClass(201, "chenssy");
        System.out.println(inner_1.getName());
        
        InnerClass inner_2 = out.getInnerClass(23, "chenssy");
        System.out.println(inner_2.getName());
    }
}

六、总结：

1、首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private,protected,default,public，它有类成员的修饰符: static,final,abstract；
2、非静态内部类nested inner class：隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源，包括private。

外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。

非静态内部类不能包含任何static成员。
3、静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化。

静态内部类能包含static或非static成员；

静态内部类只能访问外部类static成员；

外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.静态成员即可访问，对于非static成员，只能用对象.非静态成员进行访问。
4、对于方法中的内部类或块中内部类（即局部内部类）只能访问块中或方法中的final变量。
5、局部内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说局部内部类和内部类没什麽区别。但局部内部类不能在方法以外访问，方法中不可以有static内部类。

6、匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数；匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递。

7、外部类与内部类、局部内部类的访问修饰符：

（1）对于外部类，只有两种访问修饰符，public与默认(default)，因为外部类放在包中，只有两种可能，包可见与包不可见。

（2）对于内部类（局部内部类、匿名内部类除外），可以使用所有的访问修饰符，因为内部类放在外部类中，与成员变量的地位一致，所以有四种可能。

（3）局部内部类与局部变量一样不能用访问权限修饰符。

参考文章：https://blog.csdn.net/chenssy/article/details/13024951

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/114678.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...