Java-内部类

内部类

内部类：在一个类中定义了其他的类，该类就称为内部类，比较灵活，缺点很明显，破换了程序的机构。

Class Outer{  //定义一个外部类
    
    private String msg = "msg"; //私有属性
    
    public void fun(){//普通方法
        //实例化内部类
        Inner in = new Inner();
        
        in.print();
    }
    
    Class Inner{//在Outer内部定义了一个Inner类
        
        public void print(){
            
            System.out.println(Outer.this.msg);
            //Outer类中的属性
            
        }
    }
}

public class InnerTest{
    
    public static void main(String[]args){
        
        Outer out = new Outer();
        
        out.fun();
    }
}

为什么要使用内部类？

摘自《Thinking in Java》：

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外部类是否已经继承了其他接口的实现，对于内部类都没有影响。

接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

在程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。

内部类的特性

1. 内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
2. 在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
3. 创建内部类对象的时刻并不依赖于外部类对象的创建
4. 内部类并没有令人 迷惑的"is-a"关系，他就是一个独立的实体。
5. 内部类提供了更好的封装，除了该外部类，其他类都不能访问。

---

• 内部类可以轻松的访问外部类中的私有属性和方法，在程序中外部类同样也可以轻松的访问内部类的私有属性和方法。

• 内部类是一个编译时的概念，一旦编译成功后，内部类就与外部类属于两个完全不同的类（他们之间肯定还存在一定的联系）。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

• Java中的内部类主要分为：

1. 成员内部类
2. 局部内部类
3. 匿名内部类
4. 静态内部类

class Outer{  //定义一个外部类
	
	private String msg="msg"; //私有属性
	
	public void fun() { //普通的方法
		
		//实例化内部类
		Inner in=new Inner();
		
		in.print();
		
		System.out.println(in.info); //访问内部类的私有属性
	}
	
	class Inner{  //在Outer类的内部定义了一个Inner类
		private String info="下雨了，回家收衣服了";
		
		public void print() {
			
			System.out.println(Outer.this.msg); //Outer类中的属性
		}
	}
	
}


public class InnerTest {

	public static void main(String[] args) {
		Outer out=new Outer();
		
		out.fun();
	}
	
}

• 内部类实例化方式

外部类.内部类 内部类对象=new 外部类().new 内部类();

class Outer1{
	
	private String msg="msg"; //外部类的私有属性
	
	class Inner{ //内部类
		
		public void print() {
			System.out.println(Outer1.this.msg);
		}
	}
}


public class InnerTest02 {

	public static void main(String[] args) {
		
		Outer1.Inner in=new Outer1().new Inner();
		
		in.print();
	}
}

---

成员内部类

• 成员内部类是最普通的外部类。成员内部类可以无限制的访问外部类的属性和方法，该外部类可以通过实例化内部类的方式访问成员内部类的属性和方法。

• 在成员内部类中需要注意的亮点：1. 成员内部类中不能存在任何static的变量和方法。 2. 成员内部类是依附于外部类的，所以只有创建外部类才能够创建内部类。

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

---

局部内部类

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

• 定义在方法中

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

---

匿名内部类

• 匿名内部类是没有名字的

public class OuterClass {
    public InnerClass g 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为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

1. 匿名内部类是没有访问修饰符的。
2. new 匿名内部类，这个类首先要存在。如果我们将那个InnerClass接口注释掉，就会出现编译出错。
3. 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。
4. 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

---

静态内部类

• 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