1、
構造方法沒有返回型別，類方法有。
2、
類方法 static 所有物件
3、
繼承：extends

引用
/*
 *如程式碼，問題:
h4所指向的物件和h2所指向的物件，是否是同一個物件？
 */
package basis;

public class Hero 
{
    public String name;
    protected float hp;
    
    public static void main(String[]args)
    {//建立物件並使用一個“引用”來指向這個物件。
        Hero h1 = new Hero();
        Hero h2 = new Hero();
        
        Hero h3 = h1;//h3指向h1所指的物件
        Hero h4 = h3;
        //h1,h3,h4 3個引用都指向同一個物件。
        
        h1.name = "garen";
        h2.name = "teemo";//物件例項化
        System.out.println(h4.name);
        System.out.println(h2.name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
繼承
extends
在LOL中，武器是物品的一種，也是有名稱和價格的
所以在設計類的時候，可以讓武器繼承物品，從而繼承名稱和價格屬性

/*
 *設計一個類Armor護甲
繼承Item類，並且額外提供一個屬性ac: 護甲等級 int型別

例項化出兩件護甲
名稱 價格 護甲等級
布甲 300 15
鎖子甲 500 40
 */
package basis;

//在第一個公共類裡面寫主類，新的類寫下面。方法寫裡面
public class Hero {
    public static void main(String[]args) {
        Armor cloth = new Armor();//類名
        cloth.name = "布甲";
        cloth.price = 300;
        cloth.ac = 15;
        
        //chain束縛，鏈條 ，mail郵寄 ，mailed 有甲殼的
        Armor chainMail = new Armor();
        chainMail.name = "鎖子甲";
        chainMail.price =500;
        chainMail.ac = 40;
        
        System.out.println(cloth.name + "   " +cloth.price + "   " + cloth.ac);
        System.out.println(chainMail.name + "   " +chainMail.price + "   " + chainMail.ac);
    }
}

//把新寫的類放在下面
class Item1{
    String name;
    int price;
}
class Armor extends Item1{
    int ac;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
方法過載
方法名是一樣的，但是引數型別不一樣
在呼叫方法attack的時候，會根據傳遞的引數型別以及數量，自動呼叫對應的

/*
 *設計一個類Support (輔助英雄)繼承Hero，提供一個heal(治療)方法
對Support的heal方法進行過載
heal() 
heal(Hero h) //為指定的英雄加血
heal(Hero h, int hp) //為指定的英雄加了hp的血
 */
//輔助英雄Support繼承Hero
class Support extends Hero{
    //方法過載
    public void heal() {
        System.out.println(name + "被一個不知名是好心人救了");
    }
    
    public void heal(Hero h1) {
        System.out.println(name + "為" +h1.name +"加血");
    }
    
    public void heal(Hero h1,int hp) {
        System.out.println(name + "為" +h1.name +"加了" +hp +"的血量");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
構造方法
通過一個類建立一個物件，這個過程叫做例項化
例項化是通過呼叫構造方法(又叫做構造器)實現的
構造方法沒有返回型別

/*
 *為Hero設計4個引數的構造方法
這四個引數分別是 
String heroName
float heroHP
float heroArmor
int heroMoveSpeed
 */
package basis;

public class heroTest {
    String name;
    float hp;
    float armor;
    int moveSpeed;
    //構造方法
    //和方法差不多，但是無返回值。
    public heroTest(String heroname,float heroHP,float heroArmor,int heroMoveSpeed) {
        name = heroname;
        hp = heroHP;
        armor = heroArmor;
        moveSpeed = heroMoveSpeed;
    }
    public static void main(String[] args) {
        heroTest garen = new heroTest("蓋倫",330,30,100);
        System.out.println(garen.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
類屬性(static)
1、當一個屬性被static修飾的時候，就叫做類屬性，又叫做靜態屬性
當一個屬性被宣告成類屬性，那麼所有的物件，都共享一個值
2、比如蓋倫的hp 和 提莫的hp 是不一樣的。
但是所有物件的類屬性的值，都是一樣的
3、Hero.copyright;

/*
 * 通過garen.copyright修改其值
 garen.copyright = "Blizzard Entertainment Enterprise";
 然後列印teemo.copyright，觀察是否有變化
 */
public class heroTest {
    public String name;
    float hp;
    static String copyright;//類屬性，靜態屬性
    
    public static void main(String[]args) {
        heroTest garen = new heroTest();
        //會有警告說，應該是Hero.copyright
        garen.copyright = "人民文學出版社版權所有";
        
        heroTest teemo = new heroTest();
        System.out.println(teemo.copyright);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
類方法
訪問一個物件方法，必須建立在有一個物件的前提的基礎上
訪問類方法，不需要物件的存在，直接就訪問
Math.random（）；

Q：什麼時候設計物件方法，什麼時候設計類方法
name屬性是物件屬性，只有存在一個具體物件的時候，name才有意義。 如果方法裡訪問了物件屬性，那麼這個方法，就必須設計為物件方法
功能性

public static void printGameDuration(){
        System.out.println("已經玩了10分50秒");
 }
1
2
3
package basis;
/*
 * 在一個類方法中，直接呼叫一個物件方法，
比如在battleWin中呼叫die()
能否直接呼叫？ 為什麼？
 */

public class Hero {
    public String name;
    //類方法是有返回值的
    public static void battleWin(){
        System.out.println("我贏了！！！");
        //不能直接呼叫，物件方法要有物件！
        //例項化一個物件，貌似就可以呼叫了
        Hero garen = new Hero();
        garen.die();
    }
    
    public void die(){
        System.out.println("我死了。");
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Hero.battleWin();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
屬性初始化
先後執行：
宣告> 塊 > 建構函式

package basis;
/*
 *物件屬性的初始化有三種方式
故意把初始化塊，放在構造方法下面，問題：

這三種方式，誰先執行？誰後執行？
 */

public class Hero {
    //1、宣告該屬性時初始化
    public float hp= 110; 
    //2、構造方法中初始化     
    public Hero(){
        hp = 220;
    }
    //3、塊初始化
    {
        hp = 330;
    }
    public static void main(String[]args){
        Hero garen = new Hero();
        System.out.println(garen.hp);
    }         
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
訪問修飾符
屬性通常使用private封裝起來（見private專題）
方法一般使用public用於被呼叫
會被子類繼承的方法，通常使用protected
4.簡單說, 能用private就用private，不行就放大一級==，用package,再不行就用protected，最後用public。 這樣就能把資料儘量的封裝起來，沒有必要露出來的，就不用露出來了

--------------------- 
作者：urnotbear 
來源：CSDN 
原文：https://blog.csdn.net/conan2017/article/details/85094842 
版權宣告：本文為博主原創文章，轉載請附上博文連結！