單例&&工廠模式&&內部類

設計模式：

解決某類問題的一個固定的編程模式，思路  23種

1.單例模式：只有一個實例

//這個類的只給提供一個實例
public class SessionFactory {
	//1.聲明一個私有的靜態的本類的屬性
	private static SessionFactory sf;
	//2.構造 方法私有化
	private SessionFactory() {
	
	}
	//3.提供一個靜態方法，返回私有的靜態的本類的屬性
	//向外界提供一個實例
	public static SessionFactory getIntance(){
		if(sf==null){
			sf = new SessionFactory();
		}		
		return sf;
	}
}

測試

public class SessionFactoryTest {

	@Test
	public void test() {
		SessionFactory sf = SessionFactory.getIntance();
		SessionFactory sf1 = SessionFactory.getIntance();
		System.out.println(sf==sf1);
	}
}

2.工廠模式：一般對象都是通過new構造方法來創建的，工廠模式是提供了一種方法，可以通過這個方法來獲取對象

public class AccountFactory {
	//Account工廠
	public static Account openAccount(int type,String ename, String password, String email,
			String personId, double balance){
		
		if(type==0){
			return new SavingAccount(ename, password, email, personId, balance);
		}else if(type==1){
			return new CreditAccount(ename, password, email, personId, balance, 10000);
		}
		
		return null;
	}
}

內部類

什麼是內部類，定義在類的內部的類叫內部類

分類：

以類成員的形式定義：成員內部類

有無static修飾

有：靜態內部類

無：動態內部類

定義在方法的內部：局部內部類，匿名內部類

Jdk1.8之前的匿名內部類只能訪問被final修飾的局部變量

public class Outer {
	private int a=5;//成員屬性
	
	public void m1(){
		System.out.println("a"+a);
//		System.out.println("ia"+ia);//內部類可以直接訪問外部類的成員，外部類不能直接訪問內部類的成員
		Inner1 inner1 = new Inner1();
		System.out.println("id"+inner1.a);
	}
	//成員內部類
	public class Inner1{
		private int a = 10;//覆蓋外部類的a屬性
		public void m1(){
			System.out.println("訪問外部類的私有屬性a"+Outer.this.a);
			//如果內部類沒有覆蓋a,可以直接訪問外部類的a
			Outer.this.m1();//Outer.this表示外部類的當前對象
		}
		
		public void m2(){
			Inner2 i2 = new Inner2();
			i2.m1();
		}
	}
	
	public static class Inner2{
		public void m1(){
//			System.out.println(a);//靜態成員不能訪問動態成員
			System.out.println("靜態成員不能訪問動態成員");
		}
	}
	
	public void m3(){
		//定義在方法的內容的類叫局部內部類,局部內部類只在方法內可見
		class Inner4 {
			public void m1(){
				
			}
		}
		
		Inner4 i4 = new Inner4();
		i4.m1();
	}
	
	public void m4(){
		int b = 10;
		//匿名內部類，通常用於創建某一個接口或類的子類，且只需要使用一次
		Account a = new Account() {
			@Override
			public void withdraw(double save) {
//				System.out.println(b);//jdk1.8之前匿名內部類只能訪問被final修飾的局部變量
			}
		};
	}
}

測試

mport org.junit.Test;

public class OuterTest {

	@Test
	public void test() {
		Outer outer = new Outer();
		outer.m1();//訪問外部類的m1方法
		//a5   id10
	}
	@Test
	public void test2() {
		Outer outer = new Outer();
//		outer.m1();
		//訪問內部類m1方法
		Outer.Inner1 in = outer.new Inner1();//創建動態內部類對象:new Outer().new Inner();
		in.m1();
		//訪問外部類的私有屬性a5
		//a5
		//id10
	}
	@Test
	public void test3() {
		Outer outer = new Outer();
//		outer.m1();
		//訪問靜態內部類m1方法
		Outer.Inner2 in = new Outer.Inner2();//創建靜態內部類對象：new Outer.StaticInner();
		in.m1();
	}

}

爲什麼要使用內部類：

內部類可以直接使用外部類的私有屬性

訪問規則

靜態內部類只能訪問靜態成員

成員內部類可以類的外部訪問

靜態內部類new Outer.StaticInner()

動態內部類：new Outer().new Inner()

 

局部內部類只能在方法的內部訪問

當內部類被編譯後，其生成的class文件名爲：外部類名$內部類名.class