一 程式碼塊

1.區域性程式碼塊(方法)

書寫位置:方法中

作用:限制作用域

書寫位置:類中 方法外

程式碼的執行順序:

①系統呼叫

②只要建立物件 就會呼叫

③構造程式碼塊 在 構造方法 之前被呼叫

作用:當你有方法 需要每一個物件都呼叫的時候,可以將這個方法在構造程式碼塊中呼叫(不常用)

使用關鍵詞static修飾的程式碼塊

位置:類中方法外

呼叫順序:

1.隨著類的載入

2.只加載一次

3.在構造程式碼塊之前執行

應用場景:

載入驅動(載入資料庫驅動---一個類)

public class Demo01 {
	public static void main(String[] args) {
		//fun1();
		
		Person p1 = new Person();
		p1.name = "發了";
		p1.sayHi();
		
		Person p2 = new Person("啊哦",10);
		p2.sayHi();
		
	}

	public static void fun1() {
//		{
//			// 區域性程式碼塊 限制變數的作用域
//			int num = 10;
//		}
//		System.out.println(num);
	}
}

//暴力除錯法
//小黃鴨除錯法(邏輯除錯)
class Person{
	String name;
	int age;
	// 無參 和 有參構造方法
	// 介紹自己方法
	// 吃
	public Person() {
		 name = "奧迪";
		 age = 16; 
		 System.out.println("我是無參的構造方法");
	}
	public Person(String name , int age) {
		this.name = name;
		this.age = age;
		System.out.println("我是有參的構造方法");
	}
	public void sayHi() {
		System.out.println(name + " " + age);
	}
	public void eat() {
		System.out.println("人--吃飯");
	}
	//構造程式碼塊
	{
		System.out.println("我執行了嗎?");
	}
	//靜態程式碼塊
	static {
		System.out.println("我是靜態程式碼塊");
	}
}
 

public class Demo02 {
	static {
		System.out.println("我是main方法的靜態程式碼塊");
	}
	public static void main(String[] args) {
		System.out.println("我是main方法");
		
		Test test1 = new Test();
		test1.name = "xx";
		
		Test test2 = new Test("dd");
		
	}

}
class Test {
	String name;
	public Test() {
		System.out.println("我是 test類 無參構造方法");
	}
	
	public Test(String name) {
		this.name = name;
		System.out.println("我是 test類 有參構造方法");
	}
	
	{
		System.out.println("我是 test類  構造程式碼塊");
	}
	static {
		System.out.println("我是test類  靜態程式碼塊");
	}
}
 

列印順序為

先執行main函式,而在此之前需要在方法區將Demo02.class執行,根據之前所說的,在隨著類的載入,其靜態構造程式碼塊將會率先執行,列印①"我是main方法的靜態程式碼塊",之後呼叫main函式先列印②"我是main方法",隨後建立一個物件test,而建立物件之前,又需要先在方法區載入Test類,而類中又有static修飾的靜態程式碼塊,所以列印③"我是test類 靜態程式碼塊",隨之列印④"我是test類 構造程式碼塊",類中程式碼塊執行完畢後,隨即建立完無參物件.列印⑤"我是test類 無參構造方法".之後又建立test2物件,同上,列印⑥"我是test類 構造程式碼塊",⑦"我是test類 有參構造方法".

二 面向物件特徵之繼承

面向物件的特徵為:封裝,繼承,多型

繼承:

1.可以進行傳遞

2.繼承的是 屬性 和 行為(不是全部)

3.繼承 建立 類和類之間的關係

繼承的好處:

1.減少程式碼量

2.提高工作效率

3.增強了類與類之間的關係(讓類和類的關係更加緊密)

繼承的弊端:

提高內聚:希望一個類中,方法與方法之間聯絡加強

降低耦合:希望類與類之間減少聯絡

而繼承違反了 低耦合.

什麼時候使用繼承?

繼承:一定要符合 邏輯(比如:蘋果 -子類 是 水果 -父類)

如若兩個類沒有合適的繼承關係的話,可以考慮建立並繼承一個第三類.

比如 專案經理 和 程式設計師,沒有合適的父子類的邏輯關係,這是可以增加並繼承一個員工類.

注意:

1.Java中 只允許 單繼承(類與類)(通過介面實現多繼承)

Java中 還允許 多層繼承(繼承鏈) A->B->C

2.當你想只使用共有方法和屬性時,一般選擇 使用繼承鏈最頂端的類

3.當你想使用特有方法的時候, 一般選擇 使用繼承鏈最末端的類

4.如果一個類沒有寫繼承 ,那麼這個類 預設繼承 Object類(基類)

三 繼承中的構造方法

注意:構造方法是不能繼承的

當建立子類物件的時候,為了保證繼承的完整性(不管你在建立子類物件的時候,使用的是無參還是有參構造)

系統會預設幫你呼叫 父類中的 無參 構造方法

public class Demo05 {
	public static void main(String[] args) {
		Son son = new Son();
		System.out.println("-----------------動感光波------------------");
		Son son1 = new Son("小新");
		
	}
}
class Father{
	String name;
	public Father() {
		System.out.println("我是Father類的無參構造方法");
	}
	public Father(String name) {
		this.name = name;
		System.out.println("我是Father類的有參構造方法");
	}
	public void sayHi() {
		System.out.println(name);
	}
}
class Son extends Father{
	public Son() {
		//系統幫你在 構造方法的第一行,寫了一句程式碼
		//如果你不寫,系統會預設幫你加上
		super();//呼叫父類的構造方法
		System.out.println("我是Son類的無參構造方法");
	}
	public Son(String name) {
		super();
		this.name = name;
		System.out.println("我是Son類的有參構造方法");
	}
}

列印的結果是:

再來看這段程式碼

public class Demo06 {
	public static void main(String[] args) {
		TestB testB = new TestB();
		testB.print();
	}
}
class TestA{
	int num1 = 10;
	int num2 = 20;
	public void fun() {
		System.out.println("我是父類的方法");
	}
}
class TestB extends TestA{
	int num2 = 30;
	public void print() {
		System.out.println(this.num1);
		System.out.println(this.num2);
		//直接呼叫父類的屬性 使用super關鍵詞
		System.out.println(super.num2);
		//super也可以呼叫父類的方法
		super.fun();
	}
}

super和this

super在子類中代表的是 父類的物件

this在子類中,可以呼叫子類的屬性 和 方法

(當子類中沒有這個屬性 或者方法的時候,就去父類中尋找,找到就用,沒找到就報錯)

其列印的是:

如果父類沒有無參的構造方法,此時只需要在子類的構造方法中第一行,呼叫一下父類構造方法

public class Demo07 {
	public static void main(String[] args) {
		Audi audi = new Audi();
	}
}
class Car{
	String name;
//	public Car() {
//		System.out.println("我是Car的無參");
//	}
	public Car(String name) {
		this.name = name;
		System.out.println("我是Car的有參");
	}
}
class Audi extends Car{
	public Audi() {
		//只要你在構造方法的第一行
		//呼叫一下父類構造方法(無參 有參都行)
		super("雙鑽");
		System.out.println("我是Audi的無參");
	}
	public Audi(String name) {
		super("四鑽");
		this.name = name;
		System.out.println("我是Audi的有參");
	}
}

四 方法過載和重寫

方法過載(Overload)(在一個類中進行)

方法重寫(Override)(前提:至少兩個類 並且還有繼承關係)

方法重寫相當於對父級的該方法進行升級

重寫:跟父類的寫法完全一致

書寫一個類,都寫什麼方法?

有參無參構造方法

set/get方法

重寫toString方法輸出屬性

public class Demo08 {
	public static void main(String[] args) {
		TestD testD = new TestD();
		testD.print();
	}
}
class TestC{
	public void print() {
		System.out.println("我是C類的 print方法");
	}
}
class TestD extends TestC{
	public void print() {
		//重寫父類的方法時
		//調不呼叫父類的方法 要根據你的需求而定
		//ios7 siri 只會說英文
		//ios8 siri 英文,中文都能說了
		super.print();
		System.out.println("我是D類的 print方法");
		
		IOS8 ios8 = new IOS8();
		//咱們直接列印物件
		//希望直接把這個類的 屬性輸出出來
		System.out.println(ios8);
		ios8.siri();
	}
}
class IOS7{
	public void siri() {
		System.out.println("說英文");
	}
}
class IOS8 extends IOS7{
	//註解 標識這個方法是重寫父類
	@Override
	public void siri() {
		super.siri();
		System.out.println("說中文");
	}
	public void fun() {
		
	}
	//這個方法 一般用來輸出 本類中的屬性
	@Override
	public String toString() {
		//呼叫的是父類的方法
		//打印出來 全類名@16進位制的hashcode碼
		return "我就想看看屬性";
	}
}

五 關鍵字final

1.可以修飾方法 方法不能被重寫

2.修飾類 類不能被繼承

3.修飾變數 變數不能修改

final修飾引用資料型別,不能進行重新指向(地址不能修改)

物件中的屬性不會影響修改

public class Demo09 {
	public static void main(String[] args) {
//	final int num = 10;
//		num = 20;
	}
}
class TestE{
	//堆記憶體分配預設值 是無效的預設
//	final修飾成員變數的時候,需要賦值
//	賦值初始值,有三種方式
	//一般使用final會直接定義成靜態常量
	//使用類名直接呼叫 方便
	//常量命名規範 所有字母大寫 多單詞用下劃線分開
//	final int num = 10;
	public static final int MAX_VALUE = 10;
	
	public final void fun() {
		
	}
	
	public TestE() {
		//可以在構造方法中對變數進行賦值
//		num = 10;
	}
	{
		//也可以在構造程式碼塊中進行賦值
//		num = 10;
	}
}
class TestF extends TestE{
//	private void fun() {
//		
//	}
	
}