06. 物件導向基本概念

							物件導向基本概念


         李紹群
 learry@pavo.seed.net.tw
                         物件導向基本概念




物件的基本概念(Object)
 物件的內容
    屬性(property)
    方法(method)
 物件的特性
    繼承(inheritance)
    多型(polymorphism)
    資料隱藏(data hiding)



                               2
                                                                 物件導向基本概念




類別(Class)
 什麼是類別
        將資料結構本身以及操作此資料結構的方法封
         裝起來
 類別的宣告
 class 類別名稱 {              class Person {
     資料型態       屬性;            String name;
     ……..
                               String birthday;
     傳回值的資料型態 方法名稱(參數) {
         敘述;
                               public void sayHello() {
         ……..
         return 傳回值;               System.out.println("大家好!");
     }                         }
 }                         }
                                                                       3
                            物件導向基本概念




使用物件
 建立物件
    john = new Person();
    Person 是類別, john 是物件
 屬性的宣告及存取
    物件名稱.屬性
    物件名稱.屬性 = 值;
 方法的呼叫
    物件名稱.方法(參數)


                                  4
                                                            物件導向基本概念




屬性的宣告及存取
/* 宣告 Person類別 */
class Person {
   String name;
   String birthday;
}

public class Person1 {
  public static void main(String[] args) {
     Person p1;

        /* 建立 Person 物件 */
         p1 = new Person();
         p1.name = "John";
         p1.birthday="1911/10/10";

        System.out.println("Person1的姓名為:" + p1.name);
        System.out.println("Person1的生日為:" + p1.birthday);
    }
}
                                                                  5
                                                       物件導向基本概念




方法的宣告及呼叫
/* 宣告 Person類別 */
class Person {
   String name, birthday;

    public void sayHello() {
      System.out.println(name + "向大家問好");
    }
}

public class Person2 {
  public static void main(String[] args) {
     Person p1;

        /* 建立 Person 物件 */
         p1 = new Person();
         p1.name = "John"; p1.birthday="1911/10/10";

        System.out.println("物件建立完畢!");
        p1.sayHello();
    }
}                                                            6
                            物件導向基本概念




課堂練習
 請建立一個日期資料的類別(Date)，包含屬性
 年(year)、月(month)、日(day)以及顯示日期的
 方法(printDate)，並完成一個程式顯示今天與
 明天日期的程式。例如(2005/10/31)




                                  7
                        物件導向基本概念




資料成員的存取
 public 修飾子
     資料成員或方法可以讓其他類別存取或呼叫
 protected 修飾子
    資料成員或方法僅能讓類別本身或者子類別存
     取或呼叫
 private 修飾子
     資料成員或方法僅能在類別本身存取或呼叫



                              8
                                                          物件導向基本概念




資料成員的存取
/* 宣告 Person類別 */
class Person {
   public String name;
   private String birthday;

    public void setBirthday(String date) {
      birthday = date;
    }
    public String getBirthday() {
      return birthday;
    }
}

public class Person3 {
  public static void main(String[] args) {
      Person john;

        /* 建立 Person 物件 */
        john = new Person();
        john.name = "John";
        john.setBirthday("1911/10/10");
        System.out.println("姓名為" + john.name);
        System.out.println("生日為" + john.getBirthday());
    }
}
                                                                9
                                           物件導向基本概念




課堂練習
 請將之前建立的日期物件加上判斷日期是否正
 確的方法validDate判斷日期是否正確該方法型
 態為
 private boolean validDate(int d, int m, int y)




                                                  10
                           物件導向基本概念




建構子(Constructor)
 在物件一開始建立時便會執行
    建構子與類別同名，例如 Person 的建構函式為
     Person();
    建構子沒有傳回值
    建構子的方法支援多載(Overload)




                                 11
                                                            物件導向基本概念




建構子範例
/* 宣告 Person類別 */
class Person {
    String name, birthday;

    public Person () {
      System.out.println("正在建立Person類別的物件");
    }
}

public class Person4 {
  public static void main(String[] args) {
     Person p1;

        /* 建立 Person 物件 */
         p1 = new Person();
         p1.name = "John";
         p1.birthday="1911/10/10";

        System.out.println("Person1的姓名為:" + p1.name);
        System.out.println("Person1的生日為:" + p1.birthday);
    }
}                                                                12
                            物件導向基本概念




this 參照子
 在類別的成員方法和建構子可以使用 this 關鍵
 字參考目前的副本方法和變數
    如果方法的參數列和副本變數名稱相同則
        this.變數名稱表示是副本變數




                                 13
                                                            物件導向基本概念




/* 宣告 Person類別 */
class Person {
    String name, birthday;

    public Person (String name, String birthday) {
      System.out.println("正在建立Person類別的物件");
      this.name = name;
      this.birthday = birthday;
    }
}

public class Person5 {
  public static void main(String[] args) {
     Person p1;

        /* 建立 Person 物件 */
         p1 = new Person("John", "1911/10/31");

        System.out.println("Person1的姓名為:" + p1.name);
        System.out.println("Person1的生日為:" + p1.birthday);
    }
}                                                                14
                                     物件導向基本概念




多載化(overloading)
 一個類別擁有一個以上相同名稱的方法
    String類別中的 valueOf 方法
        valueOf(int) : 將整數轉為字串
        valueOf(float) : 將浮點數轉為字串




                                          15
                                                            物件導向基本概念




/* 宣告 Person類別 */
class Person {
   String name, birthday;

    public Person() {
      System.out.println("正在建立Person物件");
      name="Bob"; birthday="1923/2/2";
    }

    public Person (String name, String birthday) {
      System.out.println("正在建立Person類別的物件");
      this.name = name; this.birthday = birthday;
    }
}

public class Person5 {
  public static void main(String[] args) {
     Person p1,p2;

        /* 建立 Person 物件 */
         p1 = new Person("John", "1911/10/31");

        p2 = new Person();

        System.out.println("Person1的姓名為:" + p1.name);
        System.out.println("Person1的生日為:" + p1.birthday);
        System.out.println("Person2的姓名為:" + p2.name);
        System.out.println("Person2的生日為:" + p2.birthday);
    }                                                            16
}
                      物件導向基本概念




課堂練習
 請將Date類別建立建構子當物件建立時將日期
 設定為1900/1/1




                           17
                                 物件導向基本概念




終結者(Finalizer)
 在物件被資源回收(garbage collection)前執行
  的方法
 garbage collection
     Java處理物件的終結機制
     會將物件所佔用的記憶體釋放出來
 方法宣告
     procted void finalizer()



                                      18
                                                            物件導向基本概念




/* 宣告 Person類別 */
class Person {
    String name, birthday;

    public Person () {
      System.out.println("正在建立Person類別的物件");
    }
    public void finalizer() {
      System.out.println("Person類別的物件將被回收");
    }
}

public class Person6 {
  public static void main(String[] args) {
     Person p1;

        /* 建立 Person 物件 */
         p1 = new Person();
         p1.name = "John"; p1.birthday="1911/10/10";

        System.out.println("Person1的姓名為:" + p1.name);
        System.out.println("Person1的生日為:" + p1.birthday);
        p1 = null;
        System.gc(); // 呼叫資源回收
        p2 = new Person();
                                                                 19
    }
}
                             物件導向基本概念




課堂練習
 請將Date類別新增終結者，告訴使用者目前的
 日期即將過去，(例如 1900/1/1 即將過去)




                                  20
                                物件導向基本概念




繼承(Inheritance)
 一個類別可以直接繼承現存類別的部份或者全部的成
  員資料和方法，並可以增加額外的成員資料或方法
 子類別繼承父類別的方法和變數
     使用 extends 關鍵字
  class 子類別名稱 extends 父類別名稱 {
      宣告及敘述
      ……….
  }
 存取父類別
   使用 super 關鍵字



                                     21
                                                      物件導向基本概念




父類別宣告
/* 宣告Vehicle 類別 */
class Vehicle {
   //成員資料
   private int engineNo;
   private int owner;

    public void setNumber(int no) {        //設定引擎號碼
      engineNo = no;
    }
    public void setOwner(int owner) {      //設定所有人
      this.owner = owner;
    }
    public void printVehicle() {    //顯示車輛資料
      System.out.println("所有人: " + owner);
      System.out.println("引擎號碼: " + engineNo);
    }
}




                                                           22
                                                 物件導向基本概念




子列類別宣告
/* 宣告 Car 類別 */
class Car extends Vehicle {
   //成員資料
   private int doors; //幾門

    public Car(int owner, int no, int doors) {
      setNumber(no); // 呼叫父類別的成員方法
      setOwner(owner);
      this.doors = doors;
    }

    public void printCar() {
      System.out.println("====車輛資料====");
      printVehicle();
      System.out.println("車門: " + doors);
    }
}




                                                      23
                                             物件導向基本概念




主程式
public class CarExample1 {
  //主程式
  public static void main(String[] args) {
     //宣告Car 類別型態物件並建立物件
     Car sentra = new Car(1, 123456, 4);
     Car civic = new Car(2, 456789, 2);

        // 更改所有人
        sentra.setNumber(234567);

        //呼叫物件方法
        sentra.printCar();
        civic.printCar();
    }
}




                                                  24
                            物件導向基本概念




課堂練習
 請建立Bicycle單車的類別，內含色彩(color)，
 車型(style)和車價(price)等資料以及顯示單車
 資料的方法(printBicycle)，然後建立子類別競
 速單車(RacingBike)，新增幾段變數(geer)的
 成員和顯示單車資訊的方法(showBicycle)




                                 25
                           物件導向基本概念




類別(static)方法與變數
 何謂類別方法與變數
    不需要事先生成物件，就可以直接呼叫使用
    呼叫方式 :
         類別.方法(參數);
         類別.變數;
    Integer.parseInt();
 宣告方式
    加上 static 關鍵字


                                26
                             物件導向基本概念




複寫和隱藏父類別的方法
 覆寫(Override)
     若父類別的方法不符合需求，可在子列別中宣
      告一個同名、同參數和傳回值的方法來取代父
      類別
 隱藏(Hide)
     物件的副本方法不能取代類別方法(static)，若
      父類別擁有類別方法，我們在子類別宣告同樣
      的類別方法來取代他



                                  27
                                                  物件導向基本概念




父類別宣告
/* 宣告Vehicle 類別 */
class Vehicle {
   //成員資料
   private int engineNo;
   private int owner;

    // 類別方法
    public static void printBrand() {
       System.out.println("品牌: Renault");
    }

    public int getNumber() { return engineNo; }

    public int getOwner() { return owner; };

    public void setNumber(int no) {   //設定引擎號碼
      engineNo = no;
    }
    public void setOwner(int owner) { //設定所有人
      this.owner = owner;
    }
    public void printVehicle() {      //顯示車輛資料
      System.out.println("所有人: " + owner);
      System.out.println("引擎號碼: " + engineNo);
    }
}                                                      28
                                                 物件導向基本概念




子列類別宣告
/* 宣告 Car 類別 */
class Car extends Vehicle {
   //成員資料
   private int doors; //幾門

    public Car(int owner, int no, int doors) {
      setNumber(no); // 呼叫父類別的成員方法
      setOwner(owner);
      this.doors = doors;
    }

    public static void printBrand() {
      System.out.println("品牌: Honda");
    }
    public void printCar {
      System.out.println("====車輛資料====");
      printVehicle();
      System.out.println("車門: " + doors);
    }
}

                                                      29
                                             物件導向基本概念




主程式
public class CarExample2 {
  //主程式
  public static void main(String[] args) {
     //宣告Car 類別型態物件並建立物件
     Car city = new Car(1, 123456, 4);

        // 更改所有人
        city.setOwner(2);

        //呼叫物件方法
        city.printBrand();
        city.printCar();
    }
}




                                                  30
                              物件導向基本概念




隱藏父類別的資料成員
 隱藏父類別的資料成員只要變數名稱相同即可，
  即使型態不同一樣也可以隱藏
Class Vehicle {
  private int owner;
  ………….
}


Class Car extends Vehicle {
   private String owner;
   ……
}




                                   31
                                                      物件導向基本概念




父類別宣告
/* 宣告Vehicle 類別 */
class Vehicle {
   //成員資料
   private int engineNo;
   private int owner;

    public int getNumber() { return engineNo; }

    public int getOwner() { return owner; };

    public void setNumber(int no) {        //設定引擎號碼
      engineNo = no;
    }
    public void setOwner(int owner) {      //設定所有人
      this.owner = owner;
    }
    public void printVehicle() {    //顯示車輛資料
      System.out.println("所有人: " + owner);
      System.out.println("引擎號碼: " + engineNo);
    }
}
                                                           32
                                                    物件導向基本概念




子列類別宣告
/* 宣告 Car 類別 */
class Car extends Vehicle {
   //成員資料
   private int doors;    //幾門
   private String owner;

    public Car(String owner, int no, int doors) {
      setNumber(no); // 呼叫父類別的成員方法
      this.owner = owner;
      this.doors = doors;
    }
    public void printCar {
      System.out.println("====車輛資料====");
      printVehicle();
      System.out.println("車門: " + doors);
    }
}




                                                         33
                                                物件導向基本概念




主程式
public class CarExample {
  //主程式
  public static void main(String[] args) {
     //宣告Car 類別型態物件並建立物件
     Car city = new Car("Sentra", 123456, 4);


        //呼叫物件方法
        city.printCar();
    }
}




                                                     34
                     物件導向基本概念




使用父類別建構子
 子類別不能繼承父類別的建構子，只能在子類
  別中使用super關鍵字呼叫父類別的建構子
 若被子類別覆寫的方法和隱藏的成員變數，也
  可以使用super來呼叫及存取




                          35
                                            物件導向基本概念




父類別宣告
/* 宣告Vehicle 類別 */
class Vehicle {
   //成員資料
   public static int count=0;
   public int engineNo;
   public int owner;

    public Vehicle(int owner, int no) {
      this.owner = owner;
      engineNo = no;
      count++;
    }

    public void printVehicle() { //顯示車輛資料
      System.out.print("Nission");
    }
}


                                                 36
                                                          物件導向基本概念




子列類別宣告
/* 宣告 Car 類別 */
class Car extends Vehicle {
   //成員資料
   private int doors;      //幾門
   private int engineNo;
   private int owner;

    public Car(int owner, int no, int doors) {
      super(owner, no);
      owner = 100;
      engineNo = 100000;
      this.doors = doors;
    }

    public void printVehicle() {
      super.printVehicle();
      System.out.println("====車輛資料====");
      System.out.println("所有人(父): " + super.owner);
      System.out.println("引擎號碼(父): " + super.engineNo);
      System.out.println("所有人(子): " + owner);
      System.out.println("引擎號碼(子): " + engineNo);
      System.out.println("車門: " + doors);
      System.out.println("車輛數: " + count);
    }
}
                                                               37
                                             物件導向基本概念




主程式
public class CarExample4 {
  //主程式
  public static void main(String[] args) {
     //宣告Car 類別型態物件並建立物件
     Car sentra = new Car(1, 123456, 4);
     Car civic = new Car(2, 56789, 2);

        //呼叫物件方法
         sentra.printVehicle();
         civic.printVehicle();
    }
}




                                                  38
                                  物件導向基本概念




抽象類別(1)
 抽象類別(Abstract)
     提供類別繼承的基礎
          使用 abstract 關鍵字
          子類別必須實作
      abstract class 類別名稱 {
        ……………..
        //抽象方法
        abstract void 方法名稱(參數);
      }




                                       39
                             物件導向基本概念




抽象類別(2)
 抽象類別不能建立物件但是可以宣告成參考子類別副
 本的變數
 抽象類別 物件名稱 = new 子類別(參數);
 判斷物件的類別

 if (物件 instanceof 類別) {

     ……..
     // 物件是該類別時執行
 }

 類別轉換
    參考子類別的物件不能直接使用子類別的變數跟方法必須經
     過轉換才可以使用
 子類別 物件名稱 = (子類別) 參考子類別物件;
                                  40
                            物件導向基本概念




抽象父類別
/* 宣告 Shape 類別 */
abstract class Shape {
   //成員資料
   public double x;
   public double y;

    //抽象方法：計算面積
    abstract void area();
}




                                 41
                                                    物件導向基本概念




子類別
/* 宣告 Circle 類別 */
class Circle extends Shape{
   //成員資料
   public double r;

    //建構子
    public Circle(double x, double y, double r) {
       this.x = x;
       this.y = y;
       this.r = r;
    }
    public void area() {
       System.out.println("圓形面積：" + 3.1416*r*r);
    }
}

                                                         42
                                                       物件導向基本概念




主程式
public class ShapeExample1 {

    public static void main(String[] args) {

        Circle c; // 抽象類別的物件變數
        Circle c1 = new Circle(5.0, 1.0, 4.0);
        Shape c2 = new Circle(10.0, 10.0, 7.0);
        //顯示圓形資料
        System.out.println("圓形c1的資料");
        System.out.println("X座標: " + c1.x);
        System.out.println("Y座標: " + c1.y);
        System.out.println("半徑: " + c1.r);
        c1.area();

        if (c2 instanceof Circle) // 檢查是否為 Circle的副本
            System.out.println("c2 是 Circle 類別的副本");

        System.out.println("圓形c2的資料");
        System.out.println("X座標: " + c2.x);
        System.out.println("Y座標: " + c2.y);
        c = (Circle) c2; // 型別轉換
        System.out.println("半徑: " + c.r);
        c2.area();
    }
}
                                                            43
                       物件導向基本概念




多型
 使應用程式更容易擴充
    不需針對不同類型的資料建立類別
    只需繼承一個基礎類別建立同名的方法，即可
     處理不同的資料類型




                            44
                            物件導向基本概念




基礎類別
/* 宣告 Shape 類別 */
abstract class Shape {
   //成員資料
   public double x;
   public double y;

    //抽象方法：計算面積
    abstract void area();
}




                                 45
                                                   物件導向基本概念




子類別(1)
/* 宣告 Circle 類別 */
class Circle extends Shape{
   //成員資料
   private double r;

    //建構子
    public Circle(double x, double y,，
                                     double r) {
       this.x = x;
       this.y = y;
       this.r = r;
    }
    public void area() {
       System.out.println("圓形面積：" + 3.1416*r*r);
    }
}

                                                        46
                                                                   物件導向基本概念




子類別(2)
/* 宣告 Rectangle 類別 */
class Rectangle extends Shape{
   //成員資料
   private double x1;
   private double y1;
   //建構子
   public Rectangle (double x, double y, double x1, double y1) {
      this.x = x; this.y = y;
      this.x1 = x1; this.y1 = y1;
   }
   public void area() {
      System.out.println("矩形面積：" + (x1-x)*(y1-y));
   }
}



                                                                        47
                                                                物件導向基本概念




主程式
public class ShapeExample2 {

    public static void main(String[] args) {

        Shape s; // 抽象類別的物件變數
        Circle s1 = new Circle(5.0, 1.0, 4.0);
        Rectangle s2 = new Rectangle(10.0, 10.0, 20.0, 20.0);
        s = s1; //圓形
        s.area();

        s = s2; //矩形
        s.area();
    }
}




                                                                     48