面向物件（1）

創建及實體化物件

public class Item {
    //類屬性
    String name; //姓名
    int price; //價格
	
    //實體化物件
    public static void main(String[] args) {
        Item xuePing =  new Item();
        xuePing.name = "血瓶";
        xuePing.price = 50;      

        Item caoXie =  new Item();
        caoXie.name = "草鞋";
        caoXie.price = 300;    
    }
}

當一個變數被宣告在類下面，變數就叫做欄位或者屬性、成員變數、Field，其作用域就是從其宣告的位置開始的整個類
屬性的型別可以是基本屬性，比如int整數，float 浮點數也可以是型別別，比如String 字串
屬性名稱一般為小寫，當為多個單詞時后面單詞首字母大寫
new Item() 代表創建物件，而 Item xuePing = new Item() 代表參考xuePing指向物件，xuePing這個變數是Item型別

物件方法

public class Hero {
    String name; //姓名   
    float hp;//血量 
    float armor; //護甲    
    int moveSpeed; //移動速度
 
    //獲取護甲值，回傳值為float型別
    float getArmor(){
        return armor;
    }
     
    //回血
    void recovery(float blood){
        hp = hp + blood;
    }
    
    //增加移動速度，具有方法引數
    void addSpeed(int speed){
        //在原來的基礎上增加移動速度
        moveSpeed = moveSpeed + speed;
    }
    
    public static void main(String[] args){
        Hero garen = new Hero();
        garen.name = "蓋倫";
        garen.moveSpeed = 350;
        garen.addSpeed(100);
    }
     
}

方法主要用于表明物件功能，通常用函式表示
方法函式中可以有回傳值，回傳值型別記得與函式開頭保持一致；也可以有方法引數
- 如果一個變數，是宣告在一個方法上的，就叫做引數，引數的作用域為該方法內的所有代碼
宣告在方法內的變數，叫做區域變數，其作用域在宣告開始的位置，到其所處于的塊結束位置

繼承

//Armor類繼承了Item類及其屬性
public class Armor extends Item {
	int ac;//護甲等級
	
    //實體化物件
    public static void main(String[] args) {
        Armor buJia =  new Armor();
        buJia.name = "布甲";
        buJia.price = 300;  
        buJia.ac = 15;
        System.out.println(buJia.name);
        System.out.println(buJia.ac);

        Armor suoZiJia =  new Armor();
        suoZiJia.name = "鎖子甲";
        suoZiJia.price = 500; 
        suoZiJia.ac = 40;
        System.out.println(suoZiJia.name);
        System.out.println(suoZiJia.ac);
    }
}

繼承主要解決共性抽取
Armor通過繼承Item類，除了自己設計的ac屬性，也具備了name和price屬性
子類可以擁有父類中的內容，也可以有自己的內容
Java 繼承的三個特點：
- Java語言是單繼承的
- Java語言可以多級繼承
- 一個子類的父類是唯一的，但是一個父類可以擁有很多個子類

方法多載

public class Support extends Hero {
    
    //heal方法名一樣，但引數串列不同
	public void heal(){
		System.out.println(name + "提供治療");
	}

	//可變數量的引數，可使用操作陣列的方式處理引數heros
	public void heal(Hero...heros){
		for (int i = 0; i < heros.length; i++){
			System.out.println(name + "對" + heros[i].name + "進行了一次治療 " + "血量為：" + heros[i].hp);
		}	
	}
    
	public void heal(Hero h, float hp){
		System.out.println(h.name + "加血量為：" + hp + "血量為：" + (h.hp+hp));
	}
    
	public static void main(String[] args){
		Hero h1  = new Hero();
		h1.name = "蓋倫";
		h1.hp = 50;
		Hero h2 = new Hero();
		h2.name = "提莫";
		h2.hp = 40;
		Support h = new Support();
		h.name = "奶媽";
        //呼叫方法時，根據傳遞的引數型別以及數量，自動呼叫對應的方法
		h.heal();
		h.heal(h1, h2);
		h.heal(h1, 20);
		h.heal(h2, 30);
	}
}

方法的多載指的是方法名一樣，但是引數型別不一樣
采用可變數量的引數時只需要設計一個方法，public void attack(Hero ... heros) 即可代表上述所有的方法，在方法里使用操作陣列的方式處理引數heros
在呼叫方法的時候，會根據傳遞的引數型別以及數量，自動呼叫對應的方法

構造方法

public class Hero {
    String name;
    float hp;
    
    // 方法名和類名一樣（包括大小寫）
    // 沒有回傳型別
    public Hero() {
        System.out.println("實體化一個物件的時候，必然呼叫構造方法");
    }
    
    //有參的構造方法
    //上述默認的無參的構造方法就失效了
    //有參的構造方法可以簡化類的撰寫
    public Hero(String heroname){  
        name = heroname;
    }
    
    //當沒有撰寫任何構造方法，那么編譯器將會默認贈送一個構造方法，沒有引數和方法體，即
    //public Hero(){}
    
    public static void main(String[] args) {
        //實體化一個物件的時候，必然呼叫構造方法
        Hero garen =  new Hero("蓋倫");  
        Hero h = new Hero();//有參時此構造方法失效
    }
}

構造方法是專門用來創建物件的方法，當我們通過關鍵字new創建物件時，其實就是在呼叫構造方法
構造方法的名稱必須和所在類名稱完全一樣（包括大小寫）
構造方法不能return一個具體回傳值，所以構造方法不要寫回傳值型別，連void都不寫
如果沒有撰寫任何構造方法，那么編譯器將會默認贈送一個構造方法，沒有引數和方法體
一旦撰寫至少一個構造方法，那么編譯器將不再贈送
構造方法也可以進行多載

繼承中的構造方法

public class Hero {
    public Hero(){
        System.out.println("父類無參構造");
    }
    
    public Hero(int num){
        System.out.println("父類有參構造");
    }
}
//////////////////////////////////////
public class Support extends Hero{
    public Support(){
    	//當未呼叫父類構造方法時默認隱含super()
        //super();
        super(20);//根據有參無參呼叫父類不同的構造方法
        System.out.println("子類構造方法");
    }    
    public static void main(String[] arags){
  		Support h = new Support();
    }
}

子類構造方法中有一個默認隱含的 super() 呼叫，所以先呼叫父類構造，后執行子類構造
子類構造可以通過super關鍵字來呼叫父類多載構造
super的父類構造呼叫必須是子類構造方法的第一個陳述句，即不能一個子類構造呼叫多次super構造
- super關鍵字的用法：在子類成員方法中訪問父類成員變數或成員方法，在子類構造方法中訪問父類構造方法

private關鍵字

public class Hero {
	String name; //姓名   
    private float hp;//血量
    private float armor; //護甲    
    int moveSpeed; //移動速度
    
    //向armor設定數值
    public void setArmor(float num){
    	if(num < 0)
        	System.out.println("資料不合理");
        else
        	armor = num;
    }
    //獲取成員資料，回傳值為float型別
    public float getArmor(){
        return armor;
    }
     
    //向hp設定數值
    public void setHp(float num){
        if(num < 0)
        	System.out.println("資料不合理");
        else
        	hp = num;
    }
    
    //獲取成員資料，回傳值為float型別
    public float getHp(){
    	return hp;
    }
}

///////////////////////////////////////////////////////////

//Support繼承Hero同時，對成員變數進行了保護
public class Support extends Hero {
    
	//可變數量的引數，使用操作陣列的方式處理引數heros
	public void heal(Hero...heros){
		for (int i = 0; i < heros.length; i++){
			System.out.println(name + "對" + heros[i].name + "進行了一次治療 " + "血量為：" + heros[i].getHp());
		}	
	}
	public void heal(Hero h, float hp){
		System.out.println(h.name + "加血量為：" + hp + "血量為：" + (h.getHp()+hp));
	}
	public static void main(String[] args){
		Hero h1  = new Hero();
		h1.name = "蓋倫";
		h1.setHp(50);
		Hero h2 = new Hero();
		h2.name = "提莫";
		h2.setHp(40);
		Support h = new Support();
		h.name = "奶媽";
		h.heal(h1, h2);
		h.heal(h1, 20);
		h.heal(h2, 30);
	}
}

private關鍵字可以將需要保護的成員變數進行修飾，
一旦使用private進行修飾，那么本類中仍然可以隨意訪問，但超出本類范圍之外就不能隨意訪問，
需要間接訪問private成員變數，即定義一對Getter/Setter方法，命名規則為 setXxx 或 getXxx ，對于Getter來說不能有引數，回傳值型別和成員變數對應；對于Setter來說不能有回傳值，引數型別和成員變數對應，

this關鍵字

this即代表當前物件（通過誰呼叫方法，誰就是this）
當方法的區域變數和類的成員變數重名時，根據就近原則，優先使用區域變數，如果需要訪問本類中的成員變數可以通過 this.成員變數 訪問
```
//通過this訪問屬性
public void setName(String name){
    //name代表的是引數name
    //this.name代表的是屬性name
    this.name = name;
}
```
在本類成員方法中，呼叫另一個成員方法，可以使用 this.成員方法

在本類構造方法中，呼叫另一個構造方法，可以使用 this(...)

此呼叫也必須是構造方法的第一個陳述句，且super和 this兩種構造呼叫不能同時使用

public class Hero{
    public Hero(){
       //super();//同時呼叫會報錯，
        this(12);//可以通過this()呼叫有參構造方法
       // this(1, 2);//同時呼叫時會報錯，即必須是構造方法的第一個陳述句
    }
    public Hero(int i){
        this(1, 2);
    }
     public Hero(int i, int j){
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/188602.html

標籤：Java

上一篇：2020淘寶雙十一快速刷金幣工具

下一篇：Java學習-JDK動態代理