2. 程式人生 > >面向物件核心技術（java）

面向物件核心技術（java）

阿新 • • 發佈：2020-04-14

一、類的封裝詳解

在“面向物件程式設計基礎（java）”的時候講過，封裝是面向物件程式設計的核心思想。同時我們也知道類是載體，只不過我們把物件的屬性和行為封裝在載體中。

 現我們用封裝的方式來實現，一個顧客去一家餐飲吃飯，點了一份西紅柿炒蛋。

分析：

  • 顧客去餐館，要跟餐館服務員點菜
  • 餐館服務員拿選單去通知後廚的廚師
  • 廚師拿到選單，開始準備工作和烹飪

注意：顧客是把想吃的菜告訴了餐館服務員，那麼顧客是可以跟餐館服務員進行接觸的，同時服務員還要記錄顧客想吃的菜品。因為要把這個菜品轉達給後廚廚師。所以後廚廚師是一直在後面沒有跟顧客接觸。

//定義餐館類，為顧客提供服務
public class Restaurant{
    //每一個餐館都有廚師
    private Cook cook = new Cook();
    public static void main(String[] args){
        //例項化餐館，提供服務
        Restaurant rest = new Restaurant();
        System.out.println("我想吃西紅柿炒蛋，幫我來一份");
        rest.takeOrder("西紅柿炒蛋");
    }
    
    //有為顧客下單行為
    public void takeOrder(String dish){
        cook.cooking(dish);
        System.out.println(dish + "已經炒好了，請慢慢享用");
    }
}
​
//定義廚師類
class Cook{
    //廚師名字
    private String name; 
    public Cook(){
        this.name = "託尼"; 
    }
    //洗菜行為
    private WashDishes(){
        System.out.println(this.name + "洗菜"); 
    }
    //炸花生米行為
    private void Rice(){
        System.out.println(this.name + "炸花生米"); 
    }
    //炒菜行為
    public void Cooking(String dish){
        WashDishes();
        Rice();
        System.out.println(name + "開始炒" + dish);
    }
}

 

在簡述封裝時，就提到過手機類，關於手機當中的功能使用者只要負責使用，內部怎麼實現不要管。那麼關於餐館，顧客是跟服務員進行溝通而餐館的廚師並沒有和顧客溝通。也就是說，顧客只負責吃自己下單的菜，關於廚師是誰並不知道，所以關於這個過程我們就可以稱之為封裝。

延伸：請分別以餐館類、使用者類、服務員類、廚師類來完成這個工作。

//餐館類
public class Restaurant3
{
  //餐飲名字
  public static String name = "三無真味私廚";
  public static void main(String[] args){
    Restaurant3 rest = new Restaurant3();
    User user = new User();
    Waiter waiter = new Waiter();
    System.out.println("歡迎光臨"+name+","+user.name+",我是"+waiter.name+"為您服務");
    System.out.println("請問你要吃一點什麼?");
    System.out.println("給我來一份"+user.SayLive());
    waiter.TakeOrder(user.SayLive());
    //顧客吃完去結賬
    waiter.Cash(user);
    System.out.println(user.name + "慢走");
    System.out.println("你多大了，長得很漂亮哦！");
    waiter.Que();
  }
}
​
//使用者類
class User
{
  public String name;
  public User(){
    this.name = "老闆";
  }
​
  //說出自己喜歡吃的菜
  public String SayLive(){
    return "西紅柿炒蛋";
  }
​
  //付錢
  public void Pay(double money){
    System.out.println("我已經支付了" + money + ",確認一下。");
  }
}
​
//服務員類
class Waiter
{
  public String name;
  private int age = 19;
  private Cook cook = new Cook();
​
  public Waiter(){
    this.name = "趙敏";
  }
​
  //下單
  public void TakeOrder(String dish){
    cook.GetOrder(dish);
    System.out.println("菜已經炒好了，請慢用");
  }
​
  //收銀
  public void Cash(User user){
    System.out.println(user.name+"您好，本次一共消費500元");
    user.Pay(500.00);
  }
​
  //詢問芳年
  public void Que(){
    System.out.println("年齡是不方便說滴");
  }
}
​
//廚師類
class Cook
{
  private String name;
  public Cook(){
    this.name = "周芷若";
  }
​
  //洗菜
  private void Wash(){
    System.out.println(this.name + "正清洗青菜");
  }
  
  //打碎雞蛋
  private void Eggs(){
    System.out.println(this.name + "正在打碎雞蛋");
  }
​
  //炒菜
  private void cooking(String dish){
    Wash();
    Eggs();
    System.out.println(this.name + "開始炒菜" + dish);
  }
​
  //接單子
  public void GetOrder(String dish){
    System.out.println("廚師接到顧客選單"+dish);
    this.cooking(dish);
  }
}

 

 總結：就是把一些只提供使用的功能隱藏在載體裡，也就是類中！

二、類的繼承

繼承的思想就是子類可以繼承父類原有的屬性和方法，也可以增加父類所不具備的屬性和方法，或者直接重寫父類中的某些方法。

語法：子類名 extends 父類名

 分析：繼承是讓一個類繼承另一個類，只需要使用enxtends關鍵字就可以了，同時也要注意java中僅支援單一繼承，也就是一個類只有一個父類。

例：電腦類和平板電腦之間的繼承

//電腦類
class Computer {
    String Color = "黑色";
    String Screen = "液晶顯示屏";
    void startUp(){
      System.out.println("電腦正在開機，請稍等...."); 
    }
}
​
//平板電腦
public class Pad extends Computer {
  //平板電腦自己的屬性
  String Battery = "10000毫安鋰電池";
  public static void main(String[] args){
    //父類自己例項化
    Computer cp = new Computer();
    System.out.println("Computer的顏色是" + cp.Color);
    //電腦類物件呼叫開機方法
    cp.startUp();
    //建立Pad平板電腦類
    Pad ipad = new Pad();
    //呼叫父類的屬性
    System.out.println("ipad的螢幕是："+ipad.Screen);
    //ipad呼叫自己的屬性
    System.out.println("ipad的電池：" + ipad.Battery);
    ipad.startUp();
  }
}

 

分析：從上面程式碼可以得出一個結論，繼承只是關係。父類和子類都可以進行例項化，子類物件可以去使用父類的屬性和方法，而不要做具體實現。同時子類也可以擴充套件自己的屬性和方法。關於父類屬性和方法被子類物件使用就是程式碼重複性。

三、方法的重寫

父類的成員都會被子類繼承，當父類的某個方法並不適用於子類時，就需要在子類重寫父類的這個方法。

重寫的實現

繼承不只是擴充套件父類的功能，還可以重寫父類的成員方法。重寫可以理解為覆蓋，就是在子類中將父類的成員方法名稱保留，再重新編寫父類成員方法的實現內容，更改成員方法的儲存許可權，或修改成員方法的返回資料型別。

總結：

  1. 資料返回型別可以進行重寫
  2. 重寫方法也可以增加方法的引數
  3. 訪問許可權只能從小到大，也就是父類為private，子類可以寫成public

注意 ：

子類與父類的成員方法返回值、方法名稱、引數型別以及個數完全相同，唯一不同的是方法實現內容，這一種方式來重寫可以稱之為重構。

//子類重寫父類Eat方法，同時也修改了父類Eat方法的返回型別
public class Mans extends Humans{
     public String Eat(){
        return "吃東西行為";
     }
     public static void main(String[] args){
        Mans m = new Mans();
        System.out.println(m.Eat());
     }
}
​
//人類
class Humans{
    public void Eat(){
        System.out.println("吃東西的行為"); 
    }
}

 

 

//子類重寫父類方法Eat(),並在子類Eat()方法中可以接收一個引數
public class Mans extends Humans{
    public void Eat(String name){
         System.out.println("吃東西行為" + name);
    }
  
    public static void main(String[] args){
        Mans m = new Mans();
        m.Eat("利害吧！");
    }
}
​
class Humans{
    public void Eat(){
        System.out.println("吃東西行為"); 
    }
}

 

 

//重寫父類方法Eat(),重寫內容是修改父類的訪問許可權
public class Mans extends Humans{
    public void Eat(){
        System.out.println("吃東西行為"); 
    }
    public static void main(String[] args){
        Mans m = new Mans();
        m.Eat();
    }
}
​
class Humans{
    private void Eat(){
        System.out.println("吃東西行為"); 
    }
}

 

子類如何來呼叫父類屬性和方法

如果子類重寫了父類的方法之後就無法呼叫父類的方法了嗎？答，是可以的，在子類重寫父類方法時還想呼叫父類方法可以使用super關鍵字來呼叫父類的方法。

在子類裡super關鍵字代表父類物件。

public class Child extends Supers{
    public void Pint(){
        super.Pint();
        System.out.println("我重寫了父類的方法"); 
    }
    public static void main(String[] args){
        Supers s = new Supers();
        s.Pint();
    }
}
class Supers{
    public void Pint(){
        System.out.println("我是父類的方法");  
    }
}

 

 四、所有類的父類——Object

在java中所有的類都直接或者間接繼承了java.lang.Object類。也稱Object為基類。所以Object類比較特殊，因為他是所有類的父類，是java類中最高層類。也就是說，在我們建立一個class時，如果沒有指定該類的繼承類，那麼java.leng.Object類都是他們預設的繼承類

public Humans{}  => public Humans extends Object{}

 

分析：在Object類中主要包括clone()、finalize()、equals()、toString()等這一些方法。所以所有的類都可以重寫Object類中的方法。

注意：Object類中的getClass()、notify()、notifyAll()、wait()等方法是不能重寫的，因為這一些方法定義了final型別，關於final型別下面會講到。

1.getClass()方法

getClass()方法會返回某個對執行時的Class例項也就是物件，再通過Class例項呼叫getName()方法獲取類的名稱。

//得到一個物件的類名稱
public class Hello{
    public static void main(String[] args){
        Hello h = new Hello(); 
        System.out.println(h); //Hello
    }
  
    public String toString(){
        return getClass().getName(); 
    }
}

 

總結：getClass()和getName()這兩個方法的配合就是獲取物件的類名。

2.equals()方法在Object類中是用來比較兩個物件的引用地址是否相等。

class H{}
public class Hello{
    public static void main(String[] args){
        String s1 = new String("111");
        String s2 = new String("222");
        System.out.println(s1.equals(s2)); //true
        H h1 = new H();
        H h2 = new H();
        System.out.println(h1.equals(h2)); //false
    }
}

五、類的多型

多型在程式裡面的意思就是一種定義有多種實現。例如：java裡的“+”有個個數

相加、求和，還有就是字串連線符。類的多型性可以從兩個方面體現：一是方法的過載，二是類的上下轉型。

5.1 方法的過載

構造方法的名稱由類名決定。如果以不同的方式建立類的物件，那麼就需要使用多個形參不同的構造方法來完成。在類中如果有多個構造方法存在，那麼這一些構造方法的形參個數不一相同，而且必須且到方法“方法的過載”。那麼方法的過載就是在同一個類中允許同時存在多個同名方法，只要這些方法的引數個數或者型別不同就可以。

 

public class OverLoadDemo{
    public static int add(int a){
        return a;
    }
  
    public static int add(int a, int b){
        return a + b; 
    }
  
    public static double add(double a, double b){
        return a + b;
    }
    public static int add(int a, double b){
        return (int)(a + b);
    }
  
    public static int add(double a, int b){
        return (int)(a + b);
    }
  
    public static int add(int... a){
        int sum = 0;
        for (int a = 0; i < a.length; i++){
            sum += a[i];
        }
        return sum;
    }
    public static void main(String[] args){
        System.out.println("呼叫add(int)方法：" + add(1));
        System.out.println("呼叫add(int,int)方法：" + add(1,2));
        System.out.println("呼叫add(double,double)方法：" + add(1.5,2.9));
        System.out.println("呼叫add(int,double)方法：" + add(15,2.9));
        System.out.println("呼叫add(double,int)方法：" + add(15.8,9));
        System.out.println("呼叫add(int... a)方法：" + add(1,2,3,4,5,6,7,8,9));
        System.out.println("呼叫add(int... a)方法：" + add(1,2,3,4,5));
    }
}

 

 

 

注意：在類方法中只要方法的引數個數或者型別不同，並且方法名稱一樣，那麼這樣一來就構成了過載

5.2 向上轉型

子類引用的物件轉化為父類型別稱為向上轉型。通俗地來說就是將子類物件轉為父類物件。此處父類物件也可以是介面。

class Parent
{
  public static void draw(Parent p){
    System.out.println("我開始來了");
  }
}
​
public class Zhuangxing extends Parent
{
  public static void main(String[] args){
    Zhuangxing zx = new Zhuangxing();
    zx.draw(zx);
}

 

Parent是我們Zhuangxing的父類，父類中有一個draw()有一個引數，這個引數的型是Parent，也就是父類自己。在Zhuangxing類中的主方法裡我們得到子類物件，並呼叫了父類的draw()方法，同時也吧子類物件作為引數傳入draw()方法。因為Parent類和Zhuangxing是繼承關係，所以吧子類物件賦值給父類型別物件時，這我們就管他稱為向上轉型。

class Parent{
  public static void hello(){
    System.out.println("你好");
  }
}
public class Zhuangxing extends Parent{
  public String name = "張三";
  public static void main(String[] args){
    //向上轉型是子類物件當成是父類物件
    //Zhuangxing zx = new Parent(); 這是錯誤的
    Parent p = new Zhuangxing(); //把子類物件當成父類物件看
    p.name; //報錯，找不到此方法
  }
}

 

分析：

在向上轉型時，父類的物件無法呼叫子類獨有的屬性或者方法。而我們父類物件呼叫自己的屬性或者方法是可以的。這其實就是向上轉型的一個特性，向上轉型的物件會遺失子類中父類沒有的方法，而且子類的同名方法會覆蓋父類的同名方法。相當於向上轉型時，改物件對於只存在子類中而父類中不存在的方法是不能訪問的。同時，若子類重寫了父類的某些方法，在呼叫這些方法時，實際上呼叫的是子類定義的方法，這也就是動態連結、動態呼叫。通俗的來理解，蘋果可以是水果，但不能說水果就是蘋果。如果要讓水果呼叫蘋果的特有屬性和方法，這是不符合常理的。

class Fruit //水果類
{
  public void sayName(){
    System.out.println("我是水果");
  }
}
public class Apple extends Fruit //蘋果類並繼承水果類
{
  public static void main(String[] args){
    //向上轉型
    Fruit apple = new Apple();
    apple.sayName();
    apple.Hello(); //這裡就會報錯，說沒有此方法
  }
  
  //這是蘋果類獨有的方法
  public void Hello(){
    System.out.println("我是蘋果類獨有的方法");
  }
​
  public void sayName(){
    System.out.println("我是蘋果...");
  }
}

 

總結：向上轉型是對父類物件的方法進行擴充，即父類物件可以訪問子類物件重寫父類的方法。

5.3 向下轉型

向下轉型就是指父類型別的物件轉型為子類型別。也就是，宣告的是子類型別，但引用的是父類型別的物件。

同時向上轉型可以由java編譯器自動來完成的，但是向下轉型就要人工強制轉換。

class Fruit{
    public void sayName(){
        System.out.println("我是水果"); 
    }
}
​
public class Apple extends Fruit{
    public void sayName(){
        System.out.println("我是蘋果"); 
    }
    
    //子類獨有方法
    public void Hello(){
        System.out.println("我是子類獨有方法"); 
    }
  
    public static void main(String[] args){
        Fruit apple = new Apple(); //父類型別引用的是子類物件
        apple.sayName(); //輸出的是  - 我是蘋果
        
        //強制轉播換->父類型別Fruit的物件apple向下轉型為子類型別Apple
        Apple fruit = (Apple)apple;
        fruit.sayName(); //我是蘋果
        fruit.Hello(); //不會報錯->輸出我是子類獨有方法內容
    }
}

 

分析：

首先apple的型別是Fruit水果類，但實際引用的是子類Apple的例項，所以apple是向上轉型Fruit型別。從程式碼來看，apple是父類型別（fruit），引用的是子類物件。所以再將apple從Fruit型別向下轉換為Apple型別是安全的。因為我們apple物件本身指向的就是子類物件。

注意-->上下轉型關於載入問題

不管是向上還是向下，載入類時都會載入到記憶體當中。不過向上轉型時，物件雖然遺失了父類沒有同名的方法，但這些已經載入到了記憶體當中，因為是向上轉型，所以物件不能呼叫這一些方法罷了。同時載入類，除了物件特有的屬性不會被載入外，其他的都會被載入。

向上和向下轉型總結

  1. 向上轉型和向下轉型是實現多型的一種機制
  2. 向上轉化編譯器自動實現，目的是抽象化物件，簡化程式設計
  3. 向上轉型時，子類將遺失父類不同名的方法，子類同名的方法將覆蓋父類的方法
  4. 向下轉型需要強制轉換
  5. 向下轉型要注意物件引用的是子類物件還是父類物件，引用子類物件不會報錯，引用父類就會報錯

同時向上轉型和向下轉型是java抽象程式設計的奧祕。向上轉型是實現多型的一種機制，我們可以通過多型性提供的動態分配機制執行相應的動作，使用多型編寫的程式碼不使用多種型別進行檢測的程式碼更加易於擴充套件和維護。

5.4 instanceof關鍵字

class Fruit{
    public void sayName(){
        System.out.println("我是水果"); 
    }
}
public class Apple extends Fruit{
    public static void main(String[] args){
        //fruit是父類型別引用指向的還是父類型別
        Fruit fruit = new Fruit();
        //Fruit型別的fruit向下強制轉型為Apple型別
        Apple apple = (Apple)fruit;
        apple.sayName();
    }
    public void sayName(){
        System.out.println("我是蘋果"); 
    }
}

 

程式碼編譯環境不會報錯，但執行程式碼就會包java.lang.ClassCastException：Fruit cannot be cast to Apple錯。這也是我們剛開始學習轉型時會遇到的場景。

物件A instanceof 類B  => 翻譯就是：物件A是否為類B的例項，如果是返回true，否則為false

 

class Fruit{
    public void sayName(){
        System.out.println("我是水果"); 
    }
}
public class Apple extends Fruit{
    public static void main(String[] args){
        Fruit apple = new Apple(); // 向下轉型
        Apple fruit = null;
        //判斷apple是不是Apple的例項
        if (apple instanceof Apple){
            fruit = (Apple)apple;
        }
        fruit.sayName(); //我是蘋果
        fruit.Hello();//我是子類獨有方法
    }
    public void sayName(){
        System.out.println("我是蘋果");
    }
    public void Hello(){
        System.out.println("我是子類獨有方法"); 
    }
}

&n

相關推薦

面向物件核心技術（java）

一、類的封裝詳解 在“面向物件程式設計基礎（java）”的時候講過，封裝是面向物件程式設計的核心思想。同時我們也知道類是載體，只不過我們把物件的屬性和行為封裝在載體中。  現我們用封裝的方式來實現，一個顧客去一家餐飲吃飯，點了一份西紅柿炒蛋。 分析： 顧客去餐館，要跟

王玉蘭201771010128《面向物件與程式設計（Java）》第十一週學習總結

 一：理論知識部分： （1）集合：集合(Collection或稱為容器)是一種包含多個元素並提供對所包含元素操作方法的類，其包含的元素可以由同一型別的物件組成，也可以由不同型別的物件組成。 A：集合類的作用：– Java的集合類提供了一些基本資料結構的支援。– 例如Vector、Hashtabl

201771010128王玉蘭《面向物件與程式設計（Java）》第十七週學習總結

第一部分：理論基礎 執行緒的同步 多執行緒併發執行不確定性問題解決方案：引入線 程同步機制，使得另一執行緒要使用該方法，就只 能等待。 在Java中解決多執行緒同步問題的方法有兩種： - Java SE 5.0中引入ReentrantLock類。 - 在共享記憶體的類方法前加synchronized修飾

面向物件程式設計基礎（java）

面向物件程式設計基礎 1.1 面向物件概述 在程式開發初期，大家使用的是結構化開發語言，也就是面向過程（opp），但隨著市場需求劇增，軟體的規模也越來越大，結構化語言的弊端也暴露出來。 開發週期無休止的拖延，軟體質量也越來越差。 為了更好的適應市場，有人就開始以另一種開發思想引入程式中，也就是面向物件的開發思

重走Java基礎：面向物件-抽象類（abstract）

抽象類，什麼是抽象類？ 1. 抽象類的產生 當編寫一個類時，我們往往會為該類定義一些方法，這些方法是用來描述該類的功能具體實現方式，那麼這些方法都有具體的方法體。 但是有的時候，某個父類只是知道子類應該包含怎麼樣的方法，但是無法準確知道子類如何實現這些方法。比如一個圖形類應該有一

java核心技術（8）第四章

1、面向過程程式設計：演算法+資料=程式 面向物件程式設計：資料+演算法=程式（更容易掌握，理解，找bug） 2、封裝（encapsulation） 關鍵在於絕對不能讓類中的方法直接方位其他類的例項域。程式僅通過方法與物件的資料交付。 這是提高重用性和可靠性的關鍵。

java核心技術（8）異常

異常： 程式錯誤導致的異常屬於RuntimeExcepiton 如果出現RuntimeException異常，那麼就一定是你的問題！ error和RuntimeException稱為未檢查異常，其他的稱為已檢查異常，編譯器將檢查是否為所有已檢查異常提供了異常處理器

java核心技術（8）泛型程式設計

泛型程式設計（Generic programming） 意味著編寫的程式碼可以被很多不同型別的物件所重用。 比雜亂的使用Object物件然後再進行強制型別轉換具有更好的可讀性和安全性。尤其對於集合。 public static <T extends Comparab

java:面向物件-多型（PolyMorphic）概述

package day09; /* * A:多型（PolyMorphic）概述 * 事物存在多種形態 * B:多型前提 * a:要有繼承關係 * b:要有方法重寫 * c:要有父類引用指

Java面向物件——String類（二）

String類的常用方法及基本使用 1.charAt(int index)：返回指定索引處的char值 package m10d27; public class String_3 { publ

Java面向物件程式設計思想（一）

宣告：學基礎，在校學生，本文所有內容來自純書本，然後通過自己的理解和參考編寫而來，如有說的不對的地方，歡迎評論指錯！（僅做學習交流） 類和物件的建立 類的建立:（public private protected）+ class + 類名 { <類

Java面向物件設計模式（十三）——策略模式（strategy）

策略模式（strategy） 策略模式定義了一系列演算法，並將每個演算法封裝起來，使他們可以相互替換，且演算法的變化不會影響到使用演算法的客戶。         一種方法是 需要設計一個介面，為

java面向物件面試題（2）

1) 給定如下java程式碼程式片斷：        class A{               public A(){                      System.out.pri

Java面向物件設計模式（一）——工廠方法模式

工廠方法模式（Factory Method） 工廠方法模式分為三種： 1、普通工廠模式，就是建立一個工廠類，對實現了同一介面的一些類進行例項的建立。首先看下關係圖： 舉例如下：（我們舉一個傳送郵件和簡訊的例子） 首先，建立二者的共同介面： publici

用Java實現面向物件程式設計(入門)（四）

四、■介面1、介面中的屬性都是全域性靜態常量，介面中的方法都是全域性抽象方法，介面中沒有構造方法。  ★Java中實現介面的定義語法和類實現介面的語法如下：∵[修飾符] interface 介面名 extends 父介面1，父介面2，……｛//常量定義//方法定義 ｝∴cl

Java基礎-面向物件-簡單總結（2）

面向物件：    Java是一種面向物件的語言，優點：1，系統結構穩定。2.子系統相對獨立。3.軟體可重用性，可維護性和可拓展性強。    面向物件的三大特徵：封裝，繼承，多型。    物件：描述客觀事物的實體。    類：具有相同屬性物件的集合。類中定義了物件將會有的屬性（

JAVA面向物件學習筆記（一）

1、方法： 1）方法不能獨立定義，方法只能在類體裡定義； 2）從邏輯意義上看，方法要麼屬於該類本身，要麼屬於該類的一個物件； 3）永遠不能獨立執行方法，只想方法必須使用類或物件作為呼叫者； 4）static修飾的方法不能訪

深入理解Flink核心技術（轉載）

優點 流程圖 align 優化器 red 興趣 hdf 定義 lin 作者：李呈祥 Flink項目是大數據處理領域最近冉冉升起的一顆新星，其不同於其他大數據項目的諸多特性吸引了越來越多的人關註Flink項目。本文將深入分析Flink一些關鍵的技術與特性，希望能夠幫助讀者對

Hibernate 核心技術（一）

配置 color lac 持久 relation 實體 true obj 輕量級 簡介 Hibernate是一個開源的對象關系映射（ORM）框架。對JDBC進行了非常輕量級的對象封裝。 將對象和數據庫表建立映射關系，Hibernate框架使用在數據持久化層（da

淺談對Js面向物件的理解（1）

    面向物件的語言有一個標誌，那就是它們都有類的概念，通過類來建立任意多個具有相同屬性和方法的物件。它是一種程式開發的方法，它將物件作為程式的基本單元，將邏輯和資料封裝其中，以提高程式碼的靈活性、重用性和擴充套件性。物件是把資料及對資料的操作方法放在一起，作為一個相互依存的整體。簡單的