Java基礎讀書筆記（三）——面向對象的特徵

面向對象的特徵

- 封裝性：

   封裝就是把每個對象的數據（屬性）和操作（行爲）包裝在一個類中。

類的構造方法：

 將成員變量初始化封裝起來的方法。構造方法是一種特殊的成員方法。
 （1）構造方法名與類名相同。
 （2）構造方法不返回值，沒有返回類型（包括void類型）。
 （3）構造方法總是和new運算符一起被調用。
 （4）構造方法可以重載。即每個類可以有零個或多個構造方法。
 （5）構造方法在創建對象時直接執行，一般顯示不能直接調用。
 （6）系統默認未定義構造方法的類中時缺省的空構造方法。

eg：輸出指定學生的年齡和性別

public class Student {
    public String Name;
    public int age;
    public char sex;
/**
 * 構造方法，Student前無任何返回類型。
 */
    public Student(String name, int age, char sex) {
        super();
        Name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return Name;
    }
    public int getAge() {
        return age;
    }
    public char getSex() {
        return sex;
    }
    public static void main(String[] args) {
          Student s1 = new Student("Mark", 27, '女');//創建Student類的對象
          Student s2 = new Student("Jackson", 17, '男');
          System.out.println("Mark的年齡："+s1.getAge());//對象成員方法的調用
          System.out.println("Jackson的性別："+s2.getSex());
    }

}

運行結果：

this和super的引用

Java系統默認每個類都缺省的具有null、this、super三個對象的引用變量。
==null==：代表空對象，一般用null來代表未創建的對象。
==this==:指當前對象的引用。
==super==：指對父類的引用。是用來訪問父類被隱藏的數據成員;是調用父類中被子類覆蓋的方法;是調用父類的構造函數。

eg:this的運用

public class ThisEg {
      private String name;
      private int age;
    public ThisEg(String name, int age) {
        super();  //調用父類（隱藏繼承的Object類）的構造函數
        this.setName(name);//用this引用當前對象
this.setAge(age);
        this.print();
    }
    public void setName(String name) {
        this.name = name; //this指明賦值號左邊爲引用當前對象的成員變量，以免混淆
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void print(){
        System.out.println("Name="+name+";Age="+age);//在此行中並不需要用this,因爲並不會導致混淆
    }
    public static void main(String[] args) {
        ThisEg ts = new ThisEg("Yi", 23);
    }
}

運行結果：

eg:super的運用

public class Person {
      private String name;
      private int age;
    public void setName(String name) {
        this.name = name;
    public void setAge(int age) {
        this.age = age;
    }
    public void print(){
        System.out.println("Name="+name+";Age="+age);
    }

}
public class SuperEg extends Person{
    /**
     * 覆蓋掉父類中的print()方法
     */
      public void print(){
          System.out.println("test:");
          super.print(); //直接調用父類的成員方法
      }
      public static void main(String[] args) {
        SuperEg  se = new SuperEg();
        se.setName("Danniu");
        se.setAge(8);
        se.print();  //調用覆蓋後的方法
    }
}

運行結果

類成員訪問權限修飾符

修飾符	同一個類	同一個包	子類	所有類
Public	允許訪問	允許訪問	允許訪問	允許訪問
protected	允許訪問	允許訪問	允許訪問
缺省的	允許訪問	允許訪問
private	允許訪問

==把重要的數據修飾爲private，然後寫一個public的函數訪問，正好體現了面向對象編程的封裝性，是面向對象編程安全性的體現； 子類繼承父類，覆蓋父類的成員和方法時，修飾符的訪問權限不能小於父類。==

- 繼承性

 （1）Java語言不支持多繼承，但允許一個類實現多個接口。
（2）所有的Java類都直接或間接的繼承了Java.lang.Object類。

- 多態性

 1）多態是指同名的不同方法根據發送消息的對象以及方法傳送參數的不同，採取不同的行爲方式的特性。
2）將一個方法調用同一個方法主體連接到一起就稱爲“綁定”（binding）
==前期綁定==：（靜態綁定）在程序執行前。Java中static和final(private方法屬於final)方法是前期綁定。（編譯時多態）
==後期綁定==：（動態綁定，dynamic binding）在程序運行時，根據對象的類型進行綁定。（運行時多態）
3）Javazhong 提供兩種多態機制：覆蓋、重載。

覆蓋（Overiding）和重載(Overloading)

兩者之間的區別：

覆蓋	重載
子類和父類的關係	同一個類內部多個方法間的關係
兩個方法間的關係	可能有多個重載方法
相同的方法名和形參表	只能與相同的方法名，不能有相同的形參表
區分方法的是調用它的對象	根據形參來決定調用的是哪個方法
final修飾的方法不能被覆蓋	final修飾的方法只能被重載

覆蓋：

public class Person {
    String name;

    public void eat(Food d) {
        System.out.println(this.name + "吃" + d.name);

    }
    public  void speak(){
        System.out.println("講中文！")
    };
}


public class English extends Person{
    public void speak(){
        System.out.println("講英文！");
    }

}

public class Test {

    public static void main(String[] args) {
        Person p = new Chinese();
        p = new English();
        p.speak();
    }

}

運行結果：

重載:

public class OverloadEg {
    //重載的方法
    int add(int a,int b){
        return (a+b);
    }
//  int add(long a,long b){}   非法重載，long和方法中的int是同一簡單類型的參數
    double add(double a,double b){
        return (a+b);
    }

    public static void main(String[] args) {
         int a;
         double b;
         OverloadEg p = new OverloadEg();
         a = p.add(1, 2);
         b = p.add(4, 5);
         System.out.println("a="+a);
         System.out.println("b="+b);
    }
}

運行結果：

運行時多態

 多態（polymorohism）提高了程序的可擴充性。
 （1）通過繼承父類對象的引用變量來引用子類對象的方法來實現。

 （2）通過接口類型變量引用實現接口的類對象來實現。

//定義接口Animal
public interface Animal {
   void run();
}
//實現接口Animal的類Cat
public class Cat implements Animal {

    public void run() {
        System.out.println("貓會跑");

    }
}
//實現接口Animal的類Dog
public class Dog implements Animal {

    @Override
    public void run() {
        System.out.println("狗會跳");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
        Animal a;
        a = new Cat();
        a.run();
        a =new Dog();
        a.run();
    }
}

運行結果：