Java面向對象的三大特征

一、Java面向對象的特征之封裝

   1、封裝的概念

      面向對象是利用對象來代表現實生活中的事物。使用對象的屬性來表示事物的特性；使用對象中的方法代表事物的行為亦成為動作。將事物的屬性和方法封存到一起形成對象的過程就是對象的封裝。

    封裝一方面將屬性和方法放置到一起形成對象，另一方面也要控制這些方法和屬性的訪問權限。

    作用：封裝提高代碼的復用性，降低了代碼的冗余度，保證數據的合法性。

   2、訪問權限控制符及訪問控制權限

3.訪問權限控制符的使用

1.  可以用在成員屬性上
2.  可以用在成員方法上
3.  可以用在類、接口上：當用於修飾類和接口時，只能是public或friendly，不能寫private和protected。

 

public class Person04 {
    //公有
    public String name;
    //保護
    protected String gender;
    //默認
    double salary;
    //私有
    private String jour;
    
    void say() {
        System.out.println("說...");
    } 
    
    void eat() {
        System.out.println("吃...");
    }
    public Person04(String name, String gender, double salary, String jour) {
        this.name = name;
        this.gender = gender;
        this.salary = salary;
        this.jour = jour;
    }public static void main(String[] args) {
        Person04 p  = new Person04("za","nan", 1212,"今天學習的java面向對象");
        //1.本類中private、protected、frindly和public都可以訪問
        System.out.println(p.name);
        System.out.println(p.gender);
        System.out.println(p.salary);
        System.out.println(p.jour);
    }
}

二、Java面向對象的特征之繼承

    1、繼承的概念

           將現實生活中事物之間的從屬包含關系反映到計算機中的類描述時，可以通過繼承體現。即：在開發一個類及其子類的過程中，讓子類（派生類）自動具有該類的屬性和成員方法。被繼承者稱為父類（超類、基類），繼承者稱為子類（派生類）。

    2、繼承的實現

        在聲明類的過程中，通過extends關鍵字來繼承另一個類。如果構造方法的第一行沒有顯示調用父類的構造函數，則默認會在當前構造方法的第一行隱式調用父類的無參構造方法，即super（）；super的用法見另一篇博客——JAVA常用關鍵字super和this作用的介紹。

    3、繼承的特點

1. 不支持多繼承：java只支持單繼承，不支持多繼承。
2. 不支持循環繼承：java中繼承禁止循環。
   

    4、方法重寫

         當子類不喜歡從父類中繼承的方法，而在本類中寫一個同名同參數的方法來實現自子的邏輯，從而覆蓋父類中的方法時，稱之為產生了方法的重寫。

      可以在重寫的方法前通過@Overdide告知編譯器當前方法需要重寫，利用編譯器來檢查方法名和參數使用是否正確。重寫必須遵循的規則為：

1. 方法簽名必須一致（方法名、參數列表）；
2. 子類聲明的訪問權限修飾符的權限要大於等於父類聲明的訪問修飾符的權限；
3. 如果父類中返回的值類型是基本數據類型或者void，則子類要保持一致；
4. 如果父類方法返回值是類類型，則子類方法中的返回值可以是該類型或者其子孫類型。

   具體示例如下所示：

 

package cn.tedu.extend;

class A { }
class B extends A{ }
//繼承的特點：
//1. java只支持單繼承，不支持多繼承
//2. java中繼承禁止成環
class C extends B{    }

class Person01 {
    private String name;
    private int age;
    public A  say() {
        System.out.println("人說....");
        return null;
    }
    public void eat() {
        System.out.println("人吃....");
    }
}
class Teacher01 extends Person01 {
    //方法重寫的特點：子類返回類型C是父類的子類
    @Override
    public C say() {
        System.out.println("老師在一本正經的說...");
        return null;
    }
    //注解的作用：防止開發者誤寫，起到提示作用
    @Override
    public void eat() {
        System.out.println("洗個手");
        //super類似於父類的虛擬對象
        super.eat();
        System.out.println("抽根煙...");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Teacher01 t = new Teacher01();
        t.eat();
    }

}

三、Java面向對象的特征之多態

 1、多態的概念

    多態是同一行為具有多個不同表現形式或形態的能力。具體到程序中是指程序中定義的引用變量所指向的具體類型和引用能調用的方法在編程是並不能確定，而是在程序運行時才能確定該引用指向哪個類的實例對象。

   重寫和向上造型是多態的基礎。

   根據多態的綁定時期來划分可將多態分為：編譯時多態（方法的重載）和運行時多態（向上造型和方法重寫）。

  2、重寫

     子類覆蓋父類的方法，重新實現或者擴展功能即為重寫。

   3、向上造型

         通俗來說，就是“子類當做父類使用”，即將子類的對象賦值該父類的引用。此時，該引用只能看到父類聲明的方法和屬性，調用方法時，調用的是子類的重寫方法或繼承自父類的方法；訪問屬性時訪問的是父類的屬性。

      如果想使用子類中特有的方法，則只能強制轉換為子類的引用之后才能調用。

   示例如下所示：

class Person {
    public String name = "張三";
    public void say() {
        System.out.println("人說....");
    }
    public void eat() {
        System.out.println("人吃....");
    }
}

class Teacher extends Person {
    public String name = "李四";
    @Override
    public void say() {
        System.out.println("老師在一本正經的說...");
    }
    public void teach() {
        System.out.println("老師在上課...");
    }
    
}
public class Demo01 {
    public static void main(String[] args) {
        //1.--向上造型，子類當做父類用
        Person t = new Teacher();
        //2. 向上造型，父類引用只能看到父類聲明的屬性和方法
        t.eat();
        t.say();
        //t.teach();
        //4. 向上造型，如果父類引用想要看到子類身上特有的屬性和方法，
        //需要進行類型的強制轉換
        Teacher teach = (Teacher)t;
        teach.teach();
        //3. 向上造型，指向子類對象的父類引用調用的時子類的方法和父類的屬性
        t.say();
        System.out.println(t.name);
    }

}

 

    4、多態的用處

            基於重寫和向上造型，我們可以在開發程序時，面向父類開發，但是在使用時用子類進行重寫、擴展和改造父類的能力，調用方法時傳入子類的對象，使程序執行子類定義的方法，為程序提供了很強的靈活性和擴展性。

        多態本身是為了解耦。

 

    多態的使用如下所示：

//Car類：所有車的父類
class Car {
    public void run() {
        System.out.println("在地上以30km/h速度跑...");
    }
}
//汽車類:繼承自父類car，改造了car，重寫並增強了run方法
class Automobile extends Car {
    @Override
    public void run() {
        System.out.println("汽車在地上以60km/h速度跑...");
    }
}
//火車類:繼承自父類car，改造了car，重寫並增強了run方法
class Train extends Car {
    @Override
    public void run() {
        System.out.println("火車在地上以120km/h速度跑...");
    }
}
//若干年后開發出了飛車：同樣繼承自Car，重寫run方法
class Aerodyne extends Car {
    @Override
    public void run() {
        System.out.println("飛車在以1200km/h速度飛...");
    }
}
//Car類的使用者
class TranDemo {
    //方法中使用多態：面向父類開發，所有car的子類都可以接受
    //沒有和任何具體的car寫死，后續可以繼續開發Car的子類，進一步增強能力，
    //增加了靈活性。
    //public void trans(Automobile car) {
      public void trans(Car car) {    
        System.out.println("准備貨物...");
        car.run();
        System.out.println("卸載貨物...");
    }
}
public class Demo02 {
   public static void main(String[] args) {
       Automobile auto  = new Automobile();
       Train train = new Train();
       Aerodyne aero = new Aerodyne();
       TranDemo trans = new TranDemo();
       //可以傳入汽車，火車，或者飛車auto，train，aero
       trans.trans(aero);       
  }
}