【172天】黑馬程序員27天視頻學習筆記【Day10】

時間 2021-08-12

標籤 java 程序員學習 this 命令行 code 視頻對象繼承接口欄目快樂工作简体版

原文原文鏈接

【172天】黑馬程序員27天視頻學習筆記【Day10】

叨逼叨兩句

我勒個去，不要小看這一天的內容啊，真特麼多，看來我Java繼承還真挺通常的，還要繼續努力！

明天覆習這10天內容。

10-（01-05）：package與import

package關鍵字概述及做用

就是文件夾
按功能劃分或者按模塊劃分
增刪改查

包的定義及注意事項

package語句在java文件中只能有一個
若是沒有package，默認表示沒有包名
package語句必須是程序的第一條可執行代碼
該視頻值得在看一遍

帶包的類編譯和運行

用javac編譯test.java應該這樣：javac -d . test.java這樣編譯後生成的class文件路徑將是com/heima/test.class。
.表明當前目錄，這裏也能夠改爲別的目錄。
要運行這樣一個文件，須要在建立這個包的目錄打開命令行運行`java
com.heima.test`

package com.heima;

public class test {

}

該視頻值得在看一遍

import關鍵字的概述和使用

做用：讓那些帶包的類，對調用其的類可見

package com.heima;
import com.baidu.Person;
class Test {
    public static void main(String[] args) {
        Person a = new Person();
        System.out.println(a.getName());
    }
}

package com.baidu;
class Person {
    private String name;
    
    public String getName(){
        return name;
    } 
}

*通配符開發通常不用，由於它須要檢索，挨個匹配，下降效率。

10-（06-07）

權限修飾符權限說明

本類   同一個包下(子類和無關類)  不一樣包下(子類)    不一樣包下(無關類)
private        Y       
默認(default)   Y         Y
protected      Y         Y                    Y
public         Y         Y                    Y               Y

修飾符使用一覽

修飾符類別

權限修飾符：private、default、protected、public
狀態修飾符：static、final
抽象修飾符：abstract

類

權限修飾符：default、public（經常使用）
狀態修飾符：final
抽象修飾符：abstract

成員變量

權限修飾符：private（經常使用）、default、protected、public
狀態修飾符：static、final
抽象修飾符：無

成員方法

權限修飾符：private、default、protected、public
狀態修飾符：static、final
抽象修飾符：abstract

構造方法

權限修飾符：private、default、protected、public
狀態修飾符：無
抽象修飾符：無

其它組合規則

成員變量：public static final
成員方法：java
1. public static
2. public abstract
3. public final
abstract和final、static、private不可同時使用

10-（08-16）內部類

內部類概述及訪問特色

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

外部類要訪問內部類的成員，必須建立對象。程序員

外部類.內部類 p = 外部類對象.內部類對象

package test_heima_08;

public class Test_Demo07 {
    public static void main(String[] args){
        Outer.Inner p = new Outer().new Inner();
        p.test();
    }
}


class Outer {
    class Inner {
        public void test(){
            System.out.println("Hello");
        }
    }
}

私有成員內部類的調用方法

在外部類裏面建立一個成員方法，而後在該成員方法內建立對象調用內部類的方法。學習

package test_heima;

public class Test_Demo08 {
    public static void main(String[] args){
        Outer2 a = new Outer2();
        a.kkk();
        
    }
}

class Outer2 {
    private int age = 1;
    
    private class Inner2 {
        public void test(){
            System.out.println("test");
        }
    }

    public void kkk(){
        Inner2 a = new Inner2();
        a.test();
    }
}

靜態內部類的調用

package test_heima;

public class Test_Demo09 {
    public static void main(String[] args){
        
        //外部類.內部類 對象名 = 外部類名.內部類對象
        //其實邏輯上應該是 Outer3.Inner oi = Outer3.new Inner();
        //可是這樣寫不符合習慣，全部仍是把new放左邊了
        Outer3.Inner oi = new Outer3.Inner();
        oi.method();
        
        //外部類名.內部類名.方法名
        Outer3.Inner.method2();
    }
}

class Outer3 {
    static class Inner {
        public void method() {
            System.out.println("非靜態方法調用");
        }
        
        public static void method2() {
            System.out.println("靜態方法調用");
        }
    }
}

內部類成員對不一樣成員變量的調用（重要！！！）

package test_heima;

public class Test_Demo10 {
    public static void main(String[] args){
        Outer4.Inner oi = new Outer4().new Inner();
        oi.show();
    }
}

class Outer4 {
    public int a = 3;
    class Inner {
        public int a = 2;
        public void show(){
            int a = 1;
            System.out.println(a);
            System.out.println(this.a);
            System.out.println(Outer4.this.a);
        }
    }
}

局部內部類裏面的方法調用方式

局部內部類開發用的不多

局部內部類裏面的方法調用方式this

package test_heima;

public class Test_Demo11 {
    public static void main(String[] args){
        Outer6 p = new Outer6();
        p.method();
    }
}

class Outer6 {
    
    public void method(){
        
        class Inner {
            public void test(){
                System.out.println("Hello");
            }
        }
    
        Inner si = new Inner();
        si.test();
        
    }
}

局部內部類訪問局部變量的方式

在JDK1.7中，局部內部類訪問他所在的方法中的局部變量時，須要加上final修飾符。可是JDK1.8中不須要了，估計是個bug。
局部內部類訪問他所在的方法中的局部變量必須用final修飾，爲何？由於調用這個方法時，局部變量若是沒有final修飾符修飾，其生命週期和方法相同，將會隨着方法的彈棧而消失，那麼若局部內部類的對象尚未從堆中消失，想要使用這個局部變量，就沒有了，但若加上final，在類加載時，該常量將會進入常量池，即便方法彈棧，常量池的常量還在，也能夠繼續使用。

package test_heima;

public class Test_Demo12 {
    public static void main(String[] args){
        Outer7 a = new Outer7();
        a.method();
    }
}

class Outer7 {
    public void method(){
        
        int a = 1; //在JDK1.7中這樣寫不行，須要加final，讓局部變量進入常量池，保證在方法彈棧後，對象依然能夠訪問。
        
        class Inner {
            public void test(){
                System.out.println(a);
            }
        }
        
        Inner si = new Inner();
        si.test();
    }
}

匿名內部類的使用格式和理解

匿名內部類是內部類的簡化寫法
匿名內部類是局部內部類的一種，必須寫在方法裏。
前提：存在一個類（方便匿名內部類繼承，這個類能夠是具體類，也能夠是抽象類）或者接口（方便匿名內部類實現）

格式：命令行

new 類名或者接口名(){
    重寫方法;
}

本質：一個繼承成了該類或者實現了該接口的子類匿名對象。

package test_heima;

public class Test_Demo13 {
    public static void main(String[] args){
        Outer8 si = new Outer8();
        si.method();
    }
}

interface Inter {
    public void test();
}

class Outer8 {
    class Inner implements Inter {
        public void test(){
            System.out.println("Hello");
        }
    }
    
    public void method(){
        //如何調用test（）？
        //法1:有名字a
//        Inner a = new Inner();
//        a.test();
        
        //法2：匿名
        new Inter(){
            public void test(){
                System.out.println("Hello");
            }
        }.test();
        
    }
    
}

匿名內部類重寫多個方法的狀況

匿名內部類適用於一次性使用，屢次調用建議使用有名的內部類。code

package test_heima;

public class Test_Demo14 {
    public static void main(String[] args){
        Outer11 si = new Outer11();
        si.method();
    }
}

interface Inter2 {
    public void print1();
    public void print2();
}

class Outer11 {
    public void method(){
        
        //這樣屢次調用使用匿名內部類並不方便，建議屢次調用使用有名的內部類。
        new Inter2(){
            public void print1(){
                System.out.println("print1");
            }
            
            public void print2(){
                System.out.println("print2");
            }
        }.print1();
        
        new Inter2(){
            public void print1(){
                System.out.println("print1");
            }
            
            public void print2(){
                System.out.println("print2");
            }
        }.print2();
    }
}

能夠將父類引用指向子類對象，可是，因爲匿名對象沒類名，沒法實現向下轉型，因此沒法使用子類特有的方法。視頻

package test_heima;

public class Test_Demo14 {
    public static void main(String[] args){
        Outer11 si = new Outer11();
        si.method();
    }
}

interface Inter2 {
    public void print1();
    public void print2();
}

class Outer11 {
    public void method(){
        
        
        Inter2 p = new Inter2(){ //這個匿名內部類其實至關於一個實現了Inter2接口的子類匿名對象
            public void print1(){
                System.out.println("print1");
            }
            
            public void print2(){
                System.out.println("print2");
            }
            
            public void print3(){  //這個子類特有的方法無法使用
                System.out.println("print3");
            }
        };
        
        p.print1();
        p.print2();
        //p.print3();//沒法使用子類特有方法
        
        
    }
}

匿名內部類在開發中的應用

用來傳遞參數

package test_heima;

//如何調用PersonDemo中的method方法
public class Test_Demo15 {
    public static void main(String[] args){
        //法1：使用多態
//        PersonDemo a = new PersonDemo();
//        a.method(new Student());
        
        //法2：使用匿名內部類
        PersonDemo a = new PersonDemo();
        a.method(new Person(){
            public void talk(){
                System.out.println("Hello1");
            }
        });
    }
}

abstract class Person {
    public void talk(){}
}

class PersonDemo {
    public void method(Person p){
        p.talk();
    }
}

//法1：使用多態
class Student extends Person {
    public void talk(){
        System.out.println("Hello");
    }
}

練習

這集視頻值得再看一遍

package test_heima;

public class Test_Demo16 {
    public static void main(String[] args){
        Outer33.method().show();
    }
}

interface Inter33 {
    void show();
}

class Outer33 {
    //補齊代碼
    public static Inter33 method(){ //返回Inter33接口的子類對象
        return new Inter33(){
            public void show(){
                System.out.println("HelloWorld");
            }
        };
    }
}

//控制檯輸出"HelloWorld"