第一天1.什么是類？什么是對象？
1)現實世界是由很多很多對象組成的
基于對象抽出了類
2)對象:真真正正存在的單個的個體
類:代表一類個體(類型、類別)
3)類中可以包含:
3.1)所有對象所共有的屬性(靜)----變量
3.2)所有對象所共有的行為(動)----方法
4)一個類可以創建多個對象
同一個類創建的多個對象，結構相同，數據不同
5)類是對象的模板，對象是類的具體的實例
2.如何創建類？如何創建對象？
3.引用類型畫等號:
1)指向同一個對象
2)對其中一個引用的修改會影響另外一個
eg:房門鑰匙
基本類型畫等號:
1)賦值
2)對其中一個值的修改不會影響另外一個
eg:身份證復印件
4.null:空，即不指向任何對象
若引用的值為null，則該引用不能再進行任何操作了
若操作則空指針異常(NullPointerException)
補充
1. 1)找對象:一堆小格子
2)抽類:格子類Cell
3)設計類中的成員變量和方法:
4)創建對象:
2. 面向過程是一種以過程為核心的編程思想，即分析出解決問題所需要的步驟，然后使用方法將這些步驟一步一步的實現，使用的時候，在main方法中一個一個依次調用就可以了。
3. 請描述類和對象的關系
參考答案
對象是一個客觀存在的實體，是面向對象編程過程中分析與解決問題的出發點與基礎。對象的實質就是內存中的一塊數據存儲區域，其數據結構由定義它的類來決定。
類是用于構建對象的模板，對象通過類的實例化產生，一個類可以創建多個對象，每個對象擁有自己的數據和行為。
3 請描述引用類型和基本類型的區別
參考答案
除8種基本類型之外，用類名（接口、數組）聲明的變量稱為引用類型變量，簡稱“引用”。引用的功能在于訪問對象。
基本類型變量本身就包含了其實例數據，而引用類型變量中存儲的是某個對象在內存中的地址信息。當一個引用類型變量指向該類的對象時，就可以通過這個變量訪問對象。
第二天 1.方法的簽名:方法名+參數列表
2.方法的重載:
1)同一個類中，方法名稱相同，參數列表不同
2)編譯器在編譯時自動根據方法的簽名綁定調用不同的方法
3.構造方法:構造函數、構造器、構建器
1)給成員變量賦初值
2)與類同名，沒有返回值類型
3)在創建(new)對象時被自動調用
4)若自己不寫構造，則系統默認提供一個無參構造方法
若自己寫了構造，則不再默認提供
5)構造方法可以重載
4.this:指代當前對象，哪個對象調指的就是哪個對象
方法中訪問成員變量之前，默認有個this.
this用法:
1)this.成員變量名----訪問成員變量
2)this.方法名()------調用方法
3)this()-------------調用構造方法
5.引用類型數組
1)
1 Cell[] cells = new Cell[4];2 cells[0] = new Cell(2,5);3 cells[1] = new Cell(3,6);4 cells[2] = new Cell(4,7);5 cells[3] = new Cell(5,8);
2)
1 Cell[] cells = new Cell[]{2 new Cell(2,5),3 new Cell(3,6),4 new Cell(4,7),5 new Cell(5,8)6 }
3)
1 int[][] arr = new int[3][];2 arr[0] = new int[2];3 arr[1] = new int[3];4 arr[2] = new int[2];5 arr[1][0] = 100; //arr中第2個元素中的第1個元素賦值為100
4)
1 int[][] arr = new int[3][4]; //3行4列2 for(int i=0;i<arr.length;i++){3 for(int j=0;j<arr[ i].length;j++){4 arr[ i][j] = 100;5 }6 }
1)找對象:T對象,J,O,I,S,Z,L
2)抽類:T類，J類，L類，O,S,Z,I類
3)設計類中的成員變量和方法:
4)創建對象測試:
知識點補充：
1.一個文件中可以包含多個類
public修飾的類只能有一個
public修飾的類的名字必須與文件名相同
第三天 1.內存管理:理解
1)堆:
1.1)存儲所有new出來的對象
1.2)成員變量的生命周期:
創建對象時存在堆中，對象被回收時一并消失
1.3)沒有任何引用所指向的對象即為垃圾，
垃圾回收器(GC)不定時查看，看到垃圾則自動回收
1.4)內存泄露:無用的對象沒有被及時的回收
建議:若對象不再使用，及時將引用設置為null
2)棧:
2.1)存儲正在調用的方法中的所有局部變量
2.2)調用方法時在棧中為該方法分配一塊對應的棧幀，
棧幀中存儲方法中的局部變量，
方法執行結束時棧幀被消除，局部變量一并消失
2.3)局部變量的生命周期:
方法被調用時存在棧中，方法結束時棧幀被消除時一并消失
3)方法區:
3.1)存儲.class字節碼文件以及所有方法
3.2)方法只有一份，通過this來區分具體的引用
2.繼承:
1)有利于代碼的重用(避免代碼重復)
2)通過extends實現繼承
3)父類/基類:所有子類所共有的特征和行為
子類/派生類/:子類所特有的特征和行為
4)子類繼承父類后，具有:
父類共有的+子類特有的
5)一個父類可以有多個子類，
一個子類只能有一個父類---單一繼承
6)繼承具有傳遞性
7)java規定:構造子類之前必須先構造父類
子類構造中若沒有調用父類構造，則默認添加super()來調用父類的無參構造
若子類構造中調了父類構造，則不再默認提供
super()必須位于子類構造的第一句
3.super:指代當前對象的父類對象
用法:
1)super.成員變量名---訪問父類的成員變量
2)super.方法名()-----調用父類的方法
3)super()------------調用父類的構造方法
4.向上造型
1)父類型的引用指向子類的對象
2)能點出來什么，看引用的類型
知識點補充：
1.成員變量:
1)類中，方法外
2)new時存在堆中，對象被回收時一并被清除
3)有默認值
局部變量:
1)方法中
2)方法被調用時存在棧中，調用結束棧幀被清除時一并消失
3)沒有默認值
成員變量:有幾個對象就有幾份(堆)
成員方法:只有一份(方法區)
2. 在JAVA中，有java程序、虛擬機、操作系統三個層次，其中java程序與虛擬機交互，而虛擬機與操作系統交互。編譯好的java字節碼文件運行在JVM中。
程序中無論代碼還是數據，都需要存儲在內存中，而java程序所需內存均由JVM進行管理分配，開發者只需關心JVM是如何管理內存的，而無需關注某種操作系統是如何管理內存的，這就保證了java程序的平臺無關性。
JVM會將申請的內存從邏輯上劃分為三個區域：堆、棧、方法區。這三個區域分別用于存儲不同的數據。
3．GC線程會從棧中的引用變量開始跟蹤，從而判定哪些內存是正在使用的，若GC無法跟蹤到某一塊堆內存，那么GC就認為這塊內存不再使用了，即為可回收的。但是，java程序員不用擔心內存管理，因為垃圾收集器會自動進行管理。
4. 構建T類和J類的父類Tetromino類，將公共的（T類和J類公有的）信息存放在父類中， T類和J類繼承Tetromino父類。此時，子類即可以共享父類的數據。這個過程就是泛化的過程。
5.簡述JVM垃圾回收機制
垃圾回收機制是Java提供的自動釋放內存空間的機制。
垃圾回收器（Garbage Collection，GC）是JVM自帶的一個線程，用于回收沒有被引用的對象。
6 Java程序是否會出現內存泄露
會出現內存泄漏。一般來說內存泄漏有兩種情況。
一是在堆中分配的內存，在沒有將其釋放掉的時候，就將所有能訪問這塊內存的方式都刪掉；另一種情況則是在內存對象明明已經不需要的時候，還仍然保留著這塊內存和它的訪問方式（引用）。第一種情況，在Java中已經由于垃圾回收機制的引入，得到了很好的解決。所以，Java中的內存泄漏，主要指的是第二種情況。
7.Foo foo = new Foo();
foo.f();
以上代碼的內存實現原理為：
1.Foo類首先被裝載到JVM的方法區，其中包括類的信息，包括方法和構造等。
2.在棧內存中分配引用變量foo。
3.在堆內存中按照Foo類型信息分配實例變量內存空間；然后，將棧中引用foo指向foo對象堆內存的首地址。
4.使用引用foo調用方法，根據foo引用的類型Foo調用f方法。
8．當調用子類構造器來初始化子類對象時，父類構造器總會在子類構造器之前執行。子類構造器調用父類構造器分如下幾種情況。
A，子類構造器執行體的第一行使用super顯式調用父類構造器，系統將根據super調用里傳入的實參列表調用父類對應的構造器。
B，子類構造器執行的第一行代碼使用this顯式調用本類中重載的構造器，系統將根據this調用里傳入的實參列表調用本類中的另一個構造器。執行本類中另一個構造器時即會調用父類構造器。
C，子類構造器執行體中既沒有super調用，也沒有this調用，系統將會在執行子類構造器之前，隱式調用父類無參數的構造器。
第四天 1.方法的重寫(override):
1)發生在父子類中，方法名相同，參數列表相同，方法體不同
2)重寫方法被調用時，看對象
2.重寫與重載的區別:----常見面試題
1)重寫:
1.1)父子類中，方法名相同，參數列表相同
1.2)遵循"運行期"綁定，根據對象的類型調用方法
2)重載(overload):
2.1)同一個類中，方法名相同，參數列表不同
2.2)遵循"編譯期"綁定，根據引用的類型綁定方法
3.package:
1)避免類的命名沖突
2)類的完全限定名:包名.類名
3)包名建議所有字母小寫
import:
1)同包中的類可以直接訪問，
不同包中類訪問兩種方式:
1.1)通過import聲明類/引入類
1.2)完全限定名----繁瑣
2)語法: import 包名.類名;
4.訪問控制修飾符:
1)public:公開的，任何類
2)private:私有的，本類
3)protected:受保護的，本類、子類、同包類
4)默認:什么也不寫，本類、同包類
說明:
1)類的訪問控制只能是public和默認
2)類中的成員如上4種都可以
5.static:靜態的
1)靜態變量:
1.1)由static修飾
1.2)是屬于類的，存在方法區中，只有一份
1.3)常常通過類名.來訪問
1.4)何時用:所有對象的數據都一樣時使用
2)靜態方法:
2.1)由static修飾
2.2)是屬于類的，存在方法區中，只有一份
2.3)常常通過類名.來訪問
2.4)靜態方法沒有隱式this傳遞，
所以靜態方法中不能直接訪問實例成員
2.5)何時用:方法的操作僅與參數相關而與對象無關
3)靜態塊:
3.1)由static修飾
3.2)類被加載時自動執行，類只被加載一次，
靜態塊只執行一次
3.3)何時用:常常用于加載靜態資源(圖片、音頻、視頻等)
6.final:最終的
1)修飾變量:變量不能被改變
2)修飾方法:方法不能被重寫
3)修飾類:類不能被繼承
7.static final-----------自學
補充知識點：
1.實例變量多還是靜態變量多?
----------實例變量多
----------靜態方法不可能多
2. 靜態方法沒有隱式的this傳遞，
沒有this意味著沒有對象，
實例變量是屬于對象，必須通過對象點來訪問
所以靜態方法中不能直接訪問實例成員
3. 成員變量:
1)實例變量:屬于對象的，存在堆中，
有幾個對象有幾份 通過對象點來訪問
2)靜態變量:屬于類的，存在方法區中，
只有一份 通過類名點來訪問
4.重寫遵守"兩同兩小一大"原則:----等于時絕對正確
* 1)兩同:
* 1.1)方法名相同
* 1.2)參數列表相同
* 2)兩小:
* 2.1)子類的返回值類型小于或等于父類的
* 2.1.1)void和基本類型時，必須相同
* 2.1.2)引用類型時，小于或等于父類的
* 2.2)子類拋出的異常小于或等于父類的-----異常之后
* 3)一大:
* 3.1)子類的訪問權限大于或等于父類的-----修飾符之后
5.方法重載的要求是“兩同一個不同“的原則，
* 1)兩同:
* 1.1)方法名相同，
同一類中是指兩個方法可以是同一個類中聲明的，或者是繼承來的，抑或一個是聲明的，另一個是繼承來的
* 1.2) 同一類
* 2)一不同:參數列表不同
6. 對于類的修飾可以使用public和默認方式。 其中，public修飾的類可以被任何一個類使用，而默認訪問控制的類只可以被同一個包中的類使用。
而protected和private訪問修飾符是不可以修飾類的，但其可以修飾內部類（后面課程詳細介紹）。
7. 關于package和import語句，下面說法錯誤的是：
A. package 提供了一種命名機制，用于管理類名空間
B. 定義類時，除了定義類的名稱以外，必須要指定一個包名
C. import語句用于導入所需要的類
D. 同時使用不同包中相同類名的類，包名不能省略
8. final關鍵字修飾成員變量，意為初始化后不可改變（對象一旦創建即不可改變），那么該成員變量可以在聲明時賦初始值，也可以在構造方法或是靜態代碼塊中初始化。
第五天 1.static final常量:
1)常量必須聲明同時初始化
2)不能被改變、通過類名.來訪問
3)常量名建議所有字母大寫，多個單詞用_分隔
4)在編譯時被直接替換為具體的值---效率高
2.抽象方法:
1)由abstract修飾
2)只有方法的定義，沒有方法的具體實現(連{}都沒有)
3.抽象類:
1)由abstract修飾
2)包含抽象方法的類必須是抽象類
若一個類中沒有抽象方法，也可以聲明為抽象類---我愿意
3)抽象類不能被實例化(new)
4)抽象類是需要被繼承的，子類:
4.1)重寫父類的所有抽象方法--常用
4.2)也聲明為抽象類----不常用
5)抽象類的意義:
5.1)封裝子類所共有的數據和行為--子類重用
5.2)為所有子類提供了一種公共的類型--向上造型
5.3)包含抽象方法，為所有子類提供統一的入口
4.接口:
1)是一個標準、規范
只要符合了這個標準、就能干某件事---API
2)由interface定義
3)只能包含常量和抽象方法
4)接口不能被實例化
5)接口是需要被實現/繼承的，實現類/子類:
必須重寫接口中的所有抽象方法
6)一個類可以實現多個接口，
若又繼承又實現時，必須先繼承后實現
7)接口可以繼承接口
補充知識點
1. 抽象類中可以包含抽象方法和非抽象方法，而接口中的所有方法均為抽象的。
2. 接口里不包含構造器；抽象類里可以包含構造器，抽象類里的構造器并不是用于創建對象，而是讓其子類調用這些構造器來完成屬于抽象類的初始化操作
3. //演示接口的基礎語法
1 interface Inter1{ 2 public static final int NUM = 250;3 public abstract void show();4 double PI = 3.14159; //默認public static final5 void say(); //默認public abstract6 }
第六天 正課:
1.多態:多種形態
1)多態的意義:
1.1)同一類型的引用在指向不同的對象時，有不同的實現
行為的多態: cut(),run()
1.2)同一對象被造型為不同的類型時，有不同的功能
對象的多態: 我,水
2)向上造型:
2.1)父類型的引用指向子類的對象
2.2)能造型成的類型:父類、所實現的接口
2.3)能點出來什么，看引用的類型
3)強制類型轉換，成功的條件只有兩個:
3.1)引用所指向的對象，就是該類型
3.2)引用所指向的對象，實現了該接口
4)只要不符合如上兩個條件，
則發生ClassCastException類型轉換異常
一般在轉換之前先通過instanceof判斷:
引用所指向的對象是否是該類型
2.成員內部類:單獨應用的幾率不太大
1)類中套類，里面的叫內部類Inner，外面的叫外部類Outer
2)內部類通常只服務于外部類，對外不具備可見性
3)通常在外部類中創建內部類的對象
4)內部類中可以直接訪問外部類的成員(包括私有的)
內部類中有一個隱式的引用指向了創建它的外部類對象
外部類名.this.
3.匿名內部類:
1)想創建一個類(子類)的對象，并且該對象只創建一次，
此時該類不必命名，稱之為匿名內部類
2)內部類(成員、匿名)有獨立的.class
4.面向對象三大特征:
1)封裝:
1.1)類:封裝的是對象的特征和行為
1.2)方法:封裝的具體的業務邏輯/實現
1.3)訪問控制修飾符:封裝的是訪問的權限
2)繼承:
2.1)便于代碼的重用
2.2)extends，父:共有的 子:特有的
3)多態:
3.1)意義:
3.1.1)同一類型的引用指向不同對象時，有不同的實現
行為的多態
3.1.2)同一對象被造型為不同的類型的，有不同的功能
對象的多態
3.2)向上造型、強制轉換、instanceof
3.3)兩種表現形式:
3.3.1)重寫
3.3.2)重載
知識點補充:
1.父類大，子類小
類型轉換:
1)自動類型轉換:從小到大
2)強制類型轉換:從大到小
2. 設計原則:
1)將公共的特征和行為抽到父類中
2)若所有子類行為都一樣，設計為普通方法
若所有子類行為不一樣，設計為抽象方法
3)符合既是也是的關系時，使用接口
3. 繼承要符合is a的關系
4. 1)創建了Inter2的一個子類，沒有名字
2)為該子類創建了一個對象，名為o3
3).大括號中的為該子類的類體
Inter2 o3 = new Inter2(){};
知識點鞏固：
1 1.public class Answer { 2 public static void main(String[] args) { 3 int score = 20; 4 Answer ans= new Answer(); 5 ans.add(score); 6 System.out.println(" main： score = " + score); 7 } 8 void add(int score) { 9 System.out.println(" add： score=" + score++);10 }11 }
解析：輸出add： score=20
main： score =20
原因是score只定義在main函數中，作用域也是main函數，程序調用ans.add函數時，往函數中傳給了參數score=20，但是這個函數沒有返回值。Main函數中輸出的還是變量score=20
|
