Static

static

• static是静态的意思，可以修饰成员变量和成员方法

• static修饰成员变量表示该成员变量值在内存中存储一份，可以被共享访问、修改。

成员变量可以分为2类

• 静态成员变量（有static修饰，属于类，内存中加载一次）：成表示如在线人数信息等需要被共享的信息，可以被共享访问。

  public class User{
      //静态成员变量
      public static String onlineNumber = 161
  }

  • 访问方式：

    • 类名.静态成员变量。（推荐）

    • 对象.静态成员变量。（不推荐）

• 实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age、等属于每个对象的信息。

  public class User{
      public static String onlineNumber = 161;
      //实例成员变量：
      private String name;
      private int age;
  }

  比较：

  public class User{
      //静态成员变量
      public static int num = 161;
      //实例成员变量
      private String name;
      private String age;
      public static void main(String []args){
          //1. 类名，静态成员变量
          System.out.println(User.num);
          //1.对象名，实例成员变量
          System.out.println(User.name);  //报错，name为该类中每一个对象的变量，不能通过类调用。
          User u = new User();
          u.name = "张三";
          u.age = 18;
          System.out.println(u.name);
          Syetem.out.println(u.age);
          u.num++;  //新来了一个人
          Syetem.out.println(u.num);
          User u2 = new User();
          u2.name = "李四";
          u2.age = 19;
          System.out.println(u2.name);
          Syetem.out.println(u2.age);
          u2.num++; 
          System.out.println(u.num);
          System.out.println(User.num);//推荐方式
          //注意：同一个类中的静态成员变量的访问可以省略类名。
          System.out.println(num);
          
      }
  }

  输出结果：

  

   

static 内存机制

 

在main方法传入方法区时，会像堆内存中创建一个静态变量区，用来存储静态变量。

static修饰成员方法

成员方法的分类

• 静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问

• 实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

  public class Student{
      //实例成员变量，无static修饰，属于对象
      private String name;
      public void study(){
          System.out.println(name+"在好好学习~~")
      }
      
      public static int getMax(int age1,int age2){
          return age1>age2? age1:age2;
      }
      
      public static void main(String[]args){
          //类名.静态成员方法
          System.out.println(Student.getMax(10,2));
          //注意，同一个类中访问静态成员的类名可以不写
          System.out.println(getMax(23,44));
          //2. 对象.实例成员方法
          //study（）会报错
          Student student = new Student();
          student.name = "猪八戒"；
              student.study();
          //3.对象.静态成员方法（不推荐）
          System.out.println(student.getMax(20,10));
      }
  }

• 每种方法的使用场景时怎么样的？

  • 表示自己的行为的，且方法中需要访问实例成员，则该方法必须申明成实例方法。

  • 如果该方法是执行一个通用功能为目的，或者需要方便访问，则可以声明为静态方法。

static修饰成员方法的内存原理

 

static的注意事项

• 静态方法只能访问静态的成员，不可以直接访问实例成员

• 实例方法可以访问静态的成员，也可以访问实例成员

• 静态方法中不会出现this关键字

static应用知识

工具类

• 工具类是什么？

  • 类中都是一些静态的方法，每个发方法都是完成一个公用的共呢个为目的，这个类用来给系统开发人员共同使用的。

• 使用工具类的好处

  • 一调用方便，二是提高了代码复用（一次编码，处处可用）

• 为什么工具类中的方法不用实例方法做？

  • 实例方法需要创建对象调用

  • 此时用对象值是为了调用方法，这样会浪费内存

• 工具类定义时的其它要求：

  • 由于工具里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有

    public class Test{
        private Test(){
            
        }
        public static String getVerifyCode(int n){
            String strs = "";
            String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
            Random random = new Random();
            for(int i = 0;i<n;i++){
             int num = random.nextInt(str.length);
                char ch = str.charAt(num);
                strs = str+ch;
            }
        return strs;
        }
    }

代码块

• 代码块概述：

  • 代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法外。

  • 在Java类下，使用{}括起来的代码被称为代码块。

• 代码块分为：

  • 静态代码块：

    • 格式：static{}

    • 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次

    • 使用场景：在类加载的时候做一些静态数据初始化的操作，以便于后续使用

      public class Test{
          public static int num;
          static 
      }

  • 构造代码块（了解，见得少）：

    • 格式：{}

    • 特点：每次创建对象，调用构造器执行时，都会执行改代码中的代码，并且在构造器执行之前执行

    • 使用场景：初始化实例资源

单例模式

• 什么是设计模式？

  • 开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，成为设计模式

  • 设计模式有20多种，对应20多种软件开发过程中遇到的问题

  • 学设计模式主要是学2点：

    • 第一：用这种模式来解决什么问题

    • 第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

• 饿汉单例设计模式

  • 在用类获取对象的时候，对象已经提前为你创建好了

  • 设计步骤

    • 定义一个类，把构造器私有化，放置被人随意调用

    • 定义一个静态变量存储一个对象

    package com.itheima.d3_static_code;
    //饿汉单例模式   在吃饭时，饭已经做好了
    //在用类获取对象时，对象已经提前创建好了。
    public class SingleInstance {
        private SingleInstance(){}
        public static SingleInstance singleInstance = new SingleInstance();
    ​
        public static void main(String[] args) {
            SingleInstance singleInstance = SingleInstance.singleInstance;//通过调用静态变量的方式，创建对象
            SingleInstance singleInstance1 = SingleInstance.singleInstance;
            System.out.println(singleInstance1==singleInstance);
        }
    }

• 懒汉单例模式

  • 当真正需要该对象的时候，才回去创建一个对象（延迟加载对象）。

  • 设计步骤

    • 定义一个类，把构造器私有

    • 定义一个静态变量存储对象

    • 提供一个返回单例的方法

    package com.itheima.d3_static_code;
    //懒汉单例模式：像吃饭的时候才去做饭
    //在需要单例对象的时候才去创建对象
    public class SingleInstance2 {
        private static SingleInstance2 singleInstance2;  //创建静态对象来存储单例对象
        private SingleInstance2(){}  //构造器私有化
        public static SingleInstance2 getInstance(){  //构造方法来创建单例对象
            if (singleInstance2 ==null){
                singleInstance2 = new SingleInstance2();
            }
            return singleInstance2;
        }
    ​
        public static void main(String[] args) {
            SingleInstance2 first = getInstance();
            SingleInstance2 second = getInstance();
            System.out.println(first==second);  //输出为true
        }
    }
    ​