[TOC]

成員變量與局部變量

• 成員變量與局部變量區別：
  • A：在類中的位置不同
    • 成員變量：在類中，方法外
    • 局部變量：在方法定義中或者方法聲明上。
  • B:在內存中的位置不同：
    • 成員變量：在堆內存
    • 局部變量：在棧內存
  • C:生命周期不同
    • 成員變量：隨著對象的創建而存在，隨著對象的消失而消失
    • 局部變量：隨著方法的調用而存在，隨著方法的調用完畢而存在
  • D:初始化值不同
    • 成員變量：有默認初始值
    • 局部變量：沒有默認初始值，必須定義，賦值，然后才能使用。
• 注：局部變量名稱可以和成員變量名稱一致，在方法中使用的時候，采用就近原則。

形式參數問題

• 一個方法的形式參數是一個類類型(引用類型)，這里其實需要的是該類的對象。

//形式參數是 基本類型
class Demo {
    public int sum(int a,int b) {
        return a + b;
    }
}

//形式參數是 引用類型
class Student {
    public void show() {
        System.out.println("我愛學習");
    }
}

class StudentDemo {
    //如果你看到了一個方法的形式參數是一個類類型(引用類型)，這里其實需要的是該類的對象。
    public void method(Student s) { 
    //調用的時候，把main方法中的s的地址傳遞到了這里 Student s = new Student();
        s.show();
    }
}

class ArgsTest {
    public static void main(String[] args) {
        //形式參數是基本類型的調用
        Demo d = new Demo();
        int result = d.sum(10,20);
        System.out.println("result:"+result);
        System.out.println("--------------");
        
        //形式參數是引用類型的調用
        //需求：我要調用StudentDemo類中的method()方法
        StudentDemo sd = new StudentDemo();
        //創建學生對象
        Student s = new Student();
        sd.method(s); //把s的地址給到了這里
    }
}

匿名對象

• 匿名對象：就是沒有名字的對象。
  • 是對象的一種簡化表示形式
• 匿名對象的兩種使用情況
  • 對象調用方法僅僅一次的時候
  • 作為實際參數傳遞
• 匿名調用好處
  • 匿名對象調用完畢就是垃圾?？梢员焕厥掌骰厥?。

class Student {
    public void show() {
        System.out.println("我愛學習");
    }
}

class StudentDemo {
    public void method(Student s) {
        s.show();
    }
}

class NoNameDemo {
    public static void main(String[] args) {
        //帶名字的調用
        Student s = new Student();
        s.show();
        s.show();
        System.out.println("--------------");

        //匿名對象
        //new Student();
        //匿名對象調用方法
        new Student().show();
        new Student().show(); //這里其實是重新創建了一個新的對象
        System.out.println("--------------");

        //匿名對象作為實際參數傳遞
        StudentDemo sd = new StudentDemo();
        //匿名對象
        sd.method(new Student());

        //再來一個
        new StudentDemo().method(new Student());
     }
}

封裝概述

• 封裝概述
  • 是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。
• 好處：
  • 隱藏實現細節，提供公共的訪問方式
  • 提高了代碼的復用性
  • 提高安全性。
• 封裝原則：
  • 將不需要對外提供的內容都隱藏起來。
  • 把屬性隱藏，提供公共方法對其訪問。
• 注：
  • 測試類一般只創建對象，調用方法。

private關鍵字

• private關鍵字：

  • 是一個權限修飾符,是封裝的一種體現。
  • 可以修飾成員(成員變量和成員方法)
  • 被private修飾的成員只在本類中才能訪問。

• private最常見的應用：

  • 把成員變量用private修飾
  • 提供對應的getXxx()/setXxx()方法
  • 一個標準的案例的使用

this關鍵字

• this:代表所在類的對象引用
• 記?。?
  • 方法被哪個對象調用，this就代表那個對象

class Student {
    //姓名
    private String name;
    //年齡
    private int age;
    
    //姓名獲取值
    public String getName() {
        return name;
    }
    
    //姓名設置值
    public void setName(String name) { //name = "林青霞";
        //Student.name = name;
        this.name = name;
    }
    
    //年齡獲取值
    public int getAge() {
        return age;
    }
    
    //年齡賦值
    public void setAge(int age) {
        this.age = age;
    }
}

//測試類
class StudentTest {
    public static void main(String[] args) {
        //創建學生對象
        Student s = new Student();
        
        //給成員變量賦值
        s.setName("林青霞");
        s.setAge(27);
        //獲取數據
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

構造方法

• 構造方法作用概述
  • 給對象的數據進行初始化
• 構造方法格式
  • 方法名與類名相同
  • 沒有返回值類型，連void都沒有
  • 沒有具體的返回值。(可以有return；這一語句，表示方法到這里結束)
• 構造方法注意事項
  • 如果你不提供構造方法，系統會給出默認無參構造方法
  • 如果你提供了構造方法，系統將不再提供默認的無參構造方法。必須自己給出。（建議永遠自己給出無參構造方法?。?/li>
  • 構造方法也是可以重載的

class Student {
    private String name;
    private int age;

    public Student() {
        System.out.println("這是無參構造方法");
    }
    
    //構造方法的重載格式
    public Student(String name) {
        System.out.println("這是帶一個String類型的構造方法");
        this.name = name;
    }
    
    public Student(int age) {
        System.out.println("這是帶一個int類型的構造方法");
        this.age = age;
    }
    
    public Student(String name,int age) {
        System.out.println("這是一個帶多個參數的構造方法");
        this.name = name;
        this.age = age;
    }
    
    public void show() {
        System.out.println(name+"---"+age);
    }
}

class ConstructDemo2 {
    public static void main(String[] args) {
        //創建對象
        Student s = new Student();
        s.show();
        System.out.println("-------------");
        
        //創建對象2
        Student s2 = new Student("林青霞");
        s2.show();
        System.out.println("-------------");
        
        //創建對象3
        Student s3 = new Student(27);
        s3.show();
        System.out.println("-------------");
        
        //創建對象4
        Student s4 = new Student("林青霞",27);
        s4.show();
    }
}

一個基本類的標準代碼寫法

• 類
  • 成員變量
  • 構造方法
    • 無參構造方法
    • 帶參構造方法
  • 成員方法
    • getXxx()
    • setXxx()
• 給成員變量賦值的方式
  • 無參構造方法+setXxx()
  • 帶參構造方法

/*
    一個標準代碼的最終版。
    
    學生類：
        成員變量：
            name，age
        構造方法：
            無參，帶兩個參
        成員方法：
            getXxx()/setXxx()
            show()：輸出該類的所有成員變量值
            
    給成員變量賦值：
        A:setXxx()方法
        B:構造方法
        
    輸出成員變量值的方式：
        A:通過getXxx()分別獲取然后拼接
        B:通過調用show()方法搞定
*/
class Student {
    //姓名
    private String name;
    //年齡
    private int age;
    
    //構造方法
    public Student() {
    }
    
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    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 void show() {
        System.out.println(name+"---"+age);
    }
}

//測試類
class StudentTest {
    public static void main(String[] args) {
        //方式1給成員變量賦值
        //無參構造+setXxx()
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        //輸出值
        System.out.println(s1.getName()+"---"+s1.getAge());
        s1.show();
        System.out.println("----------------------------");
        
        //方式2給成員變量賦值
        Student s2 = new Student("劉意",30);
        System.out.println(s2.getName()+"---"+s2.getAge());
        s2.show();
    }
}

Student s = new Student();在內存中做了哪些事情?

• 加載Student.class文件進內存
• 在棧內存為s開辟空間
• 在堆內存為學生對象開辟空間
• 對學生對象的成員變量進行默認初始化
• 對學生對象的成員變量進行顯示初始化
• 通過構造方法對學生對象的成員變量賦值
• 學生對象初始化完畢，把對象地址賦值給s變量

static關鍵字

• 可以修飾成員變量和成員方法
• static關鍵字特點
  • 隨著類的加載而加載
  • 優先于對象存在
  • 被類的所有對象共享
    • 這也是我們判斷是否使用靜態關鍵字的條件
  • 可以通過類名調用,也可以通過對象調用。
• static關鍵字注意事項
  • 在靜態方法中是<font color = red>沒有this關鍵字</font>的（無法從靜態上下文引用非靜態 變量 xxx）
    • 因為靜態時隨著類的加載而加載，this是隨著對象的創建而存在。
    • 靜態比對象先存在。
  • 靜態方法只能訪問靜態的成員變量和靜態的成員方法，非靜態方法可以隨意訪問。

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);

    }
    
    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();
    }
}

靜態變量和成員變量的區別

• 所屬不同
  • 靜態變量屬于類，所以也稱為為類變量
  • 成員變量屬于對象，所以也稱為實例變量(對象變量)
• 內存中位置不同
  • 靜態變量存儲于方法區的靜態區
  • 成員變量存儲于堆內存
• 內存出現時間不同
  • 靜態變量隨著類的加載而加載，隨著類的消失而消失
  • 成員變量隨著對象的創建而存在，隨著對象的消失而消失
• 調用不同
  • 靜態變量可以通過類名調用，也可以通過對象調用
  • 成員變量只能通過對象名調用

main方法是靜態的

• public static void main(String[] args) {}
  • public 公共的，訪問權限最大，因為被jvm調用，需要訪問權限足夠大。
  • static 靜態的，不需要創建對象，被jvm調用，不用創建對象，直接類名訪問
  • void被jvm調用，不需要給jvm返回值
  • main 一個通用的名稱，雖然不是關鍵字，但是被jvm識別
  • String[] args 以前用于接收鍵盤錄入的
    • eg：java MainDemo hello world java