Java学习笔记 08 内部类的使用

亦凉 2022-06-07 01:21 89阅读 0赞

## **一、为什么要使用内部类** ##

其实使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承问题，那么我们自然可以使用其他的编码方式，但是使用内部类还能够为我们带来如下特性：  
1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。

2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。

3、创建内部类对象的时刻并不依赖于外围类对象的创建。

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

5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

public class OuterClass {
        
        private String name ;
        private int age;
    
        /**省略getter和setter方法**/
    
        public class InnerClass{
        
            public InnerClass(){
                name = "chenssy";
                age = 23;
            }
    
            public void display(){
                System.out.println("name：" + getName() +"   ;age：" + getAge());
            }
        }
    
        public static void main(String[] args) {
            OuterClass outerClass = new OuterClass();
            OuterClass.InnerClass innerClass = outerClass.new InnerClass();
            innerClass.display();
        }
    }
    --------------
    Output：
    name：chenssy   ;age：23

其实在这个应用程序中我们还看到了如何来引用内部类：引用内部类我们需要指明这个对象的类型：OuterClasName.InnerClassName。同时如果我们需要创建某个内部类对象，必须要利用外部类的对象通过.new来创建内部类：OuterClass.InnerClass innerClass = outerClass.new InnerClass();。

public class OuterClass {
        public void display(){
            System.out.println("OuterClass...");
        }
    
        public class InnerClass{
            public OuterClass getOuterClass(){
                return OuterClass.this;
            }
        }
    
        public static void main(String[] args) {
            OuterClass outerClass = new OuterClass();
            OuterClass.InnerClass innerClass = outerClass.new InnerClass();
            innerClass.getOuterClass().display();
        }
    }
    -------------
    Output:
    OuterClass...

## **二、成员内部类** ##

成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

在成员内部类中要注意两点，  
**第一：成员内部类中不能存在任何static的变量和方法；**

**第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。**

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...

推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 。

## **三、局部内部类** ##

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

定义在方法里：

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();  
        }  
    }

## **四、匿名内部类** ##

在做Swing编程中，我们经常使用这种方式来绑定事件

button2.addActionListener(    
                    new ActionListener(){    
                        public void actionPerformed(ActionEvent e) {    
                            System.out.println("你按了按钮二");    
                        }    
                    });

1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。  
2、匿名内部类中是不能定义构造函数的。  
3、匿名内部类中不能存在任何的静态成员变量和静态方法。  
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。  
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法

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

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());
        }
    }

## **五、静态内部类** ##

在java提高篇—–关键字static中提到Static可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

**1、 它的创建是不需要依赖于外围类的。**

**2、 它不能使用任何外围类的非static成员变量和方法。**

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 外围类方法 
         * @author chenssy 
         * @data 2013-10-25 
         * @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

上面这个例子充分展现了静态内部类和非静态内部类的区别。

## **总结** ##

作为一个Java菜鸟，使用内部类的情况不太多，不过大多使用的是匿名类，特别是在做排序的时候，别的用的真心不多。