精华内容
下载资源
问答
  • 原型化方法是用户和软件开发人员之间进行的一种交互过程,适用于(46)系统。它从用户界面的开发入手,首先形成(47) ,用户(48) ,并就(49) 提出意见,它是一种(50) 的设计过程。(46)A. 需求不确定性高...
     原型化方法是用户和软件开发人员之间进行的一种交互过程,适用于(46)系统。它从用户界面的开发入手,首先形成(47) ,用户(48) ,并就(49) 提出意见,它是一种(50) 型的设计过程。
    (46)A. 需求不确定性高的 B.需求确定的 C. 管理信息 D. 决策支持
    (47)A. 用户界面使用手册 B.用户界面需求分析说明书  C. 系统界面原型  D.完善的用户界面
    (48)A. 改进用户界面的设计 B. 阅读文档资料  C. 模拟用户界面的运行  D. 运行用户界面原型
    (49)A. 同意什么和不同意什么 B. 使用和不使用哪一种编程语言
    C. 程序的结构    D. 执行速度是否满足要求
    (50)A. 自外向内  B. 自顶向下  C. 自内向外  D. 自底向上
    分析:

      通常,原型是指模拟某种产品的原始模型。在软件开发中,原型是软件的一个早期可运行的版本,它反映最终系统的部分重要特性。

      使用原型的原型化方法特别适用于需求不确定性较高的软件系统的开发。它的基本思想是根据用户给出的基本需求,通过快速实现构造出一个小型的可执行的模型,满足用户的基本要求,这就是系统界面原型。让用户计算机上实际运行这个用户界面原型,在试用的过程中得到亲身感受和受到启发,做出反应和评价,提出同意什么和不同意什么。然后开发者根据用户的意见对原型加以改进。随着不断试验、纠错、使用、评价和修改,获得新的原型版本,如此周而复始,逐步减少分析和通信中的误解,弥补不足之处,进一步确定各种需求细节,适应需求的变更,从而提高了最终产品的质量。

      它是一种自外向内型的设计过程。
    答案: (46)A (47) C (48) D (49) A (50) A

    展开全文
  • 是一种创建设计模式,允许一个对象再创建另外一个可定制对象,无需知道创建的细节。 2.为什么要用原型模式: 复制类时可以简单操作,而无需在代码中直接冗余的创建,让程序有更高的效率和扩展性。 3.原型模式适用...

    原型模式

    1. 什么是原型模式:

    用原型实例指定创建对象种类,并且通过拷贝这些原型创建新的对象。是一种创建型设计模式,允许一个对象再创建另外一个可定制对象,无需知道创建的细节。

    2.为什么要用原型模式:
    复制类时可以简单操作,而无需在代码中直接冗余的创建,让程序有更高的效率和扩展性。

    3.原型模式适用于什么地方:

    • 当一个系统应该独立于他的产品创建,构成和表示时。
    • 要实例化的类是在运行时指定
    • 为了避免一个与产品类层次平行的工厂类层次时
    • 当一个类实例只能有几个不同状态组合的一种时。

    在这里插入图片描述**原型模式实现方法:**在类中实现clone方法,给使用者提供clone接口。

    一、浅拷贝复制:

    1. 对于数据类型为基本数据类型,浅拷贝会直接进行值传递,就是将该属性值复制给新的对象。
    2. 对于引用数据类型,浅拷贝会进行引用传递,也就是将该对象的引用值赋给新的对象,则新对象与被拷贝的对象的成员变量都指向一个实例,对原被拷贝的变量实例的值的改变也会影响新对象中的变量。

    实现:

    1. 实现Cloneable接口,重写clone方法。

    原型类:

    class DoriSheep implements Cloneable {
        private String name ;
        private  int age ;
        public DoriSheep sheep;
    
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            DoriSheep sheep =null;
            try {
                sheep = (DoriSheep) super.clone();
            }catch (Exception e){
                System.out.println("chucuole ");
            }
            return  sheep;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public DoriSheep getSheep() {
            return sheep;
        }
    
        public void setSheep(DoriSheep sheep) {
            this.sheep = sheep;
        }
    
        @Override
        public String toString() {
            return "DoriSheep{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sheep=" + sheep +
                    '}';
        }
    }
    

    测试类:

    public class PrototypeFirstTest {
    
        public static void main(String[] args) {
            DoriSheep sheep = new DoriSheep();
            sheep.setName("Dori");
            sheep.setAge(20);
            DoriSheep Fieldsheep = new DoriSheep();
            sheep.setSheep(Fieldsheep);
    
            try {
                DoriSheep sheep1 = (DoriSheep) sheep.clone();
                DoriSheep sheep2 = (DoriSheep) sheep.clone();
                System.out.println(sheep +"  "+sheep.sheep.hashCode());
                System.out.println(sheep1 +"  "+sheep1.sheep.hashCode());
                System.out.println(sheep2 +"  "+sheep2.sheep.hashCode());
                System.out.println("sheep1.sheep==sheep.sheep:"+ (sheep1.sheep==sheep.sheep) );
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        }
    }
    

    输出:

    在这里插入图片描述
    结论:浅拷贝后的对象与被拷贝的对象所得到引用变量是同一个实例。

    二、深拷贝复制:

    目的:使得拷贝后的对象与被拷贝的对象的引用变量不是用一个实例

    1、重写克隆方法时指定引用变量类型不同。

    class DoriSheep implements Cloneable, Serializable {
        private String name ;
        private  int age ;
        public Sheep sheep;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            DoriSheep newsheep =null;
            try {
                newsheep = (DoriSheep) super.clone();
                newsheep.sheep = (Sheep) sheep.clone();
            }catch (Exception e){
                System.out.println("chucuole ");
            }
            return  newsheep;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
    
    
        @Override
        public String toString() {
            return "DoriSheep{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sheep=" + sheep +
                    '}';
        }
    }
    

    在这里插入图片描述

    2、通过输入输出流实现

    class DoriSheep implements Cloneable, Serializable {
        private String name ;
        private  int age ;
        public Sheep sheep;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            DoriSheep newsheep =null;
            try {
                newsheep = (DoriSheep) super.clone();
                newsheep.sheep = (Sheep) sheep.clone();
            }catch (Exception e){
                System.out.println("chucuole ");
            }
            return  newsheep;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
    
    
        @Override
        public String toString() {
            return "DoriSheep{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sheep=" + sheep +
                    '}';
        }
         //深拷贝
        public Object deepClone(){
            ByteArrayOutputStream bos = null;
            ObjectOutputStream oos = null;
            ByteArrayInputStream bis = null;
            ObjectInputStream ois = null;
            DoriSheep doriSheep = null;
    
            try{
                //序列化
                bos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(bos);
                oos.writeObject(this);
    
                //反序列化
                bis = new ByteArrayInputStream(bos.toByteArray());
                ois = new ObjectInputStream(bis);
                doriSheep= (DoriSheep) ois.readObject();
                return doriSheep;
    
            }
            catch (Exception e){
             e.printStackTrace();
            }finally {
                try {
                    bos.close();
                    oos.close();
                    bis.close();
                    ois.close();
    
                }catch (Exception e){
                    e.printStackTrace();
                }
    
            }
            return doriSheep;
    
        }
    }
    

    在这里插入图片描述
    推荐用第二种,因为第一种每个引用数据类型都要实现对实例的复制,而第二种是写了一个deepclone()方法,利用输入输出流来实现,要在拷贝类中实现Serializable接口。

    原型模式缺点:

    • 需要为每个类都配备一个克隆方法,对新类来说也许不难,但对已有的类进行改造时,需要修改其源码,这违反了设计模式中的ocp原则。
    展开全文
  • 创建模式,共五:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 行为模式: 行为模式对在不同的对象之间划分责任和算法的抽象,行为模式不仅仅关注类和对象的结构,而且重点关注他们...

    创建型模式:

    创建型模式,就是创建对象的模式,抽象了实例化的过程。
    它帮助一个系统独立于如何创建、组合和表示它的那些对象。
    关注的是对象的创建,创建型模式将创建对象的过程进行了抽象,也可以理解为将创建对象的过程进行了封装,作为客户程序仅仅需要去使用对象,而不再关心创建对象过程中的逻辑

    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    行为型模式:

    行为型模式是对在不同的对象之间划分责任和算法的抽象化,行为型模式不仅仅关注类和对象的结构,而且重点关注他们之间的相互作用,通过行为型模式,可以更加清晰地划分类与对象的职责,并研究系统在运行时实例对象之间的交互。

    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    结构型模式:

    结构型模式是为解决怎样组装现有的类,设计他们的交互方式,从而达到实现一定的功能。

    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    三者之间的联系:

      创建型模式为其他两种模式使用提供了环境,好比VS软件提供了.net环境和操作平台,是各种编程语言能随心所欲地在这个平台上编译执行;
    

    结构型模式侧重于接口的使用,它做的一切工作都是对象或是类之间的交互,提供一个门,成就一个你来我往,协同合作的地球村;

    行为型模式顾名思义,侧重于具体行为,所以概念中才会出现职责分配和算法通信等内容。

    将三者结合起来成为故事,中美合作的故事——创建型模式提供国际环境,无战争,求发展;结构型模式为中美合作提供理由,即和平时代的互利共赢,行为型模式就具体到两个大国之间是如何合作,比如经济合作、文化合作等。
    ————————————————
    版权声明:本文为CSDN博主「迈巴别」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/zhanduo0118/article/details/85602983

    展开全文
  • 原型模式(Prototype Pattern)五种创建模式的其中一种,用原型实例指定创建对象的种类作为原型,并且通过拷贝原型来创建新的对象。 为什么要使用原型模式 新建一个对象有时候会很麻烦,可能涉及大量的变量初始...

    什么是原型模式

    原型模式(Prototype Pattern)是五种创建型模式的其中一种,用原型实例指定创建对象的种类作为原型,并且通过拷贝原型来创建新的对象。

    为什么要使用原型模式

    新建一个对象有时候会很麻烦,可能涉及大量的变量初始化,函数、代码块的执行,不仅浪费资源,还会涉及数据准备、访问权限等操作。

    实现

    原型模式至少涉及两个角色:

    • Prototype,即原型类:需要实现Cloneable接口,并重写clone()方法,为外部提供一个克隆自身的方法;
    • Client,即应用类:让一个原型克隆自身从而创建一个新的对象。
    public class Prototype implements Cloneable {
       //自身的一些方法...
        @Override
        public Object clone() throws CloneNotSupportedException {
            Prototype proto = (Prototype) super.clone();
            return proto;
        }
    }
    public class Client {
        public static void main(String[] args) throws CloneNotSupportedException {
            Prototype prototype = new Prototype();
            Prototype prototype1 = (Prototype) prototype.clone();
           	...
        }
    }
    

    为了探讨其中的一些细节,我们对上面的代码稍微添加一些细节部分:

    public class Prototype implements Cloneable {
        private String name;
    
        public Prototype() {
            System.out.println("empty constructor--------------------");
        }
      
        public Prototype(String name) {
            System.out.println("constructor--------------------");
            this.name = name;
        }
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            Prototype proto = (Prototype) super.clone();
            return proto;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return super.toString() + " " + this.getName();
        }
    }
    
    public class Client {
        public static void main(String[] args) throws CloneNotSupportedException {
            Prototype prototype = new Prototype();
            prototype.setName("111");
            System.out.println(prototype.toString());
            Prototype prototype1 = (Prototype) prototype.clone();
            System.out.println(prototype1.toString());
            prototype1.setName("222");
            System.out.println(prototype.toString());
            System.out.println(prototype1.toString());
        }
    }
    

    在Prototype类中加入了构造函数,重写了toString(),运行main(),结果如下:

    empty constructor--------------------
    com.company.Prototype@4554617c 111
    com.company.Prototype@74a14482 111
    com.company.Prototype@4554617c 111
    com.company.Prototype@74a14482 222
    

    可以看出:

    构造函数只执行了一次,说明复制原型类的对象并不需要执行构造函数;
    原对象和复制对象的地址不同,说明是重新创建的;
    目前看来,在复制完成之后,复制的对象似乎和原对象就没有关系了,原对象的改变不会影响复制的对象,复制的对象改变也不会影响原对象。

    真的是这样吗?

    我们修改一下代码:

    public class Car {
        private String color;
    
        public Car() {
        }
    
        public Car(String color) {
            this.color = color;
        }
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    }
    
    public class Prototype implements Cloneable {
        private String name;
        private Car car;
    
        public Prototype() {
            System.out.println("empty constructor--------------------");
        }
    
        public Prototype(String name) {
            System.out.println("constructor--------------------");
            this.name = name;
        }
    
        public Prototype(String name, Car car) {
            this.name = name;
            this.car = car;
        }
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            Prototype proto = (Prototype) super.clone();
            return proto;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Car getCar() {
            return car;
        }
    
        public void setCar(Car car) {
            this.car = car;
        }
    
        @Override
        public String toString() {
            return super.toString() + " " + this.getName() + " " + this.getCar().getColor() + " Car" +  " " + this.getCar().toString();
        }
    }
    
    public class Client {
        public static void main(String[] args) throws CloneNotSupportedException {
            Prototype prototype = new Prototype();
            Car car1 = new Car("red");
            Car car2 = new Car("yel");
            prototype.setName("111");
            prototype.setCar(car1);
            System.out.println(prototype.toString());
            Prototype prototype1 = (Prototype) prototype.clone();
            System.out.println(prototype1.toString());
            prototype1.setName("222");
            prototype1.setCar(car2);
            System.out.println(prototype.toString());
            System.out.println(prototype1.toString());
        }
    }
    

    执行结果:

    empty constructor--------------------
    com.company.Prototype@4554617c 111 red Car	com.company.Car@74a14482
    com.company.Prototype@1540e19d 111 red Car	com.company.Car@74a14482
    com.company.Prototype@4554617c 111 red Car	com.company.Car@74a14482
    com.company.Prototype@1540e19d 222 yel Car	com.company.Car@677327b6
    

    可以看过结果中第4行和第5行,Car的颜色和地址都不一样,我几乎可以得出结论它们确实不是一个对象了,但是这样写其实是有漏洞的,我通过setCar()是显式地改变了这个对象,不能正确得出结论。

    再将输出改一下:

    public class Client {
        public static void main(String[] args) throws CloneNotSupportedException {
            Prototype prototype = new Prototype();
            Car car1 = new Car("red");
            prototype.setName("111");
            prototype.setCar(car1);
            System.out.println(prototype.toString());
            Prototype prototype1 = (Prototype) prototype.clone();
            System.out.println(prototype1.toString());
            prototype1.setName("222");
            prototype1.getCar().setColor("black");
            System.out.println(prototype.toString());
            System.out.println(prototype1.toString());
        }
    }
    

    结果变为:

    empty constructor--------------------
    com.company.Prototype@4554617c 111 red Car com.company.Car@74a14482
    com.company.Prototype@1540e19d 111 red Car com.company.Car@74a14482
    com.company.Prototype@4554617c 111 black Car com.company.Car@74a14482
    com.company.Prototype@1540e19d 222 black Car com.company.Car@74a14482
    

    所有的Car对象的地址都是同一个,颜色值也一同改变,说明clone()实现的是浅拷贝。

    浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型仍指向的还是原对象所指向的地址。 深复制:将一个对象复制后,基本数据类型和引用类型都重新创建。

    如果想对引用类型也实现深拷贝,可以采用二进制流读写等操作实现,此处不再详述。

    展开全文
  • Java学习之路4--原型模式(浅拷贝、深拷贝)什么原型模式浅拷贝的原型模式题目传统实现运用原型模式的浅克隆实现深拷贝的原型模式1.什么是深拷贝例子证明(运用浅拷贝进行...2.原型模式是一种创建设计模式,运行
  • 3、FACTORY METHOD—请MM去麦当劳吃汉堡,不同的MM有不同的口味,要每个都记住是一件烦人的事情,我一般采用Factory Method模式,带着MM到服务员那儿,说“要一个汉堡”,具体要什么样的汉堡呢,让MM直接跟服务员说...
  • “模式”是什么

    2018-11-15 19:28:36
    广义上的“模式是一种原型方法prototype,它用“模”给出标准/要求,用“式”达成目标/目的。 模Mode:表示事物的(已知)特征信息。也就是说,“模”是对事物不变性、确定性,如物理结构、内容构成等的概念,...
  •  Ezra是AxureWorld.org的创始人和组织者,这是一个免费的国际讨论社区,专注于快速UX原型设计。Ezra经常在一些大会上和个人博客www.artandtech.com上讨论用户体验相关的主题。 目录 推荐序 前言 第1章 原型基础...
  • 设计模式总结—创建

    热门讨论 2017-06-03 17:59:25
    什么是设计模式,模就是模板的意思,式就是方式,设计模式就相当于一种解决方案,每一种设计模式特定问题的一种解决方案。二十三种设计模式分为三大类(创建、结构、行为)。 先来理解一下创建模式: ...
  • “创建模式”GoF设计模式的第大类,主要包括了工厂模式、单例模式、原型模式和建造者模式4。本篇,我们对创建模式进行个小结。 存在的意义: 创建模式隐藏了了类的实例过程,客户端使用目标类时,...
  • 创建模式总结

    2018-10-04 23:02:00
    创建类模式有5,分别: 单例模式:用于得到内存中的唯一对象。 工厂方法模式:用于创建复杂对象。 抽象工厂模式:用于创建组相关或相互依赖的复杂对象。 建造者模式:用于创建模块的更加复杂的对象。 ...
  • 创建模式回顾

    2014-01-14 15:53:55
    创建类模式有5,分别: 单例模式:用于得到内存中的唯一对象。工厂方法模式:用于创建复杂对象。抽象工厂模式:用于创建组相关或相互依赖的复杂对象。建造者模式:用于创建模块的更加复杂的对象。原型...
  • 这个小节我会带着大家结合案例简单介绍下工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式这 5 创建模式下的设计模式以及在什么样的情况下要运用这些设计模式。 设计模式对设计原则的具体。用...
  • C#23设计模式

    2013-06-02 16:49:43
    请MM去麦当劳吃汉堡,不同的MM有不同的口味,要每个都记住是一件烦人的事情,我一般采用Factory Method模式,带着MM到服务员那儿,说“要一个汉堡”,具体要什么样的汉堡呢,让MM直接跟服务员说就行了。 工厂方法...
  • 创建模式,共五:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构模式,共七:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为模式,共十一:...
  • 二十三设计模式【PDF版】

    热门讨论 2011-05-30 14:13:49
    我上面这些描述其实都是一种模式,创建模式的人是大师,但是拘泥于模式的人永远是工匠. 再回到传统建筑中,中国的传统建筑是过分注重模式了,所以建筑风格发展不大,基本分南北两派,大家有个感觉,旅游时,到南 方,你发现...
  • Web语义标准解读

    2020-11-25 23:26:16
    什么是语义 <p>The Semantic Web provides a common framework that allows data to be shared and reused across application, enterprise, and community boundaries. --Wikipedia 语义Web具备让数据跨终端...
  • 23设计模式.txt

    2009-06-27 15:28:57
     3、FACTORY METHOD—请MM去麦当劳吃汉堡,不同的MM有不同的口味,要每个都记住是一件烦人的事情,我一般采用Factory Method模式,带着MM到服务员那儿,说“要一个汉堡”,具体要什么样的汉堡呢,让MM直接跟服务员...
  • 原始模型模式: 原始模型模式 通过给出原型对象来指明所要创建的对象的类型,然后用复制这个原 对象的方法创建出更多同类型的对象。 原始模型模式允许动态的增加或减少产品类, 产品 类不需要非得有任何事先...
  • 6.4 现有方法一种补充 233 6.5 重构的目标 233 6.6 本书简史 234 6.7 模式界 235 6.8 Alexander 的模式语言 235 6.9 软件中的模式 236 6.10 邀请参与 237 6.11 临别感想 237 附录A 词汇表 238 附录B 图示符号指南 ...
  • 设计模式对软件系统中不断重现的设计问题的解决方案进行文档的技术,就是一种共享专家设计经验的技术。 目的就是为了可重用代码、让代码更易读,并提高代码可靠性。 设计模式的基本要素就是模式名称、问题...
  • 1.4一种观察世界的方式 ............................................................................. 5 1.4.1代理和团体 ....................................................................................
  • 《从新手到高手——C++全方位学习-(零起点范例教学)-》,作者:范磊,出版社:科学出版社,ISBN:9787030247063,PDF 格式,影印版,大小 68Mb,被压缩为 2 部分,本资源部分:第部分下载地址:...
  • 13.5 存储时间的最好方法是一种? 第14章 系统调用 14.1 怎样检查环境变量(environment variables)的值? 14.2 怎样在程序中调用DOS函数? 14.3 怎样在程序中调用BIOS函数? 14.4 怎样在程序中存取重要的...
  • C语言编程要点

    2017-09-18 00:10:37
    13.5. 存储时间的最好方法是一种? 194 第14章 系统调用 194 14.1. 怎样检索环境变量(environment variables)的值? 195 14.2. 怎样在程序中调用DOS函数? 195 14.3. 怎样在程序中调用BIOS函数? 197 14.4. 怎样在程序...
  • Javascript高级程序设计JavaScript是一种不严格基于Java的面向对象程序设计语言,以嵌入式Java小程序的形式在Web上广为使用。《JavaScript高级程序设计》从最早期Netscape浏览器中的JavaScript开始讲起,直到当前它...
  • 什么是设计模式? 设计模式在大量的实践中总结和理论之后优选的代码结构、编程风格、 以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像经典 的棋谱,不同的棋局,我们用不同的棋谱。”...
  • 设计模式总结

    2020-03-07 10:07:04
    、为什么用设计模式? 使用设计模式为了可重用代码、让代码更容易被他人理解、保证代码...1.创建:共五:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 2.结构:共七:适配器模式...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 159
精华内容 63
关键字:

原型化方法是一种什么型