面向?qū)ο蟮娜筇卣?/h1>
1.封裝
2.繼承
3.多態(tài)
封裝注意點：
1.封裝就是將抽象的數(shù)據(jù)組裝起來,構(gòu)成class類.
2.屬性需要定義在類中，又叫做成員變量； 而定義在方法中的變量叫做局部變量。
3.局部變量使用前必須要聲明并賦初值；成員變量使用前必須要聲明，但可以不賦初值。
4.成員變量與局部變量的聯(lián)系與區(qū)別：
a) 無論是成員變量還是局部變量，使用前都需要聲明（定義）。
b) 對于局部變量來說，使用前必須要初始化；對于成員變量來說，使用前可以不初 始化。如果沒有初始化成員變量就開始使用，那么每個類型的成員變量都有一個 默認(rèn)的初始值
i. byte、short、int、long 類型的初始值為 0
ii. float、double 類型的初始值為 0.0
iii. char 類型的初始值‘\u0000’
iv. boolean 類型的初始值為 false
5.如果一個類包含了屬性與方法，那么該類的每一個對象都具有自己的屬性，但無論一個 類有多少個對象，這些對象共享同一個方法(放在代碼區(qū))。
6.關(guān)于方法參數(shù)傳遞的總結(jié)：對于 Java 中的方法參數(shù)傳遞，無論傳遞的是原生數(shù)據(jù)類型 還是引用類型，統(tǒng)一是傳值（pass by value）。
7.什么類型的引用就能指向什么類型的對象，比如 People 類型的引用就能指向 People 類 型的對象，但不能指向 Student 類型的對象。比如：
People people = new People(); // 正確
People people = new Student(); //錯誤
8.構(gòu)造方法（Constructor） ：構(gòu)造方法用于完成對象屬性的初始化工作，構(gòu)造方法的特點：
a) 構(gòu)造方法的名字必須與類名完全一致（包含大小寫）
b) 構(gòu)造方法沒有返回值，連 void 也不能出現(xiàn)。
c) 如果在定義一個類的時候，沒有為類聲明構(gòu)造方法，那么 Java 編譯器會自動為類 添加一個沒有參數(shù)且方法體為空的構(gòu)造方法（默認(rèn)的構(gòu)造方法）
d) 如果在定義一個類的時候，為類聲明了構(gòu)造方法，那么 Java 編譯器就不會再為類 添加構(gòu)造方法了。
e) 不能顯式調(diào)用類的構(gòu)造方法，構(gòu)造方法通常是通過 new 關(guān)鍵字隱式調(diào)用。
public class People {
public String name;
public int age;
People(String name,int age){
this(name);//構(gòu)造方法之間的調(diào)用，只能寫在構(gòu)造方法第一行，普通的方法重寫的調(diào)用父類的沒有這個限制
this.age = age;
}
People(String name){
this.name = name;
}
public static void main(String[] arges){
People p=new People("elese",26);
System.out.println(p.name);
System.out.println("test");
}
}
9.new 關(guān)鍵字在生成對象時完成了三件事情：
a) 為對象開辟內(nèi)存空間。
b) 調(diào)用類的構(gòu)造方法。
c) 將生成的對象的地址返回。
10.默認(rèn)的構(gòu)造方法：構(gòu)造方法沒有參數(shù)且方法體為空。
11.使用 new 來生成對象的時候，后面的小括號()表示構(gòu)造方法的參數(shù)列表，如果構(gòu)造方法 不接收參數(shù)，那么小括號中的內(nèi)容為空；如果構(gòu)造方法接收參數(shù)，那么小括號中的實際 參數(shù)就需要與構(gòu)造方法定義中的形式參數(shù)保持一致（參數(shù)數(shù)量一致、參數(shù)類型一致、按 照順序逐一賦值）。
12.方法重載
a).方法名字相同，參數(shù)個數(shù)和類型不同的方法叫重載。返回值沒有影響
public void change(int a,int b){
System.out.println("int change");
}
public void change(int a,int b,int c){
System.out.println("int3 change");
}
public int change(int a,float b){
System.out.println("float change");
return 2;
}
這三個方法都是重載方法
繼承
public class test {
public static void main(String[] args) {
System.out.print(new Apple(2.3).price);
}
}
class Fruit{
public double price;
Fruit(){
System.out.println("Fruit");
}
Fruit(double price){
System.out.println("Fruit price");
this.price = price;
}
}
class Apple extends Fruit{
Apple(double price) {
super(price);//和this一樣，必須填寫在第一行
System.out.println("apple");
this.price = 2.4;
}
}
輸出結(jié)果：
Fruit price
apple
2.4
繼承注意點
1.當(dāng)一個類沒有構(gòu)造方法的時候，系統(tǒng)會默認(rèn)添加一個無參構(gòu)造方法。如果有構(gòu)造方法，系統(tǒng)將不會添加構(gòu)造方法
2.構(gòu)造方法之間的關(guān)系必定的方法的重載
3.繼承后，子類的構(gòu)造方法中如果沒有顯示調(diào)用父類的構(gòu)造方法，將隱士調(diào)用父類的無參構(gòu)造方法（如果某種原因不存在）將會編譯出錯
4.子類顯示調(diào)用父類構(gòu)造方法的時候super必須寫在構(gòu)造方法的第一行
13.方法重寫，發(fā)生在子類與父類之際
多態(tài)
定義：子類就是父類（玫瑰花是花，男人是人），多態(tài)的意思就是：父類引用指向子類對象。（說白了就是父類引用指向子類對象的時候編譯器讓你編譯通過而已。向上轉(zhuǎn)型。如果向下轉(zhuǎn)型編譯器不讓通過而已，強(qiáng)制轉(zhuǎn)換就可以蒙混編譯器）
public class test {
public static void main(String[] args) {
//多態(tài)，向上轉(zhuǎn)型(就是保證了，轉(zhuǎn)型后調(diào)用的不會出錯)
Fruit f = new Apple();
f.getColor();
//向下轉(zhuǎn)型（swift的概念，這個概念能成功的依據(jù)就是保證向下轉(zhuǎn)型的對象本身就是能轉(zhuǎn)型成這個的對象，如果向下轉(zhuǎn)型的對象，不是期望轉(zhuǎn)型的對象就會出錯）
Object o = new Apple();
Apple a = (Apple)o;
a.getColor();
}
}
class Fruit{
public void getColor(){
System.out.println("getColor");
}
}
class Apple extends Fruit{
public void getPrice(){
System.out.println("getPrice");
}
}
抽象類
// 抽象類
abstract class AbstractTest{
int a;
void go(){
}
abstract void run(); //抽象方法
}
warning：
1.具有抽象方法的類，稱為抽象類
2.抽象類不能是實例化，只能用于繼承
3.有抽象方法之說，沒有抽象屬性之說，其他的和普通類無異
4.子類繼承抽象類，子類必須實現(xiàn)抽象類中的所有抽象方法，否則就將子類定義為抽象方法
接口（interface）
//接口的定義，因為類只能繼承一個，那么接口就運(yùn)用而生，一個類可以實現(xiàn)多個接口
interface run{
static final String str = "liyang";
int a = 0; //默認(rèn)的都是static final的
void fun(); //默認(rèn)的都是抽象方法，可以省略abstract
}
static 關(guān)鍵字
public class test {
public static void main(String[] args) {
animal.run(); //類直接調(diào)用
new animal().run(); //對象直接調(diào)用
animal a = null;
a.run(); // 輸出為lilei,那么可以推斷靜態(tài)方法和靜態(tài)屬性都是根據(jù)引用類型來調(diào)用的
}
}
class animal {
static String name = "lilei"; //類屬性，所有類對象共有，放在靜態(tài)常量區(qū)，而非堆棧區(qū)
static void run(){ //類方法（里面只能訪問類屬性）
System.out.println(name);
}
}
warning:靜態(tài)方法只能被繼承不能被重寫
1.靜態(tài)代碼塊
public class test {
public static void main(String[] args) {
new P();
new P();
}
}
class P{
int c =getC();
static int a=getA();
static {
System.out.println("static Code");
}
static int b=getB();
static int getA(){
System.out.println("getA");
return 2;
}
static int getB(){
System.out.println("getB");
return 2;
}
int getC(){
System.out.println("getC");
return 2;
}
P(){
System.out.println("P Constructor");
}
}
輸出結(jié)果：
getA
static Code
getB
getC
P Constructor
getC
P Constructor
總結(jié)：
1.java文件先被編譯成class文件，切java文件和class文件不是一一對應(yīng)的，一個java文件可以對應(yīng)N個class，一個class文件代表一個類
2.類（class）在被使用的時候，首先將class文件加載到JVM虛擬機(jī)，執(zhí)行將該類的靜態(tài)變量初始化和執(zhí)行靜態(tài)代碼塊，切執(zhí)行順序是從上到下執(zhí)行，只會在被加載的時候執(zhí)行一次
3.成員變量的初始化會優(yōu)先于構(gòu)造方法的初始化，沒有給值就是默認(rèn)值，從getC()可以看出
4.執(zhí)行構(gòu)造方法，構(gòu)造方法中，再將其修改為指定的值，這是慣用手法
final關(guān)鍵字
- final可以修飾類，屬性和方法
1.修飾類，類就不可被繼承
2.修飾屬性，屬性就不可被修改，相當(dāng)于常量
a).聲明的時候賦值
b).構(gòu)造方法里賦值
3.修飾方法，那么方法就不能被重寫
訪問修飾符
- 簡述：
1.public （任何地方都可以使用）
2.protected（受保護(hù)的，可以在子類中使用）
3.private(私有的，只有在該類內(nèi)部使用)
4.default(不加任何修飾符，就是包權(quán)限，只能在相同包下類似public的權(quán)限)
