工厂模式和单例模式

矫情吗；* 2023-06-09 07:57 105阅读 0赞

### 工厂模式 ###

定义一个具体的工厂类负责创建一些类的实例

优点：客户端不需要再负责对象的创建，从而明确了各个类的职责

缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

/*  
    动物抽象类：public abstract Animal { public abstract void eat(); }
    	具体狗类：public class Dog extends Animal {}
    	具体猫类：public class Cat extends Animal {}
    
    开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。
    */
    public abstract class Animal {
    	public abstract void eat();
    }

public class Cat extends Animal {
    	@Override
    	public void eat() {
    		System.out.println("猫吃鱼");
    	}
    }

public class Dog extends Animal {
    	@Override
    	public void eat() {
    		System.out.println("狗吃肉");
    	}
    }

主要负责创建一些类的实例

public class AnimalFactory {
    
    	private AnimalFactory() {
    	}
    
    	public static Dog createDog() {
    		return new Dog();
    	}
    
    	public static Cat createCat() {
    		return new Cat();
    	}
    }

public class AnimalDemo {
    	public static void main(String[] args) {
    		// 具体类调用
    		Dog d = new Dog();
    		d.eat();
    		Cat c = new Cat();
    		c.eat();
    		System.out.println("------------");
    
    		// 工厂有了后，通过工厂调用
    		Dog dd = AnimalFactory.createDog();
    		Cat cc = AnimalFactory.createCat();
    		dd.eat();
    		cc.eat();
    
    	}
    }

### 单例模式 ###

主要是确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供  
优点：在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能  
缺点：没有抽象层，因此扩展起来会很难  
职责过重，在一定程序上违背了单一职责

#### 主要分为饿汉式和懒汉式 ####

饿汉式：类加载就能创建对象  
懒汉式：用的时候才去创建对象  
饿汉式是线程安全的

##### 饿汉式 #####

public class Student{
    
    //构造私有
    private Student（）{}
    
    //静态方法只能访问静态的成员变量，加静态
    //为了不让外界直接访问这个值，加private
    private static Student s=new Student（）；
    
    //提供公共的访问方式
    //为了外界能够直接使用该方法，加静态
    public static Student getStudent（）{
    return s；
    }
    }

测试
    /*
     * 单例模式：保证类在内存中只有一个对象。
     * 
     * 如何保证类在内存中只有一个对象呢?
     * 		A：把构造方法私有
     * 		B:在成员位置自己创建一个对象
     * 		C:通过一个公共的方法提供访问
     */
    public class StudentDemo {
    	public static void main(String[] args) {
    		// Student s1 = new Student();
    		// Student s2 = new Student();
    		// System.out.println(s1 == s2); // false
    
    		Student s1 = Student.getStudent();
    		Student s2 = Student.getStudent();
    		System.out.println(s1 == s2); // true
    
    		System.out.println(s1); // null，cn.cyp_03.Student@175078b
    		System.out.println(s2);// null，cn.cypy_03.Student@175078b
    	}
    }

##### 懒汉式 #####

public class Teacher{
    
    private Teacher（）{}
    
    private static Teacher t=null；
    
    public syschronized static Teacher getTeacher（）{
    if（t==null）{
    t=new Teacher（）；
    }
    return t；
    }
    }

测试
    public class TeacherDemo {
    	public static void main(String[] args) {
    		Teacher t1 = Teacher.getTeacher();
    		Teacher t2 = Teacher.getTeacher();
    		System.out.println(t1 == t2);
    		System.out.println(t1); // cn.cyp_03.Teacher@175078b
    		System.out.println(t2);// cn.cyp_03.Teacher@175078b
    	}
    }