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