面向物件三大特征:封裝、繼承、多型

• 面向物件三大特征:封裝、繼承、多型
  • 訪問控制符
  • 封裝
    • • 封裝的定義
      • 封裝的意義
  • 繼承
    • • super
        • 在子類中呼叫父類的屬性或方法
        • 在子類中呼叫父類構造器
      • 方法的重寫
      • 重寫小結
      • 為什么要重寫?
  • 多型
    • • 什么是多型？
      • 多型存在的條件
      • 代碼實作

訪問控制符

• 在講封裝之前我們先了解一下關于訪問控制符

? Java 提供了 3 個訪問控制符：private、 protected 和 public ，代表 3 種不同的訪問級別，再加上一個默認的訪問控制級別（不使用任何訪問控制符），共有 4 個訪問控制級別，

• private（當前類訪問權限）：類中的一個的成員被 private 修飾，它只能在當前類的內部被訪問；
• default（包訪問權限）：類中的一個成員或者一個外部類不使用任何訪問控制符修飾，它能被當前包下其他類訪問；
• protected（子類訪問權限）：類中的一個的成員被 protected 修飾，它既可以被當前包下的其他類訪問，又可以被不同包的子類訪問；
• public（公共訪問權限）：類中的一個成員或者一個外部類使用 public 修飾，它能被所有類訪問，

我們可以用一個表，來看一下訪問修飾符

看完了修飾符，我么開始學習封裝

封裝

• 程式設計追求：高內聚，低耦合，高內聚就是類的內部資料操作細節自己完成，不允許外部干涉！低耦合：僅暴露少量的方法給外部使用！

封裝的定義

封裝指的是將物件的狀態資訊隱藏在物件內部，不允許外部程式直接訪問物件內部資訊，而是通過該類所提供的方法來實作對內部資訊的操作和訪問，

封裝的意義

• 1.提高代碼的安全性，保護資料
• 2.隱藏代碼的實作細節
• 3.統一介面
• 4.增加系統可維護性

下面我們用代碼來實際看一下關于封裝的應用：

首先定義一個學生類，在類中我們定義了三個屬性，但是屬性的修飾符是private

也就是私有的，我們只能在類中去使用這個方法，那么我們在測驗類中想要呼叫它，這時我們可以定義一個公共的方法來使用它

public class Student {
    //private關鍵字，定義私有屬性
    //名字
    private String name;
    //學號.
    private String id;
    //性別
    private String sex;
   }

public class Student {
    //private關鍵字，定義私有屬性
    //名字
    private String name;
    //學號.
    private String id;
    //性別
    private String sex;
  //通過get用來獲取類中的name
public String getName() {
    return this.name;
}
//set給這個屬性設定值

public void setName(String name) {
    this.name = name;
}
}

現在我們可以在測驗類中，看一下，

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName("lingstar");
        System.out.println(student.getName());
    }

}

輸出：

lingstar

我們在操作中也可以使用快捷鍵，AIL+INSERT然后點擊Getter或者Setter或者Getter and Setter來快速添加此方法

封裝可以也可以對傳入其中的資料進行判斷，看資料是否合理？

eg：以傳入的性別為例

性別只有男或者女，當傳入性別為其他時候，我們回傳"您輸入的性別有誤"

我們在類中添加一下代碼

代碼：

public String getSex() {
    return sex;
}

public void setSex(String sex) {
    switch (sex) {
        case " 男":
            this.sex = sex;
            break;
        case "女":
            this.sex=sex;
            break;
        default:
            System.out.println("您輸入的性別有誤！");
    }
}

然后實際運行看一下：

測驗代碼：

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.setSex("what");
        System.out.println(student.getSex());
    }

}

輸出：

您輸入的性別有誤！
null

當輸入正確的資訊時：

public class Application {
    public static void main(String[] args) {
        System.out.println(student.getName());
        student.setSex("男");
        System.out.println(student.getSex());
    }

}

輸出：

	男

通過這么一個簡單的例子，想要了解全部的封裝的意義不太現實，這就需要我們在空閑時間多去練習和使用封裝！

繼承

• Java繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的資料或新的功能，也可以用父類的功能，但不能選擇性地繼承父類，

• Java 使用 extends 作為繼承的關鍵字，子類繼承了父類，就會獲得父類的全部成員變數和方法

• java只有單繼承沒有多繼承

• 私有的(private)東西是無法繼承的

代碼示例：

我們首先定義一個Person類

public class Person {
    public void run(){
        System.out.println("人會奔跑");
    }
}

然后定義一個Student類,讓學生類繼承Person類

public class Student extends Person{

}

在測驗類中呼叫一下這個學生類，看能否輸出它父類的方法！

public class Application {
        public static void main(String[] args) {

            Student student=new Student();
            student.run();
      }

    }

在java中所有的類都繼承Object類

輸出一下看是否呼叫Person中的run方法

人會奔跑

可以用ctrl+h看一下結構

我們可以看到Person類繼承于Object類，然后Studet

又繼承Person類

super

? super在java中兩種用法

• 在子類中呼叫父類的屬性或方法

? 因為在java中子類沒辦法直接呼叫父類的方法或屬性，如果想要呼叫，必須使用java關鍵字！

寫個簡單的代碼實際體驗一下java關鍵字

先定義Person類：

public class Person {
    protected String name="star";

}

然后定義一個學生類，讓學生類繼承這個類：

public class Student extends Person{
    public String name="lingstar";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

}

定義測驗類，用來輸出結果

public class Application {
        public static void main(String[] args) {
            Student student=new Student();
            student.test("星星");
      }

    }

輸出：

星星
lingstar
star

• 在子類中呼叫父類構造器

? 在Java中，子類是父類的派生類，它的實體化依賴于父類的實體化，所以它的任何一個建構式都必須要初始化父類，Java就是super關鍵字呼叫父類構造方法，且呼叫父類的無參構造必須放在第一行！

person類：

public class Person {
    public Person(){
        System.out.println("呼叫了person的無參構造");
    }
}

student類：

public class Student extends Person{
public Student(){
    System.out.println("呼叫了Student的無參構造");
}
}

直接實體化student看一下，代碼是怎樣執行的！

public class Application {
        public static void main(String[] args) {
            Student student=new Student();
      }
    }

輸出結果：

呼叫了person的無參構造
呼叫了Student的無參構造

從結果可以看出，是先呼叫了父類的無參構造方法，再呼叫子類的無參構造，

也就相當于是

public Student(){
    super();
    System.out.println("呼叫了Student的無參構造");
}
}

在studen中是這樣執行的，先呼叫父類的構造器，且super只能放在第一行，放在下面會報錯！

super總結：

? 1.super呼叫父類的構造方法，必須在構造方法的第一個！

? 2.super必須只能出現在子類的方法或構造方法中！

? 3.super和this不能同事呼叫構造方法！

super與this的區別：

方法的重寫

? 在子類中如果創建了一個與父類中相同名稱、相同回傳值型別、相同引數串列的方法，只是方法體中的實作不同，以實作不同于父類的功能，這種方式被稱為方法重寫（override），又稱為方法覆寫，當父類中的方法無法滿足子類需求或子類具有特有功能的時候，需要方法重寫，

注意：重寫都是方法的重寫與屬性無關

eg：

定義一個A類和B類，讓A繼承B類，里面有一個相同的方法，輸出先看一下效果

public class A extends B{
    @Override//注解：有功能的注解
    public void test(){
        System.out.println("A=>test()");
    }
}

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

測驗類：

public class Application {
        public static void main(String[] args) {
            //方法的呼叫只跟左邊，定義的資料型別有關
            A a=new A();
            //a.test呼叫的是A類的方法
            a.test();
            //父類的參考指向了A
            B b=new A();
            b.test();
      }

    }

輸出：

A=>test()
B=>test()

我們把static去掉，看一下方法的重寫

public class A extends B{
    @Override//注解：有功能的注解
    public void test(){
        System.out.println("A=>test()");
    }
}

再運行看一下結果：

A=>test()
A=>test()

因為靜態方法(加 static)是類的方法,而非靜態是物件的方法，

有static時，b呼叫了B類的方法，因為b是用B定義的，

沒有static時，b呼叫的是物件的方法，而b是用A類new的，

重寫小結

? 1.重寫需要有繼承關系，子類重寫父類的方法

? 2.子類與父類的方法名必須相同,方法體不同

? 3.引數串列必須相同

? 4.修飾符的范圍可以擴大

? 5.拋出的例外：范圍可以被縮寫，但不能擴大：ClassNotFoundException-->Exception(大)

? 6.重寫快捷鍵AIL+INSERT：Override

為什么要重寫?

? 因為有時父類的功能，子類不一定需要，或者不一定滿足

多型

什么是多型？

多型就是同一個行為具有多個不同表現形式或形態的能力，多型只是方法的多型，屬性沒有多型！

多型存在的條件

? 1.繼承關系，需要有父子類之間的聯系

? 2.方法需要被重寫

? 這些不能重寫：

? static 方法，屬于類，不屬于示例

? fianl 常量

? private修飾

? 3.父類參考指向子類物件

代碼實作

接下來通過代碼來體會一下：

先寫一個Person類，讓他作為Student類的父類

public class Person {
    public void run(){
        System.out.println("人會快速跑");
    }
}

再寫Student類，繼承Person類，且在Student類中重寫Person類的方法

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("人也會慢跑");
    }
}

然后再通過測驗類來看一下

public class Application {
        public static void main(String[] args) {
            //一個物件的實際型別是確定的
//            new Student();
//            new Person();

//          可以指向的參考型別就不確定了：父類的參考指向子類
            //物件能執行哪些方法，主要看物件左邊的型別，和右邊關系不大！
            //student能呼叫的方法都是自己的或者父類的
            Student s1=new Student();
            //Person雖然可以指向子類，但是不能呼叫子類獨有的方法
            Person s2=new Person();
            Object s3=new Student();//如果子類重寫了父類，呼叫子類，如果子類沒有重寫就呼叫父類
            s2.run();
            //如果我在子類Student中寫一個方法，而用s2去呼叫是呼叫不出來的！
            s1.run();

      }

    }

輸出：

人會快速跑
人也會慢跑

標籤：Java

上一篇：Java 插入公式到PPT幻燈片

下一篇：新一代服務網關Gateway的實踐筆記