一：设计模基本介绍

  1. 静态方法和属性的几点经典使用
  2. 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索

    三：单例设计模式应用举例

  • 单例设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

1：饿汉式

步骤如下：

  1. 构造器私有化 -> 防止直接new
  2. 类的内部直接创建对象（static）

  3. 向外暴露一个静态的公共方法 ```java public class Modern {

    public static void main(String[] args) {

    1.  //使用girl对象接收，如果没有需要也可以不接收直接输出
    2.  Girl girl = Girl.getInstance();
    3.  System.out.println(girl);
    5.  System.out.println(Girl.getInstance());
    7.  System.out.println(Girl.n1);//等价于上面两行
    8.  //用这个静态属性时会导致girl这个对象被加载
    9.  //所以静态属性的初始化是会被执行的，所以个对象呢就有了

    } } class Girl{ private String name; public static int n1 =100; //對象，通常是重量級的對象, 餓漢式可能造成創建了對象，但是沒有使用. //为了能够在静态方法中，返回 gf对象，需要将其修饰为 static private static Girl girl = new Girl(“绘梨衣”); //饿汉式：在类加载的时候就创建了对象，即使没有使用这个对象

    private Girl(String name) {

    1.  this.name = name;

    }

    public static Girl getInstance(){

    1.  return girl;

    }

    @Override public String toString() {

    1.  return "Girl{" +
    2.      "name='" + name + '\'' +
    3.      '}';

    } }

  1. <a name="RvenE"></a>
  2. #### 2：懒汉式
  4. - 仍然构造器私有化
  5. - 定义一个static静态属性对象
  6. - 提供一个public的static方法可以返回一个Car对象
  7. - 懒汉式：只有当用户是哦给你getinstance时，才返回cat对象，只有再次调用时，会返回上次创建的对象，从而保证了单例
  8. ```java
  9. public class Modern {
  10.     public static void main(String[] args) {
  11.         Cat cat = Cat.Getinstance();
  12.         System.out.println(cat);
  13.     }
  14. }
  16. class  Cat{
  17.     private String name;
  18.     private static Cat cat;
  20.     private  Cat(String name) {
  21.         this.name = name;
  22.     }
  24.     public static Cat Getinstance(){
  25.         if (cat ==null){
  26.             cat = new Cat("小可爱");
  27.         }
  28.         return cat;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Cat{" +
  34.                 "name='" + name + '\'' +
  35.                 '}';
  36.     }
  37. }

四：饿汉式和懒汉式对比

  1. 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。
  2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。(后面学习线程后，会完善一把)
  3. 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
  4. 在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式。