1:成員變量和局部變量的區別
(1)在類中的位置不同
成員變量：類中方法外
局部變量：方法定義中或者方法聲明上
(2)在內存中的位置不同
成員變量：在堆中
局部變量：在棧中
(3)生命週期不同
成員變量：隨着對象的創建而存在，隨着對象的消失而消失
局部變量：隨着方法的調用而存在，隨着方法的調用完畢而消失
(4)初始化值不同
成員變量：有默認值
局部變量：沒有默認值，必須定義，賦值，然後才能使用
2:類作爲形式參數的問題?
(1)如果你看到一個方法需要的參數是一個類名，就應該知道這裏實際需要的是一個具體的對象。
3:匿名對象
(1)沒有名字的對象
(2)應用場景
A:調用方法，僅僅只調用一次的時候。
b:可以作爲實際參數傳遞。
4:封裝
(1)隱藏實現細節，提供公共的訪問方式
(2)好處：
A:隱藏實現細節，提供公共的訪問方式
B:提高代碼的複用性
C:提高代碼的安全性
(3)設計原則
把不想讓外界知道的實現細節給隱藏起來，提供公共的訪問方式
(4)private是封裝的一種體現。
封裝：類，方法，private修飾成員變量
5:private關鍵字
(1)私有的意義，可以修飾成員變量和成員方法
(2)特點：被private修飾的後的成員只能在本類中被訪問
(3)private的應用：
以後再寫一個類的時候：
把所有的成員變量給private了
提供對應的getXxx()/setXxx()方法
6:this關鍵字
(1)代表當前類的引用對象
記住：哪個對象調用方法，該方法內部的this就代表那個對象
(2)this的應用場景：
A:解決了局部變量隱藏成員變量的問題
B:其實this還有其他的應用，明天講解。
7:構造方法
(1)作用：用於對對象的數據進行初始化
(2)格式：
A:方法名和類名相同
B:沒有返回值類型，連void都不能有
C:沒有返回值
構造方法中可不可以有return語句呢?
可以。而是我們寫成這個樣子就OK了：return;
其實，在任何的void類型的方法的最後你都可以寫上：return;
(3)構造方法的注意事項
A:如果我們沒寫構造方法，系統將提供一個默認的無參構造方法
B:如果我們給出了構造方法，系統將不再提供默認構造方法
如果這個時候，我們要使用無參構造方法，就必須自己給出。
(4)給成員變量賦值的方式
A:setXxx()
B:帶參構造方法
(5)標準案例
class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age) {
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 StudentDemo {
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("劉意",30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}
8:代碼：Student s = new Student();做了哪些事情?
(1)把Student.class文件加載到內存
(2)在棧內存爲s開闢空間
(3)在堆內存爲學生對象申請空間
(4)給學生的成員變量進行默認初始化。
(5)給學生的成員變量進行顯示初始化。
(6)通過構造方法給成員變量進行初始化。
(7)對象構造完畢，把地址賦值給s變量。
10:static關鍵字
(1)靜態的意思。可以修飾成員變量和成員方法。
(2)靜態的特點：
A:隨着類的加載而加載
B:優先與對象存在
C:被類的所有對象共享
這其實也是我們判斷該不該使用靜態的依據。
舉例：飲水機和水杯的問題思考
D:可以通過類名調用
既可以通過對象名調用，也可以通過類名調用，建議通過類名調用。
(3)靜態的內存圖
靜態的內容在方法區的靜態區
(4)靜態的注意事項；
A:在靜態方法中沒有this對象
B:靜態只能訪問靜態(代碼測試過)
(5)靜態變量和成員變量的區別
A:所屬不同
靜態變量：屬於類，類變量
成員變量：屬於對象，對象變量，實例變量
B:內存位置不同
靜態變量：方法區的靜態區
成員變量：堆內存
C:生命週期不同
靜態變量：靜態變量是隨着類的加載而加載，隨着類的消失而消失
成員變量：成員變量是隨着對象的創建而存在，隨着對象的消失而消失
D:調用不同
靜態變量：可以通過對象名調用，也可以通過類名調用
成員變量：只能通過對象名調用
(6)main方法是靜態的
public:權限最大
static:不用創建對象調用
void:返回值給jvm沒有意義
main:就是一個常見的名稱。
String[] args:可以接收數據，提供程序的靈活性
11:如何製作幫助文檔
(1)寫一個類
(2)加入文檔註釋
(3)通過javadoc工具生成即可
javadoc -d 目錄 -author -version ArrayTool.java
12:通過JDK提供的API學習了Math類
(1)Math類
A:是針對數學進行操作的類
B:沒有構造方法，因爲它的成員都是靜態的
C:產生隨機數
public static double random(): [0.0,1.0)
D:如何產生一個1-100之間的隨機數
int number = (int)(Math.random()*100)+1;
E:猜數字小遊戲
13:代碼塊
(1)用{}括起來的代碼。
(2)分類：
A:局部代碼塊
用於限定變量的生命週期，及早釋放，提高內存利用率。
B:構造代碼塊
把多個構造方法中相同的代碼可以放到這裏，每個構造方法執行前，首先執行構造代碼塊。
C:靜態代碼塊
對類的數據進行初始化，僅僅只執行一次。
(3)靜態代碼塊,構造代碼塊,構造方法的順序問題?
靜態代碼塊 > 構造代碼塊 > 構造方法
14:繼承
(1)把多個類中相同的成員給提取出來定義到一個獨立的類中。然後讓這多個類和該獨立的類產生一個關係，
這多個類就具備了這些內容。這個關係叫繼承。
(2)Java中如何表示繼承呢?格式是什麼呢?
A:用關鍵字extends表示
B:格式：
class 子類名 extends 父類名 {}
(3)繼承的好處：
A:提高了代碼的複用性
B:提高了代碼的維護性
C:讓類與類產生了一個關係，是多態的前提
(4)繼承的弊端：
A:讓類的耦合性增強。這樣某個類的改變，就會影響其他和該類相關的類。
原則：低耦合，高內聚。
耦合：類與類的關係
內聚：自己完成某件事情的能力
B:打破了封裝性
(5)Java中繼承的特點
A:Java中類只支持單繼承
B:Java中可以多層(重)繼承(繼承體系)
(6)繼承的注意事項：
A:子類不能繼承父類的私有成員
B:子類不能繼承父類的構造方法，但是可以通過super去訪問
C:不要爲了部分功能而去繼承
(7)什麼時候使用繼承呢?
A:繼承體現的是：is a的關係。
B:採用假設法
(8)Java繼承中的成員關係
A:成員變量
a:子類的成員變量名稱和父類中的成員變量名稱不一樣，這個太簡單
b:子類的成員變量名稱和父類中的成員變量名稱一樣，這個怎麼訪問呢?
子類的方法訪問變量的查找順序：
在子類方法的局部範圍找，有就使用。
在子類的成員範圍找，有就使用。
在父類的成員範圍找，有就使用。
找不到，就報錯。
B:構造方法
a:子類的構造方法默認會去訪問父類的無參構造方法
是爲了子類訪問父類數據的初始化
b:父類中如果沒有無參構造方法，怎麼辦?
子類通過super去明確調用帶參構造
子類通過this調用本身的其他構造，但是一定會有一個去訪問了父類的構造
讓父類提供無參構造
C:成員方法
a:子類的成員方法和父類中的成員方法名稱不一樣，這個太簡單
b:子類的成員方法和父類中的成員方法名稱一樣，這個怎麼訪問呢?
通過子類對象訪問一個方法的查找順序：
在子類中找，有就使用
在父類中找，有就使用
找不到，就報錯
15:final關鍵字
(1)是最終的意思，可以修飾類，方法，變量。
(2)特點：
A:它修飾的類，不能被繼承。
B:它修飾的方法，不能被重寫。
C:它修飾的變量，是一個常量。
A:局部變量
a:基本類型 值不能發生改變
b:引用類型 地址值不能發生改變，但是對象的內容是可以改變的
B:初始化時機
a:只能初始化一次。
b:常見的給值
定義的時候。
構造方法中。
16:多態
(1)同一個對象在不同時刻體現出來的不同狀態。
(2)多態的前提：
A:有繼承或者實現關係。
B:有方法重寫。
C:有父類或者父接口引用指向子類對象。
多態的分類：
a:具體類多態
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象類多態
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多態
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多態中的成員訪問特點
A:成員變量
編譯看左邊，運行看左邊
B:構造方法
子類的構造都會默認訪問父類構造
C:成員方法
編譯看左邊，運行看右邊
D:靜態方法
編譯看左邊，運行看左邊
爲什麼?
因爲成員方法有重寫。
(4)多態的好處：
A:提高代碼的維護性(繼承體現)
B:提高代碼的擴展性(多態體現)
(5)多態的弊端：
父不能使用子的特有功能。
現象：
子可以當作父使用，父不能當作子使用。
(6)多態中的轉型
A:向上轉型
從子到父
B:向下轉型
從父到子
(7)孔子裝爹的案例幫助大家理解多態
(8)多態的練習
A:貓狗案例
B:老師和學生案例
17:抽象類
(1)把多個共性的東西提取到一個類中，這是繼承的做法。
但是呢，這多個共性的東西，在有些時候，方法聲明一樣，但是方法體。
也就是說，方法聲明一樣，但是每個具體的對象在具體實現的時候內容不一樣。
所以，我們在定義這些共性的方法的時候，就不能給出具體的方法體。
而一個沒有具體的方法體的方法是抽象的方法。
在一個類中如果有抽象方法，該類必須定義爲抽象類。
(2)抽象類的特點
A:抽象類和抽象方法必須用關鍵字abstract修飾
B:抽象類中不一定有抽象方法,但是有抽象方法的類一定是抽象類
C:抽象類不能實例化
D:抽象類的子類
a:是一個抽象類。
b:是一個具體類。這個類必須重寫抽象類中的所有抽象方法。
(3)抽象類的成員特點：
A:成員變量
有變量，有常量
B:構造方法
有構造方法
C:成員方法
有抽象，有非抽象
(4)抽象類的幾個小問題
A:抽象類有構造方法，不能實例化，那麼構造方法有什麼用?
用於子類訪問父類數據的初始化
B:一個類如果沒有抽象方法,卻定義爲了抽象類，有什麼用?
爲了不讓創建對象
C:abstract不能和哪些關鍵字共存
a:final 衝突
b:private 衝突
c:static 無意義
18:接口
(1)回顧貓狗案例，它們僅僅提供一些基本功能。
比如：貓鑽火圈，狗跳高等功能，不是動物本身就具備的，
是在後面的培養中訓練出來的，這種額外的功能，java提供了接口表示。
(2)接口的特點：
A:接口用關鍵字interface修飾
interface 接口名 {}
B:類實現接口用implements修飾
class 類名 implements 接口名 {}
C:接口不能實例化
D:接口的實現類
a:是一個抽象類。
b:是一個具體類，這個類必須重寫接口中的所有抽象方法。
(3)接口的成員特點：
A:成員變量
只能是常量
默認修飾符：public static final
B:構造方法
沒有構造方法
C:成員方法
只能是抽象的
默認修飾符：public abstract
(4)類與類,類與接口,接口與接口
A:類與類
繼承關係，只能單繼承，可以多層繼承
B:類與接口
實現關係，可以單實現，也可以多實現。
還可以在繼承一個類的同時，實現多個接口
C:接口與接口
繼承關係，可以單繼承，也可以多繼承
(5)抽象類和接口的區別(自己補齊)?
A:成員區別
抽象類：
接口：
B:關係區別:
類與類：
類與接口：
接口與接口：
C:設計理念不同
抽象類：is a，抽象類中定義的是共性功能。
接口：like a，接口中定義的是擴展功能。
(6)練習：
A:貓狗案例，加入跳高功能
B:老師和學生案例，加入抽菸功能
19:形式參數和返回值的問題
(1)形式參數：
類名：需要該類的對象
抽象類名：需要該類的子類對象
接口名：需要該接口的實現類對象
(2)返回值類型：
類名：返回的是該類的對象
抽象類名：返回的是該類的子類對象
接口名：返回的是該接口的實現類的對象
(3)鏈式編程
對象.方法1().方法2().......方法n();
這種用法：其實在方法1()調用完畢後，應該一個對象；
方法2()調用完畢後，應該返回一個對象。
方法n()調用完畢後，可能是對象，也可以不是對象。
20:包
(1)其實就是文件夾
(2)作用：
A:區分同名的類
B:對類進行分類管理
a:按照功能分
b:按照模塊分
(3)包的定義
package 包名;
多級包用.分開。
(4)注意事項：
A:package語句必須在文件中的第一條有效語句
B:在一個java文件中，只能有一個package
C:如果沒有package，默認就是無包名
(5)帶包的編譯和運行
A:手動式
B:自動式
javac -d . HelloWorld.java
21:導包
(1)我們多次使用一個帶包的類，非常的麻煩，這個時候，Java就提供了一個關鍵字import。
(2)格式：
import 包名...類名;
另一種：
import 包名...*;
(3)package,import,class的順序
package > import > class
22:權限修飾符
(1)權限修飾符
本類 同一個包下 不同包下的子類 不同包下的無關類
private Y
默認 Y Y
protected Y Y Y
public Y Y Y Y
(2)這四種權限修飾符在任意時刻只能出現一種。
public class Demo {}
23:常見的修飾符
(1)分類：
權限修飾符：private,默認,protected,public
狀態修飾符：static,final
抽象修飾符：abstract
(2)常見的類及其組成的修飾
類：
默認,public,final,abstract
常用的：public
成員變量：
private,默認,protected,public,static,final
常用的：private
構造方法：
private,默認,protected,public
常用的：public
成員方法：
private,默認,protected,public,static,final,abstract
常用的：public
(3)另外比較常見的：
public static final int X = 10;
public static void show() {}
public final void show() {}
public abstract void show();
24:內部類
(1)把類定義在另一個類的內部，該類就被稱爲內部類。
舉例：把類B定義在類A中，類B就被稱爲內部類。
(2)內部類的訪問規則
A:可以直接訪問外部類的成員，包括私有
B:外部類要想訪問內部類成員，必須創建對象
(3)內部類的分類
A:成員內部類
B:局部內部類
(4)成員內部類
A:private 爲了數據的安全性
B:static 爲了訪問的方便性
成員內部類不是靜態的：
外部類名.內部類名 對象名 = new 外部類名.new 內部類名();
成員內部類是靜態的：
外部類名.內部類名 對象名 = new 外部類名.內部類名();
(5)成員內部類的面試題(填空)
30,20,10
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public viod show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
(6)局部內部類
A:局部內部類訪問局部變量必須加final修飾。
B:爲什麼呢?
因爲局部變量使用完畢就消失，而堆內存的數據並不會立即消失。
所以，堆內存還是用該變量，而改變量已經沒有了。
爲了讓該值還存在，就加final修飾。
通過反編譯工具我們看到了，加入final後，堆內存直接存儲的是值，而不是變量名。
(7)匿名內部類(掌握)
A:是局部內部類的簡化形式
B:前提
存在一個類或者接口
C:格式:
new 類名或者接口名() {
重寫方法;
}
D:本質：
其實是繼承該類或者實現接口的子類匿名對象
(8)匿名內部類在開發中的使用
我們在開發的時候，會看到抽象類，或者接口作爲參數。
而這個時候，我們知道實際需要的是一個子類對象。
如果該方法僅僅調用一次，我們就可以使用匿名內部類的格式簡化。
interface Person {
public abstract void study();
}
class PersonDemo {
public void method(Person p) {
p.study();
}
}
class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.method(new Person() {
public void study() {
System.out.println("好好學習，天天向上");
}
});
}
}