08.01_面向物件(程式碼塊的概述和分類)(瞭解)(面試的時候會問,開發很少用)

• A:程式碼塊概述
  • 在Java中，使用{}括起來的程式碼被稱為程式碼塊。
• B:程式碼塊分類
  • 根據其位置和宣告的不同，可以分為區域性程式碼塊，構造程式碼塊，靜態程式碼塊，同步程式碼塊(多執行緒講解)。
• C:常見程式碼塊的應用
  • a:區域性程式碼塊
    • 在方法中出現；限定變數生命週期，及早釋放，提高記憶體利用率
  • b:構造程式碼塊 (初始化塊)
    • 在類中方法外出現；多個構造方法方法中相同的程式碼存放到一起，每次呼叫構造都執行，並且在構造方法前執行
  • c:靜態程式碼塊
    • 在類中方法外出現，並加上static修飾；用於給類進行初始化，在載入的時候就執行，並且只執行一次。
    • 一般用於載入驅動

class Demo1_Code {
	public static void main(String[] args) {
		{//區域性程式碼塊
			int x = 10;						//限定變數的宣告週期
			System.out.println(x);
		}
		
		Student s1 = new Student();
		System.out.println("---------------");
		Student s2 = new Student("張三",23);
	
	}

	static {//靜態程式碼塊，即使在主方法下面，但是優先於主方法執行
		System.out.println("我是在主方法類中的靜態程式碼塊");
	}
}

class Student {
	private String name;
	private int age;

	public Student(){
		//study();
		System.out.println("空參構造");
	}					//空參構造

	public Student(String name,int age) {//有參構造
		//study();
		this.name = name;
		this.age = age;
		System.out.println("有參構造");
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	{  //構造程式碼塊:每建立一次物件就會執行一次,優先於建構函式執行
		//System.out.println("構造程式碼塊");
		study();
	}

	public void study() {
		System.out.println("學生學習");
	}

	static {									//隨著類載入而載入,且只執行一次，即使建立兩個物件，也只執行一次
		System.out.println("我是靜態程式碼塊");	//作用:用來給類進行初始化,一般用來載入驅動
	}											//靜態程式碼塊是優先於主方法執行
}
 

08.02_面向物件(程式碼塊的面試題)(掌握)

• A:看程式寫結果

•   class Student {
    	static {
    		System.out.println("Student 靜態程式碼塊");//3
    	}
    	
    	{
    		System.out.println("Student 構造程式碼塊");//4//6
    	}
    	
    	public Student() {
    		System.out.println("Student 構造方法");//5//7
    	}
    }
  
    class Demo2_Student {
    	static {
    		System.out.println("Demo2_Student靜態程式碼塊");//1
    	}
    	
    	public static void main(String[] args) {
    		System.out.println("我是main方法");//2
    		
    		Student s1 = new Student();
    		Student s2 = new Student();
    	}
    }
   
  

輸出結果：1234567

08.03_面向物件(繼承案例演示)(掌握)

• A:繼承(extends)
  • 讓類與類之間產生關係,子父類關係
• B:繼承案例演示：
  • 動物類,貓類,狗類
  • 定義兩個屬性(顏色,腿的個數)兩個功能(吃飯，睡覺)
• C:案例演示
  • 使用繼承前
• D:案例演示
  • 使用繼承後

class Demo1_Extends {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.color = "花";
		c.leg = 4;
		c.eat();
		c.sleep();

		System.out.println(c.leg  + "..." + c.color);
	}
}

class Animal {
	String color;					//動物的顏色
	int leg;						//動物腿的個數

	public void eat() {				//吃飯的功能
		System.out.println("吃飯");
	}

	public void sleep() {			//睡覺的功能
		System.out.println("睡覺");
	}
}

class Cat extends Animal {
	
}

class Dog extends Animal {
	
}

/*
extends是繼承的意思
Animal是父類
Cat和Dog都是子類
*/

08.04_面向物件(繼承的好處和弊端)(掌握)

• A:繼承的好處
  • a:提高了程式碼的複用性
  • b:提高了程式碼的維護性
  • c:讓類與類之間產生了關係，是多型的前提
• B:繼承的弊端

  • 類的耦合性增強了。

  • 開發的原則：高內聚，低耦合。

  • 耦合：類與類的關係

  • 內聚：就是自己完成某件事情的能力

08.05_面向物件(Java中類的繼承特點)(掌握)

• A:Java中類的繼承特點
  • a:Java只支援單繼承，不支援多繼承。(一個兒子只能有一個爹)
    • 有些語言是支援多繼承，格式：extends 類1,類2,…
  • b:Java支援多層繼承(繼承體系)
• B:案例演示
  • Java中類的繼承特點
    • 如果想用這個體系的所有功能用最底層的類建立物件
    • 如果想看這個體系的共性功能,看最頂層的類

08.06_面向物件(繼承的注意事項和什麼時候使用繼承)(掌握)

• A:繼承的注意事項

  • a:子類只能繼承父類所有非私有的成員(成員方法和成員變數)
  • b:子類不能繼承父類的構造方法，但是可以通過super(馬上講)關鍵字去訪問父類構造方法。
  • c:不要為了部分功能而去繼承
  • 專案經理 姓名 工號 工資 獎金
  • 程式設計師 姓名 工號 工資（專案經理，程式設計師不能繼承）

• B:什麼時候使用繼承

  • 繼承其實體現的是一種關係：“is a”。
    Person
    Student
    Teacher
    水果
    蘋果
    香蕉
    橘子

  採用假設法。
  如果有兩個類A,B。只有他們符合A是B的一種，或者B是A的一種，就可以考慮使用繼承。

08.07_面向物件(繼承中成員變數的關係)(掌握)

• A:案例演示（父類、子類中）
  • a:不同名的變數
  • b:同名的變數（就近原則，子父類出現同名的變數只是在講課中舉例子有,在開發中是不會出現這種情況的
    子類繼承父類就是為了使用父類的成員,那麼如果定義了同名的成員變數沒有意義了）

08.08_面向物件(this和super的區別和應用)(掌握)

• A:this和super都代表什麼
  • this:代表當前物件的引用,誰來呼叫我,我就代表誰
  • super:代表當前物件父類的引用
• B:this和super的使用區別
  • a:呼叫成員變數
    • this.成員變數 呼叫本類的成員變數,也可以呼叫父類的成員變數
    • super.成員變數 呼叫父類的成員變數

class Demo4_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
	}
}

class Father {
	int num1 = 10;
	int num2 = 30;
}

class Son extends Father {
	int num2 = 20;
	public void print() {
		System.out.println(this.num1);	//10			//this既可以呼叫本類的,也可以呼叫父類的(本類沒有的情況下)
		System.out.println(this.num2);	//20			//就近原則,子類有就不用父類的了
		System.out.println(super.num2); //30
	}
}

• b:呼叫構造方法
  * this(…) 呼叫本類的構造方法
  * super(…) 呼叫父類的構造方法
• c:呼叫成員方法
  * this.成員方法 呼叫本類的成員方法,也可以呼叫父類的方法
  * super.成員方法 呼叫父類的成員方法

08.09_面向物件(繼承中構造方法的關係)(掌握)

• A:案例演示
  • 子類中所有的構造方法預設都會訪問父類中空引數的構造方法
• B:為什麼呢?

  • 因為子類會繼承父類中的資料，可能還會使用父類的資料。

  • 所以，子類初始化之前，一定要先完成父類資料的初始化。

  • 其實：

    • 每一個構造方法的第一條語句預設都是：super() Object類最頂層的父類，如果不寫繼承，就預設繼承Object類。

class Demo5_Extends {
	public static void main(String[] args) {
		Son s = new Son();
	}
}

class Father extends Object {
	public Father() {
		super();
		System.out.println("Father 的構造方法");
	}
}

class Son extends Father {
	public Son() {
		super();		//這是一條語句,如果不寫,系統會預設加上,用來訪問父類中的空參構造
		System.out.println("Son 的構造方法");
	}
}

08.10_面向物件(繼承中構造方法的注意事項)(掌握)

• A:案例演示
  • 父類沒有無參構造方法,子類怎麼辦?
  • super解決
  • this解決
• B:注意事項
  • super(…)或者this(….)必須出現在構造方法的第一條語句上

class Demo6_Extends {
	public static void main(String[] args) {
		Son s1 = new Son();
		System.out.println(s1.getName() + "..." + s1.getAge());
		System.out.println("--------------------");
		Son s2 = new Son("張三",23);
		System.out.println(s2.getName() + "..." + s2.getAge());
	}
}

class Father {
	private String name;			//姓名
	private int age;				//年齡

	public Father(String name,int age) {	//有參構造
		this.name = name;
		this.age = age;
		System.out.println("Father 有參構造");
	}

	public void setName(String name) {	//設定姓名
		this.name = name;
	}

	public String getName() {			//獲取姓名
		return name;
	}

	public void setAge(int age) {		//設定年齡
		this.age = age;
	}

	public int getAge() {				//獲取年齡
		return age;
	}
}

class Son extends Father {
	public Son() {						//空參構造
		this("王五",25);				//本類中的構造方法
		//super("李四",24);				//呼叫父類中的構造方法
		
		System.out.println("Son 空參構造");
	}

	public Son(String name,int age) {	//有參構造
		super(name,age);     //父類有參構造
		System.out.println("Son 有參構造");
	}
}

08.11_面向物件(繼承中的面試題)(掌握)

• A:案例演示

•   看程式寫結果1
    class Fu{
    	public int num = 10;
    	public Fu(){
    		System.out.println("fu");
    	}
    }
    class Zi extends Fu{
    	public int num = 20;
    	public Zi(){
    		System.out.println("zi");
    	}
    	public void show(){
    		int num = 30;
    		System.out.println(num);
    		System.out.println(this.num);
    		System.out.println(super.num);
    	}
    }
    class Test1_Extends {
    	public static void main(String[] args) {
    		Zi z = new Zi();
    		z.show();
    	}
    }
  

fu zi 30 20 10
看程式寫結果2
class Fu {
static {
System.out.println(“靜態程式碼塊Fu”);
}

		{
			System.out.println("構造程式碼塊Fu");
		}

		public Fu() {
			System.out.println("構造方法Fu");
		}
	}

	class Zi extends Fu {
		static {
			System.out.println("靜態程式碼塊Zi");
		}

		{
			System.out.println("構造程式碼塊Zi");
		}

		public Zi() {
			System.out.println("構造方法Zi");
		}
	}

	Zi z = new Zi(); 請執行結果。

1、vm呼叫了main方法，main方法進棧
2、遇到Zi z=new Zi();會將Fu.class和Zi.class分別載入進記憶體，再建立物件，當Fu.class載入進記憶體，父類的靜態程式碼塊會隨著Fu.class一起載入，當Zi.class載入進記憶體，子類的靜態程式碼塊會隨著Zi.class一起載入。第一個輸出靜態程式碼塊Fu，第二個輸出靜態程式碼塊Zi
3、走子類的構造方法，因為Java是分層初始化的，先初始化父類再初始化子類，所以先走的是父類構造，但是在執行父類構造時發現父類有構造程式碼塊，構造程式碼塊是優先於構造方法執行的，所以第三個輸出是構造程式碼塊Fu,第四個輸出構造方法Fu
4、Fu類初始化結束，子類初始化，第五個輸出的是構造程式碼塊Zi,構造方法Zi

08.12_面向物件(繼承中成員方法關係)(掌握)

• A:案例演示
  • a:不同名的方法
  • b:同名的方法

class Demo7_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
		s.method();
	}
}

class Father {
	public void print() {
		System.out.println("Fu print");
	}
}

class Son extends Father {
	public void method() {
		System.out.println("Zi Method");
	}

	public void print() {      //父類方法重寫
		super.print();		   //super可以呼叫父類的成員方法
		System.out.println("Zi print");
	}
}

08.13_面向物件(方法重寫概述及其應用)(掌握)

• A:什麼是方法重寫
  • 重寫:子父類出現了一模一樣的方法(注意:返回值型別可以是子父類,這個我們學完面向物件講)
• B:方法重寫的應用：
  • 當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法。這樣，即沿襲了父類的功能，又定義了子類特有的內容。
• C:案例演示
  • a:定義一個手機類。

class Demo7_Phone {
	public static void main(String[] args) {
		Ios8 i = new Ios8();
		i.siri();
		i.call();
	}
}

/*
B:方法重寫的應用：
	* 當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法。這樣，即沿襲了父類的功能，又定義了子類特有的內容。
	ios7系統 siri speak English
	ios8系統 siri 說中文
*/

class Ios7 {
	public void call() {
		System.out.println("打電話");
	}

	public void siri() {
		System.out.println("speak English");
	}
}

class Ios8 extends Ios7 {
	public void siri() {		//方法重寫
		System.out.println("說中文");
		super.siri();//呼叫原本父類方法
	}
}

08.14_面向物件(方法重寫的注意事項)(掌握)

• A:方法重寫注意事項

  • a:父類中私有方法不能被重寫(private)

    • 因為父類私有方法子類根本就無法繼承

  • b:子類重寫父類方法時，訪問許可權不能更低

    • 最好就一致

  • c:父類靜態方法，子類也必須通過靜態方法進行重寫(static)

    • 其實這個算不上方法重寫，但是現象確實如此，至於為什麼算不上方法重寫，多型中我會講解(靜態只能覆蓋靜態)

  • 子類重寫父類方法的時候，最好宣告一模一樣。

• B:案例演示
  • 方法重寫注意事項

08.15_面向物件(方法重寫的面試題)(掌握)

• A:方法重寫的面試題

  • Override(重寫)和Overload(過載)的區別?Overload能改變返回值型別嗎?

  • overload可以改變返回值型別,只看引數列表

  • 方法重寫：子類中出現了和父類中方法宣告一模一樣的方法。與返回值型別有關,返回值是一致(或者是子父類)的

  • 方法過載：本類中出現的方法名一樣，引數列表不同的方法。與返回值型別無關。

  • 子類物件呼叫方法的時候：

    • 先找子類本身，再找父類。

08.16_面向物件(使用繼承前的學生和老師案例)(掌握)

• A:案例演示
  • 使用繼承前的學生和老師案例
  • 屬性:姓名,年齡
  • 行為:吃飯
  • 老師有特有的方法:講課
  • 學生有特有的方法:學習

08.17_面向物件(使用繼承後的學生和老師案例)(掌握)

• A:案例演示
  • 使用繼承後的學生和老師案例

public class Demo2_Dollection {
	public static void main(String[] args) {
         Student s1=new Student();
         s1.setName("張三");
         s1.setAge(23);
         System.out.println(s1.getName()+"..."+s1.getAge());
         s1.eat();
         s1.study();       
         System.out.println("--------------");
         Student s2=new Student("李四",24);
         System.out.println(s2.getName()+"..."+s2.getAge());
         s2.eat();
         s2.study();  
	}

}

class Person {
	private String name;
	private int age;

	public Person() {
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void eat() {
		System.out.println("吃飯");
	}
}

class Student extends Person {

	public Student() {
	}

	public Student(String name, int age) {
		super(name, age);
	}

	public void study() {
		System.out.println("學生學習");
	}
}

class Teacher extends Person {

	public Teacher() {}

	public Teacher(String name, int age) {
		super(name, age);
	}

	public void teach() {
		System.out.println("老師講課");
	}
}

08.18_面向物件(貓狗案例分析,實現及測試)(掌握)

• A:貓狗案例分析
• B:案例演示
  • 貓狗案例繼承版
  • 屬性:毛的顏色,腿的個數
  • 行為:吃飯
  • 貓特有行為:抓老鼠catchMouse
  • 狗特有行為:看家lookHome

class Test5_Animal {
	public static void main(String[] args) {
		Cat c1 = new Cat("花",4);
		System.out.println(c1.getColor() + "..." + c1.getLeg());
		c1.eat();
		c1.catchMouse();

		Dog d1 = new Dog("黑",2);
		System.out.println(d1.getColor() + "..." + d1.getLeg());
		d1.eat();
		d1.lookHome();
	}
}

class Animal {
	private String color;					//毛的顏色
	private int leg;						//腿的個數

	public Animal(){}

	public Animal(String color,int leg) {
		this.color = color;
		this.leg = leg;
	}

	public void setColor(String color) {	//設定顏色
		this.color = color;
	}

	public String getColor() {				//獲取顏色
		return color;
	}

	public void setLeg(int leg) {			//設定腿的個數
		this.leg = leg;
	}

	public int getLeg() {					//獲取腿的個數
		return leg;
	}

	public void eat() {						//吃飯
		System.out.println("吃飯");
	}
}

class Cat extends Animal {
	public Cat() {}							//空參構造

	public Cat(String color,int leg) {		//有參構造
		super(color,leg);
	}

	public void eat() {						//吃魚
		System.out.println("貓吃魚");
	}

	public void catchMouse() {				//抓老鼠
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public Dog() {}							//空參構造

	public Dog(String color,int leg) {		//有參構造
		super(color,leg);
	}

	public void eat() {						//吃肉
		System.out.println("狗吃肉");
	}

	public void lookHome() {				//看家
		System.out.println("看家");
	}
}

08.19_面向物件(final關鍵字修飾類,方法以及變數的特點)(掌握)

• A:final概述
• B:final修飾特點
  • 修飾類，類不能被繼承
  • 修飾變數，變數就變成了常量，只能被賦值一次
  • 修飾方法，方法不能被重寫
• C:案例演示
  • final修飾特點

  final修飾變數叫做常量，一般會與public static 公用，public static final double PI=3.14;

常量命名規範，如果是一個單詞，所有字母大寫，如果有多個單詞，將每個單詞的首字母大寫，中間加上下劃線

08.20_面向物件(final關鍵字修飾區域性變數)(掌握)

• A:案例演示

  • 方法內部或者方法宣告上都演示一下(瞭解)

  • 基本型別，是值不能被改變

  • 引用型別，是地址值不能被改變,物件中的屬性可以改變

class Demo2_Final {
	public static void main(String[] args) {
		final int num = 10;
		//num = 20;     //基本資料型別，值不能被改變
		System.out.println(num);

		final Person p = new Person("張三",23);
		//p = new Person("李四",24);   //引用資料型別，地址值不能被改變
		p.setName("李四");
		p.setAge(24);

		System.out.println(p.getName() + "..." + p.getAge());  //李四   24

		method(10);
		method(20);//method(10)執行完後就彈棧了
	}

	public static void method(final int x) {
		System.out.println(x);
	}
}

class Person {
	private String name;			//姓名
	private int age;				//年齡

	public Person(){}				//空參構造

	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//設定姓名
		this.name = name;
	}

	public String getName() {		//獲取姓名
		return name;
	}

	public void setAge(int age) {	//設定年齡
		this.age = age;
	}

	public int getAge() {			//獲取年齡
		return age;
	}
}

08.21_面向物件(final修飾變數的初始化時機)(掌握)

• A:final修飾變數的初始化時機
  • 顯示初始化
  • 在物件構造完畢前即可

class Demo3_Final {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.print();
	}
}


class Demo {
	final int num;						//成員變數的預設初始化值是無效值
	
	public Demo() {
		num = 10;
	}
	public void print() {
		System.out.println(num);
	}
}