day08-----------面向對象（傳智視頻）

/*
	我想要對數組進行操做
	
	如何製做一個說明書呢?
		A:寫一個工具類
		B:對這個類加入文檔註釋
			怎麼加呢?
			加些什麼東西呢?
		C:用工具解析文檔註釋
			javadoc工具
		D:格式
			javadoc -d 目錄 -author -version ArrayTool.java
			
			目錄：就能夠寫一個文件夾的路徑
			
	製做幫助文檔出錯：
		找不到能夠文檔化的公共或受保護的類：告訴咱們類的權限不夠
*/

1:打開幫助文檔
2:點擊顯示，找到索引，看到輸入框
3:知道你要找誰?以Scanner舉例
4:在輸入框裏面輸入Scanner，而後回車
5:看包
	java.lang包下的類不須要導入，其餘的所有須要導入。
	
	要導入：
	java.util.Scanner
6:再簡單的看看類的解釋和說明，別忘了看看該類的版本
7:看類的結構
	成員變量	字段摘要 	
	構造方法	構造方法摘要 
	成員方法 	方法摘要
8:學習構造方法	
	A:有構造方法	就建立對象
	B:沒有構造方法	成員可能都是靜態的
9:當作員方法
	A:左邊
		是否靜態：若是靜態，能夠經過類名調用
		返回值類型：人家返回什麼，你就用什麼接收。
	B:右邊
		看方法名：方法名稱不要寫錯
		參數列表：人家要什麼，你就給什麼；人家要幾個，你就給幾個

/*
	代碼塊：在Java中，使用{}括起來的代碼被稱爲代碼塊。
	根據其位置和聲明的不一樣，能夠分爲
		局部代碼塊:局部位置,用於限定變量的生命週期。
		構造代碼塊:在類中的成員位置,用{}括起來的代碼。每次調用構造方法執行前，都會先執行構造代碼塊。
			做用：能夠把多個構造方法中的共同代碼放到一塊兒，對對象進行初始化。
		靜態代碼塊:在類中的成員位置,用{}括起來的代碼,只不過它用static修飾了。
			做用：通常是對類進行初始化。
			
	面試題?
		靜態代碼塊,構造代碼塊,構造方法的執行順序?
		靜態代碼塊 -- 構造代碼塊 -- 構造方法
		靜態代碼塊：只執行一次
		構造代碼塊：每次調用構造方法都執行
*/
class Code {
	static {
		int a = 1000;
		System.out.println(a);
	}

	//構造代碼塊
	{
		int x = 100;
		System.out.println(x);
	}
	
	//構造方法
	public Code(){
		System.out.println("code");
	}
	
	//構造方法
	public Code(int a){
		System.out.println("code");
	}
	
	//構造代碼塊
	{
		int y = 200;
		System.out.println(y);
	}
	
	//靜態代碼塊
	static {
		int b = 2000;
		System.out.println(b);
	}
}

class CodeDemo {
	public static void main(String[] args) {
		//局部代碼塊
		{
			int x = 10;
			System.out.println(x);
		}
		//找不到符號
		//System.out.println(x);
		{
			int y = 20;
			System.out.println(y);
		}
		System.out.println("---------------");
		
		Code c = new Code();	
		System.out.println("---------------");
		Code c2 = new Code();
		System.out.println("---------------");
		Code c3 = new Code(1);
	}
}

/*
	寫程序的執行結果。
	
	林青霞都60了，我很傷心
	我是main方法
	Student 靜態代碼塊
	Student 構造代碼塊
	Student 構造方法
	Student 構造代碼塊
	Student 構造方法
*/
class Student {
	static {
		System.out.println("Student 靜態代碼塊");
	}
	
	{
		System.out.println("Student 構造代碼塊");
	}
	
	public Student() {
		System.out.println("Student 構造方法");
	}
}

class StudentDemo {
	static {
		System.out.println("林青霞都60了，我很傷心");
	}
	
	public static void main(String[] args) {
		System.out.println("我是main方法");
		
		Student s1 = new Student();
		Student s2 = new Student();
	}
}

類與類產生了關係，其實也是繼承的一個弊端：
		類的耦合性加強了。
		
		開發的原則：低耦合，高內聚。
		耦合：類與類的關係
		內聚：就是本身完成某件事情的能力

/*
	Java中繼承的特色：
		A:Java只支持單繼承，不支持多繼承。
			有些語言是支持多繼承，格式：extends 類1,類2,...
		B:Java支持多層繼承(繼承體系)
*/

/*
class Father {}
class Mother {}
class Son exnteds Father {} //正確的
class Son extends Father,Mother {} // 錯誤的
*/

class GrandFather {
	public void show() {
		System.out.println("我是爺爺");
	}
}

class Father extends GrandFather {
	public void method(){
		System.out.println("我是老子");
	}
}

class Son extends Father {}

class ExtendsDemo2 {
	public static void main(String[] args) {
		Son s = new Son();
		s.method(); //使用父親的
		s.show(); //使用爺爺的
	}
}

/*
	繼承的注意事項：
		A:子類只能繼承父類全部非私有的成員(成員方法和成員變量)
		B:子類不能繼承父類的構造方法，可是能夠經過super(立刻講)關鍵字去訪問父類構造方法。
		C:不要爲了部分功能而去繼承
			class A {
				public void show1(){}
				public void show2(){}
			}
			
			class B {
				public void show2(){}
				public void show3(){}
			}
			
			//咱們發現B類中出現了和A類同樣的show2()方法，因此，咱們就用繼承來體現
			class B extends A {
				public void show3(){}
			}
			這樣其實很差，由於這樣你不但有了show2(),還多了show1()。
			有可能show1()不是你想要的。
			
	那麼，咱們何時考慮使用繼承呢?
		繼承其實體現的是一種關係："子類is a父類的一種"。
			Person
				Student
				Teacher
			水果
				蘋果
				香蕉
				橘子
				
		採用假設法。
			若是有兩個類A,B。只有他們符合A是B的一種，或者B是A的一種，就能夠考慮使用繼承。
*/

/*
	問題是：
		我不只僅要輸出局部範圍的num，還要輸出本類成員範圍的num。怎麼辦呢?
		我還想要輸出父類成員範圍的num。怎麼辦呢?
			若是有一個東西和this類似，可是能夠直接訪問父類的數據就行了。
			恭喜你，這個關鍵字是存在的：super。
			
	this和super的區別?
		分別是什麼呢?
			this表明本類對應的引用。
			super表明父類存儲空間的標識(能夠理解爲父類引用,能夠操做父類的成員)

		怎麼用呢?
			A:調用成員變量
				this.成員變量 調用本類的成員變量
				super.成員變量 調用父類的成員變量
			B:調用構造方法
				this(...)	調用本類的構造方法
				super(...)	調用父類的構造方法
			C:調用成員方法
				this.成員方法 調用本類的成員方法
				super.成員方法 調用父類的成員方法
*/

/*
	繼承中構造方法的關係
		A:子類中全部的構造方法默認都會訪問父類中空參數的構造方法
		B:爲何呢?
			由於子類會繼承父類中的數據，可能還會使用父類的數據。
			因此，子類初始化以前，必定要先完成父類數據的初始化。
			
			注意：子類每個構造方法的第一條語句默認都是：super();
*/
class Father {
	int age;

	public Father() {
		System.out.println("Father的無參構造方法");
	}
	
	public Father(String name) {
		System.out.println("Father的帶參構造方法");
	}
}

class Son extends Father {
	public Son() {
		//super();
		System.out.println("Son的無參構造方法");
	}
	
	public Son(String name) {
		//super();
		System.out.println("Son的帶參構造方法");
	}
}	

class ExtendsDemo6 {
	public static void main(String[] args) {
		//建立對象
		Son s = new Son();
		System.out.println("------------");
		Son s2 = new Son("林青霞");
	}
}

/*
	看程序寫結果：
		A:一個類的靜態代碼塊,構造代碼塊,構造方法的執行流程
			靜態代碼塊 > 構造代碼塊 > 構造方法
		B:靜態的內容是隨着類的加載而加載
			靜態代碼塊的內容會優先執行
		C:子類初始化以前先會進行父類的初始化
		
	結果是：
		靜態代碼塊Fu
		靜態代碼塊Zi
		構造代碼塊Fu
		構造方法Fu
		構造代碼塊Zi
		構造方法Zi
*/
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");
	}
}

class ExtendsTest2 {
	public static void main(String[] args) {
		Zi z = new Zi();
	}
}

/*
	看程序寫結果：
		A:成員變量的問題
			int x = 10; //成員變量是基本類型
			Student s = new Student(); //成員變量是引用類型
		B:一個類的初始化過程
			成員變量的初始化
				默認初始化
				顯示初始化
				構造方法初始化
		C:子父類的初始化(分層初始化)
			先進行父類初始化，而後進行子類初始化。
			
	結果：
		YXYZ
		
	問題：
		雖然子類中構造方法默認有一個super()
		初始化的時候，不是按照那個順序進行的。
		而是按照分層初始化進行的。
		它僅僅表示要先初始化父類數據，再初始化子類數據。
*/
class X {
	Y b = new Y();
	X() {
		System.out.print("X");
	}
}

class Y {
	Y() {
		System.out.print("Y");
	}
}

public class Z extends X {
	Y y = new Y();
	Z() {
		//super
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z(); 
	}
}

1：方法重寫和方法重載的區別?方法重載能改變返回值類型嗎?

方法重寫：
	在子類中，出現和父類中如出一轍的方法聲明的現象。
	
方法重載：
	同一個類中，出現的方法名相同，參數列表不一樣的現象。


方法重載能改變返回值類型，由於它和返回值類型無關。


Override：方法重寫
Overload：方法重載

2：this關鍵字和super關鍵字分別表明什麼?以及他們各自的使用場景和做用。

this:表明當前類的對象引用
super:表明父類存儲空間的標識。(能夠理解爲父類的引用，經過這個東西能夠訪問父類的成員)

/*
	學生案例和老師案例講解
	
	學生：
		成員變量；姓名，年齡
		構造方法：無參，帶參
		成員方法：getXxx()/setXxx()
	老師：
		成員變量；姓名，年齡
		構造方法：無參，帶參
		成員方法：getXxx()/setXxx()
		
	看上面兩個類的成員，發現了不少相同的東西，因此咱們就考慮抽取一個共性的類：
	人：
		成員變量；姓名，年齡
		構造方法：無參，帶參
		成員方法：getXxx()/setXxx()
		
		學生 繼承 人
		老師 繼承 人
*/
//定義人類
class Person {
	//姓名
	private String name;
	//年齡
	private int age;
	
	public Person() {
	}

	public Person(String name,int age) { //"林青霞",27
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

//定義學生類
class Student extends Person {
	public Student() {}
	
	public Student(String name,int age) { //"林青霞",27
		//this.name = name;
		//this.age = age;
		super(name,age);
	}
}

//定義老師類
class Teacher extends Person {

}

class ExtendsTest4 {
	public static void main(String[] args) {
		//建立學生對象並測試
		//方式1
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		System.out.println(s1.getName()+"---"+s1.getAge());
		
		//方式2
		Student s2 = new Student("林青霞",27);
		System.out.println(s2.getName()+"---"+s2.getAge());
		
		//補齊老師類中的代碼並進行測試。
	}
}