工作偷懶篇：JAVA:Inner Class=C++:Nested Class

    還是開門見山：住在山里；

為什么需要內部類？有什么好處呢？感覺不用也沒什么，我也這樣任為的，不過一定要好處了--費話

PS：用得最多的，假設有一個接口，這個接口里面一個方法的名字，參數和你的類中的方法一個樣，咋辦--修改名稱了，最直接，但還是有另一種方法，用內部類--特性：內部類對外部類的所有內容都可以訪問；

 

前面都是費話，騙稿費的，下面來真的：

 

封装性:把你的秘密藏起來；

 

 

package cn.lake.test;
/**
 * @Description 白癡者
 * @author Lake_Xie
 *
 */
public interface Fool {
    int value();
}

 

package cn.lake.test;
/**
 * @Description 聰明者
 * @author Lake_Xie
 *
 */
public interface Acumen {
    String goal();
}

 

package cn.lake.test;

public class Cry {
	/**
	 * @Description 傻子坐
	 * 
	 * @author Lake_Xie
	 * 
	 */
	private class Sit implements Fool {
		private int i = 11;
		//重寫
		public int value() {
			return i;
		}
	}

	/**
	 * @Description 醒目躺
	 * 
	 * @author Lake_Xie
	 * 
	 */
	protected class Lie implements Acumen {
		private String label;

		private Lie(String lieTo) {
			label = lieTo;
		}
		//重寫
		public String goal() {
			return label;
		}
	}

	public Acumen comeOn(String s) {
		return new Lie(s);
	}

	public Fool laugh() {
		return new Sit();
	}
}

 

 

package cn.lake.test;

/**
 * @Description 哭一下試試
 * @author Lake_Xie
 *
 */
class TestCry {
	public static void main(String[] args) {
		Cry p = new Cry();
		Fool c = p.laugh();
		Acumen d = p.comeOn("Lake_xie");
	}
}

 

說明：先有Cry再來Fool和Acumen因為非靜態的；

 

好處多多:內部類對象可以訪問創建它的外部類對象的內容-也包括變量(公私都可以)，不過還前提，內部類對象必須有指向外部類對象的引用。也對前面說明那個非靜態誰先創建一個說明補充吧；

實質：JAVA編譯器在創建內部類對象時，隱式的把其外部類對象的引用也傳了進去，一起保存，就得到一個結果：內部類對象始終可以訪問其外部類，不允許出現靜態的數據包括方法；

 

package cn.lake.test;

public class Cry {
	//加加加
	private int count=10;
	/**
	 * @Description 傻子坐
	 * 
	 * @author Lake_Xie
	 * 
	 */
	private class Sit implements Fool {
		private int i = 11-count;
		//重寫
		public int value() {
			return i;
		}
	}

	/**
	 * @Description 醒目躺
	 * 
	 * @author Lake_Xie
	 * 
	 */
	protected class Lie implements Acumen {
		private String label;

		private Lie(String lieTo) {
			label = lieTo;
		}
		//重寫
		public String goal() {
			return label;
		}
	}

	public Acumen comeOn(String s) {
		return new Lie(s);
	}

	public Fool laugh() {
		return new Sit();
	}
}

 

如果再倒霉碰到外部變量和內部一樣，那只能用this了；

 

有點煩那就來試試靜態的怎么樣!因為非靜態的說了；

 

靜態內部類：

 

無法表達我的心意只能說區別吧：

1. 沒有指向外部的引用；

2. 可以有多層嵌套，可以靜態數據或者非靜態數據；

 

局部內部類：

 

package cn.lake.test;
/**
 * <pre>
 * 代碼在內部
 * </pre>
 * @author Lake_Xie
 *
 */
public class CryOne {
	public Acumen comeOn(String s) {
		class Lie implements Acumen {
			private String label;

			private Lie(String lieTo) {
				label = lieTo;
			}

			public String goal() {
				return label;
			}
		}
		return new Lie(s);
	}

	public static void main(String[] args) {
		CryOne g = new CryOne();
		Acumen d = g.comeOn("Lake_xie");
	}
}

 

comeOn的方法定義了一個內部類，處理完了返回一個對象，他只有這個作用了，按需要去做了；

 

接下業引用別人一個例子：

 

package cn.lake.test;

public class CryTwo {
	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("slip");
			String s = ts.getSlip();
		}
	}

	public void track() {
		internalTracking(true);
	}

	public static void main(String[] args) {
		CryTwo g = new CryTwo();
		g.track();
	}
}

 

      你不能在if之外創建這個內部類的對象，因為這已經超出了它的作用域。不過在編譯的時候，內部類TrackingSlip和其他的類一樣同時被編譯，只不過它由它自已的作用域，超出這個范圍就無效，除此之外它和其他內部類一樣；

 

匿名內部類：

 

語法：

new interfaceName()

        {

            ......

         }

new superclassName()

         {

             ......

         }

 

例子：