昨天知識總結

• 1.static
  • 成員變數和區域性變數的區別
  • static修飾成員後的作用
  • static作用總結
• 2.構造方法
  • 構造方法的使用
  • this
• 3.匿名物件
• 4.注意點
• 5.靜態程式碼塊和構造程式碼塊

封裝性

• 封裝性：（根據對屬性的封裝說明），把對成員變數的訪問私有化，通過一個公共的方法間接的實現
• 好處：提高了程式碼的安全性，可讀性，複用性
• 髒資料：在程式中出現的不合邏輯的資料
• 原因：直接將資料交給了成員變數
• 如何避免髒資料？
  • 1.不要將值賦值給成員變數----讓成員變數不可見，將成員變數私有化
  • 2.通過方法間接的訪問他，先過濾，後賦值
• 因為對所有的屬性都要進行賦值和取值，系統在制定了一套預設的規則 -----get set方法
  • set—完成賦值
    • 構成：修飾詞 返回值 方法名（引數列表）{方法體 返回值 }
    • 返回值：不需要返回值----這裡寫void
    • 方法名：set+對應成員變數的名字，成員變數的首字母大寫
    • 引數列表：只有一個引數，引數的型別行與成員變數的型別一致，名字是成員變數的名字
    • 方法體：不需要返回值，我們可以寫 this.成員變數 = 形參的名字
  • get—完成取值
    • 構成：修飾詞 返回值 方法名（引數列表）{方法體 返回值 }
    • 修飾詞：一般是public
    • 返回值：型別與成員變數一致
    • 方法名：get+對應成員變數的名字，成員變數的首字母大寫
    • 引數列表：不需要引數
    • 快捷鍵
    • shift+alt+s

	public static void main(String[] args) {
 

		//開槍射擊
		Gun gun = new Gun();
		gun.setBulletNumber(-5);
		gun.shoot();
	}
class Gun{
	//屬於修飾詞，被他修飾的成員變數只能在當前類中可見
	private  int bulletNumber;
	private int age;
	private int hight;
	private int mode1;
	private String name;
	//新增子彈的方法
//	public void addBullerNumber(int number) {
//	}
	public void setBulletNumber
 
(int bulletNumber) {
		
		if(bulletNumber < 0) {
			this.bulletNumber = 0;
		}else {
			this.bulletNumber = bulletNumber;		}
	}
	public int getBulletNumber() {
		return bulletNumber;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getHight() {
		return hight;
	}
	public void setHight(int hight) {
		this.hight = hight;
	}
	public int getMode1() {
		return mode1;
	}
	public void setMode1(int mode1) {
		this.mode1 = mode1;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	//開槍射擊
	public void shoot() {
		if(bulletNumber == 0) {
			--bulletNumber;
		}else{
		System.out.println("剩餘的子彈數量"+--bulletNumber);
		}
	}
}

類的關係–繼承

• extends：表示前面的繼承後面的，如果一個類沒有父類，預設繼承Object

//建立他們的父親
//如果一個類裡沒有父類，預設值Object
class Phone {
	String color;
	int model;
	public void callPhone() {
		System.out.println("打電話");
		
	}
}
//建立Hua類
class Huawei extends Phone{
//	String color;
//	int model;
	String niu;
	public void callPhone() {
		System.out.println("打電話");
		
	}
}

重寫

• 當子類有與父類同名（方法的所有位置都相同）的方法時，我們稱為重寫，
• 注意點：子類的同名方法相當於把父類的覆蓋了，父類的方法不會再被呼叫
• 作用：在不改變父類方法名的前提下，實現父類現有功能的基礎上，實現功能的擴充；
• this：是一種引用資料型別，代表當前的物件，儲存的是當前物件的地址
• super：不是引用資料型別，可以代表父親，通過super可以呼叫父類的方法
• 注意點總結：
  • 1.私有方法不能被重寫
  • 2.同名方法子類的許可權大於等於父類的
  • 3.靜態的方法只能覆蓋靜態的

//建立他們的父親
//如果一個類裡沒有父類，預設值Object
class Phone {
	String color;
	int model;
	public void callPhone() {
		System.out.println("打電話");
		
	}
}
//建立Iphonei類
//  子類 extends 父類
class Iphone extends Phone{
//	String color;
//	int model;
	String gui;

	public void fangShui() {
		System.out.println("防水");
	}
	//重寫父類的方法
	public void callPhone() {
		//System.out.println("打電話");
		//this.callPhone();//這裡會有優先找子類的同名方法，造成死迴圈
		super.callPhone();//直接調到的是父類的方法
		
		//寫自己的功能
		System.out.println("寫自己的功能");
	}
}

繼承使用構造方法

• 1.當一個類只有一個帶引數的構造方法，只能使用帶引數的，不能使用無參的，如果想使用，必須手動建立無參構造方法
• 2.建立構造方法的時候，如果我們不手動呼叫super（），系統會在自動呼叫父類無參構造方法
  • 原因：父類中也有成員變數需要進行初始化，而物件的成員變數只能由自己初始化所以必須呼叫super（），每個
  • 構造方法都會有預設的super（）
• 3.當父類中只有帶引數的構造方法，子類的構造方法中就必須在第一行手動呼叫父類中帶引數的構造方法super（引數）
  • 原因：因為在子類中有可能用到父類的成員變數，而成員變數在使用之前必須先進行初始化，否則不能使用
• 總結：在繼承體系之中，最好就是將父類的無參，有參構造方法都生成

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.play();
	}
class Animal{
	private String name;
	public Animal(String name) {
		super();
		this.name = name;
	}
	public Animal() {
		super();
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}



class Dog extends Animal{
	public Dog() {
		super();//預設的程式碼，代表在呼叫父類空參的構造方法
	}
	public Dog(String name) {
		//super代表的方法必須放在第一行
		super(name);//代表呼叫父類有參構造方法
		this.setName(name);
	}
	public void play() {
		System.out.println("play");
	}
}

單例設計模式

• 設計模式：將前人總結好的經驗我們直接拿來使用，
• 一共有23種，常用的有單例設計模式，模板設計模式，工廠設計模式，裝飾設計模式，介面卡設計模式，代理設計模式，
• 單例設計模式：一個類只有一個物件，建立一個全域性訪問點，將它提供出去大家使用
  • 1.使用者只允許有一個物件
  • 2.單例類
  • 3.全域性的訪問點：得到的唯一的物件就是全域性的訪問點，怎麼做到全域性？-----static
  • 4.提供出去？
  • 5.供大家使用-----單例的功能，通過給單例類新增成員實現
• 單例類的作用：
  • 1.可以實現兩個物件之間的傳值
  • 2.可以在全域性範圍內呼叫很多的功能。
  • 好處：可以讓兩個物件在完全沒有關係的前提下，實現值得傳遞，降低了耦合性，提高了內聚性
• 耦合性，內聚性在微觀上說：描述的是類與類之間的關係
  • 好處：我們應該儘量提高內聚性，減少耦合性，可以提高程式的健壯性，增加程式碼的可移植性，方便實現模組兒化程式設計
• 如何做到低耦合高內聚？
  • 在處理類魚類的關係的時候，讓類之間的關係越緊密耦合性越高，內聚性越低，反之，關係越鬆散耦合性越低，內聚性越高，

餓漢式

• 餓漢式：在定義變數的同時，完成賦值

class SingleInstance{
	//第二步：在單例類的內部建立當前類的物件，私有化,並變成靜態的
	private static SingleInstance singleInstance = new SingleInstance();
	public int num; 
	public static SingleInstance1 getInstance;
	//第一步：將構造方法私有化
	private SingleInstance() {
		
	}
	//第三步：建立一個靜態的公共的方法，將單例類物件提供出去
	public  static SingleInstance getInstance() {
		return singleInstance;
	}
	//功能區-----一般建立的是非靜態的成員實現功能
	//建立成員變數
	//建立成員方法
}

懶漢式

• 懶漢式:開始只是定義變數，什麼時候使用，什麼時候負責製造

class SingleInstance1{
	//第三步：在單例類的內部建立當前類的物件，私有化,並變成靜態的
	private static SingleInstance1 singleInstance = null;
	//第一步：將構造方法私有化
	private SingleInstance1() {
		
	}
	//第三步：建立一個靜態的公共的方法，將單例類物件提供出去
	public  static SingleInstance1 getInstance() {
		if(singleInstance == null) {//為了保證物件的唯一性
			singleInstance = new SingleInstance1();
			}
		return singleInstance;
	}

修飾詞final

• final:最終的，不可改變的
• 可以修飾的內容有
  • 類:final修飾的類不能有子類
  • 成員方法：final修飾的方法不能重寫
  • 成員變數：被final修飾的變數必須先給一個值這個值不能被改變
  • 區域性變數：被final修飾的變數是一個定值，不能被改變

class Pig{
	final String name = "bingbing";//被final修飾的變數必須先給一個值這個值不能被改變
	public void play(int a) {
		
	}
}
class XiaoPig extends Pig {
	public void play(int a) {
		
	}
}