一、面向對象

　　面向對象 ： 就是一種編程思想

1、類和對象

　　類是指描述一類事物，或者看成是一個分類，可以把類看作構造對象的模板。

　　對象是指具體的個體（也叫實例-instance）。創建對象使用 new，沒對象就 new 一個對象。

1、設計類

語法：

1 class 類名{
2     成員變量  (字段)
3     方法 （具體的一個功能行為）   
4 }

類規範書寫：

①類名首字符大寫;

②類名必須具有意義;

③必須寫註釋；

1 public class Car {
2     String name;  //
 
字段
3     Integer price;
4 
5     void run(){  //方法，具體行為
6         System.out.println("run");
7     }
8 }

2、構造方法

　　創建對象本質上是調用類的構造方法。

 1 public class Car {
 2     String name;  //字段
 3     Integer price;
 4 
 5     void run(){  //方法，具體行為
 6         System.out.println("run");
 7     }
 8 
 9     //構造方法，無參構造方法
 

10     public Car() {
11     }
12 }

特點：

1、每一個類中都至少有一個構造方法；如果沒有看到（顯示的），那麽存在一個隱式的無參數的構造方法；如果一個類中有顯示的構造方法，那麽隱式的就不存在了。

2、構造方法的名字和類名一致（包括大小寫完全一致）。

3、沒有返回值類型，構造方法內部不需要返回任何的數據。

4、其他的和普通方法類型 ，可以有修飾（public）,可以有形參列表，可以有方法體。

5、在創建對象的同時給對象的字段賦值，有參數的構造方法的作用。

6、構造器總是伴隨著new操作一起調用的。

 1 public class Car {
 2     String name;  //
 
字段
 3     Integer price;
 4 
 5     void run(){  //方法，具體行為
 6         System.out.println("run");
 7     }
 8 
 9     //構造方法
10     public Car() {
11     }
12 
13     //有參構造方法
14     public Car(String name, Integer price) {  //在創建對象的同時給對象的字段賦值
15         this.name = name;
16         this.price = price;
17     }
18 }

3、封裝

　　在面向對象程式設計方法中，封裝是指一種將抽象性函式接口的實現細節部份包裝、隱藏起來的方法（數據隱藏）。

在Java 中的體現

1 把類中的字段（實例域）私有化；

2 給每一個字段都提供一組getter， setter方法 (方法的規範寫法)；

3 在測試類中嘗試創建對象,並通過調用getter setter方法完成對字段的賦值和取值；

優點：

　　適當的封裝可以讓代碼更容易理解與維護，也加強了代碼的安全性。減少耦合。類內部的結構可以自由修改。可以對成員變量進行更精確的控制。隱藏信息，實現細節。

 1 public class Student {
 2     private String name;  //私有化字段
 3     private Integer age;
 4 
 5     //getter和setter方法
 6     public String getName() {
 7         return name;
 8     }
 9 
10     public void setName(String name) {
11         this.name = name;
12     }
13 
14     public Integer getAge() {
15         return age;
16     }
17 
18     public void setAge(Integer age) {
19         this.age = age;
20     }
21 }

this介紹：

　　當setter方法，裏面參數名稱都一樣的時候，就選擇就近原則；使用this。

4、繼承

1、具體實現

　　提高了代碼的維護性和復用性，並且讓代碼更加簡潔。

Java類中的繼承的語法格式：

1 class A{ }
2 
3 class B extends A{ }

　　A 是 B 的父類，B 是 A 的子類。子類中可以繼承父類的東西。

 1 /**
 2  * 父類
 3  */
 4 public class Animal {
 5 
 6     public void move(){
 7         System.out.println("move");
 8     }
 9     
10 }

　　子類，非私有字段和方法可以被繼承到。構造方法不能被繼承。

 1 /**
 2  * 子類
 3  */
 4 public class Cat extends Animal {
 5 
 6     @Override
 7     public void move() {
 8         super.move();  //super關鍵字：通過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。
 9     }
10 }

　　Java中只能是單繼承，即一個類只有一個父類；但支持多重繼承（多層繼承），即一個類可以有子類,子類還可以子類... 子子孫孫無窮無盡...

2、方法的重寫（Override）

方法重寫的要求：

1、子類和父類的方法簽名（方法名+方法參數列表）一致。

2、子類的訪問權限不能比父類更低。

3、最好加上@Override，來讓編譯器檢查是否重寫正確。

4、私有方法和 static 方法不能被重寫。

5、子類的返回值類型可以和父類相同或者是父類返回類型的子類。

 1 /**
 2  * 子類
 3  */
 4 public class Cat extends Animal {
 5     @Override
 6     public void move() {
 7         System.out.println("move on");  //重寫父類方法
 8     }
 9 
10 }

5、接口

　　接口通常以interface來聲明。一個類通過繼承接口的方式，從而來繼承接口的抽象方法。

聲明語法：

interface 接口名{
 // 內部可以有哪些成員--參考類
字段  全部都是全局常量（public static final修飾）
方法  全部都是抽象方法（缺省修飾public abstract）
構造方法  沒有！
}

接口名一般加個大寫的 I 在前面。

1 public interface IAnimal {
2     
3     void run();
4     
5     void eat();
6 }

　　使用 implements 關鍵字可以變相的使java具有多繼承的特性，使用範圍為類繼承接口的情況，可以同時繼承多個接口（接口跟接口之間采用逗號分隔）。

註意：

1、必須全部覆寫接口中的抽象方法。

2、否則實現類也抽象類。

3、一個類可以實現多個接口，但必須重寫所有接口中的抽象方法。

 1 public class AnimalImpl implements IAnimal {
 2     @Override
 3     public void run() {
 4         System.out.println("run");
 5     }
 6 
 7     @Override
 8     public void eat() {
 9         System.out.println("eat");
10     }
11 }

6、多態

　　 多態是同一個行為具有多個不同表現形式或形態的能力。即同一個事件發生在不同的對象上會產生不同的結果。

多態的優點：

1. 消除類型之間的耦合關系

2. 可替換性

3. 可擴充性

4. 接口性

5. 靈活性

6. 簡化性

多態存在的三個必要條件

1、繼承

2、重寫

3、父類引用指向子類對象

 1 /**
 2  * 父類
 3  */
 4 public class Animal {
 5     public void eat() {
 6         System.out.println("吃東西");
 7     }
 8 }
 9 
10 /**
11  * 子類
12  */
13 class Cat extends Animal {
14     public void eat() {
15         System.out.println("貓吃魚");
16     }
17 
18     public void work() {
19         System.out.println("貓抓老鼠");
20     }
21 }
22 
23 class Dog extends Animal {
24     public void eat() {
25         System.out.println("狗吃骨頭");
26     }
27     public void work() {
28         System.out.println("狗看家");
29     }
30 }
31 
32 class Person extends Animal {
33     public void eat() {
34         System.out.println("人吃東西");
35     }
36     public void work() {
37         System.out.println("人努力工作");
38     }
39 }

測試多態：

 1 public class Test {
 2     public static void main(String[] args) {
 3         Animal a = new Cat();  // 向上轉型
 4         a.eat();   // 調用的是 Cat 的 eat ：首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。
 5         Cat c = (Cat)a;  // 向下轉型，強制轉換
 6         c.work();    // 調用的是 Cat 的 work
 7 
 8         Animal b = new Dog();
 9         b.eat();
10         Dog d = (Dog)b;
11         d.work();
12 
13         Animal person = new Person();
14         person.eat();
15         Person p = (Person)person;
16         p.work();
17         
18         /* 輸出：
19         貓吃魚
20         貓抓老鼠
21         狗吃骨頭
22         狗看家
23         人吃東西
24         人努力工作*/
25     }
26 }

多態的實現方式

1、重寫

2、接口

3、抽象類和抽象方法

Java基礎（五）