關於如何正確地定義Java內部類方法詳解

class Outer {//外部類
    class Inner {//內部類 
        //方法和屬性
    }
}

/**
 * @author 一一哥Sun 
 * 千鋒教育
 * 成員內部類
 */
public class OuterClass {
    // 外部類的非靜態成員
    String name = "一一哥";
    private String hobby = "擼碼";
    static int age = 30;

    // 非靜態方法
    public void show() {
        //這裡的this是指OuterClass對象
	System.out.println("show方法...name="+this.name);
        //如果是在外部類裡面創建內部類的對象，就不需要創建外部類實例，可以直接new 內部類()
	//InnerClass inner = new InnerClass();
    }

    // 定義一個成員內部類
    public class InnerClass {
	// 也可以定義私有屬性
	private int a = 10;
	//在早期的JDK中，成員內部類中不能定義靜態變量；但在新版JDK中，成員內部類中可以定義靜態變量
	static int b = 20;

	// 非靜態方法
	public void m1() {
            // 這裡的this對象是InnerClass內部類對象
            System.out.println("成員內部類的成員變量:" + this.a);
            //外部類.this.屬性或方法，這個this是外部類對象
            System.out.println("外部類的成員變量:" + OuterClass.this.name);
            //內部類中可以訪問外部類的私有成員和靜態成員
            System.out.println("外部類的私有成員變量:" + hobby);
            System.out.println("外部類的靜態變量:" + age);
	}

	//在早期的JDK中，成員內部類中不能定義靜態方法；但在新版JDK中，成員內部類中可以定義靜態方法
	public static void m2() {
            System.out.println("調用成員內部類的靜態變量:" + b);
            System.out.println("調用外部類的靜態變量:" + age);

            //在靜態方法中創建內部類對象，也要通過內部類 對象名 = new 外部類().new 內部類();的格式
            //InnerClass innerClass = new OuterClass().new InnerClass();
	}
    }
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 */
public class InnerClassTest {
    public static void main(String[] args) {
	//在外部的其他類中，不能直接創建內部類對象，否則：
	//No enclosing instance of type OuterClass is accessible. 
	//Must qualify the allocation with an enclosing instance of type OuterClass 
	//(e.g. x.new A() where x is an instance of OuterClass).
	//InnerClass inner=new InnerClass();

        //在外部的其他類中創建內部類對象，需要通過如下格式：
	//內部類 對象名 = new 外部類().new 內部類();
	//InnerClass inner=new OuterClass().new InnerClass();
		
	//也可以拆分成如下格式：
	OuterClass outer=new OuterClass();
	InnerClass inner=outer.new InnerClass();
	inner.m1();
	
	InnerClass.m2();	
    }
}

public class PartClass {
    public void method() {
        //在方法中定義的內部類，就是局部內部類
        class Inner {
            //屬性
            //方法
        }
    }
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 * 
 * 局部內部類---定義在方法中的內部類
 */
public class PartOuterClass {
    //類的成員變量
    String name="一一哥";
    private int age=30;
    static String hobby="java";
    
    public void show() {
    	//局部變量
        //JDK 7之前，匿名內部類和局部內部類中訪問外部的局部變量時，該變量需要明確地帶有final修飾符
        //final int num = 10;
        //Effectively final特性
        int num = 10;
        
        //局部內部類，類似於是方法中的局部對象
        class PartInnerClass{
            //內部可以正常定義方法
            public void m1() {
            	//訪問外部類的非靜態成員，可以使用OuterClass.this.成員的格式，也可以直接訪問
            	//System.out.println("外部類的成員變量"+name);
                System.out.println("外部類的成員變量"+PartOuterClass.this.name);
                System.out.println("外部類私有的成員變量"+age);
                System.out.println("外部類的靜態變量"+hobby);
                
                //局部內部類，可以直接訪問方法中的局部變量
                System.out.println("訪問局部變量"+num);
            }
            
            //在新版的jdk中，也可以定義靜態的屬性和方法，老版的jdk則不行
            static int b=10;
            
            public static void m2() {
            	System.out.println("外部類的靜態變量，hobby="+hobby+"，b="+b);
            }
        }
        //創建局部內部類對象
        PartInnerClass inner = new PartInnerClass();
        inner.m1();
        //在當前類中，局部內部類可以直接訪問靜態成員
        PartInnerClass.m2();
    }    
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 */
public class PartInnerClassTest {
    public static void main(String[] args) {
	//創建外部類對象，調用方法，執行局部內部類
	PartOuterClass outer=new PartOuterClass();
	outer.show();
    }
}

new <類或接口> (){
    重寫類或接口的方法
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 * 
 * 點擊監聽事件
 */
public interface OnClickListener {
    //點擊事件
    void onClick();
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 * 
 * 局部內部類---定義在方法中的內部類
 */
public class Button {
    //處理案例點擊的監聽事件
    public void setOnClickListener(OnClickListener listener) {
    	listener.onClick();
    }
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 * 
 * 匿名內部類測試
 */
public class AnonyInnerClassTest {
    public static void main(String[] args) {
	//外部變量
	int num=20;
	//測試匿名內部類
	Button btn=new Button();
	//模擬處理按鈕的點擊事件
	btn.setOnClickListener(new OnClickListener() {//這裡就是一個匿名內部類	
            //在匿名內部類中，可以允許使用非靜態代碼塊進行成員初始化操作。
            int i; 
            {   // 非靜態代碼塊，在構造方法之後執行
		i = 100;    //成員初始化
            }
			
            @Override
            public void onClick() {
		System.out.println("按鈕被點擊啦...i="+i+",num="+num);
            }
	});	
    }
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 * 
 * 外部類和內部類
 */
public class OuterClass {
    //普通屬性，屬於外部類
    static int outerNum=10;
	
    //定義一個靜態的內部類，如果不帶static，就是一個普通的內部類。
    //內部類的使用，和普通類一樣，裡面可以正常定義屬性、方法、構造方法等。
    //static前面可以帶public等任意訪問修飾符，也可以不帶！
    static class InnerClass{
	//私有屬性無法在類的外部直接訪問
	//private int innerNum=20;
	int innerNum=20;
		
	public void printNum() {
            //定義外部類對象
            OuterClass outer=new OuterClass();
            //這裡的this是指InnerClass內部類對象！	System.out.println("innerNum="+this.innerNum+",outerAge="+outer.outerAge+",outerNum="+OuterClass.outerNum);
	}
    }
}

/**
 * @author 一一哥Sun
 * 千鋒教育
 * 
 * 測試訪問內部類
 */
public class InnerClassTest {
    public static void main(String[] args) {
	//創建內部類對象，格式為“外部類.內部類 對象名 = new 外部類.內部類的構造方法”
	OuterClass.InnerClass inner = new OuterClass.InnerClass();
	//調用內部類的方法
	inner.printNum();
	//訪問外部類屬性
	System.out.println("outerNum="+OuterClass.outerNum);    
	//訪問內部類屬性
	System.out.println("innerNum="+inner.innerNum);
    }
}