Java高级1——面向对象static关键字和单例设计模式总结

---

一、static关键字

1. 基本介绍

含义静态，用来作修饰符，修饰变量和方法为静态（类）成员变量和静态成员方法以及作静态代码块

成员变量是定义在类中方法体外的变量用来描述类的属性，包括静态（成员）变量即类变量和非静态（成员）变量即实例变量
局部变量是定义在方法体内的变量

2. 使用场景

2.1 类变量

2.1.1 调用

类名.变量名（同一个类中可省去类名 ）
对象名.变量名（不推荐）

2.1.2 特点

仅当类加载时加载一次，属于类和全体对象共享访问和修改

public class Student {
    // 类变量
    static String name;
    static int count;
    // 实例变量（对象的变量）
    int age;
}
public class Test {
    public static void main(String[] args) {
        // 有无static修饰成员变量的用法，特点
        Student.name = "张三"; // 类名.类变量调用
        System.out.println(Student.name); // output: 张三

        Student s1 = new Student();
        s1.name = "李四";      // 对象.类变量调用 可以这样但没必要
        System.out.println(s1.name); // output: 李四
}

2.1.3 应用场景

某些数据希望被全体对象共享访问和修改

public class User {
    // 在开发中，如果某个数据只需要一份，且希望能够被共享(访问、修改)，则该数据可以定义成类变量来记住。
    public static int number; // 类变量本身打算共享数据 所以一般用public

    public User() {
        // User.number++;
        number++;
        // 注意：在同一个类中，访问自己类的类变量才可以这样
    }

}

2.2 类方法

2.2.1 访问

类名.方法名（同一个类中可省去类名 ）
对象.方法名（不推荐）

2.2.2 特点

仅当类加载时加载一次，属于类和全体对象共享使用

public class Student {
    double score;
    // 类方法
    public static void printHelloWorld(){
        System.out.println("Hello World");
        System.out.println("Hello World");
    }

    // 实例方法
    public void printPass(){
        System.out.println("成绩：" +
                (score >= 60 ? "及格" : "不及格"));

    }
}
public class Test {
    public static void main(String[] args) {
        // 1. 类方法用法
        // 类名.类方法
        Student.printHelloWorld();

        // 对象.类方法
        Student s1 = new Student();
        s1.printHelloWorld();


        // 2. 实例方法的用法
        // 对象.实例方法
        s1.printPass(); // double默认值0.0 输出不及格
        // Student.printPass则会报错


    }
}

2.2.3 应用场景

工具类

工具类是里面有一些方法给予开发人员使用的，工具类只用到方法，所以没必要创建对象（可将构造器私有），所以用类方法

public class MyUtil {

    private MyUtil(){
    }

    public static String createCode(int n){
        String code = "";
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        Random r = new Random();
        // 2、开始定义一个循环产生每位随机字符
        for (int i = 0; i < n; i++) {
            // 3、随机一个字符范围内的索引。
            int index = r.nextInt(data.length());
            // 4、根据索引去全部字符中提取该字符
            code += data.charAt(index); // code = code + 字符
        }
        return code;
    }
}
public class LoginDemo {
    public static void main(String[] args) {
//        String code = "";
//        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
//
//        Random r = new Random();
//        // 2、开始定义一个循环产生每位随机字符
//        for (int i = 0; i < n; i++) {
//            // 3、随机一个字符范围内的索引。
//            int index = r.nextInt(data.length());
//            // 4、根据索引去全部字符中提取该字符
//            code += data.charAt(index); // code = code + 字符
//        }
//        return code;
        // 1、定义2个变量 一个是记住最终产生的随机验证码 一个是记住可能用到的全部字符
        System.out.println(MyUtil.createCode(4));

public class RegisterDemo {
    public static void main(String[] args) {
//        String code = "";
//        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
//
//        Random r = new Random();
//        // 2、开始定义一个循环产生每位随机字符
//        for (int i = 0; i < n; i++) {
//            // 3、随机一个字符范围内的索引。
//            int index = r.nextInt(data.length());
//            // 4、根据索引去全部字符中提取该字符
//            code += data.charAt(index); // code = code + 字符
//        }
//        return code;
        System.out.println(MyUtil.createCode(6)); // 瞬间减少很多代码
    }
}
    }
}

2.2.4 补充

• main方法也是类方法
• 类方法不能访问实例成员（变量和方法），但是实例方法可以访问类成员和实例成员，以及不能出现this关键字（不能访问对象自然不能用）
• 类方法不能重写但可以重载

2.3 代码块

2.3.1 分类

有静态代码块和实例代码块两种

2.3.2 静态代码块

（1）特点

仅当类加载时加载一次，在构造器前运行，常用于给类变量初始化

（2）格式

 static{ 内容
 }

2.3.3 实例代码块

（1）特点

每次创建对象的时加载一次，在构造器前运行，常用于给实例变量初始化

（2）格式

{ 内容
    }

2.3.4 实例

public class Student {
    static int number = 80;
    static String schoolName;

    // 静态代码块 作用：对类变量进行初始化
    static {
        System.out.println("静态代码块执行了！");
        schoolName = "清华";
    }

    // 实例代码块
    {
        System.out.println("实例代码块执行了！");
    }

    public Student(){
        System.out.println("无参数构造器执行了！");
    }

    public Student(String name){
        System.out.println("有参数构造器执行了！");
    }
    
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.schoolName);
        // Test类中只执行了一次静态代码块内容，而且其可以对类变量进行初始化

        System.out.println("----------");
        Student s1 = new Student();
        Student s2 = new Student("张三");

    }
}

output:
静态代码块执行了！// 类加载时运行
80
80
80 // 只运行一次
清华 // 静态代码块初始化成功
----------
实例代码块执行了！ // 构造器前运行
无参数构造器执行了！
实例代码块执行了！ // 每次都运行
有参数构造器执行了！

3. 单例设计模式

3.1 含义

只能创建一个对象

3.2 作用和应用场景

类似任务管理器这些，没必要调出多个对象的时候，可以使用单例，是这种模式设计上最优解，减少内存

3.3 写法

1. 私有类变量记住对象
2. 私有构造器
3. 让类方法返回对象

3.4 类型

3.4.1 饿汉式单例

（1）含义

早已创建好对象在类变量中，调用方法的时候立刻返回对象

（2）优点

反应速度快，但是可能会多占用内存（类一开始引进就会加载）

public class A {
    // 1. 定义一个类变量记住类的对象
    private static A a = new A();

    // 2. 私有类的构造器

    private A() {
    }


    // 3. 定义一个类方法返回类的对象
    public static A getObject(){
        return a;
    }


}

3.4.2 懒汉式单例

（1）含义

类变量中对象未创建，但仅当调用方法时将对象创建并返回

（2）优点

调用方法的时候才加载对象，内存占用少

public class B {
    // 懒汉式单例创建
    private static B b;
    private B(){

    }
    public static B getInstance(){
        if(b == null){
           b = new B();
        }
        return b;
    }
}

public class Test1 {
    public static void main(String[] args) {
        A a1 = A.getObject();
        A a2 = A.getObject();
        System.out.println(a1 == a2); // output: ture 说明两个变量是一个变量
        B b1 = B.getInstance();
        B b2 = B.getInstance();
        System.out.println(b1 == b2); // output: ture 说明两个变量是一个变量

    }
}

---

二、总结

• 总的来说static关键字是静态的意思，它用来修饰类的成员变量和成员方法作为类变量和类方法还有静态代码块，类变量和类方法共同特点是属于类，全体对象共享访问和修改，访问方法建议是类名.变量或方法名
• 类变量的应用场景可以有给用户数量计数的count变量等，类方法的应用场景有工具类，工具类要注意私有构造器，其本质可以通过直接类名.方法名调用方法没必要创建对象。类方法不能被重写但可以被重载
• 类里面代码块分为静态代码块和实例代码块两种，同时用来给类变量或实例变量初始化等，静态代码块随着类加载而加载，只执行一次，实例代码块每次创建对象时执行一次，在构造器之前
• 单例设计模式是通过私有类变量来存储一个对象，并通过类方法返回一个对象，根据对象是否在调用方法前已经创建分为饿汉式和懒汉式