精华内容
下载资源
问答
  • 需求分析中原型化方法

    千次阅读 热门讨论 2016-12-25 21:46:26
    采用逐步求精的方法使原型逐步完善,这是一种在新的层次上不断反复推进的过程. 它与瀑布模型的关键区别是它可以大大避免在瀑布模型冗长的开发过程中看不见产品雏形的现象. ...

    前提:

    看了一段是时间的软工,赶快来发总结的。

    原型化方法之前的时候是在 软件谁家模型的时候了解过原型模型,不由自主的想到了。

    原型化方法

    内容:


    原型化方法

    原型基本思想:根据用户提出的需求,由用户与开发者共同确定系统的基本要求和主要功能,并在较短时间内简历一个实验性的,简单的小型系统。
     原型:优点。符合人们认识事物的规律,开发周期短,费用相对少,应变能力强。

    缺点。不符合大型系统,开发难以控制,系统难以维护。范围。小型系统的开发。采用原型化的方法会增加成本。
    2. 分类

    探索型,实验型,进化型
    原则。逻辑设计与物理设计分开的原则,面向用户的原则,结构化分析的原则。


    原型模型

    原型模型的优点

    原型模型的最大特点是:

    利用原型法技术能够快速实现系统的初步模型,

    供开发人员和用户进行交流,

    以便较准确地获得用户的需求;

    采用逐步求精的方法使原型逐步完善,这是一种在新的层次上不断反复推进的过程.

    它与瀑布模型的关键区别是它可以大大避免在瀑布模型冗长的开发过程中看不见产品雏形的现象.







    如下图:将原型化方法在开发的每个阶段都对应起来,参照六个阶段,进行原型开发。也就是在每一个阶段都会进行原型化分析,考虑用户的需求。






    总结

    原型化方法,用来改进瀑布模型的 ,在设计中会有用不得参与,用户可以提出自己的要求,是整个开发过程更加的人性化。










    展开全文
  • JS原型原型链是什么

    万次阅读 多人点赞 2018-06-15 17:50:58
    Javascript语言的继承机制一直很难被人理解。...Brendan Eich设计javascript之初是为了实现网页与浏览器之间交互的一种简单的脚本语言 如果真的是一种简易的脚本语言,其实不需要有"继承"机

    Javascript语言的继承机制一直很难被人理解。

    它没有"子类"和"父类"的概念,也没有"类"(class)和"实例"(instance)的区分,全靠一种很奇特的"原型链"(prototype chain)模式,来实现继承。

    Brendan Eich设计javascript之初是为了实现网页与浏览器之间交互的一种简单的脚本语言

    如果真的是一种简易的脚本语言,其实不需要有"继承"机制。但是,Javascript里面都是对象,必须有一种机制,将所有对象联系起来。所以,Brendan Eich最后还是设计了"继承"。


     

    背景介绍

    1.构造函数

    构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象。每个构造函数都有prototype(原型)属性

    2.原型模式

    每个函数都有prototype(原型)属性,这个属性是一个指针,指向一个对象,这个对象的用途是包含特定类型的所有实例共享的属性和方法,即这个原型对象是用来给实例共享属性和方法的。
    而每个实例内部都有一个指向原型对象的指针。

    image.png

    原型链

    每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数的指针,而实例都包含指向原型对象内部的指针。我们让原型对象的实例(1)等于另一个原型对象(2),
    此时原型对象(2)将包含一个指向原型对象(1)的指针,
    再让原型对象(2)的实例等于原型对象(3),如此层层递进就构成了实例和原型的链条,这就是原型链的概念


     

    构造函数

    构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象。 即为对象变量赋初始值。每个构造函数的实例都将共享构造函数的初始值。 构造函数的出现是为了解决使用Object构造函数和字面量表示法不方便创建大量重复对象的问题。

    传统创建对象实例的方法

    
       var person={
           name:'张女士',
           age:'80',
           gender:'女'
       };
     console.log(person)
    

    注:这个方法如果用于创建大量相同属性和方法的对象时,会产生大量重复代码

    构造函数的方法

    
         //构造函数方法创建对象实例
         function Person(name,age,gender) {
         this.name=name;
         this.age=age;
         this.gender=gender;
         this.say=function () {
         alert(this.name)
               }
         }
        var person1=new Person('钟女士',80,'女');
        var person2=new Person('张女士',80,'女');
        console.log(person2)
        console.log(person1)
    

    原型模式

    使用构造函数的问题是,每个方法都要在每个实例上重新创建一遍,即在构造函数的不同实例上的同名函数是不相等的。而我们创建每个构造函数都有一个prototype(原型)属性,这个属性是个指针,指向一个对象,而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法,我们使用这个原型对象来共享实例的属性和方法的模式就叫原型模式

    
      //原型模式创建对象
    function Person(){
     }
    Person.prototype.name='钟女士';
    Person.prototype.age=80;
    Person.prototype.gender='女';
    var person1= new Person();
    console.log(person1)
    //简写原型模式
    Person.prototype={
       constructor:Person
       name:'钟女士',
       age:80,
       gender:'女'
     }
    

    注:每个原型对象都有constructor属性,由于简写模式重写了默认的prototype对象,所以constructor也会被重新定义,不再指向他的构造函数,所以可以自己写一个constructor属性指向他的构造函数

    原型链

    每个构造函数都有原型对象,每个构造函数实例都包含一个指向原型对象的内部指针(proto),如果我们让第一个构造函数的原型对象等于第二个构造函数的实例,结果第一个构造函数的原型对象将包含一个指向第二个原型对象的指针,再然第三个原型对象等于第一个构造函数的实例,这样第三个原型对象也将包含指向第一个原型对象的指针,以此类推,就够成了实例于原型的链条,这就是原型链的基本概念

    
    function One(){
     }
     function Two(){
     }
     function Three(){
     }
     Two.prototype=new One();
     Three.prototype=new Two();
     var three=new Three();
     console.log(three);
     console.log(three.__proto__===Three.prototype) //true
     console.log(three.__proto__.__proto__===Two.prototype) //true
     console.log(three.__proto__.__proto__.__proto__===One.prototype)  //true
     console.log(three.__proto__.__proto__.__proto__.__proto__===Object.prototype)  //true
    

     

    在对象实例中,访问对象原型的方法

    • 1、使用proto属性
      此属性是浏览器支持的一个属性,并不是ECMAScript里的属性

    • 2.Object.getPrototypeOf

    • 3.使用constructor.prototype的方法
      对于不支持proto的浏览器,可以使用constructor,访问到对象的构造函数,在用prototype访问到原型

     

    使用原型链解释ANUGLAR作用域

    在开发过程中,我们可能会出现控制器的嵌套,看下面这段代码:

        <div ng-controller="OuterCtrl">
            <span>{{a}}</span>
             <div ng-controller="InnerCtrl">
                <span>{{a}}</span>
             </div>
         </div>
        <script>
        function OuterCtrl($scope) {
        $scope.a = 1;
        }
        function InnerCtrl($scope) {
        }
        </script>
    

    我们可以看到界面显示了两个1,而我们只在OuterCtrl的作用域里定义了a变量,但界面给我们的结果是,两个a都有值,现在自控制器里的a是从父控制器里继承过来的

    我们可以父子级的作用域看成两个原型对象,其中一个原型对象继承另一个原型对象的实例

    
    function Outer() {
        this.a = 1;
    }
    
    function Inner() {
    }
    
    var outer = new Outer();
    Inner.prototype=new Outer();
    var inner = new Inner();
    console.log(outer.a)
    console.log(inner.a)
    

    Angular的实现机制其实也就是把这两个控制器中的$scope作了关联,外层的作用域实例成为了内层作用域的原型。

    既然作用域是通过原型来继承的,自然也就可以推论出一些特征来。比如说这段代码,点击按钮的结果是什么?

    <div ng-controller="OuterCtrl">
        <span>{{a}}</span>
        <div ng-controller="InnerCtrl">
            <span>{{a}}</span>
            <button ng-click="a=a+1">a++</button>
        </div>
    </div>
    <script>
    function OuterCtrl($scope) {
        $scope.a = 1;
    }
    
    function InnerCtrl($scope) {
    }
    </script>
    

    点了按钮之后,两个a不一致了,里面的变了,外面的没变,这是为什么?

    
    function Outer() {
        this.a = 1;
    }
    
    function Inner() {
    }
    
    var outer = new Outer();
    Inner.prototype=new Outer();
    var inner = new Inner();
    inner.a = inner.a + 1;
    console.log(outer.a)
    console.log(inner.a)
    

    因为在原型链中,访问一个实例属性时,会在实例本身查找,如果找不到,则搜索实例的原型,如果再搜索不到,则继续沿着原型链往上查找。找到之后则会赋给该实例,所以inner上面就被赋值了一个新的a,outer里面的仍然保持原样,这也就导致了刚才看到的结果。

    上下级共享变量

    比如说,我们就是想上下级共享变量,不创建新的,该怎么办呢?

    
    function Outer() {
        this.data = {
            a: 1
        };
    }
    
    function Inner() {
    }
    
    var outer = new Outer();
    Inner.prototype = outer;
    
    var inner = new Inner();
    
    console.log(outer.data.a);
    console.log(inner.data.a);
    inner.data.a += 1;
    
    console.log(outer.data.a);
    console.log(inner.data.a);
    

    我们可以把a写在一个对象里,当inner找到对象data并赋值到自己身上时,其实是复制了对象的指针(参考高程第4章复制引用类型和基本类型的区别),我们对对象里的属性的改动都会反映到所有引用该对象的元素上。
    反映到AngularJs,我们可以这么写

    <div ng-controller="OuterCtrl">
        <span>{{data.a}}</span>
        <div ng-controller="InnerCtrl">
            <span>{{data.a}}</span>
            <button ng-click="data.a=data.a+1">increase a</button>
        </div>
    </div>
    <script>
    function OuterCtrl($scope) {
        $scope.data = {
            a: 1
        };
    }
    
    function InnerCtrl($scope) {
    }
    </script>
    

    这样点击按钮两个控制器的a都会+1

     

    展开全文
  • 什么原型对象?原型链?

    千次阅读 2019-03-27 22:31:08
    对象是个包含相关数据和方法的集合(通常由一些变量和函数组成,我们称之为对象里面的属性和方法)。 对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射,而数组做的是数字到值的映射...

    对象

    对象基础

    对象的定义

    对象是一个包含相关数据和方法的集合(通常由一些变量和函数组成,我们称之为对象里面的属性和方法)。

    对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射,而数组做的是数字到值的映射。

    创建一个对象通常先定义初始化变量。

    var person = {};
    person  // Object {}
    

    点表示法

    对象的名字表现为一个命名空间(namespace),它必须写在第一位-----当你想访问对象内部的属性或方法时,然后是一个点(.),紧接着是你想要访问的项目,标识可以是简单属性的名字(name),或者是数组属性的一个子元素,又或者是对象的调用方法。例如:

    person.age
    person.interests[1]
    person.bar()
    

    子命名空间

    可以用一个对象来做另一个对象成员值。例如将name成员

    name:['wh','xi'],
    

    改成

    name :{
        first : 'wh',
        last : 'xi'
    },
    

    这样,我们实际上创建了一个子命名空间,听起来有点复杂,但用起来很简单,你只需要链式的再使用一次点表示法,像这样:

    person.name.first
    person.name.last
    

    注意:你需要改变你之前的代码,从

    name[0]
    name[1]
    

    改成

    name.first
    name.last
    

    否则,你的方法不再有效。

    括号表示法

    另外一种访问属性的方式是使用括号表示法(bracket notation),替代这样的代码

    person.age
    person.name.first
    

    使用如下所示的代码:

    person['age']
    person['name']['first']
    

    这看起来很像访问一个数组的元素,从根本上来说是一回事儿,你使用了关联了值的名字,而不是索引去选择元素。难怪对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射,而数组做的是数字到值的映射。

    原型原型链

    原型对象

    在JavaScript 中,每当定义一个对象(函数) 时候,对象中都会包含一些预定义的属性。其中函数对象的一个属性就是原型对象 prototype 。注:普通对象没有prototype,但是有_ _ proto _ _ 属性 。

    原型对象其实就是普通对象 (Function.prototype 除外,它是函数对象,但它很特殊,他没有prototype 属性(前面说道函数对象都有prototype 属性))。

    原型对象是用来做什么的呢?

    主要作用是用于继承。举个例子:

    var person = function(name){
        this.name = name;
    };
    person.prototype.getName = function(){
        return this.name;
    }
    var veb = new person('Veblen');
    veb.getName(); // Veblen
    

    从这个例子可以看出,通过给person.prototype设置了一个函数对象的属性,那有person实例(例中:veb) 出来的普通对象就继承了这个属性。具体是怎么实现的继承,就要讲到下面的原型链了。

    prototype
    每个函数都有一个 prototype 属性,就是我们经常在各种例子中看到的那个 prototype ,比如:

    function Person() {
    
    }
    // 虽然写在注释里,但是你要注意:
    // prototype是函数才会有的属性
    Person.prototype.name = 'Kevin';
    var person1 = new Person();
    var person2 = new Person();
    console.log(person1.name) // Kevin
    console.log(person2.name) // Kevin
    

    那这个函数的 prototype 属性到底指向的是什么呢?是这个函数的原型吗?

    其实,函数的 prototype 属性指向了一个对象,这个对象正是调用该构造函数而创建的实例的原型,也就是这个例子中的 person1 和 person2 的原型。

    那什么是原型呢?你可以这样理解:每一个JavaScript对象(null除外)在创建的时候就会与之关联另一个对象,这个对象就是我们所说的原型,每一个对象都会从原型"继承"属性。

    让我们用一张图表示构造函数和实例原型之间的关系:

    构造函数和实例原型的关系图在这里插入图片描述

    在这张图中我们用 Object.prototype 表示实例原型。

    原型链

    JS 在创建对象(不论是普通对象还是函数对象) 的时候,都有一个叫做   
    

    _ _ proto _ _ 的内置属性,用于指向创建它的函数对象的原型对象 prototype 。

    console.log(veb.__proto__ == person.prototype)  //true
    同样,person.prototype 对象也有__proto__ 属性,它指向创建它的函数对象(Object)的 prototype
    	console.log(person.prototypr.__proto__ Object.prototype)   //true
    继续,Object.prototype对象也有__proto__属性,但是它比较特殊,为null
    console.log(Object.prototype.__proto__)  //null
    
    

    我们把这个有_ _ proto _ _ 串起来的直到Object.prototype. _ _proto _ _ 为null的链叫做原型链。

    图:(原型链)1551927801776

    展开全文
  • 【23设计模式专题】三 原型模式

    千次阅读 多人点赞 2020-04-18 15:03:38
    了解原型模式,知道浅克隆和深克隆是怎么回事

    程序猿学社的GitHub,欢迎Star
    github技术专题
    本文已记录到github

    前言

    通过前面两章,我们已经知道单例模式,工厂模式,本文就来看一看原型模式

    概念

    用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。原型模式属于一种创建型的设计模式

    • 可以理解为克隆技术,克隆羊
    • copy技术,直接原封不动的copy一个内容
    • 修真小说,到了元婴期,就是肉体被毁灭,只要元婴没有被灭,还可以复活。
    • 王者荣耀里面最新出来的一个英雄,镜,可以制造一个分身。分身也拥有攻击力

    实战

    场景

    隔壁老王: “社长,你们公司需要填写周报吗?”
    社长: “需要填写的,而且每周,都会有一次周例会”
    隔壁老王: “填写周报好浪费时间,还得排版,再填写内容”
    社长: “你是怎么实现的”
    隔壁老王: “我每次重新生成一个excel,再排版的”
    社长: “老铁,你这太实诚咯”

    传统方式

    package com.cxyxs.designmode.prototype;
    
    import lombok.Data;
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:42
     * Modified By:
     */
    @Data
    public class Weekly {
        private String name;
        /** 本周计划 */
        private String weekPlan;
        /** 下周计划 */
        private String nextWeekPlan;
        /**  填写时间 */
        private Date createTime;
    
        public Weekly(String name, String weekPlan, String nextWeekPlan, Date createTime) {
            this.name = name;
            this.weekPlan = weekPlan;
            this.nextWeekPlan = nextWeekPlan;
            this.createTime = createTime;
        }
    }
    
    • 使用@Data注解,实际上就是简化代码,无需写set get方法,使用了lombok插件
    package com.cxyxs.designmode.prototype;
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:45
     * Modified By:
     */
    public class WeeklyTest {
        public static void main(String[] args) {
            Weekly weekly = new Weekly("隔壁小王","用户模块开发","订单模块开发",new Date());
            System.out.println("--------本周周报--------");
            System.out.println(weekly.toString());
            System.out.println("--------下周周报--------");
            Weekly weekly1 = new Weekly("隔壁小王","订单模块开发","订单模块开发相关单元测试",new Date());
            System.out.println(weekly1.toString());
        }
    }
    


    隔壁老王: “社长,有没有什么方法,可以简化周报这块,提高我编写周报的效率”
    社长: “直接copy一份,上一次编写的周报(原型模式),在此之上,再做修改”

    原型模式

    package com.cxyxs.designmode.prototype.shallow;
    
    import lombok.Data;
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:42
     * Modified By:
     */
    @Data
    public class Weekly implements  Cloneable{
        private String name;
        /** 本周计划 */
        private String weekPlan;
        /** 下周计划 */
        private String nextWeekPlan;
        /**  填写时间 */
        private Date createTime;
    
        public Weekly(String name, String weekPlan, String nextWeekPlan, Date createTime) {
            this.name = name;
            this.weekPlan = weekPlan;
            this.nextWeekPlan = nextWeekPlan;
            this.createTime = createTime;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    通过上面的代码,我们小小的梳理一下,实现的过程
    实现原型模式就两步:

    • 实现Cloneable接口
    • 重写clone方法
    • 学过java的社友,都知道,Object是一切类的老祖宗,代码里面的super.clone(),实际上,就是调用Object的clone方法,通过查看他的源码,发现,又遇到native方法,说明实现克隆不是通过java实现的(c或者c++)
    package com.cxyxs.designmode.prototype.shallow;
    
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:45
     * Modified By:
     */
    public class WeeklyTest {
        public static void main(String[] args) throws  Exception{
            Date date = new Date();
            Weekly weekly = new Weekly("隔壁小王","用户模块开发","订单模块开发",date);
            System.out.println("--------本周周报--------");
            System.out.println(weekly.toString());
            System.out.println("--------下周周报--------");
            Weekly weekly1 = (Weekly) weekly.clone();    //使用克隆(copy方式)
            //Weekly weekly1 = new Weekly("隔壁小王","订单模块开发","订单模块开发相关单元测试",new Date());
            System.out.println(weekly1.toString());
            System.out.println(weekly == weekly1);
        }
    }
    

    • 可以发现结果为false,说明重新生成了一个对象,而且克隆的对象和原来的一模一样,回顾一下,我们第一章学习过的单例模式,又增加了一种,可以破解单例的方法。
      单例模式,谁说程序猿没有女(男)朋友?

    社长: “实际上,上面这种写法还存在一点的问题”
    隔壁老王: “社长,存在什么问题”
    社长: “上面这种写法,只能实现浅克隆,没有实现完全的克隆,我们先通过一个例子来看一看把”

    浅克隆

    package com.cxyxs.designmode.prototype.shallow;
    
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:45
     * Modified By:
     */
    public class WeeklyTest1 {
        public static void main(String[] args) throws  Exception{
            Date date = new Date();
    
            Weekly weekly = new Weekly("隔壁小王","用户模块开发","订单模块开发",date);
            Weekly weekly1 = (Weekly) weekly.clone();    //使用克隆(copy方式)
            System.out.println(weekly.toString());
            System.out.println(weekly1.toString());
            //修改克隆后对象的值
            date.setTime(1546315871);
            System.out.println("--------------");
            System.out.println(weekly.toString());
            System.out.println(weekly1.toString());
        }
    }
    

    • 先实现克隆后,我们再修改createTime的值,可以发现,修改后,克隆前和克隆后的值都一样,说明这两个对象的指向的都是同一个地方。

    浅克隆

    • 浅克隆会进行值传递(只是针对基本数据类型)
    • 如果是引用数据类型,浅克隆会进行引用传递,实际上,就是把引用地址copy一份给新的对象,实际上,都是指向同一个地址。

    深克隆

    重写clone方法实现深克隆

    package com.cxyxs.designmode.prototype.shallow;
    
    import lombok.Data;
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:42
     * Modified By:
     */
    @Data
    public class Weekly implements  Cloneable{
        private String name;
        /** 本周计划 */
        private String weekPlan;
        /** 下周计划 */
        private String nextWeekPlan;
        /**  填写时间 */
        private Date createTime;
    
        public Weekly(String name, String weekPlan, String nextWeekPlan, Date createTime) {
            this.name = name;
            this.weekPlan = weekPlan;
            this.nextWeekPlan = nextWeekPlan;
            this.createTime = createTime;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            try {
                Weekly weekly = (Weekly) super.clone();
                //把数据克隆
                Date clone = (Date) createTime.clone();
                weekly.setCreateTime(clone);
                return weekly;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    • 因为考虑到createTime,指向的是同一个引用,所以,我们每次克隆的时候,都把这个字段重新克隆一次。
    • 通过上图,可以看出,修改时间,只是克隆前的值发生了改变。 可以这样理解,在修真小说内,到了分神期,可以修炼第二分身,实际上,你攻击本体时,只是本体受到伤害,就算本体死亡,第二分身还可以继续存活。

    隔壁老王: “社长,看了一下,你写的代码,这还是属性的,如果有上百个属性,我这一个个改,也忒麻烦咯。有没有不用这样一个个设置的方法”
    社长: “这种方法的copy,实际上是内存的copy,直接操作内存的,也是性能最好的,如果你觉得这种方式太麻烦了,我们可以通过序列化和反序列的方式来实现”

    通过序列化实现深克隆

    package com.cxyxs.designmode.prototype.shallow.seri;
    
    import lombok.Data;
    
    import java.io.*;
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:42
     * Modified By:
     */
    @Data
    public class Weekly implements Serializable {
        private String name;
        /** 本周计划 */
        private String weekPlan;
        /** 下周计划 */
        private String nextWeekPlan;
        /**  填写时间 */
        private Date createTime;
    
        public Weekly(String name, String weekPlan, String nextWeekPlan, Date createTime) {
            this.name = name;
            this.weekPlan = weekPlan;
            this.nextWeekPlan = nextWeekPlan;
            this.createTime = createTime;
        }
    
        public Object copy() throws  Exception{
            //序列化
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
    
            //反序列化
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            Weekly weekly = (Weekly) ois.readObject();
            return weekly;
        }
    }
    

    实现序列化两部曲:

    • 实现Serializable接口
    • 实现序列化和反序列化对应的代码
    package com.cxyxs.designmode.prototype.shallow.seri;
    
    
    
    import java.util.Date;
    
    /**
     * Description:
     * Author: 程序猿学社
     * Date:  2020/4/12 18:45
     * Modified By:
     */
    public class WeeklyTest2 {
        public static void main(String[] args) throws  Exception{
            Date date = new Date();
    
            Weekly weekly = new Weekly("隔壁老王","用户模块开发","订单模块开发",date);
            Weekly weekly1 = (Weekly) weekly.copy();    //使用克隆(copy方式)
            System.out.println(weekly.toString());
            System.out.println(weekly1.toString());
            //修改克隆后对象的值
            date.setTime(11);
            System.out.println("--------------");
            System.out.println(weekly.toString());
            System.out.println(weekly1.toString());
        }
    }
    
    • 通过这种方式实现对象的深度克隆,无需一个个设置引用类型属性的clone方法。

    总结: 如果,需要创建大量的对象,建议使用原型模式。实际上他是不符合ocp原则的。应该实现对扩展开放,对修改关闭。不会调用类的重构方法 ,可以破解单例模式。


    原创不易,不要白嫖,觉得有用的社友,给我点赞,让更多的老铁看到这篇文章。
    因技术能力有限,如文中有不合理的地方,希望各位大佬指出,在下方评论留言,谢谢,希望大家一起进步,一起成长。

    作者:程序猿学社
    原创公众号:『程序猿学社』,专注于java技术栈,分享java各个技术系列专题,以及各个技术点的面试题。
    原创不易,转载请注明来源(注明:来源于公众号:程序猿学社, 作者:程序猿学社)。

    展开全文
  • 文章目录原型实现模型分类:、抛弃式原型开发二、演化式原型开发三、增量式原型开发 、抛弃式原型开发 1、定义:验证和澄清系统的需求描述,重新构造系统。 2、流程图 3、典型例子 开发者与客户进行沟通交流,...
  • 1.单例模式 单例模式(Singleton Pattern):确保某个类只有个实例,而且自己实例并向整个系统提供这个实例。  通用类图如下:    通用代码如下:public class Singleton { private static final ...
  • 类似于这种项目,采用传统意义上的瀑布模型就非常合适了,如果范围控制和风险控制做的比较好的话,真的如同个瀑布一样,会“飞流直下三千尺”,直接将项目送到客户的小机上,部署运行,大家欢乐的拿到绩效
  • 什么原型设计方法

    千次阅读 2009-03-24 15:48:00
    1 引子终于签下合同,得到了“正式”的客户提供的“需求书”(也许就是几片纸),凭借自己的理解立即投入开发...或者,个项目拆成为多期,从而收取部分款项,而很多的开发都作废。这样的案例真是何其多也!
  • 这种类型的设计模式属于对象创建模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个...
  • 局限性:前个阶段没有完成便无法开始下阶段的工作 现实情况:然而完整而准确的需求规格说明是很难得到的 原因: 在开发早期用户往往对系统只有个模糊的想法,很难完全准确地表达对系统的全面要求 (早期难以...
  • 设计方法原型法、敏捷开发)

    千次阅读 2017-03-13 15:18:58
    原型法和敏捷开发 原型法 定义:又称快速原型法,不属于敏捷开发。...2. 进化型原型 - 此类原型的构造从目标系统的个或多个基本需求出发,通过修改和追加的过程逐渐丰富,演化成为最终的系统。
  • 原型实例指定创建对象的种类,并且通过拷贝来创建新的对象。 2.模式作用 可以一定程度上解耦,消费者和对象的构造过程隔离开,对象如何构造与消费者完全无关。 可以一定程度提升效率,复杂对象的构造往往需要较...
  • 原型系统

    千次阅读 2019-03-20 18:20:00
    原型模型又叫快速原型模型,它指的是在执行实际软件的开发之前,应当建立系统的个工作原型原型是系统的个模拟执行,和实际的软件相比,通常功能有限、可靠性较低及性能不充分。通常使用几个捷径来建设原型...
  • jS原型

    千次阅读 2017-11-28 11:15:52
    “我们创建的每个函数都有个prototype(原型)属性(除了Function.bind()返回的函数),这个属性是个指针,指向个对象,而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。” –摘自人民邮电...
  • 原型模式

    千次阅读 2019-09-25 20:21:13
    这种类型的设计模式属于创建模式,它提供了一种创建对象的最佳方式。 这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高...
  • 这种类型的设计模式属于创建模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高...
  • Java设计模式_(创建)_原型模式

    万次阅读 2017-09-19 17:19:13
    Prototype原型模式是一种创建设计模式,Prototype模式允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象...
  • 设计模式之原型模式(创建)

    千次阅读 2019-02-17 23:05:36
    原型模式(Prototype Pattern):原型模式是提供一个原型接口,提供原型的克隆,创建新的对象,是一种对象创建模式。 模式结构 原型模式包括如下角色 Prototype :抽象原型类 ConcretePrototype:具体原型类 ...
  • 对于js的原型原型链的理解

    万次阅读 多人点赞 2019-06-23 22:20:23
    原型模式是用于创建重复的对象,同时又能保证性能,这种类型的设计模式属于创建模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。原型模式的目的是用原型实例...
  • 身为位产品经理或设计师,原型设计工具是必不可少的工作伙伴。但我们难免会遇到预算有限的时候,这时候,去哪里寻找款好用的免费原型设计工具呢?以下,小编为大家精心挑选了7款免费的原型工具,并对其进行了...
  • 创建模式之原型模式——深拷贝和浅拷贝

    万次阅读 多人点赞 2021-09-22 09:56:39
    原型模式在我们的代码中是很常见的,但是又容易被我们所忽视的一种模式,比如我们常用的的BeanUtils.copyProperties就是一种对象的浅拷贝。 看看有哪些场景需要原型模式 资源优化 性能和安全要求 一个对象多个修改...
  • 可以一定程度增加扩展性,若增加个产品实现,只需要实现产品接口,修改工厂创建产品的方法,消费者可以无感知(若消费者不关心具体产品是什么的情况)。 可以一定程度增加代码的封装性、可读性。清楚的代码结构,...
  • 瀑布模型  优点:它提供了个模板,这个模板使得分析、设计、编码、测试和支持的方法可以在该模板下有个共同的指导。虽然有不少缺陷但比在软件开发中随意的状态要好得多缺点:(1) 实际的项目大部分情况难以...
  • 需求工程中的面谈和原型

    千次阅读 多人点赞 2020-04-24 09:46:39
    1.什么是半结构面谈? 事先需要根据面谈内容准备面谈的问题和面谈结构,但在面谈过程中,会见者可以根据实际情况采取一些灵活的策略。 面谈的类别: 面谈的优点: 1.面谈的开展条件较为简单,经济成本较低; 2.能...
  • 要理解原型原型模式必须先理解Java里的浅复制和深复制。有的地方,复制也叫做克隆。Java提供这两克隆方式。 因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现下子变得很简单。
  • 结构化方法、面向对象方法的区别

    千次阅读 2016-06-22 09:32:16
    结构化方法、面向对象方法的区别 ...抽象原则是一切系统科学方法都必须遵循的基本原则它注重把握系统的本质内容而忽略与系统当前目标无关的内容它是一种基本的认知过程和思维方式 (2)分解原则 分解原
  • 快速原型模型

    千次阅读 2018-03-18 10:44:41
    快速原型模型需要迅速建造个可以运行的软件原型 ,以便理解和澄清问题,使开发人员与用户达成共识,最终在确定的客户需求基础上开发客户满意的软件产品。 快速原型模型允许在需求分析阶段对软件的需求进行初步而非...
  • 验证中的FPGA原型验证

    万次阅读 2018-06-07 17:14:30
     FPGA原型设计是一种成熟的技术,用于通过将RTL移植到现场可编程门阵列(FPGA)来验证应用专用IC(ASIC),专用标准产品(ASSP)和片上系统(SoC)的功能和性能。 (FPGA)。 由于硬件复杂性不断增加,需要验证的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,173
精华内容 42,069
关键字:

原型化方法是一种什么型