Java入門教程九(封裝繼承多型)

韭菜Java發表於2019-06-09
Java封裝繼承多型

封裝

封裝就是將物件的屬性和方法相結合，通過方法將物件的屬性和實現細節保護起來，實現物件的屬性隱藏。做法就是：修改屬性的可見性來限制對屬性的訪問，併為每個屬性建立一對取值（getter）方法和賦值（setter）方法，用於對這些屬性的訪問。

public class Person
{
    private String name;     //姓名
    private int age;         //年齡
    private String phone;    //聯絡電話
    private String address;  //家庭住址
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name=name;
    }
    
    public int getAge()
    {
        return age;
    }
    
    public void setAge(int age)//封裝的常用表現，在內部進行業務邏輯的控制，外部只呼叫即可
    {
        if(age<18||age>40)//對年齡進行限制
        {
            System.out.println("年齡必須在18到40之間！");
            this.age=20;    //預設年齡
        }
        else
        {
            this.age=age;
        }
    }
    
    public String getPhone()
    {
        return phone;
    }
    
    public void setPhone(String phone)
    {
        this.phone=phone;
    }
    
    public String getAddress()
    {
        return address;
    }
    
    public void setAddress(String address)
    {
        this.address=address;
    }
}

繼承

繼承是程式碼複用的一種形式，即在具有包含關係的類中，從屬類繼承主類的全部屬性和方法，從而減少了程式碼冗餘，提高了程式執行效率。例如，一個矩形（Rectangle類）屬於四邊形（Quadrilateral），正方形、平行四邊形和梯形同樣都屬於四邊形。從類的角度來解釋，可以說成 Rectangle 類是從 Quadrilateral 類繼承而來的，其中 Quadrilateral 類是基類，Rectangle 類是派生類。

Java入門教程九(封裝繼承多型)

繼承是通過擴充套件其他類而形成新類來實現的，原來的類稱為父類（super class）或基類，新類稱為原來類的子類或派生類。在子類中，不僅包含父類的屬性和方法，還可以增加新的屬性和方法，使得父類的基本特徵可被所有子類的物件共享。類的繼承並不改變類成員的訪問許可權。也就是說，如果父類的成員是公有的、被保護的或預設的，它的子類仍具有相應的這些特性。

class class_name extends extend_class
{
    //類的主體
}
public class Person
{
    public String name;   //姓名
    public int age;       //年齡
    public String sex;    //性別
}
public class Student extends Person
{
    private String stuNo;         //學號
    private String department;    //所學專業
}
//學生繼承了人類，同時具有了，姓名、年齡、性別屬性

多型

多型性是物件導向程式設計的又一個重要特徵，它是指在父類中定義的屬性和方法被子類繼承之後，可以具有不同的資料型別或表現出不同的行為，這使得同一個屬性或方法在父類及其各個子類中具有不同的含義。

對物件導向來說，多型分為編譯時多型和執行時多型。其中編譯時多型是靜態的，主要是指方法的過載，它是根據引數列表的不同來區分不同的方法。通過編譯之後會變成兩個不同的方法，在執行時談不上多型。而執行時多型是動態的，它是通過動態繫結來實現的，也就是大家通常所說的多型性。

public class Figure
{
    double dim1;
    double dim2;
    Figure(double d1,double d2)//有參的構造方法
    {
        this.dim1=d1;
        this.dim2=d2;
    }
    double area()//用於計算物件的面積
    {
        System.out.println("通過多型，在子類中重寫。");
        return 0;
    }
}
public class Rectangle extends Figure
{
    Rectangle(double d1,double d2)
    {
        super(d1,d2);
    }
    double area()
    {
        System.out.println("長方形的面積：");
        return super.dim1*super.dim2;
    }
}
public class Triangle extends Figure
{
    Triangle(double d1,double d2)
    {
        super(d1,d2);
    }
    double area()
    {
        System.out.println("三角形的面積：");
        return super.dim1*super.dim2/2;
    }
}
public static void main(String[] args)
{
    Figure figure;                     //宣告Figure類的變數
    figure=new Rectangle(9,9);
    System.out.println(figure.area()); //輸出：長方形的面積：81。
    figure=new Triangle(6,8);
    System.out.println(figure.area()); //輸出：三角形的面積：24。
}

過載

過載是 Java 多型性的表現。在 Java 語言中，同一個類中的兩個或多個方法可以共享同一個名稱，只要它們的引數宣告不同即可，這種情況被稱為方法過載

在 JDK 的 java.io.PrintStream 中定義了十多個同名的 println() 方法

public void printin(int i){…}
public void println(double d){…}
public void println(String s){…}
System.out.println(102);       //呼叫println(int i)方法
System.out.println(102.25);    //呼叫println(double d)方法
System.out.println("價格為 102.25");    //呼叫println(String s)方法

方法過載時必須要注意以下兩點：

過載方法的引數列表必須和被過載的方法不同，並且這種不同必須足以清楚地確定要呼叫哪一個方法。

過載方法的返回值型別可以和被過載的方法相同，也可以不同，但是隻有返回值型別不同不能表示為過載。

pubic class Person{
    private String name;
    //方法一
    public Person(){
    }
    //過載方法，可直接設定姓名
    public Person(String _name){
        this.name = _name;
    }
}

重寫

子類中如果建立了一個與父類中相同名稱、相同返回值型別、相同引數列表的方法，只是方法體中的實現不同，以實現不同於父類的功能，這種方式被稱為方法重寫，又稱為方法覆蓋。
在重寫方法時，需要遵循下面的規則：
引數列表必須完全與被重寫的方法引數列表相同，否則不能稱其為重寫。
返回的型別必須與被重寫的方法的返回型別相同，否則不能稱其為重寫。
訪問修飾符的限制一定要大於被重寫方法的訪問修飾符（public>protected>default>private）。
重寫方法一定不能丟擲新的檢査異常或者比被重寫方法宣告更加寬泛的檢査型異常。例女口，父類的一個方法宣告瞭一個檢査異常 IOException，在重寫這個方法時就不能丟擲 Exception，只能丟擲 IOException 的子類異常，可以丟擲非檢査異常。

public class Person
{
    public String name;    //名字
    public int age;        //年齡
    public Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getInfo()
    {
        return "我叫"+name+"，今年"+age+"歲";
    }
}
public class Student extends Person
{
    private String hobby;
    public Student(String name,int age,String hobby)
    {
        super(name,age);
        this.hobby=hobby;
    }
    public String getInfo()
    {
        return"我叫"+this.name+"，我今年"+this.age+"歲，我愛吃"+hobby+"。";
    }
}
public static void main(String[] args)
{
    Person person=new Student("小明",20,"雞");
    System.out.println(animal.getInfo());  //輸出：我叫小明，我今年20歲，我愛吃雞。
}

相關文章