设计模式-----工厂
模式好处：减少代码冗余，健壮性， 可扩展性，解耦合。
与代理相比：解决问题的方法和看待问题的角度一样。
案例：一个老板希望造优盘。
1、 钱少，没有经验：小作坊，金士顿，联想，东芝，威刚。
爱国者优盘，索尼优盘，朗科优盘
原则：开闭原则。
2、 钱多了，有经验了：小工厂（小霸王优盘场）
一号车间 一号生产线：金士顿2.0
二号生产线：联想2.0
三号生产线：东芝2.0
3、2.0------》3.0
钱多了，有经验了：小工厂（小霸王优盘场）
一号车间 一号生产线：金士顿2.0
二号生产线：联想2.0
三号生产线：东芝2.0
二号车间 一号生产线：金士顿3.0
二号生产线：联想3.0
三号生产线：东芝3.0
工厂出现的原因：
产品增加了，导致了不好管理。
简单工厂：
使用场合：产品种类不多的时候，
一个工厂：
public class USBFlashFactory implements USBFlash{
public void getUSBFlah(String name){
if(name.equlas("kingston")){
return new Kingston();
}
if(name.equlas("kingston")){
return new Kingston();
}
.........
}
}
接口和抽象类的不同：
接口：interface--变量--不能实例化
抽象：私有类型
使用：接口一般用在顶层，抽象类，实现类
案例:插座接口----抽象的家用电器--电饭煲仔。。。
抽象的VGA---电脑
方法工程：
由于简单工厂中，产品类型增加而导致了，扩展差，
工厂中代码的变更----开闭原则。
/**
*简单工厂
*/
/**
*创建一个接口
*/
public interface USBFlash{
//每个优盘都有自己的名字
public void getName();
}
/**
*创建实现类
*/
public class KingStonUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是金士顿优盘======");
}
}
/**
*创建实现类
*/
public class LenovoUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是联想优盘======");
}
}
/**
*创建实现类
*/
public class ToshibaUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是东芝优盘======");
}
}
/**
*工厂
*/
public class USBFlashiFactory {
public USBFlash getUSBFlash(String name){
if(name.equalsIgnoreCase("Kingston")){
return new KingStonUSBFalsh();
}
else if(name.equalsIgnoreCase("lenovo")){
return new LenovoUSBFalsh();
}
else if(name.equalsIgnoreCase("toshiba")){
return new ToshibaUSBFalsh();
}else{
System.out.println("=====没有这个优盘====");
return null;
}
}
}
/**
*测试
*/
public class Test{
public static void main(String[ ] args){
//通过工厂创建优盘
USBFlash usb = new USBFlashFactory().getUSBFlash("KingSton");
usb.getName();
}
}
类图（简单工厂）
/**
* 方法工厂
*/
/**
*创建一个接口
*/
public interface USBFlash{
//每个优盘都有自己的名字
public void getName();
}
/**
*创建实现类
*/
public class KingStonUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是金士顿优盘====method==");
}
}
/**
*创建实现类
*/
public class LenovoUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是联想优盘====method==");
}
}
/**
*创建实现类
*/
public class ToshibaUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是东芝优盘====method==");
}
}
/**
*创建抽象工厂
**/
public abstract class AbstractUSBFlashFactory{
//?:泛型,接受类型必须是继承USBFlas的类
public abstract USBFlash createUSBFlash(Class<? exrends USBFlash> c);
}
/**
*创建实体工厂
*/
public class USBFlashiFactory extends AbstractUSBFlash{
//创建优盘
public USBFlash createUSBFlash(Class<? exrends USBFlash> c){
USBFlash usb = null;
try{
//实例化
usb = (USBFlash)Class.forName(c.getName()).newInstance();
}catch(){
e.printStankTrace;
}
return usb;
}
}
/**
*测试
*/
public class Test{
public static void main(String[ ] args){
//创建工厂
AbstractUSBFlash usbfactory = new USBFlashFactory();
//实例化优盘（一号线，专产金士顿优盘）
USBFlash usb = usbfactory.createUSBFlash(KingstonUSBFlash.class);
//实例化优盘（二号线，专产联想优盘）
USBFlash usb = usbfactory.createUSBFlash(LenovoUSBFlash.class);
//得到优盘的名字
usb.getName();
}
}
类图（方法工厂）
/**
* 抽象工厂
*/
/**
*创建一个接口
*/
public interface USBFlash{
//每个优盘都有自己的版本和名称
public void getName();
public void getVersion();
}
/**
*创建抽象类
*/
public abstract class KingStonUSBFlash implement USBFlash{
//重写名称
public void getNmae(){
System.out.println("===========我是金士顿优盘====abstract==");
}
}
/**
*创建抽象类
*/
public abstract class LenovoUSBFlash implement USBFlash{
public void getNmae(){
System.out.println("===========我是联想优盘====abstract==");
}
}
/**
*创建实现类
*/
public class Toshiton2USBFlash extends AbstractKingSton{
@Override
public void getVersion() {
// TODO Auto-generated method stub
System.out.println("===========我是金士顿优盘2.0====method==");
}
}
/**
*创建实现类
*/
public class Toshiton3USBFlash extends AbstractKingSton{
@Override
public void getVersion() {
// TODO Auto-generated method stub
System.out.println("===========我是金士顿优盘3.0====method==");
}
}
/**
*创建抽象工厂
**/
public interface USBFactory{
//创造一个金士顿优盘
publc USBFlash createKingston();
//创造一个联想优盘
publc USBFlash createLenovo();
}
/**
*创建实现2.0工厂
**/
public interface class USBFlash2Factory implements USBFlashFactory{
public USBFlashcreateKingston(){
return new Kinston2USBFlash;
}
public USBFlashcreateKingston(){
return new Lenovo2USBFlash;
}
}
/**
*创建实现3.0工厂
**/
public interface class USBFlash3Factory implements USBFlashFactory{
public USBFlashcreateKingston(){
return new Kinston3USBFlash;
}
public USBFlashcreateKingston(){
return new Lenovo3USBFlash;
}
}
/****测试**/
public class Test{
public static voin main(String[] args){
//创建工厂
USBFlashFactory usbf2 = new USBFlash2Factory();
USBFlashFactory usbf3 = new USBFlash2Factory();
//创建生产线；
USBFlash usb2=usbf2.createKingston();
USBFlash usb3=usbf3.createKingston();
//生产产品
usb2.getName();
usb2.fetVersion();
usb3.getName();
usb3.fetVersion();
}
}
类图（抽象工厂）