Java笔记之static关键字

本篇文章为学习笔记

文章目录

• 前言
• 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;
          }
      }
  

---

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