java设计模式prototype模式
按我的理解,原型引入的根本原因就是在于它可以利用一个原型对象(在这,我指的是实例,而非类),快速地生成一批和原型对象一样的实例。举个例子来说,你有一个类A的实例a (A a=new A()),现在你想生成一个和a一样的实例b,那么,按照原型的定义,你应该可以这样做b=a.clone()。这样,你就可以得到一个和a一模一样的实例b(即a和部b的数据成员的值完全一样)。
上面是原型的一个简单说明,那么引入原型有什么好处呢?按我的理解,就是在于:你如果要生成一大批很相像的类的实例时,省得每次去做重复的赋值工作。再举个例子,如果你有一个类A,它有十个成员变量,现在你打算生成100个A的实例,而这些实例的变量值大部分相同(比如说七个相同),只有一小部分不一样(比如说三个),那么如果没有Prototype,那么你就得每次New一个A的对像,然后赋值,这样,你要重复100次同样的七个变量的赋值工作,显然,这样很麻烦。现在你有了原型,那么问题就简单了,你只要生成一个A的实例,再通过clone来生成其它的实例,然后再一一修改其它实例不同的地方。
java 设计模式用了哪些
在JDK(Java Development Kit)类库中,开发人员使用了大量设计模式,正因为如此,我们可以在不修改JDK源码的前提下开发出自己的应用软件,研究JDK类库中的模式实例也不失为学习如何使用设计模式的一个好方式。
创建型模式:
(1) 抽象工厂模式(Abstract Factory)
• Java.util.Calendar#getInstance()
• java.util.Arrays#asList()
• java.util.ResourceBundle#getBundle()
• java.NET.URL#openConnection()
• java.sql.DriverManager#getConnection()
• java.sql.Connection#createStatement()
• java.sql.Statement#executeQuery()
• java.text.NumberFormat#getInstance()
• java.lang.management.ManagementFactory (所有getXXX()方法)
• java.nio.charset.Charset#forName()
• javax.xml.parsers.DocumentBuilderFactory#newInstance()
• javax.xml.transform.TransformerFactory#newInstance()
• javax.xml.xpath.XPathFactory#newInstance()
(2) 建造者模式(Builder)
• java.lang.StringBuilder#append()
• java.lang.StringBuffer#append()
• java.nio.ByteBuffer#put() (CharBuffer, ShortBuffer, IntBuffer,LongBuffer, FloatBuffer 和DoubleBuffer与之类似)
• javax.swing.GroupLayout.Group#addComponent()
• java.sql.PreparedStatement
• java.lang.Appendable的所有实现类
(3) 工厂方法模式(Factory Method)
• java.lang.Object#toString() (在其子类中可以覆盖该方法)
• java.lang.Class#newInstance()
• java.lang.Integer#valueOf(String) (Boolean, Byte, Character,Short, Long, Float 和 Double与之类似)
• java.lang.Class#forName()
• java.lang.reflect.Array#newInstance()
• java.lang.reflect.Constructor#newInstance()
(4) 原型模式(Prototype)
• java.lang.Object#clone() (支持浅克隆的类必须实现java.lang.Cloneable接口)
(5) 单例模式 (Singleton)
• java.lang.Runtime#getRuntime()
• java.awt.Desktop#getDesktop()
结构型模式:
(1) 适配器模式(Adapter)
•java.util.Arrays#asList()
•javax.swing.JTable(TableModel)
•java.io.InputStreamReader(InputStream)
•java.io.OutputStreamWriter(OutputStream)
•javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
•javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()
(2) 桥接模式(Bridge)
• AWT (提供了抽象层映射于实际的操作系统)
•JDBC
(3) 组合模式(Composite)
•javax.swing.JComponent#add(Component)
•java.awt.Container#add(Component)
•java.util.Map#putAll(Map)
•java.util.List#addAll(Collection)
•java.util.Set#addAll(Collection)
(4) 装饰模式(Decorator)
•java.io.BufferedInputStream(InputStream)
•java.io.DataInputStream(InputStream)
•java.io.BufferedOutputStream(OutputStream)
•java.util.zip.ZipOutputStream(OutputStream)
•java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
(5) 外观模式(Facade)
•java.lang.Class
•javax.faces.webapp.FacesServlet
(6) 享元模式(Flyweight)
•java.lang.Integer#valueOf(int)
•java.lang.Boolean#valueOf(boolean)
• java.lang.Byte#valueOf(byte)
•java.lang.Character#valueOf(char)
(7) 代理模式(Proxy)
• java.lang.reflect.Proxy
•java.rmi.*
行为型模式:
(1) 职责链模式(Chain of Responsibility)
•java.util.logging.Logger#log()
•javax.servlet.Filter#doFilter()
(2) 命令模式(Command)
• java.lang.Runnable
• javax.swing.Action
(3) 解释器模式(Interpreter)
• java.util.Pattern
• java.text.Normalizer
• java.text.Format
• javax.el.ELResolver
(4) 迭代器模式(Iterator)
• java.util.Iterator
• java.util.Enumeration
(5) 中介者模式(Mediator)
• java.util.Timer (所有scheduleXXX()方法)
• java.util.concurrent.Executor#execute()
• java.util.concurrent.ExecutorService (invokeXXX()和submit()方法)
• java.util.concurrent.ScheduledExecutorService (所有scheduleXXX()方法)
•java.lang.reflect.Method#invoke()
(6) 备忘录模式(Memento)
•java.util.Date
•java.io.Serializable
•javax.faces.component.StateHolder
(7) 观察者模式(Observer)
•java.util.Observer/java.util.Observable
•java.util.EventListener (所有子类)
•javax.servlet.http.HttpSessionBindingListener
•javax.servlet.http.HttpSessionAttributeListener
•javax.faces.event.PhaseListener
(8) 状态模式(State)
•java.util.Iterator
•javax.faces.lifecycle.LifeCycle#execute()
(9) 策略模式(Strategy)
• java.util.Comparator#compare()
• javax.servlet.http.HttpServlet
• javax.servlet.Filter#doFilter()
(10) 模板方法模式(Template Method)
•java.io.InputStream, java.io.OutputStream, java.io.Reader和java.io.Writer的所有非抽象方法
•java.util.AbstractList, java.util.AbstractSet和java.util.AbstractMap的所有非抽象方法
•javax.servlet.http.HttpServlet#doXXX()
(11) 访问者模式(Visitor)
•javax.lang.model.element.AnnotationValue和AnnotationValueVisitor
•javax.lang.model.element.Element和ElementVisitor
•javax.lang.model.type.TypeMirror和TypeVisitor
clone和用new创建对象的代价有什么不同?怎么产生的代价?
帮你搜了一下,以下答案看是否满意:
1、new
使用java的关键字new来创建对象实例。构造函数链中的所有构造函数都会被自动调用。
Java代码:
CreateInstance instance = new CreateInstance ();
2、clone
构造函数不被自动调用。
Java代码:
public class CreateInstance implements Cloneable{
public CreateInstance getInstance() throws CloneNotSupportedException{
return (CreateInstance) this.clone();
}
}
如果需要复制上面的那个obj指向的对象实例时,调用new CreateInstance().getInstance()方法就ok了。
JDK中Object# clone()方法的原型是:protected native Object clone() throws CloneNotSupportedException; 方法修饰符是protected,而不是public。
这种访问的不可见性使得对Object#clone()方法不可见。所以,必需重写Object的clone方法后才能使用。
Java代码:
public class CreateInstance implements Cloneable{
public CreateInstance clone throws CloneNotSupportedException{
return (CreateInstance) super.clone();
}
}
值得注意的是 :如果需要使用clone方法,必需实现java.lang.Cloneable接口,否则会抛出java.lang.CloneNotSupportedException。
另外clone方法所做的的操作是直接复制字段的内容,换句话说,这个操作并不管该字段对应的对象实例内容。
像这样字段对字段的拷贝(field to field copy)就成为”浅拷贝”,clone方法所做的正是”浅拷贝”。
3、newInstance
利用java.lang.Class类的newInstance方法,则可根据Class对象的实例,建立该Class所表示的类的对象实例。
创建CreateInstace类的对象实例可以使用下面的语句(这样需要一个已经存在的对象实例)。
CreateInstance instance = CreateInstance.class.newInstance();
或者使用下面的语句(只需要存在相应的.class文件即可)
CreateInstance instance = (CreateInstance)Class.forname(“com.create.instance.CreateInstance”).newInstance();
如果包下不存在相应.class文件,则会抛出ClassNotFoundException。
注意 :newInstance创建对象实例的时候会调用无参的构造函数,所以必需确保类中有无参数的构造函数,否则将会抛出java.lang.InstantiationException异常。
无法进行实例化。
java代码 clone()函数的作用是什么?
从楼主对回答的追问上发现,楼主的连JAVA基本的语法都很差啊。=号是赋值运算符,不是比较。
double[] vectorValue;
vectorValue = vectorValue.clone();
这个段代码执行肯定报错了。但他还的意思还是很明确的。
首先:double[] vectorValue; 这个是定义了一个double类型的数组变量vectorValue。
其次:vectorValue = vectorValue.clone(); //这个是将vectorValue 克隆一份,赋值给自己。也就是说vectorValue变量指向了新的一块内存区域。
举个例子可能更能说明问题。
public class TestMain implements Cloneable {
private int i ;
public TestMain(int i){
this.i = i ;
}
@Override
protected Object clone() {
// TODO Auto-generated method stub
return new TestMain(this.getI()+1);
}
public int getI() {
return i;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TestMain tm1 = new TestMain(1);
TestMain tm2 = tm1;
tm1 = (TestMain)tm1.clone();
System.out.println(tm1.getI()); //tm1指向的是通过clone()方法创建的新的对象的地址,i的值已经是2了。
System.out.println(tm2.getI()); //tm2指向的还是tm1创建时的地址,i的值为1
}
}