java第七天（this關鍵字、構造器、static靜態關鍵字、單例模式）

35.this關鍵字

對象的打印，打印出來的結果是邏輯地址，對對象來講是惟一的

對象方法：不帶static的類的方法

this只能存在於對象方法中使用

this就是調用這個方法的對象的引用(this也能夠不寫)

對於類的對象來講，屬性是每一個對象都有一份，是數據隔離的，可是方法是多個對象共享，不一樣的對象調用這個方法的時候用this來區分不一樣對象的數據，this是可隱藏的

本類的對象方法中能夠直接調用對象方法，this就是調用對象方法的對象

this在封裝中的使用，用於區分同名的屬性和局部變量的名字。

class Student{
    private String name;
    private int age;
    public void sleep(){
        //this表示調用對象方法的對象的引用
        System.out.println(this.name+"在睡覺");
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public void playGame(){
        System.out.println(this.name+"在玩遊戲");
        //本類對象方法中調用對象方法，this表示調用對象方法的對象的引用,this均可以省略
        this.sleep();
    }
}
public class TestStudent{
    public static void main(String[] args){
        Student a=new Student();
        a.setName("Bob");
        a.setAge(13);
        a.sleep();
        a.playGame();
    }
}

36.構造器

用於建立對象的方法叫作構造器

語法：

/**
    權限修飾符 類名（數據類型1 變量名1，....）{
        
    }
    */
    public Student(){
        
    }

構造器自己是一個方法，沒有返回值，沒有void，構造器的方法名必須和類名一致，在方法中定義要初始化的參數列表

特色：

（1）有參數的構造器能夠給屬性初始化，能夠容許方法重載

（2）一個類存在參數的構造器那麼默認構造器就別覆蓋，若是向使用默認構造器，須要顯示的定義（寫出來）

（3）構造器之間的調用（減小代碼的重複性），同一個類中構造器能夠互相調用，若是在構造器中調用其餘構造器來建立對象，只初始化，須要用this（....）l來調用；注意this（....）必須放在構造器的第一行

class Student{
    String name;
    int age;
    int gender;
    /**
    權限修飾符 類名（數據類型1 變量名1，....）{
        
    }
    */
    //顯示的定義默認構造器
    public Student(){
        
    }
    //有參數的構造器那麼默認構造器就被覆蓋，若是想使用默認構造器須要顯示的定義
    public Student(String name){
        this.name=name;
        
    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println(this.name+this.age+"歲了");
    }
    public Student(String name,int age,int gender){
        this(name,age);//構造器內調用構造器方法只初始化，須要用this(...)來調用
        this.gender=gender;
        System.out.println(this.name+this.age+"歲了性別"+this.gender);
    }
}
public class TestStudent1{
    public static void main(String[] args){
        Student a=new Student("Bob",13);
        Student b=new Student();
        System.out.println(b);
        Student c=new Student("Alex",10,1);
    }
}

37.static靜態關鍵字

（1）static修飾在屬性上

語法：static 數據類型 變量名

使用static修飾的屬性咱們認爲是類的屬性，靜態屬性，不帶static修飾的屬性是對象的屬性

特色：類的屬性訪問：第一種方式：類名.類屬性（推薦使用）

                                  第二種方式：對象實例.類屬性

          類屬性的當前的class文件加載進入jvm類屬性就被初始化了，jvm執行完畢才銷燬，class文件除了jvm，類屬性也就消失了

          類屬性能夠被每個對象共享

class Student{
    String name;
    int age;
    //static 數據類型 變量名
    static int sCount;
    public Student(){
        
    }
    public Student(String name){
        this.name=name;
    }
    public Student(String name,int age){
        this(name);
        this.age=age;
    }
}
public class TestStudent2{
    public static void main(String[] args){
        Student a=new Student("Bob",13);
        // 第二種方式：對象實例.類屬性
        a.sCount++;
        Student b=new Student();
        b.sCount++;
        Student c=new Student("Alex",10);
        c.sCount++;
        //類的屬性訪問：第一種方式：類名.類屬性（推薦使用）
        System.out.println(Student.sCount);
    }
}

（2）static修飾在方法上

語法：

public static 返回值（void） 方法名（數據類型 變量名，...）{
        方法體;
        [return 結果;]
    }

static修飾在方法上就是類方法，類方法的特色：類方法的訪問能夠經過類名.類方法，還能夠經過對象訪問；類方法當前的class文件加載進入jvm類方法就被初始化了，jvm執行完畢，class文件除了jvm，類方法也就消失了；類方法和對象方法都是被對象共享的，類方法初始化很早，jvm加載這個類的時候，這個方法就初始化了，對象方法也是早早地進入了jvm，可是不必定被啓用了，只有先建立了對象，纔有可能使用這個方法；類方法不能訪問對象屬性和對象方法。只能訪問類屬性和類方法；對象方法能夠調用對象屬性、對象方法、類屬性、類方法

類方法最多見的用法就是工具類的定義

class Student{
    String name;
    int age;
    //static 數據類型 變量名
    static int scount;
    /**
    static修飾方法，就是類方法，語法：
    public static 返回值（void） 方法名（數據類型 變量名，...）{
        方法體;
        [return 結果;]
    }
    */
    public void learn(){
        System.out.println(this.name+"在學習");
    }
    public static int getScount(){
        return scount;
    }
}
public class TestStudent3{
    public static void main(String[] args){
        //訪問類方法的第一種方式：類名.方法名()
        System.out.println(Student.getScount());
        Student a=new Student();
        //訪問類方法：對象實例.方法名()
        int scount=a.getScount();
        System.out.println(scount);
    }
}

（3）靜態代碼塊

語法

class A{
        static{
        
        }
    }

特色：靜態代碼塊主要用於初始化資源；靜態代碼塊在main以前執行；靜態代碼塊不能訪問對象屬性和方法，能夠訪問範圍內的類屬性（必須先定義）或類方法

public class TestStudent4{
    String name;
    int age;
    static int scount;
    /*靜態代碼塊；用於初始化資源，在main的前面，能夠訪問範圍內的類方法和先定義的類屬性，不能訪問對象屬性和對象方法
    class A{
        static{
        
        }
    }
    */
    static{
        System.out.println(scount);
    }
    public static void main(String[] args){
        System.out.println("靜態代碼塊");
    }
}

38.單例模式

設計模式：一共有23種設計模式，設計模式就是有經驗的前人經過時間總結下來被你們公認的代碼設計思想

步驟：

（1）私有化構造器

（2）定義一個類方法用於得到單例的對象，返回值是這個類的類型

（3）在類種提供一個Singleton類型的類屬性

（4）實現getinstance這個類方法

懶漢模式/餓漢模式

class Singleton{     /**     static Singleton s;     private Singleton(){              }     //懶漢模式     public static Singleton getInstance(){         if(s==null){             s=new Singleton;         }         return s;     }     */     static Singleton s=new Singleton();     private Singleton(){              }     //餓漢模式     public static Singleton getInstance(){         return s;     } } public class TestSingleton{     public static void main(String[] args){         Singleton s=Singleton.getInstance();         System.out.println(s);         Singleton s1=Singleton.getInstance();         System.out.println(s1);     } }