1. 简单工厂
- 简单工厂只有一个工厂
- 产品只有一种
- 根据类型去判断生产什么产品
工厂生产对象 – 俱乐部
public interface FootballClub {
void fighting();
}
俱乐部 1 – 曼联
public class ManchesterUnitedClub implements FootballClub{
@Override
public void fighting() {
System.out.println("MUN go go go");
}
}
俱乐部 2 – 拜仁
public class FCBayern implements FootballClub {
@Override
public void fighting() {
System.out.println("FCB fighting...");
}
}
工厂类
public class FootballClubFactory {
public FootballClub getFootballClub(Class<? extends FootballClub> c) {
FootballClub footballClub = null;
try {
footballClub = (FootballClub) Class.forName(c.getName()).newInstance();
} catch (IllegalAccessException | ClassNotFoundException | InstantiationException e) {
e.printStackTrace();
}
return footballClub;
}
public FootballClub getFootballClub(String type) {
if ("MUN".equals(type)) {
return new ManchesterUnitedClub();
} else if ("FCB".equals(type)) {
return new FCBayern();
}
return null;
}
}
测试
public class Test {
public static void main(String[] args) {
FootballClubFactory factory = new FootballClubFactory();
FootballClub club = factory.getFootballClub("MUN");
club.fighting();
club = factory.getFootballClub(FCBayern.class);
club.fighting();
}
}
运行结果
MUN go go go
FCB fighting...
2. 工厂方法
- 也是只有一种产品
- 每个类型的产品都有自己的工厂
抽象产物 – 球衣
public abstract class Jersey {
public abstract void keepWarm();
}
尤文球衣
public class JuvJersey extends Jersey {
@Override
public void keepWarm() {
System.out.println("尤文:这球衣不保暖啊...");
}
}
巴萨球衣
public class FCBarcelonaJersey extends Jersey {
@Override
public void keepWarm() {
System.out.println("巴萨:球衣哪有保暖的...");
}
}
球衣抽象工厂
public abstract class JerseyFactory {
public abstract Jersey produce();
}
尤文球衣工厂
public class JuvJerseyFactory extends JerseyFactory {
@Override
public Jersey produce() {
return new JuvJersey();
}
}
巴萨球衣工厂
public class FCBarcelonaJerseyFactory extends JerseyFactory {
@Override
public Jersey produce() {
return new FCBarcelonaJersey();
}
}
测试类
public class Test {
public static void main(String[] args) {
JerseyFactory jerseyFactory = new JuvJerseyFactory();
Jersey jersey = jerseyFactory.produce();
jersey.keepWarm();
jerseyFactory = new FCBarcelonaJerseyFactory();
jersey = jerseyFactory.produce();
jersey.keepWarm();
}
}
运行结果
尤文:这球衣不保暖啊...
巴萨:球衣哪有保暖的...
3. 抽象工厂
- 每个工厂生产多种产品(围巾、帽子)
- 每个工厂生产的产品属于同一品牌/阵营(利物浦、巴黎)
工厂产品1 – 围巾
public abstract class Scarf {
public abstract void keepWarm();
}
工厂产品2 – 帽子
public abstract class Hat {
public abstract void keepWarm();
}
利物浦产品
public class LiverpoolHat extends Hat {
@Override
public void keepWarm() {
System.out.println("利物浦帽子:只护头");
}
}
public class LiverpoolScarf extends Scarf {
@Override
public void keepWarm() {
System.out.println("利物浦围巾:还是只护头...");
}
}
巴黎产品
public class ParisHat extends Hat {
@Override
public void keepWarm() {
System.out.println("巴黎帽子:也是只护头!!?");
}
}
public class ParisScarf extends Scarf {
@Override
public void keepWarm() {
System.out.println("巴黎围巾:应该造点衣服...");
}
}
俱乐部产品工厂
每个工厂都应该生产帽子和围巾两种产品
public interface ClubFactory {
Scarf getScarf();
Hat getHat();
}
利物浦工厂
public class LiverpoolFactory implements ClubFactory {
@Override
public Scarf getScarf() {
return new LiverpoolScarf();
}
@Override
public Hat getHat() {
return new LiverpoolHat();
}
}
巴黎工厂
public class ParisFactory implements ClubFactory {
@Override
public Scarf getScarf() {
return new ParisScarf();
}
@Override
public Hat getHat() {
return new ParisHat();
}
}
测试
public class Test {
public static void main(String[] args) {
ClubFactory clubFactory = new LiverpoolFactory();
Hat hat = clubFactory.getHat();
Scarf scarf = clubFactory.getScarf();
hat.keepWarm();
scarf.keepWarm();
clubFactory = new ParisFactory();
scarf = clubFactory.getScarf();
hat = clubFactory.getHat();
hat.keepWarm();
scarf.keepWarm();
}
}
运行结果
利物浦帽子:只护头
利物浦围巾:还是只护头...
巴黎帽子:也是只护头!!?
巴黎围巾:应该造点衣服...