2020-08-08--Java--day11【final、權(quán)限、內(nèi)部類】

final關(guān)鍵字

final關(guān)鍵字代表最終、不可改變的。

常見四種用法：

  1. 可以用來修飾一個類
  2. 可以用來修飾一個方法
  3. 還可以用來修飾一個局部變量
  4. 還可以用來修飾一個成員變量

1.final修飾類

當final關(guān)鍵字用來修飾一個類的時候，格式：、
public final class 類名稱 { // ... }

  • 含義：當前這個類不能有任何的子類。（太監(jiān)類）
  • 注意：一個類如果是final的，那么其中所有的成員方法都無法進行覆蓋重寫（因為沒兒子。）

final類---MyClass ：

public final class MyClass /*extends Object*/ {

    public void method() {
        System.out.println("方法執(zhí)行！");
    }

}

MySubClass 類：

// 不能使用一個final類來作為父類
public class MySubClass /*extends MyClass*/ {
}

不能繼承MyClass類，因為該類使用final修飾。

2.final修飾方法

對于一般的繼承關(guān)系的類，子類可以對父類的方法進行覆蓋重寫，但是如果在父類中，該成員方法使用final修飾時，會發(fā)生什么呢?

當final關(guān)鍵字用來修飾一個方法的時候，這個方法就是最終方法，也就是不能被覆蓋重寫。
格式：
修飾符 final 返回值類型 方法名稱(參數(shù)列表) { // 方法體 }

注意事項：
對于類、方法來說，abstract關(guān)鍵字和final關(guān)鍵字不能同時使用，因為矛盾。

  • abstract修飾的類或者方法，在子類中必須被重寫，除非該子類也是抽象類。
  • final修飾的類，沒有子類，修飾的方法，不能被重寫。
    所以這兩個關(guān)鍵字不能同時在一個類或者方法上使用。

Fu類：

public abstract class Fu {

    public final void method() {
        System.out.println("父類方法執(zhí)行！");
    }
    
    public abstract /*final*/ void methodAbs() ;

}

Zi類:

public class Zi extends Fu {
    @Override
    public void methodAbs() {
        System.out.println("methodAbs執(zhí)行");
    }

    // 錯誤寫法！不能覆蓋重寫父類當中final的方法
//    @Override
//    public void method() {
//        System.out.println("子類覆蓋重寫父類的方法！");
//    }
}

可以看出子類只能重寫普通的成員方法，不能重寫final修飾的方法。

而且如果abstract和final同時修飾methodAbs()的話，直接編譯報錯。
在Zi類中既不能重寫該方法，又必須重寫該方法。

3.final修飾局部變量

局部變量--基本數(shù)據(jù)類型

基本類型的局部變量，被final修飾后，只能賦值一次，不能再更改。

對于基本類型來說，不可變說的是變量當中的數(shù)據(jù)不可改變。

Demo01Final :

public class Demo01Final {

    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        num1 = 20;
        System.out.println(num1); // 20

        // 一旦使用final用來修飾局部變量，那么這個變量就不能進行更改。
        // “一次賦值，終生不變”
        final int num2 = 200;
        System.out.println(num2); // 200

//        num2 = 250; // 錯誤寫法！不能改變！
//        num2 = 200; // 錯誤寫法！

        // 正確寫法！只要保證有唯一一次賦值即可
        final int num3;
        num3 = 30;
}
}

也就是說final修飾的基本數(shù)據(jù)類型的局部變量的數(shù)值不能改變。

思考，如下兩種寫法，哪種可以通過編譯？
寫法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);
}

根據(jù) final 的定義，寫法1報錯！寫法2通過編譯。
為什么通過編譯呢？因為每次循環(huán)，都是一次新的變量c，而寫法一中的for循環(huán)中c為final修飾的變量，不能發(fā)生改變，這也是大家需要注意的地方。

局部變量--引用數(shù)據(jù)類型

引用類型的局部變量，被final修飾后，只能指向一個對象，地址不能再更改。但是不影響對象內(nèi)部的成員變量值的修改。

對于引用類型來說，不可變說的是變量當中的地址值不可改變.

Student 類：

public class Student {

    private String name;

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

Demo01Final :

public class Demo01Final {

    public static void main(String[] args) {

        // 對于引用類型來說，不可變說的是變量當中的地址值不可改變
        Student stu1 = new Student("趙麗穎");
        System.out.println(stu1);        //cn.itcast.day11.demo01.Student@49e4cb85
        System.out.println(stu1.getName()); // 趙麗穎
        stu1 = new Student("霍建華");
        System.out.println(stu1);         //cn.itcast.day11.demo01.Student@2133c8f8
        System.out.println(stu1.getName()); // 霍建華
        System.out.println("===============");

        final Student stu2 = new Student("高圓圓");
        // 錯誤寫法！final的引用類型變量，其中的地址不可改變
//        stu2 = new Student("趙又廷");
        System.out.println(stu2.getName()); // 高圓圓
        stu2.setName("高圓圓圓圓圓圓");
        System.out.println(stu2.getName()); // 高圓圓圓圓圓圓
    }
}

4.final修飾成員變量

對于成員變量來說，如果使用final關(guān)鍵字修飾，那么這個變量也照樣是不可變。

  1. 由于成員變量具有默認值，所以用了final之后必須手動賦值，不會再給默認值了。
  2. 對于final的成員變量，要么使用直接賦值，要么通過構(gòu)造方法賦值。二者選其一。
  3. 必須保證類當中所有重載的構(gòu)造方法，都最終會對final的成員變量進行賦值。

直接賦值：常用

public class User {
        final String USERNAME = "張三";
        private int age;

構(gòu)造方法賦值：

public class User {
        final String USERNAME ;
        private int age;
        public User(String username, int age) {
                this.USERNAME = username;
                this.age = age;
  }
}

Person類：

public class Person {

    private final String name/* = "鹿晗"*/;

    public Person() {
        this.name = "關(guān)曉彤";
    }

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

    public String getName() {
        return name;
    }
      //不能設(shè)置name的值，因為final修飾
//    public void setName(String name) {
//        this.name = name;
//    }
    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1.name);         //關(guān)曉彤
        Person p2 = new Person("lizhao");
        System.out.println(p2.name);          //lizhao

}
}

成員變量的初始化

  • 要么使用直接在定義變量時賦值
  • 要么在無參構(gòu)造方法中賦值
  • 要么在有參構(gòu)造中接受創(chuàng)建對象時傳進來的值。

注意：被final修飾的常量名稱，一般都有書寫規(guī)范，所有字母都大寫。

權(quán)限修飾符

在Java中提供了四種訪問權(quán)限，使用不同的訪問權(quán)限修飾符修飾時，被修飾的內(nèi)容會有不同的訪問權(quán)限，

  • public：公共的。
  • protected：受保護的
  • default：默認的
  • private：私有的

不同權(quán)限修飾符的訪問能力

訪問位置\修飾符 public protected default(空的) private
同一類中 √ √ √ √
同一包中(子類與無關(guān)類) √ √ √
不同包的子類 √ √
不同包中的無關(guān)類 √

可見，public具有最大權(quán)限。private則是最小權(quán)限。

編寫代碼時，如果沒有特殊的考慮，建議這樣使用權(quán)限：

  • 成員變量使用 private ，隱藏細節(jié)。
  • 構(gòu)造方法使用 public ，方便創(chuàng)建對象。
  • 成員方法使用 public ，方便調(diào)用方法。

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

內(nèi)部類

如果一個事物的內(nèi)部包含另一個事物，那么這就是一個類內(nèi)部包含另一個類。
例如：身體和心臟的關(guān)系。又如：汽車和發(fā)動機的關(guān)系。

分類：

  1. 成員內(nèi)部類
  2. 局部內(nèi)部類（包含匿名內(nèi)部類）

1.成員內(nèi)部類

1.成員內(nèi)部類概述

成員內(nèi)部類 ：定義在類中方法外的類。

成員內(nèi)部類的定義格式：

修飾符 class 外部類名稱 {
    修飾符 class 內(nèi)部類名稱 {
        // ...
    }
    // ...
}

訪問特點:

  • 內(nèi)部類可以直接訪問外部類的成員，包括私有成員。
  • 外部類要訪問內(nèi)部類的成員，必須要建立內(nèi)部類的對象。

內(nèi)用外，隨意訪問；外用內(nèi)，需要內(nèi)部類對象。

在描述事物時，若一個事物內(nèi)部還包含其他事物，就可以使用內(nèi)部類這種結(jié)構(gòu)。比如，汽車類 Car 中包含發(fā)動機類 Engine ，這時， Engine 就可以使用內(nèi)部類來描述，定義在成員位置。

class Car { //外部類
        class Engine { //內(nèi)部類
         }
}

2.成員內(nèi)部類的定義與使用

如何使用成員內(nèi)部類？有兩種方式：

    1. 間接方式：在外部類的方法當中，使用內(nèi)部類；然后main只是調(diào)用外部類的方法。
    1. 直接方式，公式：
      類名稱 對象名 = new 類名稱();
      【外部類名稱.內(nèi)部類名稱 對象名 = new 外部類名稱().new 內(nèi)部類名稱();】

代碼：

Body$Heart 內(nèi)部類：

 public class Body { // 外部類

    public class Heart { // 成員內(nèi)部類

        // 內(nèi)部類的方法
        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;
    }
}

由此可見在內(nèi)部類中可以直接訪問外部類的成員變量name。
main:

public class Demo01InnerClass {

    public static void main(String[] args) {
        Body body = new Body(); // 外部類的對象
        // 通過外部類的對象，調(diào)用外部類的方法，里面間接在使用內(nèi)部類Heart
        body.methodBody();
        System.out.println("=====================");

        // 按照公式寫：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }

}

總結(jié)：
成員內(nèi)部類的使用：

  • 在外部類中創(chuàng)建內(nèi)部類的對象，調(diào)用內(nèi)部類的方法或者變量
  • 直接創(chuàng)建內(nèi)部類的對象，進行操作。

內(nèi)部類仍然是一個獨立的類，在編譯之后會內(nèi)部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號 。
比如，Person$Heart.class

3.內(nèi)部類變量重名

如果出現(xiàn)了重名現(xiàn)象，那么格式是：外部類名稱.this.外部類成員變量名。

Outer $ Inner 內(nèi)部類：

public class Outer {
    int num = 10; // 外部類的成員變量

    public class Inner /*extends Object*/ {
        int num = 20; // 內(nèi)部類的成員變量

        public void methodInner() {
            int num = 30; // 內(nèi)部類方法的局部變量
            System.out.println(num); // 局部變量，就近原則
            System.out.println(this.num); // 內(nèi)部類的成員變量
            System.out.println(Outer.this.num); // 外部類的成員變量
        }
    }
}

main：

public class Demo02InnerClass {

    public static void main(String[] args) {
        // 外部類名稱.內(nèi)部類名稱 對象名 = new 外部類名稱().new 內(nèi)部類名稱();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}

運行：

2.局部內(nèi)部類

如果一個類是定義在一個方法內(nèi)部的，那么這就是一個局部內(nèi)部類。

“局部”：只有當前所屬的方法才能使用它，出了這個方法外面就不能用了。

定義格式：

修飾符 class 外部類名稱 {
    修飾符 返回值類型 外部類方法名稱(參數(shù)列表) {
        class 局部內(nèi)部類名稱 {
            // ...
        }
    }
}

實例：
Outer:

class Outer {

    public void methodOuter() {

        class Inner { // 局部內(nèi)部類
            int num = 10;
            public void methodInner() {
                System.out.println(num); // 10
            }
        }

        Inner inner = new Inner();
        inner.methodInner();
    }

}

main:

public class DemoMain {

    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.methodOuter();           //10
    }

}

小節(jié)一下類的權(quán)限修飾符：
public > protected > (default) > private
定義一個類的時候，權(quán)限修飾符規(guī)則：

  1. 外部類：public / (default)
  2. 成員內(nèi)部類：public / protected / (default) / private
  3. 局部內(nèi)部類：什么都不能寫

局部內(nèi)部類中的final問題

局部內(nèi)部類，如果希望訪問所在方法的局部變量，那么這個局部變量必須是【有效final的】。

備注：從Java 8+開始，只要局部變量事實不變，那么final關(guān)鍵字可以省略。

原因：

  1. new出來的對象在堆內(nèi)存當中。
  2. 局部變量是跟著方法走的，在棧內(nèi)存當中。
  3. 方法運行結(jié)束之后，立刻出棧，局部變量就會立刻消失。
  4. 但是new出來的對象會在堆當中持續(xù)存在，直到垃圾回收消失。
public class MyOuter {

    public void methodOuter() {
        int num = 10; // 所在方法的局部變量

        class MyInner {

            public void methodInner() {
                System.out.println(num);   //10
            }
        }
        //在成員方法中創(chuàng)建類對象，并調(diào)用成員方法
        MyInner mi = new MyInner();
        mi.methodInner();
    }
    
    //創(chuàng)建外部對象，調(diào)用成員方法
    public static void main(String[] args) {
        MyOuter mo = new MyOuter();
        mo.methodOuter();
    }

}

3.匿名內(nèi)部類

匿名內(nèi)部類 ：是內(nèi)部類的簡化寫法。它的本質(zhì)是一個 帶具體實現(xiàn)的 父類或者父接口的 匿名的 子類對象。
開發(fā)中，最常用到的內(nèi)部類就是匿名內(nèi)部類了。以接口舉例，當你使用一個接口時，似乎得做如下幾步操作。

  1. 定義子類
  2. 重寫接口中的方法
  3. 創(chuàng)建子類對象
  4. 調(diào)用重寫后的方法

我們的目的，最終只是為了調(diào)用方法，那么能不能簡化一下，把以上四步合成一步呢？匿名內(nèi)部類就是做這樣的快捷方式。

前提

匿名內(nèi)部類必須繼承一個父類或者實現(xiàn)一個父接口。

格式

匿名內(nèi)部類的定義格式：

接口名稱/父類名稱 匿名類對象名 = new 接口名稱/父類名稱() {
    // 覆蓋重寫所有抽象方法
};

匿名內(nèi)部類的內(nèi)容：

{
    // 覆蓋重寫所有抽象方法
}
實例：

MyInterface接口：

public interface MyInterface {

    void method1(); // 抽象方法
    void method2(); //抽象方法
}
按照正常的實現(xiàn)類對接口進行實現(xiàn):
public class testZi implements MyInterface {
    @Override
    public void method1() {
        System.out.println("111");
    }
    @Override
    public void method2() {
        System.out.println("222");
    }
}

main:

public class MainClass{
    public static void main(String[] args) {
        MyInterface obj = new testZi();
        obj.method1();       //111
        obj.method2();       //222
    }
}

很麻煩，所以我們直接使用匿名內(nèi)部類對接口進行實現(xiàn)。

匿名內(nèi)部類對接口進行實現(xiàn):

直接在main中寫接口的匿名內(nèi)部類即可：

public class testZi {

    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("111");
            }

            @Override
            public void method2() {
                System.out.println("222");
            }
        };
        obj.method1();       //111
        obj.method2();       //222
    }
}

這樣的話就不用在新建一個類來實現(xiàn)接口了。

匿名內(nèi)部類的注意事項

首先對

new 接口名稱/父類名稱() {
    // 覆蓋重寫所有抽象方法
};

進行解析：

  1. new代表創(chuàng)建對象的動作。
  2. 接口名稱就是匿名內(nèi)部類需要實現(xiàn)哪個接口
  3. {...}這才是匿名內(nèi)部類的內(nèi)容
注意問題
  1. 匿名內(nèi)部類，在【創(chuàng)建對象】的時候，只能使用唯一一次。
    如果希望多次創(chuàng)建對象，而且類的內(nèi)容一樣的話，那么就需要使用單獨定義的實現(xiàn)類了。

Mian函數(shù)：

public class MainClass{

    public static void main(String[] args) {
        //創(chuàng)建匿名類和匿名對象(obj1)
        MyInterface obj = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("111");
            }

            @Override
            public void method2() {
                System.out.println("222");
            }
        };
        obj.method1();       //111
        obj.method2();       //222
        
        //創(chuàng)建匿名類和匿名對象(obj2)
        MyInterface obj2 = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("112");
            }
            @Override
            public void method2() {
                System.out.println("223");
            }
        };
        obj2.method1();       //111
        obj2.method2();       //222
    }
}

匿名對象可以多次調(diào)用方法。

  1. 匿名對象，在【調(diào)用方法】的時候，只能調(diào)用唯一一次。
    如果希望同一個對象，調(diào)用多次方法，那么必須給對象起個名字。

首先匿名對象是創(chuàng)建的時候接口名稱/父類名稱 匿名類對象名 = new 接口名稱/父類名稱() { // 覆蓋重寫所有抽象方法 };中的【匿名類對象名】。
Main類：

public class MainClass {

    public static void main(String[] args) {
        //創(chuàng)建匿名類和匿名對象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("111");
            }

            @Override
            public void method2() {
                System.out.println("222");
            }
        }.method1();            //111

        //因為匿名對象無法調(diào)用第二次方法，所以需要再創(chuàng)建一個匿名內(nèi)部類的匿名對象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("112");
            }

            @Override
            public void method2() {
                System.out.println("223");
            }
        }.method2();           //223
        
    }
}
  • 創(chuàng)建匿名類，還省略了對象名稱，這種就是匿名對象
  • 上邊的那種使用匿名類，但是有匿名類對象的例如obj，obj2的是使用匿名類，但是不是匿名類對象。
  • 那么匿名對象只能調(diào)用一次方法。
  1. 匿名內(nèi)部類是省略了【實現(xiàn)類/子類名稱】，但是匿名對象是省略了【對象名稱】
    強調(diào)：匿名內(nèi)部類和匿名對象不是一回事！?。?/strong>
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

友情鏈接更多精彩內(nèi)容