java學習day13——final關鍵字、內部類

final關鍵字

final關鍵字代表最終，不可改變的。
常見四種用法：

1. 可以用來修飾一個類

含義：當前類不能有任何的子類（太監類）
注意：一個類如果是final的，那麼其中所有成員方法無法進行覆蓋重寫（因爲沒兒子）

public final class MyClass {
    public void method(){
        System.out.println("方法執行!");
    }
}

2. 可以用來修飾一個方法

當final關鍵字用來修飾一個方法時，這個方法就是最終方法，也就是不能覆蓋重寫
注意事項：對於類、方法來說，abstract關鍵字和final關鍵字不能同時使用，因爲矛盾。

public class Fu {
    public final void method(){
        System.out.println("父類方法執行");
    }
}

3. 可以用來修飾一個局部變量

當final關鍵字修飾一個局部變量時，該局部變量就永遠不能進行更改

public class Demo01Final {
    public static void main(String[] args) {
        final int num1 = 10;//num1不能進行更改
        //正確寫法，只要保證唯一一次賦值即可
        final int num2;
        num2 = 20;
        //對於基本類型來說，不可改變變量中的數據不可改變
        //對於引用類型來說，不可改變是變量當中的地址值不可改變
        final Student stu2 = new Student("高圓圓");
        // 錯誤寫法!final的引用類型變量，其中的地址不可改變
//        stu2 = new Student("趙又廷");
        // 正確寫法，內容可以改變
        stu2.setName("趙又廷");
    }
}

Java中基本類型和引用類型的區別

4. 可以用來修飾一個成員變量

成員變量用final修飾後也不可變
注意：
a. 由於成員變量有默認值，所以用了final之後必須手動賦值
b. 對於final的成員變量，要麼使用直接賦值，要麼通過構造方法賦值。（二者選其一）
c. 必須保證類當中所有重載的構造方法，都最終會對final成員變量進行賦值。

public class Person {
    private final String name/*="鹿晗"*/;

    public Person() {
        name = "關曉彤";
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

Java中四種權限修飾符

/*
Java中有四種權限修飾符
                   public  >   protected >   (default)   >   private
同一個類(我自己)      YES           YES           YES            YES
同一個包(我鄰居)      YES           YES           YES             NO
不同包子類(我兒子)    YES           YES            NO             NO
不同包非子類(陌生人)  YES            NO            NO             NO
(default)是根本不寫
 */

內部類

如果一個事物的內部包含另一個事物，那麼這就是一個類內部包含另一個類
例如：身體和心臟的關係
分類：

1. 成員內部類
2. 局部內部類（包含匿名內部類）

成員內部類

Body類

public class Body { //外部類
    public class Heart{ //成員內部類
        public void beat(){
            System.out.println("心臟跳動");
            System.out.println("我叫"+name); //正確寫法
        }
    }
    // 外部類的成員變量
    private String name;
    // 外部類的方法
    public void methodBody(){
        System.out.println("外部類方法");
        new Heart().beat();

    }

    public String getName() {
        return name;
    }

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

main方法

/*
成員內部類的定義格式：
修飾符 class 外部類名稱{
    修飾符 class 內部類名稱）{
        // ...
    }
    // ...
}
注意：內用外，隨意訪問；外用內，需要藉助內部類對象
=====================
如何使用成員內部類？有兩種方法:
1. 間接方式：再外部類的方法中，使用內部類，然後main只是調用外部類的方法
2. 直接方式：公式：
外部類名稱.內部類名稱 對象名 = new 外部類名稱().new 內部類名稱();
 */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        //間接方式：再外部類的方法中，使用內部類，然後main只是調用外部類的方法
        body.methodBody();
        System.out.println("================");
        // 直接方式
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

內部類的同名變量訪問

public class Outer {
    int num = 10;
    public class Inner{
        int num = 20;
        public void methodInner(){
            int num = 30;
            System.out.println(num);//局部變量，就近原則
            System.out.println(this.num);//內部類的成員變量
            System.out.println(Outer.this.num);//外部類的成員變量
        }
    }
}

局部內部類

/*
如果一個類是定義在一個方法內部的，那麼這就是一個局部內部類
“局部”：只有當前所屬的方法才能使用它，出了這個方法就不能用了
定義格式：
修飾符 class 外部類名稱{
    修飾符 返回值類型 外部類方法名稱（參數列表）{
        class 局部內部類名稱{
            // ...
        }
    }
}
定義一個類的時候，權限修飾符規則：
1. 外部類：public / (default)
2. 成員內部類：public / protected / (default) / private
3. 局部內部類：什麼都不能寫
 */
public class Outer {
    public void methodOuter(){
        class Inner{
            int num = 10;
            public void methodInner(){
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}

局部內部類的final問題

局部內部類：如果希望訪問所在方法的局部變量，那麼這個局部變量必須是【有效final的】
備註：從java8開始，只要局部變量事實不變，那麼final關鍵字可以省略
原因：

1. new出來的對象在堆內存中
2. 局部變量是跟着方法走的，在棧內存中
3. 方法運行結束後，立即出棧，局部變量就會立刻消失
4. 但是new出來的對象會在堆當中持續存在，知道垃圾回收爲止

匿名內部類（重點）

/*
如果接口的實現類，或父類的子類，只需使用唯一的一次，
那麼這種情況下就可以省略掉該類的定義，而改爲使用【匿名內部類】
匿名內部類的定義格式
接口名稱 對象名 = new 接口名稱(){
    // 覆蓋重寫所有抽象方法
};

對格式“new 接口名稱(){...}”進行解析
1. new代表創建對象的動作
2. 接口名稱就是匿名內部類需要實現哪個接口
3. {...}則纔是匿名內部類的內容

另外還需要注意幾點問題：
1. 匿名內部類，在創建對象的時候，只能使用唯一一次。
如果希望多次創建對象且類的內容一樣，就必須使用單獨定義的實現類
2. 匿名對象，在【調用方法】的時候，只能調用唯一一次
如果希望同一個對象，調用多次方法，那麼必須給對象七個名字
3. 匿名內部類是省略了【實現類/子類名稱】，但是匿名對象是省略了【對象名稱】
強調：匿名內部類和匿名對象不是一回事
 */
public class DemoMain {
    public static void main(String[] args) {
        // 使用匿名內部類
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名內部類實現了方法");
            }
        };
        //既是匿名內部類，也是匿名對象
        obj.method();//匿名內部類實現了方法
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名內部類實現了方法");
            }
        }.method();
    }
}

類作爲成員變量類型

public class Hero {
    private String name; //英雄姓名
    private int age; //英雄年齡
    // 類做成員變量
    private Weapon weapon; //武器

    public void attack(){
        System.out.println(age+"歲的"+name+"在用"+weapon.code+"攻擊敵人");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

weapon類做hero類的成員變量

public class Weapon {
    public String code;//武器代號

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

public class DemoMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        Weapon weapon = new Weapon("AK-47");
        hero.setName("亞瑟");
        hero.setAge(20);
        hero.setWeapon(weapon);
        hero.attack();//20歲的亞瑟在用AK-47攻擊敵人
    }
}

接口做成員變量

public class Hero {
    private String name; //英雄姓名
    private Skill skill;

    public void attack(){
        System.out.println("我叫"+name+",開始施放技能");
        skill.use();
        System.out.println("施放技能完成");
    }

    public String getName() {
        return name;
    }

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

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

接口

public interface Skill {
    void use();
}

接口實現類

public class SkillImpl implements Skill {
    @Override
    public void use() {
        System.out.println("biu~biu~biu");
    }
}

main方法

public class DemoMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("亞瑟");
        // 設置英雄技能
        hero.setSkill(new SkillImpl());
        hero.attack();

        // 還可以改成使用匿名內部類
        Skill skill = new SkillImpl(){
            @Override
            public void use() {
                System.out.println("pia~biu~pia~biu");
            }
        };
        hero.setSkill(skill);
        hero.attack();

        // 進一步簡化，同時使用匿名內部類和匿名對象
        hero.setSkill(new SkillImpl(){
            @Override
            public void use() {
                System.out.println("pia~pia~pia");
            }
        });
        hero.attack();
    }
}

接口作爲方法的參數或返回值

import java.util.ArrayList;
import java.util.List;
/*
java.util.List證實ArrayList所實現的接口
 */
public class DemoInterface {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//多態寫法
        List<String> result = addName(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }
    public static List<String> addName(List<String> list){
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        return list;
    }
}