本篇文章为学习笔记


文章目录

  • 前言
  • static关键字
  • 1.静态变量
  • 2.静态方法
  • 3.静态代码块
  • 4.单例模式
  • 4.1 饿汉模式
  • 4.2 懒汉模式


前言

在Java中，static关键字可以修饰类的成员，如成员变量、成员方法以及代码块，被修饰的成员具有一些特殊性。

static关键字

1.静态变量

  • 在定义一个类时，只是描述某类事物的特征和行为，并没有产生具体的数据。只有通过new关键字的创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。有时候，我们希望某些特定的数据在内存中只有一份，而且能够被一个类的所有实例对象所共享。
  • Java中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，使用**“类名.变量名”**的形式来访问。
  • 部分代码展示：
//定义一个Student类
class Student{
    static String schoolName; //定义静态变量schoolName
}
public class LearnStatic1 {
    public static void main(String[] args) {
        Student student1 = new Student(); //创建学生对象
        Student student2 = new Student();
        Student.schoolName = "家里蹲大学"; //为静态变量赋值
        System.out.println("我的学校是"+student1.schoolName);
        System.out.println("我的学校是"+student2.schoolName);
    }

}
  • 因为 schoolName 是静态变量所以可以直接通过类名.变量名的方式直接调用，也可以通过实例对象进行调用。

注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译会报错。即是说不能在代码块内部定义静态变量。

2.静态方法

  • 有时我们希望在不创建对象的情况下就可以调用某个方法，即是说该方法不必和对象绑在一起。实现这样的效果只需要在类中定义的方法前加上static关键字，我们可以称这类方法为静态方法。跟静态变量的访问方式相同：类名.方法。
  • 部分代码展示：
public static void sayHello(){
        System.out.println("hello，我是一个静态方法");
    }
    
    public static void main(String[] args) {
        //静态方法方法问方式：类名.方法名
        LearnStatic1.sayHello();
    }

注意：在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在调用时可以不创建任何对象。即是说静态的变量和方法主要绑定的是类，而不是具体的对象。

3.静态代码块

  • 在Java中，使用一对大括号包围起来的若干代码被称为一个代码块，用static修饰的被称为静态代码块。
  • 当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。
  • 在程序中，通常会使用静态代码块对类的成员变量进行初始化。
  • 部分代码展示：
//静态代码块
    static{
        System.out.println("测试类的代码块执行了");
    }
    public static void main(String[] args) {
        //创建两个对象
        Person person1 = new Person();
        Person person2 = new Person();
    }
//创建一个人类
class Person{
    static String country;
    //静态代码块
    static{
        country = "China";
        System.out.println("Person类中的静态代码块被执行了");
    }

4.单例模式

  • 单例模式是Java中的一种设计模式，它是指在设计一个类时，需要保证在整个程序中运行期间针对该类只存在一个实例对象。例如工具类等在程序运行过程中，注重的是类中的方法和属性，而不是具体的实例对象，不需要创建太多的情况。
  • 实现单例模式的步骤：
  1. 构造函数私有化；
  2. 创建一个全局的静态的（static）该类型对象作为属性；
  3. 写一个公共（public）静态（static）的方法来返回该类型对象。
  • 通过创建类的对象来判断是否满足单例设计模式的要求：
JiSuan js1 = JiSuan.getJiSuan();
	JiSuan js2 = JiSuan.getJiSuan();
	System.out.println(js1 == js2);

4.1 饿汉模式

  • 把创建对象的过程，放在了定义全局变量的时候
  • 部分代码展示：
//创建一个计算工具类
public class JiSuan {
	static JiSuan  js=new JiSuan();;
	private  JiSuan(){}
//写一个方法返回对象
	public static JiSuan getJiSuan(){
    return  js;
}

4.2 懒汉模式

  • 创建对象放在了方法里
  • 懒汉模式的时候注意线程安全问题，可以在返回对象的这个方法上，加synchronized关键字
  • 部分代码展示：
public class JiSuan {
    static JiSuan js;
    private JiSuan(){}

    public synchronized static JiSuan getJiSuan(){
        if(js != null){
            return js;
        }else{
            js= new JiSuan();
            return js;
        }
    }

如有错误，欢迎大佬指出！