java學習（四）static靜態變量 和this

java中的this

/*
    this:是當前類的對象引用。簡單的記，它就代表當前類的一個對象。
    
        注意：誰調用這個方法，在該方法內部的this就代表誰。
        
    this的場景：
        解決局部變量隱藏成員變量
*/
//定義學生類
class Student {
    //姓名
    private String name;
    //年齡
    private int age;
    
    //姓名獲取值
    public String getName() {
        return name;
    }
    
    //姓名設置值
    public void setName(String name) { //name = "林青霞";
        //name = name; //變量的使用規則：就近原則
        //這里是類名，目前還沒有說過類似的用法，所以這個是有問題的
        //這里的調用只能通過對象名
        //這個對象如果存在，它應該代表的是Student的一個對象。
        //那么，誰能夠代表當前類的對象呢? java就提供了一個關鍵字 this
        //Student.name = name;
        this.name = name;
    }
    
    //年齡獲取值
    public int getAge() {
        return age;
    }
    
    //年齡賦值
    public void setAge(int age) {
        this.age = age;
    }
}

java中的static變量

/*
    static的特點：(它可以修飾成員變量，還可以修飾成員方法)
        A:隨着類的加載而加載
            回想main方法。
        B:優先於對象存在
        C:被類的所有對象共享
            舉例：咱們班級的學生應該共用同一個班級編號。
            其實這個特點也是在告訴我們什么時候使用靜態?
                如果某個成員變量是被所有對象共享的，那么它就應該定義為靜態的。
            舉例：
                飲水機(用靜態修飾)
                水杯(不能用靜態修飾)
        D:可以通過類名調用
            其實它本身也可以通過對象名調用。
            推薦使用類名調用。
            
            靜態修飾的內容一般我們稱其為：與類相關的，類成員
*/
class Student {
    //非靜態變量
    int num = 10;
    
    //靜態變量
    static int num2 = 20;
}

class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.num);
        
        System.out.println(Student.num2);
        System.out.println(s.num2);
    }
}

/*
    static關鍵字注意事項
        A:在靜態方法中是沒有this關鍵字的
            如何理解呢?
                靜態是隨着類的加載而加載，this是隨着對象的創建而存在。
                靜態比對象先存在。
        B:靜態方法只能訪問靜態的成員變量和靜態的成員方法
                靜態方法：
                    成員變量：只能訪問靜態變量
                    成員方法：只能訪問靜態成員方法
                非靜態方法：
                    成員變量：可以是靜態的，也可以是非靜態的
                    成員方法：可是是靜態的成員方法，也可以是非靜態的成員方法。
            簡單記：
                靜態只能訪問靜態。
*/
class Teacher {
    public int num = 10;
    public static int num2 = 20;
    
    public void show() {
        System.out.println(num); //隱含的告訴你訪問的是成員變量
        System.out.println(this.num); //明確的告訴你訪問的是成員變量
        System.out.println(num2);
        
        //function();
        //function2();
    }
    
    public static void method() {
        //無法從靜態上下文中引用非靜態 變量 num
        //System.out.println(num);
        System.out.println(num2);
        
        //無法從靜態上下文中引用非靜態 方法 function()
        //function();
        function2();
    }
    
    public void function() {
    
    }
    
    public static void function2() {
    
    }
}

class TeacherDemo {
    public static void main(String[] args) {
        //創建對象
        Teacher t = new Teacher();
        t.show();
        System.out.println("------------");
        t.method();
    }
}

java中的main方法

/*
    main方法的格式講解：
        public static void main(String[] args) {...}
        
        public:公共的，訪問權限是最大的。由於main方法是被jvm調用，所以權限要夠大。
        static:靜態的，不需要創建對象，通過類名就可以。方便jvm的調用。
        void:因為我們曾經說過，方法的返回值是返回給調用者，而main方法是被jvm調用。你返回內容給jvm沒有意義。
        main:是一個常見的方法入口。我見過的語言都是以main作為入口。
        String[] args:這是一個字符串數組。值去哪里了?
            這個東西到底有什么用啊?怎么給值啊?
                這個東西早期是為了接收鍵盤錄入的數據的。
                格式是：
                    java MainDemo hello world java
*/
class MainDemo {
    public static void main(String[] args) {
        //System.out.println(args); //[Ljava.lang.String;@175078b
        //System.out.println(args.length); //0
        //System.out.println(args[0]); //ArrayIndexOutOfBoundsException
        
        //接收數據后
        System.out.println(args); 
        System.out.println(args.length); 
        //System.out.println(args[0]); 
        for(int x=0; x<args.length; x++) {
            System.out.println(args[x]);
        }
    }
}

 同類中靜態方法調用非靜態方法

class ArrayDemo {
    public static void main(String[] args) {
        //定義數組
        int[] arr = {28,55,37,46,19};
    
        //靜態方法
        //printArray(arr);
        
        //非靜態方法
        //ArrayDemo ad = new ArrayDemo();
        //ad.printArray(arr);
        
        //測試類的作用：創建其他類的對象，調用其他類的功能。
        //而我們現在的操作是跟數組相關的，所以，你應該把這些操作定義到數組操作類中
        //定義一個數組的操作類
        //有了數組操作類之后的調用
        ArrayDemo at = new ArrayDemo();
        at.printArray(arr);
        
    }
    
    /*
    public static void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.println(arr[x]);
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
    */
    
    //假設該方法不是靜態的
    public void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.println(arr[x]);
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

java中在同一個文件夾下，類定義在兩個文件中和定義在一個文件中其實一樣的。

例如在同一個文件夾下有兩個文件 ArrayDemo.java 和ArrayTool.java

實例：

/*
    在同一個文件夾下，類定義在兩個文件中和定義在一個文件中其實一樣的。
*/
class ArrayDemo {
    public static void main(String[] args) {
        //定義數組
        int[] arr = {28,55,37,46,19};
        
        
        //方法改進為靜態后，就可以直接通過類名調用
        ArrayTool.printArray(arr);
    }
    
}

class ArrayTool {
    
    //把構造方法私有，外界就不能在創建對象了
    private ArrayTool(){}

    public static void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.println(arr[x]);
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}