面向物件——多型

一、定義：一個物件可以有多種形態。

二、前提：

• 需要存在繼承或者實現關係（多型是物件的概念,和類沒有關係）；
• 要有覆蓋操作。

三、多型的特點:

•  把子類物件賦給父類變數，在執行時期會表現出具體的子類特徵（父類或者介面的引用指向或者接收自己的子類物件）；
• 成員變數：只看引用變數所屬的類；
• 成員函式：編譯時，要檢視引用變數所屬的類中是否有呼叫的成員。執行時，要檢視物件所屬的類中是否有所呼叫的成員

四、作用：

• 多型的存在提高了程式的擴充套件性和後期可維護性（遮蔽不同子類物件之間的實現差異）；
• 降低耦合度；

五、引用型別轉換：

SuperDemo sd  = new SubDemo();//向上轉型以後，如果父子都有相同函式，訪問函式子類的函式

		sd.test1();
		//注意：當向上轉型以後，只能訪問父類和子類共有的方法
		SubDemo sd1 = (SubDemo)sd;//向下轉型
		sd1.test2();

		//向下轉型必須先向上轉型
		Fruit f = new Apple();
		Orange o = (Orange) f;//不行
 

注意：判斷某一個物件是否是某一種型別:instanceof運算子:

boolean result = 物件 instanceof 類名/型別

設計模式

一、單例設計模式：

class  JavaDemo
{
	public static void main(String[] args) 
	{
		//單例：單個例項
		//System.out.println("Hello World!");
		//new SingleDemo();
		/*
		SingleDemo sd1 = SingleDemo.getSD();
		System.out.println(sd1);

		SingleDemo sd2 = SingleDemo.getSD();
		System.out.println(sd2);
		*/

		SingleDemo1 sd3 = SingleDemo1.getSD();
		System.out.println(sd3);
		SingleDemo1 sd4 = SingleDemo1.getSD();
		System.out.println(sd4);

	}
}

class SingleDemo
{
	//餓漢式
	private static SingleDemo sd = new SingleDemo();
	private SingleDemo(){

	}
	public static SingleDemo getSD(){
		return sd;
	}
}

class SingleDemo1
{
	//懶漢式
	private static SingleDemo1 sd;
	private SingleDemo1(){

	}


	public static SingleDemo1 getSD(){

		if(sd==null){
			sd = new SingleDemo1();
			return sd;
		}else{
			return sd;
		}
		
		
	}
}
 

class  FactoryDemo
{
	public static void main(String[] args) 
	{
		Fruit f = null;
		f = Factory.get("橘子");
		f.eat();
	}
}

interface Fruit
{
	public void eat();
}

class Apple implements Fruit
{
	public void eat()
	{
		System.out.println("吃蘋果");
	}
}

class Orange implements Fruit
{
	public void eat()
	{
		System.out.println("吃橘子");
	}
}

class Factory//工廠類
{
	public static Fruit get(String name)
	{
		Fruit f = null;
		if("蘋果".equals(name))//這裡不能把name寫在前面，否者會出現空指標異常
		{
			f = new Apple();
		}
		if("橘子".equals(name))
		{
			f = new Orange();
		}
		return f;
	}
}
 

class  ProxyDemo
{
	public static void main(String[] args) 
	{
		ProxyCl p = new ProxyCl(new Real());
		p.browse();
	}
}

interface Net
{
	public void browse();
}

class Real implements Net//真真實現功能的類
{
	public void browse()
	{
		System.out.println("上網了");
	}
}

class ProxyCl implements Net//代理類，代理類可以實現更多的輔助功能
{
	private Net net;
	public ProxyCl(Net net)
	{
		this.net = net;
	}
	
	public boolean check()
	{
		boolean inf = true;
		return inf;
	}

	public void browse()
	{
		this.check();
		this.net.browse();
	}
}

四、介面卡模式：

在繼承介面時，就必須全部實現介面中的方法，這樣很多用不到的也要實現很麻煩，所有就有適配類的出現，即用一個抽象類並用抽象類裡的空方法體來實現介面中所有方法，然後從這個抽象類中繼承，就可以有選擇的實現相關方法

程式碼塊

一、程式碼塊: 在程式中(類/方法),使用{}括起來的一段程式碼.

二、而根據程式碼塊存在的位置,和修飾符,分三類:

   在程式碼塊中定義的變數的的作用範圍,就只在該程式碼塊有效.

1):區域性程式碼塊:在方法中定義的程式碼塊,一般的表現為if,while,for等語句.

2):初始化代塊(構造程式碼塊):在類中直接定義,和方法是平行關係.用來做初始化操作.在建立該初始化程式碼塊所在類的物件的時候,執行,建立N個物件,則執行N次.

     建立物件時,優先於構造器執行.開發中,不推薦使用,即使要在建立物件的時候做初始化操作,我們一般在構造器中完成即可.

3):靜態程式碼塊:

  使用static修飾的初始化程式碼塊.

  當靜態程式碼塊所在類的位元組碼被載入進JVM,就立馬執行靜態程式碼塊,而且只會執行一次.

  一般的,做靜態資源的初始化,載入檔案,載入資源，靜態程式碼塊優先於main方法執行----->main方法,是在位元組碼被載入進JVM之後,再呼叫的.

public static void main(String[] args) 
	{
		//程式碼塊
		/*
		{
			int a = 3;
			System.out.println("程式碼塊："+a);
		}
		*/
		//int a = 3;
		//System.out.println(a);
		new TestDemo3();
		new TestDemo3();
		new TestDemo3();


	}
}


class TestDemo3
{
	{	
		System.out.println("普通程式碼塊！");

		}
	//靜態程式碼塊，比普通程式碼塊要快，比建構函式要快，並且只會呼叫一次。
	static{
		System.out.println("靜態程式碼塊！");
	}
	public TestDemo3(){
		System.out.println("無引數的建構函式！");
	}
	
}