java day11【final、權限、內部類、引用類型】

第一章 final關鍵字

1.1 概述

學習了繼承後，咱們知道，子類能夠在父類的基礎上改寫父類內容，好比，方法重寫。那麼咱們能不能隨意的繼承 API中提供的類，改寫其內容呢？顯然這是不合適的。爲了不這種隨意改寫的狀況，Java提供了 final 關鍵字， 用於修飾不可改變內容。

final： 不可改變。能夠用於修飾類、方法和變量。

類：被修飾的類，不能被繼承。

方法：被修飾的方法，不能被重寫。

變量：被修飾的變量，不能被從新賦值。

1.2 使用方式

修飾類

格式以下：

final class 類名 {

}

查詢API發現像 public final class String 、 public final class Math 、 public final class Scanner 等，不少咱們學習過的類，都是被final修飾的，目的就是供咱們使用，而不讓咱們因此改變其內容。

修飾方法

格式以下：

修飾符 final 返回值類型 方法名(參數列表){

//方法體

}

重寫被 final 修飾的方法，編譯時就會報錯。

修飾變量

1. 局部變量——基本類型

基本類型的局部變量，被final修飾後，只能賦值一次，不能再更改。代碼以下：

public class FinalDemo1 {

public static void main(String[] args) {

// 聲明變量，使用final修飾

final int a;

// 第一次賦值

a = 10;

// 第二次賦值

a = 20; // 報錯,不可從新賦值

// 聲明變量，直接賦值，使用final修飾

final int b = 10;

// 第二次賦值

b = 20; // 報錯,不可從新賦值

}

}

思考，以下兩種寫法，哪一種能夠經過編譯？

寫法1：

final int c = 0;

for (int i = 0; i < 10; i++) {

c = i;

System.out.println(c);

}

寫法2：

for (int i = 0; i < 10; i++) {

final int c = i;

System.out.println(c);

}

根據 final 的定義，寫法1報錯！寫法2，爲何經過編譯呢？由於每次循環，都是一次新的變量c。這也是你們 須要注意的地方。

2. 局部變量——引用類型

引用類型的局部變量，被final修飾後，只能指向一個對象，地址不能再更改。可是不影響對象內部的成員變量值的 修改，代碼以下：

public class FinalDemo2 {

public static void main(String[] args) {

// 建立 User 對象

final User u = new User();

// 建立 另外一個 User對象

u = new User(); // 報錯，指向了新的對象，地址值改變。

// 調用setName方法

u.setName("張三"); // 能夠修改

}

}

3. 成員變量

成員變量涉及到初始化的問題，初始化方式有兩種，只能二選一：

顯示初始化；

public class User {

final String USERNAME = "張三";

private int age;

}

構造方法初始化。

public class User {

final String USERNAME ;

private int age;

public User(String username, int age) {

this.USERNAME = username;

this.age = age;

}

}

被final修飾的常量名稱，通常都有書寫規範，全部字母都大寫。

第二章 權限修飾符

2.1 概述

在Java中提供了四種訪問權限，使用不一樣的訪問權限修飾符修飾時，被修飾的內容會有不一樣的訪問權限

public：公共的。

protected：受保護的

default：默認的

private：私有的

2.2 不一樣權限的訪問能力

可見，public具備最大權限。private則是最小權限。

編寫代碼時，若是沒有特殊的考慮，建議這樣使用權限：

成員變量使用 private ，隱藏細節。

構造方法使用 public ，方便建立對象。

成員方法使用 public ，方便調用方法。

小貼士：不加權限修飾符，其訪問能力與default修飾符相同

第三章 內部類

1.1 概述

什麼是內部類

將一個類A定義在另外一個類B裏面，裏面的那個類A就稱爲內部類，B則稱爲外部類。

成員內部類

成員內部類 ：定義在類中方法外的類。

定義格式：

class 外部類 {

class 內部類{

}

}

在描述事物時，若一個事物內部還包含其餘事物，就可使用內部類這種結構。好比，汽車類 Car 中包含發動機 類 Engine ，這時， Engine 就可使用內部類來描述，定義在成員位置。

代碼舉例：

class Car { //外部類

class Engine { //內部類

}

}

訪問特色

內部類能夠直接訪問外部類的成員，包括私有成員。

外部類要訪問內部類的成員，必需要創建內部類的對象。

建立內部類對象格式：

外部類名.內部類名 對象名 = new 外部類型().new 內部類型()；

訪問演示，代碼以下：

定義類：

public class Person {

private boolean live = true;

class Heart {

public void jump() {

// 直接訪問外部類成員

if (live) {

System.out.println("心臟在跳動");

} else {

System.out.println("心臟不跳了");

}

}

}

public boolean isLive() {

return live;

}

public void setLive(boolean live) {

this.live = live;

}

}

定義測試類：

public class InnerDemo {

public static void main(String[] args) {

// 建立外部類對象

Person p = new Person();

// 建立內部類對象

Heart heart = p.new Heart();

// 調用內部類方法

heart.jump();

// 調用外部類方法

p.setLive(false);

// 調用內部類方法

heart.jump();

}

}

輸出結果:

心臟在跳動

心臟不跳了

內部類仍然是一個獨立的類，在編譯以後會內部類會被編譯成獨立的.class文件，可是前面冠之外部類的類名 和$符號 。

好比，Person$Heart.class

1.2 匿名內部類【重點】

匿名內部類 ：是內部類的簡化寫法。它的本質是一個 帶具體實現的 父類或者父接口的 匿名的 子類對象。 開發中，最經常使用到的內部類就是匿名內部類了。以接口舉例，當你使用一個接口時，彷佛得作以下幾步操做

1. 定義子類

2. 重寫接口中的方法

3. 建立子類對象

4. 調用重寫後的方法

咱們的目的，最終只是爲了調用方法，那麼能不能簡化一下，把以上四步合成一步呢？匿名內部類就是作這樣的快 捷方式。

前提

匿名內部類必須繼承一個父類或者實現一個父接口。

格式

new 父類名或者接口名(){

// 方法重寫

@Override

public void method() {

// 執行語句

}

};

使用方式

以接口爲例，匿名內部類的使用，代碼以下：

定義接口：

public abstract class FlyAble{

public abstract void fly();

}

建立匿名內部類，並調用：

public class InnerDemo {

public static void main(String[] args) {

/*

1.等號右邊:是匿名內部類，定義並建立該接口的子類對象

2.等號左邊:是多態賦值,接口類型引用指向子類對象

*/

FlyAble f = new FlyAble(){

public void fly() {

System.out.println("我飛了~~~");

}

};

//調用 fly方法,執行重寫後的方法

f.fly();

}

}

一般在方法的形式參數是接口或者抽象類時，也能夠將匿名內部類做爲參數傳遞。代碼以下：

public class InnerDemo2 {

public static void main(String[] args) {

/*

1.等號右邊:定義並建立該接口的子類對象

2.等號左邊:是多態,接口類型引用指向子類對象

*/

FlyAble f = new FlyAble(){

public void fly() {

System.out.println("我飛了~~~");

}

};

// 將f傳遞給showFly方法中

showFly(f);

}

public static void showFly(FlyAble f) {

f.fly();

}

}

以上兩步，也能夠簡化爲一步，代碼以下：

public class InnerDemo3 {

public static void main(String[] args) {

/*

建立匿名內部類,直接傳遞給showFly(FlyAble f)

*/

showFly( new FlyAble(){

public void fly() {

System.out.println("我飛了~~~");

}

});

}

public static void showFly(FlyAble f) {

f.fly();

}

}

第四章 引用類型用法總結

實際的開發中，引用類型的使用很是重要，也是很是廣泛的。咱們能夠在理解基本類型的使用方式基礎上，進一步 去掌握引用類型的使用方式。基本類型能夠做爲成員變量、做爲方法的參數、做爲方法的返回值，那麼固然引用類 型也是能夠的。

4.1 class做爲成員變量

在定義一個類Role（遊戲角色）時，代碼以下：

class Role {

int id; // 角色id

int blood; // 生命值

String name; // 角色名稱

}

使用 int 類型表示 角色id和生命值，使用 String 類型表示姓名。此時， String 自己就是引用類型，因爲使用 的方式相似常量，因此每每忽略了它是引用類型的存在。若是咱們繼續豐富這個類的定義，給 Role 增長武器，穿 戴裝備等屬性，咱們將如何編寫呢？

定義武器類，將增長攻擊能力：

class Weapon {

String name； // 武器名稱

int hurt； // 傷害值

}

定義穿戴盔甲類，將增長防護能力，也就是提高生命值：

class Armour {

String name；// 裝備名稱

int protect；// 防護值

}

定義角色類：

class Role {

int id；

int blood；

String name；

// 添加武器屬性

Weapon wp；

// 添加盔甲屬性

Armour ar；

// 提供get/set方法

public Weapon getWp() {

return wp;

}

public void setWeapon(Weapon wp) {

this.wp = wp;

}

public Armour getArmour() {

return ar;

}

public void setArmour(Armour ar) {

this.ar = ar;

}

// 攻擊方法

public void attack(){

System.out.println("使用"+ wp.getName() +", 形成"+wp.getHurt()+"點傷害");

}

// 穿戴盔甲

public void wear(){

// 增長防護,就是增長blood值

this.blood += ar.getProtect();

System.out.println("穿上"+ar.getName()+", 生命值增長"+ar.getProtect());

}

}

測試類：

public class Test {

public static void main(String[] args) {

// 建立Weapon 對象

Weapon wp = new Weapon("屠龍刀" , 999999);

// 建立Armour 對象

Armour ar = new Armour("麒麟甲",10000);

// 建立Role 對象

Role r = new Role();

// 設置武器屬性

r.setWeapon(wp);

// 設置盔甲屬性

r.setArmour(ar);

// 攻擊

r.attack();

// 穿戴盔甲

r.wear();

}

}

輸出結果:

使用屠龍刀,形成999999點傷害

穿上麒麟甲 ,生命值增長10000

類做爲成員變量時，對它進行賦值的操做，實際上，是賦給它該類的一個對象。

4.2 interface做爲成員變量

接口是對方法的封裝，對應遊戲當中，能夠看做是擴展遊戲角色的技能。因此，若是想擴展更強大技能，咱們在 Role 中，能夠增長接口做爲成員變量，來設置不一樣的技能。

定義接口：

// 法術攻擊

public interface FaShuSkill {

public abstract void faShuAttack();

}

定義角色類：

public class Role {

FaShuSkill fs;

public void setFaShuSkill(FaShuSkill fs) {

this.fs = fs;

}

// 法術攻擊

public void faShuSkillAttack(){

System.out.print("發動法術攻擊:");

fs.faShuAttack();

System.out.println("攻擊完畢");

}

}

定義測試類：

public class Test {

public static void main(String[] args) {

// 建立遊戲角色

Role role = new Role();

// 設置角色法術技能

role.setFaShuSkill(new FaShuSkill() {

@Override

public void faShuAttack() {

System.out.println("縱橫天下");

}

});

// 發動法術攻擊

role.faShuSkillAttack();

// 更換技能

role.setFaShuSkill(new FaShuSkill() {

@Override

public void faShuAttack() {

System.out.println("逆轉乾坤");

}

});

// 發動法術攻擊

role.faShuSkillAttack();

}

}

輸出結果:

發動法術攻擊:縱橫天下

攻擊完畢

發動法術攻擊:逆轉乾坤

攻擊完畢

咱們使用一個接口，做爲成員變量，以便隨時更換技能，這樣的設計更爲靈活，加強了程序的擴展性。 接口做爲成員變量時，對它進行賦值的操做，實際上，是賦給它該接口的一個子類對象。

4.3 interface做爲方法參數和返回值類型

當接口做爲方法的參數時,須要傳遞什麼呢？當接口做爲方法的返回值類型時，須要返回什麼呢？對，其實都是它的 子類對象。 ArrayList 類咱們並不陌生，查看API咱們發現，實際上，它是 java.util.List 接口的實現類。所 以，當咱們看見 List 接口做爲參數或者返回值類型時，固然能夠將 ArrayList 的對象進行傳遞或返回。

請觀察以下方法：獲取某集合中全部的偶數。

定義方法：

public static List<Integer> getEvenNum(List<Integer> list) {

// 建立保存偶數的集合

ArrayList<Integer> evenList = new ArrayList<>();

// 遍歷集合list,判斷元素爲偶數,就添加到evenList中

for (int i = 0; i < list.size(); i++) {

Integer integer = list.get(i); if (integer % 2 == 0) {

evenList.add(integer);

}

}

/*

返回偶數集合 

由於getEvenNum方法的返回值類型是List,而ArrayList是List的子類,

因此evenList能夠返回

*/

return evenList;

}

調用方法：

public class Test {

public static void main(String[] args) {

// 建立ArrayList集合,並添加數字

ArrayList<Integer> srcList = new ArrayList<>();

for (int i = 0; i < 10; i++) {

srcList.add(i);

}

/*

獲取偶數集合

由於getEvenNum方法的參數是List,而ArrayList是List的子類,

因此srcList能夠傳遞

*/

List list = getEvenNum(srcList);

System.out.println(list);

}

}

接口做爲參數時，傳遞它的子類對象。

接口做爲返回值類型時，返回它的子類對象。

第五章 綜合案例——發紅包【界面版】

紅包文化源遠流長。從古時的紅色紙包，到手機App中的手氣紅包，紅包做爲一種獨特的中華文化傳承至今。以前 的課程中，咱們也編寫過程序，模擬發普通紅包。那麼今天，咱們將整合基礎班課程中全部的技術和知識，編寫一 個帶界面版的 發紅包 案例。

目前，咱們還沒有學習過任何與界面相關的類。因此，界面相關代碼，已經給出。請運用所學技術分析並使用。

案例需求

分析並使用已給出的類，編寫程序，設置紅包類型。

小貼士

紅包類型：

1. 普通紅包：金額均分。不能整除的，餘額添加到最後一份紅包中

2. 手氣紅包：金額隨機。各個紅包金額累和與總金額相等。

紅包場景：

此案例是模擬羣主給羣成員發紅包，羣主本身打開最後一個紅包的場景。

案例分析

已知的類：

1. RedPacketFrame ：一個抽象類，包含了一些屬性，是紅包案例的頁面。

public abstract class RedPacketFrame extends JFrame {

/* ownerName : 羣主名稱 */

public String ownerName = "誰誰誰誰";

/* openMode : 紅包的類型 [普通紅包/手氣紅包] */

public OpenMode openMode = null;

/** * 構造方法:生成紅包界面.

* @param title 頁面的標題

. */

public RedPacketFrame(String title) {

super(title);

init();// 頁面相關的初始化操做

}

/* set方法 */

public void setOwnerName(String ownerName) {

this.ownerName = ownerName;

}

public void setOpenMode(OpenMode openMode) {

this.openMode = openMode;

}

}

2. OpenMode ：一個接口，包含一個分配方法，用來指定紅包類型。

public interface OpenMode {

/** * @param totalMoney 總金額,單位是"分"。總金額爲方便計算,已經轉換爲整數,單位爲分。

* @param count 紅包個數

* @return ArrayList<Integer> 元素爲各個紅包的金額值,全部元素的值累和等於總金額.

*

* 請將totalMoney,分紅count分,保存到ArrayList<Integer>中,返回便可.

*/

public abstract ArrayList<Integer> divide(int totalMoney, int count);

}

案例實現

環境搭建：

1. 建立項目：名稱自定義，建議爲 RedPacketDemo 。

2. 導入圖片：將 pic 目錄，導入項目中，與 src 目錄平級

3. 導入已知類：在 src 下建立一個包，名字自定義，建議爲 known ，將類 RedPacketFrame 、接口 OpenMode 拷入。

代碼實現：

1. 定義 RedPacket 類，繼承 RedPacketFrame ，代碼以下：

public class RedPacket extends RedPacketFrame {

public RedPacket(String title) {

super(title);

}

}

2. 定義測試類，建立 RedPacket 對象，代碼以下

public class RedPacketTest {

public static void main(String[] args) {

RedPacket rp = new RedPacket("大紅包");

}

}

運行代碼，打開一個發紅包的頁面。能夠輸入總金額，紅包個數，留言信息。

點擊 塞錢進紅包 按鈕，跳轉到下一頁面。

           

點擊 誰誰誰誰 和 開 ，兩個區域，發現能夠設置兩項內容：

誰誰誰誰 ：表示羣主在發紅包，可設置羣主名稱。經過此方法，熟悉類結構，直接調用父類的方法。

開 ：表示打開紅包，跳轉到下一頁面。可是開啓以前，必須先設置紅包的類型，不然沒法開啓。

3. RedPacket 對象，設置羣主名稱。

setOwnerName（String ownerName） ，是字符串做爲參數。咱們只須要傳遞一個字符串便可。

public class RedPacketTest {

public static void main(String[] args) {

// 建立紅包對象

RedPacket rp = new RedPacket("大紅包");

// 設置羣主名稱

rp.setOwnerName("我是羣大大");

}

}

4. RedPacket 對象，設置紅包類型。

setOpenMode(OpenMode openMode) ，是接口做爲參數。咱們必須定義接口的實現類，重寫接口中方法，並傳 遞實現類對象到 setOpenMode 方法中，方可設置完成。再觀察接口：

public interface OpenMode {

/** * @param totalMoney 總金額,單位是"分"。總金額爲方便計算,已經轉換爲整數,單位爲分。

* @param count 紅包個數

* @return ArrayList<Integer> 元素爲各個紅包的金額值,全部元素的值累和等於總金額. *

* 請將totalMoney,分紅count分,保存到ArrayList<Integer>中,返回便可.

*/

public abstract ArrayList<Integer> divide(int totalMoney, int count);

}

5. 普通紅包，打開方式 Common ，代碼以下：

public class Common implements OpenMode {

@Override

public ArrayList<Integer> divide(int totalMoney, int count) {

// 建立保存各個紅包金額的集合

ArrayList<Integer> list = new ArrayList<>();

// 定義循環次數,總個數‐1次

int time = count ‐ 1;

// 一次計算,生成平均金額

int money = totalMoney / count;

// 循環分配

for (int i = 0; i < time; i++) {

// 添加到集合中

list.add(money);

// 總金額扣除已分配金額 

totalMoney ‐= money;

}

// 剩餘的金額,爲最後一個紅包

list.add(totalMoney);

System.out.println("普通紅包金額:" + list);

// 返回集合

return list;

}

}

6. 發普通紅包，代碼以下：

public class RedPacketTest {

public static void main(String[] args) {

// 建立紅包對象

RedPacket rp = new RedPacket("大紅包");

// 設置羣主名稱

rp.setOwnerName("我是羣大大");

// 設置紅包類型

rp.setOpenMode(new Common());// 普通紅包

}

}

7. 手氣紅包【重點】

本質上，手氣紅包就是把總金額 totalMoney 隨機分紅指定的 count 份，因此必須規定每一份金額的取值範圍。如 果範圍過小，可能致使後分配紅包金額特別大。反之範圍太大，可能致使後分配紅包金額爲0，不夠分。可見，取 值範圍的定義規則，是手氣紅包的關鍵所在。

咱們規定：每一份隨機金額範圍（除最後一份），最小值爲1，最大值爲當前剩餘平均金額的2倍 ，單位爲"分"。

計算公式：

當前剩餘平均金額 = 剩餘總金額 / 剩餘紅包個數

舉例：總額爲50元，發5個紅包。

小貼士：爲方便表格中進行運算，此處，單位爲"元"。程序中，建議換算爲"分"進行運算。

手氣紅包，打開方式 Lucky ，代碼以下：

public class Lucky implements OpenMode {

@Override

public ArrayList<Integer> divide(int totalMoney, int count) {

// 建立保存各個紅包金額的集合

ArrayList<Integer> list = new ArrayList<>();

// 定義循環次數,總個數‐1次

int time = count ‐ 1;

// 建立隨機數對象

Random random = new Random();

// 循環分配

for (int i = 0; i < time; i++) {

/*

* 每次從新計算,生成隨機金額

* 隨機範圍: totalMoney / count* 2,totalMoney不斷的減小,

* count也不斷的減小,因此這是一個可變化的範圍.

*/

int money = random.nextInt(totalMoney / count * 2) + 1;

// 金額添加到集合

list.add(money);

// 總金額扣除已分配金額

totalMoney ‐= money;

// 紅包個數‐1

count‐‐;

}

// 剩餘的金額,爲最後一個紅包

list.add(totalMoney);

return list;

}

}

8. 發手氣紅包，代碼以下：

public class RedPacketTest {

public static void main(String[] args) {

// 建立紅包對象

RedPacket rp = new RedPacket("大紅包");

// 設置羣主名稱

rp.setOwnerName("我是羣大大");

// 設置紅包類型,二選一

// rp.setOpenMode(new Common()); // 普通紅包

rp.setOpenMode(new Lucky()); // 手氣紅包

}

}

案例總結

經過 發紅包 案例，你都學到了什麼呢？請你思考以下問題：

1. 基礎語法，你是否清晰？

2. 一些基本的類的方法，你是否可以調用？

3. 案例中哪裏體現了繼承，繼承的做用是什麼？ 

4. 接口做爲參數，如何使用？

5. 接口做爲成員變量，如何使用？

6. 如何簡化接口的使用方式？