Java物件導向編程

標籤：錯誤   類的方法   間接   extend   一個   3.3   就是   res   第一條   

一、類和對象對象

對象——用來描述一個客觀事物的實體，由一組屬性和方法構成；

屬性——對象具有的各種你特徵，比如收銀員的年齡、身高、體重；

方法——對象執行的操作，比如收銀員收銀、列印賬單、刷卡等；

類   ——具有相同屬性和方法的一組對象的集合；類是對象的抽象，對象是類的具體；

類的方法——用來完成某個特定的應用程式功能，並返回結果；

public class Visitor {  //建立一個類     public String name;     public int age;    // 定義方法    public void bookTicket(){        if(age >= 20 && age < 65){            System.out.println(name + "的年齡是" + age + ",全票為20￥");        }else if(age >= 12 && age < 20 ){            System.out.println(name + "的年齡是" + age + ",半票票為10￥");        }else{            System.out.println(name + "的年齡是" + age + ",可免費參觀");        }    }}

public class VistorTest {    public static void main(String[] args){        Scanner scanner = new Scanner(System.in);        String visName = "";        int visAge = 0;        do{            System.out.print("請輸入姓名:");            visName = scanner.next();            System.out.print("請輸入年齡:");            visAge = scanner.nextInt();            Visitor v = new Visitor();            v.age = visAge;            v.name = visName;            v.bookTicket();        } while(!"n".equals(visName));        scanner.close();    }}

方法傳參（記憶體配置）

基礎資料型別 (Elementary Data Type)：在棧中進行分配；變數名指向具體的數值；變數在聲明之後java就會立刻分配給他記憶體空間；基本類型之間的賦值是建立新的拷貝；“==”和“!=”是在比較值；基本類型變數建立和銷毀很快； 引用資料類型：在堆中進行分配,堆的讀寫速度遠不及棧；變數名指向存資料對象的記憶體位址,即變數名指向hash值；它以特殊的方式(類似C指標)指向對象實體（具體的值），這類變數聲明時不會分配記憶體，只是儲存了一個記憶體位址；對象之間的賦值只是傳遞引用；“==”和“!=”是在比較兩個引用是否相同，需要自己實現equals()方法；類對象需要JVM去銷毀；

構造方法

每個類都有一個預設的構造方法，如上常式序， 這種方法固定繁瑣；使用帶參構造方法就方便許多，編寫了構造方法之後，會取代類預設的構造方法；

 

public class Voter {    private static int count;    private static final int total = 100;    private String name;    public Voter(String name){        this.name = name;    }    ......          }

public class main {    public static void main(String[] args) {        Voter zhang=new Voter("張三");        Voter li = new Voter("李四");        Voter wang = new Voter("王舞");        ......    }}

 方法重載

public class Add {    public int addSum(int num1, int num2){        return (num1 + num2);    }    public int addSum(int num1, int num2, int num3){        return (num1 + num2 + num3);    }    public double addSum(double num1, double num2){        return (num1 + num2);    }    public double addSum(double num1, double num2, double num3){        return (num1 + num2 + num3);    }}

public class Calc {    public static void main(String [] ages){        int [] a = new int[5];        int [] s = new int[9];        Add sum = new Add();        System.out.println(sum.addSum(2.2, 3.3));        System.out.println(sum.addSum(3, 5));        System.out.println(sum.addSum(3, 5, 3.3));        System.out.println();    }}

this關鍵字

調用屬性

this.health = 170;this.name = "張三”

調用方法

this.print();

調用構造方法

this();         // 如果使用，必須是構造方法中的第一條語句this(“小黑”, 100, 100, “雄”); 

二、封裝和繼承 封裝

封裝就是講某些資訊影藏在類內部，不讓外部程式直接存取，而是通過該類提供的方法來實現對內部影藏資訊的操作和訪問；

封裝的好處：防止屬性被錯誤修改；有利於提高系統之間的松耦合，提高系統的獨立性；提高軟體的可重用性；降低構建大型系統的風險；

封裝原則：①把儘可能多的東西藏起來，對外提供介面；②把所有的屬性隱藏起來；

封裝步驟：①修改屬性的可見度（設為private）；②建立公有的getter/setter方法；③在getter/setter方法中加入屬性控制語句；

/** * 標準javaBean的建立過程 */public class JavaBean {    // 第一步：建立私人屬性    private String name;    private int ID;    private int age;    private String address;    // 第二步：生產getter和setter方法    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getID() {        return ID;    }    public void setID(int ID) {
　　　　　if (ID < 0)
　　　　　　　ID = 0        this.ID = ID;    }    public int getAge() {        return age;    }    public void setAge(int age) {
　　　　 if (age < 0)
　　　　 　　age = 0        this.age = age;    }    public String getAddress() {        return address;    }    public void setAddress(String address) {        this.address = address;    }    // 第三步：建立無參建構函式和有參建構函式    public JavaBean() {    }    public JavaBean(String name, int ID, int age, String address) {        this.name = name;        this.ID = ID;        this.age = age;        this.address = address;    }    @Override    public String toString() {        return "JavaBean{" +                "name=‘" + name + ‘\‘‘ +                ", ID=" + ID +                ", age=" + age +                ", address=‘" + address + ‘\‘‘ +                ‘}‘;    }}

包的使用

JDK包提供：①java.lang：虛擬機器自動引入；② java.util：提供一些實用類；③ java.io：輸入、輸出； 

為了使用不在同一個包中的其他類，需要在程式中使用 import 關鍵字匯入這個類；

package com.ibeifeng.java.oop.javabean;import com.ibeifeng.java.oop.buytickets.Visitor;     // 匯入buyticket包中的Visitor類public class User {    public static void main(String [] args){        Visitor user = new Visitor();        user.name = "李四";        user.age = 22;        user.bookTicket();        // 當前包與匯入包如果有重名，name都要使用全路徑，        // 如果不使用全路徑，那麼預設的是匯入的類；//        Visitor user1 = new Visitor();        com.ibeifeng.java.oop.javabean.Visitor user1 = new com.ibeifeng.java.oop.javabean.Visitor();        user1.name = "張三";        user1.age = 55;        user1.bookTicket();    }}

 成員變數存取權限控制

通過關鍵字修飾變數，從而控制存取權限

三、繼承和多態static關鍵字

 靜態變數在記憶體中只有一塊控制項，而實際變數，每次案例都會重新開闢記憶體空間；

當靜態變數不同時，根據定義順序先後執行；

當靜態變數和代碼快中的變數相同時，先定義再賦值；

執行個體方法可以直接調用靜態方法，但靜態方法不能直接調用執行個體方法，必須使用new執行個體化後，在調用。執行個體方法中不能定義靜態變數，

 靜態代碼塊：初始化靜態變數

構造方法：初始化執行個體變數

 繼承

把共性或重複的屬性方法單獨提取出來，用類來封裝，對於個性則不提取，各自保留；

繼承就是把父類的所有屬性和方法繼承過來；

被繼承的類是父類，主動繼承的類是子類，子類（A）使用關鍵字extends繼承父類（B）

單根性——java中只支援單根繼承，即一個類智能有一個直接父類

public class A extends B（）{}     // A繼承父類B

傳遞性——A繼承B，B繼承C，那麼A繼承了C，即一個類可以間接有多個父類

子類可以繼承父類，並且可以有自己的特性，但是父類不可以繼承子類

this：本類對象

super：父類對象

 當執行個體化子類時，都會先執行父類的無參構造方法

如果父類有有參建構函式，則必須顯示提供無參建構函式；

指定調用父類的有參建構函式，使用 super 關鍵字：

Public A（string name){　　super(“小王”）；          　　System.out.println("子類的有參構造方法：” + name）；  }

super關鍵字來訪問父類的成員：

　　super只能出現在子類的方法和構造發放中；

　　super調用構造方法時，只能是第一句；

　　super不能訪問父類的 private 的成員；

 

四、抽象類別和介面

 

 

五、異常

 

Java物件導向編程