java中工厂方法模式_工厂方法模式-Java设计模式笔记(二) | 六阿哥博客
工厂方法模式是定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。属于创建型，也属于GOF23种设计模式。
适用范围
1.创建对象需要大量重复的代码。
2.客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。
3.一个类通过其子类来指定创建哪个对象。
优缺点
优点：用户只需要关心所需产品对应的工厂，无需关心创建细节。加入新产品符合开闭原则，提高可扩展性。
缺点：类的个人容易过多，增加复杂度。增加了系统的抽象性和理解难度。
示例
Video.java 视频抽象类，提供生产视频的抽象方法。
package com.zaiae.design.pattern.creational.factorymethod;
public abstract class Video {
public abstract void produce();
}
1
2
3
4
5
packagecom.zaiae.design.pattern.creational.factorymethod;
publicabstractclassVideo{
publicabstractvoidproduce();
}
JavaVideo.java Java视频类，继承视频抽象类，并实现自己的生产视频逻辑。
package com.zaiae.design.pattern.creational.factorymethod;
public class JavaVideo extends Video {
@Override
public void produce() {
System.out.println("录制一套Java课程视频");
}
}
1
2
3
4
5
6
7
8
9
packagecom.zaiae.design.pattern.creational.factorymethod;
publicclassJavaVideoextendsVideo{
@Override
publicvoidproduce(){
System.out.println("录制一套Java课程视频");
}
}
PythonVideo.java Python视频类，继承视频抽象类，并实现自己的生产视频逻辑。
package com.zaiae.design.pattern.creational.factorymethod;
public class PythonVideo extends Video {
@Override
public void produce() {
System.out.println("录制一套Python课程视频");
}
}
1
2
3
4
5
6
7
8
9
packagecom.zaiae.design.pattern.creational.factorymethod;
publicclassPythonVideoextendsVideo{
@Override
publicvoidproduce(){
System.out.println("录制一套Python课程视频");
}
}
VideoFactory.java 生产视频的工厂方法基类，只定义规范和契约。我们该使用抽象类还是接口，需要根据实际需求来确定。
package com.zaiae.design.pattern.creational.factorymethod;
public abstract class VideoFactory {
public abstract Video getVideo();
}
1
2
3
4
5
packagecom.zaiae.design.pattern.creational.factorymethod;
publicabstractclassVideoFactory{
publicabstractVideogetVideo();
}
JavaVideoFactory.java 生产Java视频的工厂方法类，创建需要的对象。
package com.zaiae.design.pattern.creational.factorymethod;
public class JavaVideoFactory extends VideoFactory {
@Override
public Video getVideo() {
return new JavaVideo();
}
}
1
2
3
4
5
6
7
8
packagecom.zaiae.design.pattern.creational.factorymethod;
publicclassJavaVideoFactoryextendsVideoFactory{
@Override
publicVideogetVideo(){
returnnewJavaVideo();
}
}
PythonVideoFactory.java 生产Python视频的工厂方法类，创建需要的对象。
package com.zaiae.design.pattern.creational.factorymethod;
public class PythonVideoFactory extends VideoFactory {
@Override
public Video getVideo() {
return new PythonVideo();
}
}
1
2
3
4
5
6
7
8
packagecom.zaiae.design.pattern.creational.factorymethod;
publicclassPythonVideoFactoryextendsVideoFactory{
@Override
publicVideogetVideo(){
returnnewPythonVideo();
}
}
Test.java 客户端(应用层)调用工厂方法，创建需要的对象。
package com.zaiae.design.pattern.creational.factorymethod;
public class Test {
public static void main(String[] args) {
VideoFactory videoFactory = new JavaVideoFactory();
videoFactory.getVideo().produce();
VideoFactory videoFactory1 = new PythonVideoFactory();
videoFactory1.getVideo().produce();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
packagecom.zaiae.design.pattern.creational.factorymethod;
publicclassTest{
publicstaticvoidmain(String[]args){
VideoFactoryvideoFactory=newJavaVideoFactory();
videoFactory.getVideo().produce();
VideoFactoryvideoFactory1=newPythonVideoFactory();
videoFactory1.getVideo().produce();
}
}
UML结构图：
JDK中的使用例子
例如在 java.util.Collection 接口中的 Iterator iterator() 方法，就是一个工厂方法。
在具体的实现工厂 java.util.ArrayList 中重写 Iterator iterator() 方法，用于创建 Iterator 实例对象。
public Iterator iterator() {
return new Itr();
}
private class Itr implements Iterator {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
Itr() {}
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
publicIteratoriterator(){
returnnewItr();
}
privateclassItrimplementsIterator{
intcursor;//indexofnextelementtoreturn
intlastRet=-1;//indexoflastelementreturned;-1ifnosuch
intexpectedModCount=modCount;
Itr(){}
publicbooleanhasNext(){
returncursor!=size;
}
@SuppressWarnings("unchecked")
publicEnext(){
checkForComodification();
inti=cursor;
if(i>=size)
thrownewNoSuchElementException();
Object[]elementData=ArrayList.this.elementData;
if(i>=elementData.length)
thrownewConcurrentModificationException();
cursor=i+1;
return(E)elementData[lastRet=i];
}
publicvoidremove(){
if(lastRet<0)
thrownewIllegalStateException();
checkForComodification();
try{
ArrayList.this.remove(lastRet);
cursor=lastRet;
lastRet=-1;
expectedModCount=modCount;
}catch(IndexOutOfBoundsExceptionex){
thrownewConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
publicvoidforEachRemaining(Consumerconsumer){
Objects.requireNonNull(consumer);
finalintsize=ArrayList.this.size;
inti=cursor;
if(i>=size){
return;
}
finalObject[]elementData=ArrayList.this.elementData;
if(i>=elementData.length){
thrownewConcurrentModificationException();
}
while(i!=size&&modCount==expectedModCount){
consumer.accept((E)elementData[i++]);
}
//updateonceatendofiterationtoreduceheapwritetraffic
cursor=i;
lastRet=i-1;
checkForComodification();
}
finalvoidcheckForComodification(){
if(modCount!=expectedModCount)
thrownewConcurrentModificationException();
}
}
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！