、面向對象基礎

• 類與對象
• 封裝
• 構造方法
• 方法
• 重載
• 對象數組
• this關鍵字
• static關鍵字

1.1類與對象

類：類是抽象的，概念上的，共性的，是對象的模板

對象：個體，具體的，可以看見的，對象是個性的，是該類事物的每個個體，也稱為類的實例。

類的組成：

• 方法
• 屬性

對象的創建

• 類名 對象名= new 類名（）

對象的引用傳遞問題

• 註意引用的是對象堆內存的空間

1.2封裝

面向對象的特性：封裝，繼承，多態

封裝的概念：使用private實現類的封裝，用private關鍵字修飾屬性，修飾方法，private的含義是私有的，使用private修飾的方法和屬性不能被外部直接訪問。

封裝的特性：通過使用封裝的屬性，要通過get,set方法來獲得和設值。

1.3構造方法的問題

構造方法的作用：構造方法的作用主要是用來構造對象並且為對象的屬性賦值。構造方法的定義規則：

• 無需任何的放回值類型
• 方法名稱必須和類重名

1.4方法

方法的定義

public|private|protected|默認  + static|默認|synchroized|native|abstract+返回值類型|void|空+方法名稱（參數）+ throws Exception{
   方法體

}

方法的調用：

• 如果是普通方法，通過對象去調用
• 如果是構造方法，通過實例化去調用
• 如果是靜態方法，可以通過類名直接訪問

2.4對象數組

以類作為數組的類型，以對象作為數組的元素

Person p[] = new Person[10];//一類作為數組的類型,元素就是對象
        for (int j = 0; j < p.length; j++) {
            Person px = new Person("張三",20+j);
            p[j] = px;
        }
        
        for (int j = 0; j < p.length; j++) {
            Person per = p[j];
            System.out.println(per.getName()
 
+"===="+per.getAge());

        }

2.5方法的重載

在同一個類中，方法的名稱相同，返回值的類型相同，但是參數的個數，類型，順序不同就叫做重載，重載是面向對象多態性的一個體現。

//吃飯
    public void eat(){
        System.out.println(name + "在吃飯");
    }
    public void eat(int x){
        System.out.println(name + "在吃飯，吃了"+ x +"碗。");
    }

2.6this的關鍵字的用法

this關鍵字可以表示當前對象

this關鍵字可以表示當前類的屬性

this關鍵字可以表示調用當前類的方法

this關鍵字調用當前類的構造方法

2.7static關鍵字

• static變量的聲明和使用
• static方法的聲明及使用
• static方法塊的聲明及使用

static變量：使用static修飾的變量就叫做靜態變量

static方法：使用static修飾的方法就叫做靜態方法

public class OopDemo01 {
    static int score = 70;//靜態變量
    double salary = 5000.00;//普通變量
    public static void add(){//靜態方法
        //eat();靜態方法中不能調用非靜態方法
        System.out.println(score);
        //System.out.println(salary);靜態方法不能調用非靜態變量
    }
    public void eat(){//普通方法
        add();//非靜態方法可以調用靜態方法
        System.out.println(score);//普通方法可以調用靜態變量
        System.out.println(salary);
    }
    public static void main(String[] args) {
        
    }

對於靜態方法調用的問題

• 靜態方法中不能調用非靜態方法，靜態方法不能調用非靜態變量
• 非靜態方法可以調用靜態方法，普通方法可以調用靜態變量

棧：保存屬性（變量）名稱

堆：保存屬性（變量）值

全局數據區： static修飾的變量

全局代碼區：static修飾的方法

• 　　代碼塊：使用一對{}圍起來的就是代碼塊：
• 普通代碼塊：寫在方法中的語句
• 構造塊（實例塊）：直接寫在類中的語句，優於構造方法先執行，在實例化多個對象的時候，構造塊執行多次
• 靜態塊：直接寫在類中，使用static修飾，是優於構造塊先執行，在實例化多個對象的時候，靜態塊只執行一次

面向對象高級部分

• 繼承
• 抽象類
• 接口
• 多態

2.1繼承

繼承的作用：

• 通過繼承可以簡化子類的定義
• 擴展子類的功能

子類通過extends關鍵字繼承父類

繼承的特點：子類可以繼承父類一切非私有的屬性和方法

繼承的規定：

• java只支持單繼承，一個類不能同時有多個父類（一個人只有一個父親一樣）
• java支持多層繼承，一個類繼承自父類，父類也可以自爺爺類

子類的實例化過程：實例化子類對象的時候會先調用父類的構造方法，說明父類也進行了實例化對象操作，實際上調用父類的構造方法構造父類對象就是為子類對象開辟空間，而且可以為父類的屬性初始值。

super關鍵字的使用：父類也稱為超類（）

• super關鍵字可以調用父類的屬性（非私有）
• super可以調用父類的方法（非私有）
• super關鍵字可以調用父類的構造方法（必須放在首行）

方法的復寫（）

方法的重寫的定義：方法的返回值的類型，方法名稱，方法裏的參數的個數，順序，類型一致，就是方法的復寫，子類復寫父類的方法，調用子類的方法，擴展父類的屬性，復寫分類的方法子類的訪問權限必須要大於等於父類的方法，父類的方法不能為private。

復寫和重載的區別：

訪問修飾符

public|private|protected|默認  + static|默認|synchroized|native|abstract+返回值類型|void|空+方法名稱（參數）+ throws Exception{
   方法體

}

2.3抽象類

final :在java中final可以修飾變量方法，類

• 使用final修飾的變量就是常量，只能賦值一次，而且常量一般使用大寫字母來表示常量名稱。
• 使用final修飾的方法不能被子類復寫
• 使用final修飾的就是太監類，不能擁有子類
• 抽象類：使用abstract修飾的類就是抽象類
• 抽象方法：使用abstract修飾的方法就是抽象方法

package com.wanczy.oopHightLevelDemo;

public abstract class OopDemo003 {//定義就是抽象類
    
    public abstract void eat();//聲明抽象方法
    
}

抽象方法只需要聲明不需要實現，有一個抽象方法必須定義為抽象類

抽象類和普通類相比區別：抽象類比普通類多了抽象方法，普通類中的所有定義都可以在抽象類中使用

抽象類的使用規則：

• 抽象類本身不能實例化
• 抽象類中的抽象方法只需要聲明，不需要實現
• 含有抽象方法的類必須聲明為抽象類
• 抽象類必須要有子類，不然抽象類沒有任何意義，抽象類的子類必須要復寫抽象類中的全部抽象方法。
• 抽象類中可以有抽象方法
• 抽象類中不可以用final聲明

範例：現在有兩類員工，一類是技術類，一類是銷售類，兩種員工的提升工資的方式不一樣，技術員工類按照崗位等級提升，銷售員工按照上一年度銷售業績來提升工資

package com.wanczy.abstractDemo;

public abstract class Employee {
    private String name;
    private double salary;//工資
    
    public Employee() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Employee(String name, double salary) {
        super();
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public abstract void updSalary();//提升工資的抽象方法
}

package com.wanczy.abstractDemo;

public class TechEmployee extends Employee{
    private String post;//崗位等級
    @Override
    public void updSalary() {
        // TODO Auto-generated method stub
        double salary = super.getSalary();
        if(this.post .equals("高級工程師")){
            super.setSalary(salary*1.05);
            
        }else if(this.post.equals("中級工程師")){
            super.setSalary(salary*1.1);
        }else if(this.post.equals("初級工程師")){
            
            super.setSalary(salary*1.15);
        }
        
    }
    public String getPost() {
        return post;
    }
    public void setPost(String post) {
        this.post = post;
    }
    public TechEmployee(String post) {
        super();
        this.post = post;
    }
    public TechEmployee() {
        super();
        // TODO Auto-generated constructor stub
    }
    public TechEmployee(String name, double salary,String post) {
        super(name, salary);
        this.post = post;
        // TODO Auto-generated constructor stub
    }
    
    
    
}

package com.wanczy.abstractDemo;

public class OopDemo01 {
    public static void main(String[] args) {
        Employee e = new SaleEmployee("長桑",3000,100);
        e.updSalary();
        System.out.println(e.getSalary());
    }
}    

通過以上程序，我們可以發現，如果以後出現其他的員工類型，提升工資的方式不同，可以編寫抽象類的字類完成，不需要更改頂層設計。也就是說抽象類的作用就是在於可以方便程序的擴展。 　　

2.4接口

接口的聲明使用interface，接口只有常量和抽象方法；

package com.wanczy.oopDemo;

public interface InterfaceDemo01 {
    //常量
    //抽象方法
    public abstract void eat();
    public abstract void run();
}

如果說一個抽象類只有抽象方法和常量的話，我們就可以使用接口來表示。接口中沒有子類的概念，實現類，實現類通過implements實現接口，必須覆寫接口中所有的抽象方法。

接口的使用規則：

• 接口中訪問權限永遠都是public，public可以省列，省列後依然時public
• 接口中的方法都是抽象方法，可以省列abstract，省列後依然是abstract方法
• 接口中的常量可以省列final，省列後依然是常量
• 接口在程序中叫實現，接口必須通過實現類實現，也必須要有實現類，不然接口沒有意義
• 接口本身不能實例化
• 接口與接口之間可以繼承，一個接口可以同時繼承多個父接口，子接口中繼承了父接口中所有抽象方法和常量
• 實現類也可以實現多個接口，如果實現的多個接口中，有相同的抽象方法，那麽實現類只需要復寫一次

抽象類與接口的區別

2.7多態

多態的核心就是子類對象作為父類對象來使用，抽象類的子類對象作為抽象類對象使用，實現類對象作為接口的對象來使用。

3總結

理解抽象類和接口的區別

理解重載和覆寫的區別

熟記繼承的特點以及規定（super關鍵字的使用）

java基礎（二）