MySQL阶段DAY20(附笔记)

 【注意】：工厂模式学习知识结构如下：

 （一）、单例模式

1.Single类：

使用懒汉式：对象的延迟加载，安全的，高效的应用
双重判断提升效率和安全性

package singleton;

/*
 * 单例设计模式之饿汉式(在多线程并发时不会有问题）
 	不常用！
 public class Single {

	private Single(){}
	
	private static final Single s = new Single();
	
	public static Single getInstance(){
		return s;
	}
}
  
 -------------------------------------------------
  单例设计模式之懒汉式（在多线程并发时可能有问题，所以需要加锁）
  
 public class Single {

	private Single(){}
	
	private static  Single s = null;
	
	public static Single getInstance(){
		if(s ==null){
			s = new Single();
		}
		return s; 
	}
			
}
  
----------------------------------------------------  
 public class Single {   //改进懒汉式，加锁

	private Single(){}
	
	private static  Single s = null;
	
	public static Single getInstance(){
		if(s==null){  //首先，可能会有多个线程到这一步认为都是空，所以这是一重判断
		synchronized(Single.class){//同步代码块：被锁住的代码块
		if(s ==null){//其次，不可能两个线程同时锁住，所以，这是二重判断
			s = new Single();
		 }
	   }
	 }
		return s; 
	}
			
}


 * */

//使用懒汉式：对象的延迟加载，安全的，高效的应用
//双重判断提升效率和安全性
public class Single {

	private Single(){}
	
	private static  Single s = null;
	//这里锁住方法，效率就低了，结果就是只有一个线程能用，那其余线程怎么办？？？只能等着，效率很低且没有意义。如果是把创建对象的方法锁住就明显有效率了！！！
	public static Single getInstance() {  
		if (s == null) {//双重判断
			synchronized (Single.class) {
				if (s == null) {//双重判断
					s = new Single();
				}
			}
		}
		return s;
	}
			
}

2、Run类

package singleton;

public class Run implements Runnable {
	public void run(){
		for(int x = 0 ;x<50 ;x++){
			Single s = Single.getInstance();
			System.out.println(s);
		
		}
	}

}

3、Test

 * 设计模式：实际的软件开发，对问题的处理总结经验，设计模式。前提是面向对象
 * 
 * 23种设计模式
 * 
 *     单例设计模式：
 *         保证一个类的对象的唯一性
 *         私有构造方法
 *         在本类的成员位置，创造自己类的对象
 *         提供公共方法用来返回自己创建的对象
 * 
 * 单例在Java中的应用：Runtime

package singleton;

/*
 * 设计模式：实际的软件开发，对问题的处理总结经验，设计模式。前提是面向对象
 * 
 * 23种设计模式
 * 
 * 	单例设计模式：
 * 		保证一个类的对象的唯一性
 * 		私有构造方法
 * 		在本类的成员位置，创造自己类的对象
 * 		提供公共方法用来返回自己创建的对象
 * 
 * 单例在Java中的应用：Runtime
 * 
 * */

public class Test {
	
	public static void main(String[] args) {
		Run r = new Run();
		//多线程
		new Thread(r).start();//第一个线程进来，判断对象是空，拿锁，自己创建唯一对象
		new Thread(r).start();//第二个进程进来，对象已不空，直接返回唯一对象！
	}

}

（二）、简单工厂

 *     简单（单例）工厂类：生产对象，创建对象
 *         只创建动物对象，其他对象不做

 * 简单(单例）工厂设计模式：
 *         将所有的创建对象的任务，交给一个工厂类实现
 *         找工厂类去获取即可

1、Animal

package SimpleFactory;

public abstract class Animal {

	public abstract void eat();
	
}

2 Cat

package SimpleFactory;

public class Cat extends Animal {
	public void eat(){
		System.out.println("猫吃鱼...");//实现抽象父类，重写抽象方法
	}
}

3 Dog

package SimpleFactory;

public class Dog extends Animal{
	public void eat(){
		System.out.println("够吃骨头...");
	}

}

4 简单工厂类-Factory,只生成Animal类，将猫，狗，马都在一个工厂生产

package SimpleFactory;

/*
 * 	简单（单例）工厂类：生产对象，创建对象
 * 		只创建动物对象，其他对象不做
 * 
 * 
 * */

public class Factory {

	//定义方法，创建动物对象
	public static Animal createAnimal(String name){
		if("cat".equals(name)){
			return new Cat();//创建猫对象
		}else if("dog".equals(name)){
			return new Dog();//创建狗对象
		}/*else{
			return null;
		}*/
		return null;
	}
}

5 Test-根据需求选择对象

package SimpleFactory;

/*
 * 简单(单例）工厂设计模式：
 * 		将所有的创建对象的任务，交给一个工厂类实现
 * 		找工厂类去获取即可
 * 
 * 
 */

public class Test {

	public static void main(String[] args) {
		//直接调用静态工厂类的静态方法，传递参数，获取对象
		Animal a = Factory.createAnimal("cat");
		a.eat();
		
		a=Factory.createAnimal("dog");
		a.eat();
		
/*		a=Factory.createAnimal("car");  弊端  会报空指针！
		a.eat();*/
		
	}
	
	
}

（三）、方法工厂模式

工厂接口，其实现类是猫工厂，狗工厂....车工厂...吃工厂都行！

 *工厂方法设计模式：
 *        将每个对象，交给各自工厂(1,2,3工厂...)去创建
 *        有猫工厂 狗工厂，作用就是建立对象

1. Animal

package MethodFactory;

public abstract class Animal {

	public abstract void eat();
	
}

2.Cat 

package MethodFactory;

public class Cat extends Animal {
	public void eat(){
		System.out.println("猫吃鱼...");//实现抽象父类，重写抽象方法
	}
}

3.CatFactory 

package MethodFactory;

//实现工厂接口
public class CatFactory implements Factory{

	@Override
	public Animal createAnimal() {
		// TODO Auto-generated method stub
		return new Cat();
	}

}

4. Dog

package MethodFactory;

public class Dog extends Animal{
	public void eat(){
		System.out.println("够吃骨头...");
	}

}

5.DogFactory

package MethodFactory;
//实现工厂接口
public class DogFactory implements Factory{

	@Override
	public Animal createAnimal() {
		// TODO Auto-generated method stub
		return new Dog();
	}

}

6.Factory:方法工厂，虽然也只生产动物类，但是细分了，实现类是很多具体的工厂，如生产猫/狗/马..

package MethodFactory;

/*
		工厂接口，其实现类是猫工厂，狗工厂！
 * 
 * */

public interface Factory {
	public abstract Animal createAnimal();
}

7. Test

package MethodFactory;

/*
 *工厂方法设计模式：
 *		将每个对象，交给各自工厂去创建
 *		有猫工厂 狗工厂，作用就是建立对象
 * 
 * 
 */

public class Test {

	public static void main(String[] args) {

		Factory f = new CatFactory();//多态
		Animal a = f.createAnimal();//调用重写的方法，new出猫对象
		a.eat();
		
		
		f = new DogFactory();//多态
		a = f.createAnimal();//调用重写的方法，new出猫对象
		a.eat();
		
		
		
		
	}
	
	
}

【补充】：

（1）简单工厂类-Factory,只生成Animal类，将猫，狗，马都在一个工厂生产

（2）Factory:方法工厂，虽然也只生产动物类，但是细分了，实现类是很多具体的工厂，如生产猫/狗/马..

【笔记】：Gitee中：工作台 - Gitee.com