spring小结2

spring小结2

工厂模式

简单工厂（静态工厂）
工厂方法（实例工厂）
抽象工厂（工厂的工厂）

作用：
1.隐藏对象的创建细节，让使用者只关系对象的功能的使用
2.解耦合

工厂方法：
生产的产品类型不确定
1.提供一个工厂接口，在接口中提供一个生成产品的方法

抽象工厂：生产多种类族下的多种产品的一种解决方案
1.提供一个抽象工厂，定义所有要生产产品的规范方法
2.各种具体生产产品的工厂，改工厂需要继承自抽象工厂

简单工厂（静态工厂）

package com.kang.factory;

import com.kang.Boy;
import com.kang.Student;

public class SimpleFactory {
public static void main(String[] args) {
	Student stu = SimpleFactory.getInstance("stu",Student.class);
	System.out.println(stu instanceof Student);
	
	Boy boy  = SimpleFactory.getInstance("boy",Boy.class);
	System.out.println(boy instanceof Boy);
}

private static Student stu = new Student();
	//生产对象的方法是一个静态方法
	public static <T> T getInstance(String name,Class<T> class1) {
		
		if ("stu".equals(name)) {
			//创建学生对象
			return (T)stu;
		}else if("boy".equals(name)) {
			return (T) new Boy();
		}
		return null;
		
		
	}
}

import java.util.Arrays;
import java.util.Map;

public class Student {
	private Integer id;
	private String name;
	private Integer age;
	private int[] arr;
	private Map<String,String> map;
	private Student student;

 //   get set方法 tostring等

-------------------
    同上
public class Boy {
	private Integer id;
	private String name;
	private Integer age;
	private int[] arr;
	private Map<String,String> map;
	private Boy student;

工厂方法（实例工厂）

package com.kang.factory;
import com.kang.Student;

public class StudentFactory<T> implements InsFactory<Student> {
public static void main(String[] args) {
	InsFactory<Student> inf = new StudentFactory<>();
       Student stu=	inf.getInstance(null);
       System.out.println(stu instanceof Student);
}
	@Override
	public Student getInstance(String id) {
		
		return new Student();
	}

}

package com.kang.factory;

public interface InsFactory<T> {
  public abstract T getInstance(String id);
  
}

抽象工厂（工厂的工厂）

package com.kang.factory;


//抽象工厂
public interface AbstractFactory {
	public void createSportCar();
	public void createHomeCar();
	public void createSUVCar();
	public void createBusinessCar();

}

package com.kang.factory;

public class BenzFactory implements AbstractFactory {

	@Override
	public void createSportCar() {
		
		System.out.println("这是跑车");
	}

	@Override
	public void createHomeCar() {
		System.out.println("这是轿车");
		
	}

	@Override
	public void createSUVCar() {
		System.out.println("这是SUV");
		
	}

	@Override
	public void createBusinessCar() {
		System.out.println("这是商务车");
		
    }
}

package com.kang.factory;

public abstract class TeslaAbstractFactory  implements AbstractFactory{
  @Override
public void createBusinessCar() {
	 System.out.println("目前无法生产");	
}
  
  @Override
	public void createSportCar() {
	  System.out.println("目前无法生产");
		
	}
	
}

package com.kang.factory;

public class TeslaFactory extends TeslaAbstractFactory{

	@Override
	public void createHomeCar() {
			
	}
	@Override
	public void createSUVCar() {
			
	}
}

测试

package com.kang.test;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

import com.kang.factory.AbstractFactory;
import com.kang.factory.BenzFactory;
import com.kang.factory.TeslaFactory;

class FactoryTest {

	@Test
	void test() {
	AbstractFactory benzFactory = new BenzFactory();
	benzFactory.createSportCar();
	
	AbstractFactory teslaFactory = new TeslaFactory();
	 teslaFactory.createHomeCar();
	
	}

}