java面向对象-继承-静态static

2. 静态static

2.1 成员变量基于语法

//静态变量：类名.变量名
//实例变量（对象变量）：对象名.变量名
package com.czxy.demo01_static;

/**

 */
public class TestUser {
    public static void main(String[] args) {
        // 创建2个对象
        // 通过类名，访问成员变量，没有创建
        System.out.println(User.count);         //0

        // 通过类名，访问成员变量，创建1个
        User user1 = new User("jack");
        System.out.println(User.count);         //1

        // 通过类名，访问成员变量，创建2个
        User user2 = new User("rose");
        System.out.println(User.count);         //2


        // 通过对象名，访问实例变量/对象变量
        System.out.println(user1.username);     //jack
        System.out.println(user2.username);     //rose


    }
}

• 配套的JavaBean

package com.czxy.demo01_static;

/**

 */
public class User {
    public String username;        //实例变量（对象变量）
    public static int count;        //静态变量（类变量）

    public User(String username) {
        this.username = username;
        //静态变量 累加
        User.count ++;
    }
}

2.2 成员方法基本语法

package com.czxy.demo02_static_method;

/**

 */
public class TestStudent {
    public static void main(String[] args) {
        //类方法，类名.方法名
        Student.printHelloWorld();

        //实例方法，对象名.方法名
        Student student = new Student();
        student.printPass(80);

        Student student2 = new Student();
        student2.printPass(100);
    }
}

• 配套的JavaBean

package com.czxy.demo02_static_method;

/**

 */
public class Student {
    private double score;
    //类方法（静态方法）
    public static void printHelloWorld() {
        System.out.println("hello world !!!");
    }
    //实例方法（对象方法）
    public void printPass(double score) {
        this.score = score;
        System.out.println("我通过了！！！，分数是" + this.score);
    }
}

2.3 设计模式：单例（singleton）

• 设计模式：用于解决固定的问题，一套固定的代码。
  • 设计模式有多种（23种），每一种都是解决对应的特定问题的。
  • 常见设计模式：单例、工厂、代理 等。
• 单例设计模式：
  • 单个实例，保证在整个系统中，当前对象只能有一个实例（只能new一次）。
  • 常见分类：饿汉式、懒汉式

2.3.1 单例-饿汉式

• 饿汉式：立即就需要吃东西。类在加载后，就已经进行实例化了。

• 步骤：

  • 0）类名自定义（不同的需求，可以进行对应的命名）。例如：Singleton
  • 1）提供一个私有的无参构造。（在类的外面不能通过new创建实例）
  • 2）提供一个私有成员变量，类型为当前类，且需要实例化。（在这个地方进行唯一一次new）
  • 3）提供一个公共方法，用于获得唯一实例。例如：getInstance()

• 实现

  package com.czxy.demo06_singleton;
  
  /** 单例饿汉式
   * 要求如下：
   * 0）类名自定义（不同的需求，可以进行对应的命名）。例如：Singleton
   * 1）提供一个【私有】的无参构造。（在类的外面不能通过new创建实例）
   * 2）提供一个私有成员变量，类型为当前类，且需要实例化。（在这个地方进行唯一一次new）
   * 3）提供一个公共方法，用于获得唯一实例。例如：getInstance()
  
   */
  public class Singleton {
      //2）提供一个私有成员变量，类型为当前类，且需要实例化。（在这个地方进行唯一一次new）
      private static Singleton singleton = new Singleton();
  
      //1）提供一个【私有】的无参构造。（在类的外面不能通过new创建实例）
      private Singleton() {
  
      }
  
      //3）提供一个公共方法，用于获得唯一实例。例如：getInstance()
      public static Singleton getInstance() {
          return singleton;
      }
  }
  
  

• 测试类

  package com.czxy.demo06_singleton;
  
  /**
  
   */
  public class TestSingleton {
      public static void main(String[] args) {
          //获得单例
          Singleton s1 = Singleton.getInstance();
          Singleton s2 = Singleton.getInstance();
  
          System.out.println(s1);       //@1b6d3586
          System.out.println(s2);       //@1b6d3586
          System.out.println(s1 == s2);       //true
  
          // 创建 Singleton 类的实例
          //Singleton s3 = new Singleton();   //【异常】在Singleton类的外面不能new，构造私有
      }
  }
  
  

2.3.2单例-懒汉式

• 懒汉式：延迟吃东西，能不动嘴就动。类在加载后没有进行实例化，在需要(第一次使用)的时候进行实例化。

• 步骤：

  • 0）类名自定义（不同的需求，可以进行对应的命名）。例如：Singleton
  • 1）提供一个私有的无参构造。（在类的外面不能通过new创建实例）
  • 2）提供一个私有成员变量，类型为当前类。
  • 3）提供一个公共方法，如果没有实例，创建一个实例，如果有实例，返回即可。例如：getInstance()

• 代码

  package com.czxy.demo07_singleton_lazy;
  
  /**
   * 单例-懒汉式
   * 0）类名自定义（不同的需求，可以进行对应的命名）。例如：Singleton
   * 1）提供一个==私有==的无参构造。（在类的外面不能通过new创建实例）
   * 2）提供一个私有成员变量，类型为当前类。
   * 3）提供一个公共方法，如果没有实例，创建一个实例，如果有实例，返回即可。例如：getInstance()
  
   */
  public class Singleton {
  
      //2）提供一个私有成员变量，类型为当前类。
      private static Singleton singleton;
  
      //1）提供一个==私有==的无参构造。（在类的外面不能通过new创建实例）
      private Singleton() {
  
      }
  
      //3）提供一个公共方法，如果没有实例，创建一个实例，如果有实例，返回即可。例如：getInstance()
      public static Singleton getInstance() {
          if(singleton == null) {
              singleton = new Singleton();
          }
          // 必然获得实例
          return singleton;
      }
  }
  
  

• 测试类

  package com.czxy.demo07_singleton_lazy;
  
  /**
  
   */
  public class TestSingleton {
      public static void main(String[] args) {
          //获得单例
          Singleton s1 = Singleton.getInstance();
          Singleton s2 = Singleton.getInstance();
  
          System.out.println(s1);       //@1b6d3586
          System.out.println(s2);       //@1b6d3586
          System.out.println(s1 == s2);       //true
  
          // 创建 Singleton 类的实例
  //        Singleton s3 = new Singleton();   //【异常】在Singleton类的外面不能new，构造私有
      }
  }
  
  

2.3.3总结

• 饿汉式 & 懒汉式 优缺点？
  • 饿汉式：
    • 优点：
      • 代码结构简单，容易理解
      • 安全，可以保证最有一个实例。
    • 缺点：
      • 可能浪费资源
  • 懒汉式：
    • 优点：
      • 延迟加载，需要的时候再加载，节约空间。
    • 缺点：
      • 不安全，可能会出现多个实例。