精华内容
下载资源
问答
  • RUP:初始阶段

    千次阅读 2014-02-19 21:55:03
    以下大部分知识来自于《UML和模式应用》第三版。 初始阶段定义 ...初始阶段考虑的问题: ...1,项目设想和业务案例是...初始阶段的目标不是什么: 1,不是定义所有需求,或者产生可信赖的预算或项目计划。 2,大部分

    以下大部分知识来自于《UML和模式应用》第三版。


    初始阶段定义

     

    初始阶段考虑的问题:

    1,项目设想和业务案例是什么?

    2,是否可行?

    3,购买还是开发?

    4,粗略估计一下开发成本:10W人民币还是百万人民币,还是上千万。

    5,项目应该继续下去还是停止。

     

     

    初始阶段的目标不是什么:

    1,不是定义所有需求,或者产生可信赖的预算或项目计划。

    2,大部分需求分析在细化阶段进行,并伴以产品品质的早期编程和测试。

     

     

    初始阶段定义:

    预见项目的范围、设想和业务案例。

     

    解决主要的问题:

    渉众是否就项目设想基本达成一致,项目是否值得继续进行认真研究。

     

     

    举例说明:调查一个科研市场和教学行业市场信息。

    1,收集这个行业的相关信息(软件,政策、规定、解决方案,获取真实需求)

    2,分析这个行业内容

    3,相关结论结论。

     

    注意内容如下:

     

    需要从三个方面收集资料:现有的相关领域的软件;现有的相关领域的政策、规定、解决方案;现有的相关领域真实需求。

    需要从四个方面分析资料:从公司角度(我们具不具备这种能力);从市场角度(有谁在做?);从客户角度(我们是否会掏钱买);从用户角度(我们是否觉得这个系统有价值)。

    需要从两个方面给出结论报告:从经济角度(这里面有钱)和从技术角度(技术可达,我们具备这种技术能力:理论,解决方案,人员,环境)。

     

     

    可以使用的工具SWOT相关工具,根据企业情况进行分析。

     

    初始阶段持续时间

     

    初始阶段可能仅仅是第一次需求研讨会,并为第一次迭代制定计划的一部分。

    有案例的情况下,初始状态更短。

     

     

    初始阶段创建的制品

     

    在初始阶段完成部分制品,在后续迭代中对其进行精化。

     

    制品

    注释

    设想和业务用例

    描述高层的目标和约束,业务案例,并提供执行摘要

    用例模型

    描述功能需求。在初始阶段,确定大部分用例的名称,详细分析10%的用例

    补充性规格说明

    描述其他需求,主要是非功能性需求

    词汇表/术语表

    关键领域术语和数据字典

    风险列表和风险管理计划

     

    概念验证(验证技术思路)

     

    第一个迭代计划

     

    阶段计划和软件开发计划(粗略的估计)

     

    开发案例

    特定项目,对UP步骤和制品进行定制

     

    初始阶段关注基本范围的理解以及10%的需求。

     

    何时知道自己并不了解初始阶段

     

    • 当认为大部分项目的初始阶段会持续几周或者更长时。
    • 在初始阶段试图定义大部分的需求时。
    • 期望初始阶段的预算和计划是可靠的。
    • 定义架构(应该在细化阶段以迭代方式来定义架构)
    • 认为正确的工作顺序应该是:1)定义需求; 2)设计架构; 3)实现。
    • 没有业务案例或设想制品。
    • 详细描写所有用例。
    • 没有详细编写任何用例。与之相反。应该详细编写10%20%的用例以便获得对问题范围的真实认识。

    展开全文
  • 初始阶段详解

    千次阅读 2018-03-04 20:46:24
    一个Java类的完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段,当然也有在加载或者连接之后没有被初始化就直接被使用的情况。如图所示: 类的初始化做了什么 为类的静态变量赋予正确的初始值...

    一个Java类的完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段,当然也有在加载或者连接之后没有被初始化就直接被使用的情况。如图所示:
    这里写图片描述

    类的初始化做了什么

    • 为类的静态变量赋予正确的初始值。
    • 执行类的静态代码块。

    按照顺序自上而下运行类中的变量赋值语句和静态语句,如果有父类,则首先按照顺序运行父类中的变量赋值语句和静态语句。

    什么时候类会被初始化

    • 只有类或接口被Java程序首次主动使用时才初始化他们。

    主动使用(7种)

    • 创建类的实例(new)。
    • 访问某个类或接口的静态变量,或者对该静态变量赋值。
    • 调用类的静态方法。
    • 通过反射方式执行以上三种行为。
    • 初始化子类的时候,会触发父类的初始化。
    • Java虚拟机启动时被标明为启动类的类。(有main方法的类)
    • JDK 1.7开始提供的动态语言支持。(了解即可)

    除了以上7种情况,其它使用Java类的方式都被看作是对类的被动使用,都不会导致类的初始化。


    类的静态字段和类初始化

    根据主动使用导致类的初始化规则,访问类的静态变量会导致类的初始化。

    /**
     * 对于静态字段来说,只有直接定义了该字段的类才会被初始化,
     * 当一个类初始化时,要求其父类全部都已经初始化完毕了。
     *
     * -XX:+TraceClassLoading,用于追踪类的加载信息并打印。
     * -XX:+TraceClassUnLoading,用于追踪类的卸载信息并打印。
     */
    public class MyTest1 {
        public static void main(String[] args) {
            System.out.println(MyChild1.str2);
        }
    }
    
    class MyParent1 {
        public static String str = "hello world";
    
        static {
            System.out.println("MyParent1 static block");
        }
    
    }
    
    class MyChild1 extends MyParent1 {
        public static String str2 = "welcome";
        static {
            System.out.println("MyChild1 static block");
        }
    }
    
    

    打印的结果是:

    MyParent1 static block
    MyChild1 static block
    welcome
    

    访问MyChild1类的静态字段str2,使得类MyChild1被初始化,子类的初始化触发父类的初始化,所以MyParent1类初始化。

    如果访问MyChild1.str,那么打印的结果变成:

    MyParent1 static block
    hello world
    

    因为对于静态字段来说,只有直接定义了该字段的类才会被初始化


    类的编译期常量和类初始化

    public class MyTest2 {
        public static void main(String[] args) {
            System.out.println(MyParent2.str);
        }
    }
    
    class MyParent2 {
        public static final String str = "hello world";
        static {
            System.out.println("MyParent2 static block");
        }
    }
    

    打印结果:

    hello world
    

    这里MyParent2的静态代码块没有执行,说明MyParent2没有被初始化!其实MyParent2类在这里没有被主动使用,所以没初始化。因为静态字段str 是常量。常量在编译阶段会存入到调用这个常量的方法所在类的常量池中。本质上,调用类并没有直接引用到定义常量的类,因此不会触发定义常量类的初始化,也不会加载这个类。


    类的运行期常量和类初始化

    public class MyTest3 {
        public static void main(String[] args) {
            System.out.println(MyParent3.str);
        }
    }
    
    class MyParent3 {
        public static final String str = UUID
    									.randomUUID()
    									.toString();
    
        static {
            System.out.println("MyParent3 static block");
        }
    }
    

    打印结果:

    MyParent3 static block
    4e5bc60b-ec26-40c1-aeea-a5eddcb2dbaf
    

    静态代码块执行,说明类MyParent3 被初始化。这个例子与上个例子不一样的是这里的常量不是编译阶段就可以确定的,它要运行期间才确定。
    当一个常量的值并非编译期间可以确定的,那么其值就不会被放到调用类的常量池中,这时在程序运行时,会导致主动使用这个常量所在的类,显然会导致这个类会初始化。


    接口初始化规则

    • 接口中的字段默认都是public static final。
    • 接口中不能定义静态代码块。
    • 当一个接口初始化时,并不要求其父接口都完成了初始化只有在真正使用到父接口的时候(如引用到接口中所定义的常量时),才会初始化(但子接口初始化,父接口一定会被加载)。
    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.b);
        }
    }
    
    
    interface MyParent5 {
        int a = new Random().nextInt(4);
        Thread thread1 = new Thread() {
            {
                System.out.println("MyParent5初始化了");
            }
        };
    }
    
    interface MyChild5 extends MyParent5 {
        int b = 4;
    
        Thread thread2 = new Thread() {
            {
                System.out.println("MyChild5初始化了");
            }
        };
    }
    

    打印结果:

    4
    

    因为接口里不能定义静态代码块,所以为了能看出接口是否被初始化,这里我在接口里定义个Thread类型的变量,并返回个对象引用。如果接口初始化了,它的Thread类型的变量一定会被实例化,就会执行定义的构造代码块里的代码。(静态代码块,局部代码块,构造代码块区别。

    这里没有打印构造代码块里的内容,说明接口没有被初始化。这是因为接口中的字段默认都是public static final。访问接口的(静态常量)字段不会导致接口初始化,这里跟访问类的静态常量字段一样的,所以上面的结论适用于接口。


    子接口初始化不会导致父接口初始化

    把上面的例子做个改动,如下。

    interface MyChild5 extends MyParent5 {
        int b = new Random().nextInt(4);
    
        Thread thread2 = new Thread() {
            {
                System.out.println("MyChild5初始化了");
            }
        };
    
      // public static int b = 4;
    }
    

    打印结果:

    MyChild5初始化了
    0
    

    这里的常量是运行期间才能确定,所以MyChild5接口被初始化。但是从结果明显看出,仅仅初始化了子接口并没有初始化父接口!
    但是类的初始化是:初始化子类的时候,会触发父类的初始化。这就是类的初始化和接口初始化的区别了。


    直接访问父接口定义的常量

    继续改进代码,如下:

    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.a);
        }
    }
    

    打印结果:

    MyParent5初始化了
    0
    

    直接访问父接口的静态常量字段a(运行期间确定),导致父接口初始化。


    实现类初始化不会导致接口初始化

    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.b);
        }
    }
    
    interface MyParent5 {
        int a = new Random().nextInt(4);
        Thread thread1 = new Thread() {
            {
                System.out.println("MyParent5初始化了");
            }
        };
    }
    
    class MyChild5 implements MyParent5 {
        public static Thread thread2 = new Thread() {
            {
                System.out.println("MyChild5初始化了");
            }
        };
        public static int b = 4;
    }
    

    打印结果:

    MyChild5初始化了
    4
    

    这个例子说明,子类被初始化了,但是它实现的接口没有初始化。


    总结

    类只有被首次主动使用时才会被初始化,主动使用有7种形式。这里我并没有对每一种主动使用都去举例论证。这几个例子是我在学习《深入理解JVM》这门课程时感觉最难理解的,也是最重要的知识点。

    • 编译期常量和运行期常量对类初始化的影响。
    • 初始化对于类与接口的异同点。

    其它几种对类的主动使用,大家可以自己去通过代码去验证文章的结论,这样能加深自己的理解。

    展开全文
  • private Set<Class<?>> primarySources; public void addPrimarySources(Collection<Class<... additionalPrimarySources) { this.primarySources.addAll(additionalPrimarySources);...
  • react的初始阶段

    千次阅读 2016-06-26 16:35:39
    * getDefaultProps: 只调用一次,只有组件的第一个实例被初始化的时候才会被调用, * 实例之间共享引用,处理的是属性 * getInitialState: 初始化每个实例特有的状态,从这个函数开始, * 每个实例被初始化的...
    /*
     * getDefaultProps:         只调用一次,只有组件的第一个实例被初始化的时候才会被调用,
     *                          实例之间共享引用,处理的是属性
     * getInitialState:         初始化每个实例特有的状态,从这个函数开始,
     *                          每个实例被初始化的时候都会调用它,处理的是状态
     *                          使用这个函数必须有return 值
     * componentWillMount:      render之前最后一次修改状态的机会
     * render:                  只能访问this.state和this.props,
     *                         【只能有一个顶层组件(但是可以包含多个子组件),不能有多个顶层组件,如:数组】
     *                          不允许修改状态和DOM输出
     * componentDidMount:       成功render,并渲染完成真实DOM之后触发,可以修改DOM
     * */
     /*查看顺序*/
           var HelloWorld=React.createClass({
                   getDefaultProps:function(){console.log('getDefaultProps',1)},
                   getInitialState:function(){console.log('getInitialState',2);return null},
                   componentWillMount:function(){console.log('componentWillMount,3')},
                   render:function(){
                       console.log('render,4')
                       return <p>Hello,World</p>
                   },
                   componentDidMount:function(){console.log('componentDidMount,5')}
           })
           React.render(<HelloWorld/>,document.body)
    展开全文
  • 浅谈Java类加载的初始阶段

    千次阅读 2016-01-18 22:04:30
    类加载的初始阶段对类变量赋予正确的值。主要有两种初始化方式,一种是通过类变量初始化语句;一种是静态初始化语句。如下述代码所示,前者是类变量初始化语句,后者是静态初始化语句。

    类加载的初始化阶段对类变量赋予正确的值。主要有两种初始化方式,一种是通过类变量初始化语句;一种是静态初始化语句。如下述代码所示,前者是类变量初始化语句,后者是静态初始化语句。

    public class Example1 {
        static int width;
        static int height = (int) (Math.random() * 2.0);
    
        static {
            width = (int) (3 * Math.random() * 5.0);
        }
    }

    所有的类变量初始化语句和静态初始化语句都被Java编译器收集在一起,放在一个特殊方法里。对于类而言,该方法称为类初始化方法,对于接口而言,该方法称为接口初始化方法。在Java class文件里,类和接口的初始化方法统一被称作为<clinit>() 方法。并且这种方法只能被Java虚拟机调用,Java程序是无法调用的。
    初始化一个类包含两个步骤:
    如果类存在超类,先初始化超类
    如果类存在类初始化方法,就执行此方法
    初始化一个接口只有一个步骤:
    如果该接口存在接口初始化方法,就执行此方法,接口不初始化父接口。

    注意:初始化类的过程必须保持同步,如果有多个线程初始化一个类,仅仅允许一个线程执行初始化,其他的线程都需要等待。

    1. <clinit>()方法
      Java方法将类变量初始化语句和静态初始化语句的代码都放在Java class文件的<clinit>()中,比如查看Example1.java的class源文件,我们可以发现<clinit>()如下:
      0: invokestatic  #2                  // Method java/lang/Math.random:()D
      3: ldc2_w        #3                  // double 2.0d
      6: dmul
      7: d2i
      8: putstatic     #5                  // Field height:I
     11: ldc2_w        #6                  // double 3.0d
     14: invokestatic  #2                  // Method java/lang/Math.random:()D
     17: dmul
     18: ldc2_w        #8                  // double 5.0d
     21: dmul
     22: d2i
     23: putstatic     #10                 // Field width:I
     26: return
    

    <clinit>()方法先执行类变量初始化语句,初始化height,接着执行了静态初始化语句,初始化了width。
    并非每个类都拥有<clinit>()方法,以下三种情况就没有
    类没有申明类变量,也没有任何静态初始化语句;
    类申明了类变量,但是没有任何的类变量初始化语句,页没有静态初始化语句进行初始化;
    类近包含静态final变量的类变量初始化语句,而且是编译时候的常量;
    Example2 .java

    public class Example2 {
        static final int angle = 35;
        static final int length = angle * 2;
    }

    没有<clinit>()方法
    Example3 .java

    public class Example3 {
        static final int angle = (int) (35 * Math.random());
        static final int length = angle * 2;
    }

    <clinit>()方法,因为Math.random()不是编译器常量,因此angle和length都要进行初始化

     0: ldc2_w        #2                  // double 35.0d
     3: invokestatic  #4                  // Method java/lang/Math.random:()D
     6: dmul
     7: d2i
     8: putstatic     #5                  // Field angle:I
    11: getstatic     #5                  // Field angle:I
    14: iconst_2
    15: imul
    16: putstatic     #6                  // Field length:I
    19: return
    

    对于接口Example4.java

    public interface Example4 {
        int angle = (int) (35 * Math.random());
        int length = 2;
    }

    接口中的变量默认是public static final,可以查看class文件看到

    public static final int angle;
        descriptor: I
        flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    
      public static final int length;
        descriptor: I
        flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
        ConstantValue: int 2
    

    而且把编译期常量2之前赋值好,不产生<clinit>()方法。但是会为变量angle产生<clinit>()方法,因为他的值是运行期决定的。

     0: ldc2_w        #1                  // double 35.0d
     3: invokestatic  #3                  // Method java/lang/Math.random:()D
     6: dmul
     7: d2i
     8: putstatic     #4                  // Field angle:I
    11: return
    

    接下来我们看Java虚拟机何时初始化类变量
    2. 主动使用和被动使用
    那么Java虚拟机何时初始化类变量呢?主动使用的时候初始化。主动使用一共有6种情况:

    1)创建某个类的新实例(new,不明确的创建,反射,克隆或反序列化);
    2)调用类的静态方法(即执行字节码invokestatic指令);
    3)使用某个类的或接口的静态字段,或者对该字段赋值(即执行字节码getstatic,putstatic指令),用final修饰的静态字段除外,因为被初始化为一个编译时的常量表达式;
    4)调用Java API中的反射方法
    5)初始化某个类的子类(某个类被初始化,超类必须已经被初始化了)
    6)虚拟机启动某个被标明启动类的类(包含main方法的那个类),和条款3类似,静态方法

    被动使用,子类或者子接口使用了父类或父接口的非常量静态变量;此时该子类或子接口不发生初始化。
    也就是说主动使用中的字段必须是该类或该接口明确申明的,而不是父类或父接口中的。看下面这个例子:

    public class NewParent {
        static int hoursOfSleep = (int) (Math.random()*3.0);
        static {
            System.out.println("NewParent was initialized");
        }
    }
    
    public class NewbornBaby extends NewParent {
    
        static int hoursOfCrying = (int) (6 + (int)( Math.random() * 2.0));
    
        static {
            System.out.println("NewbornBaby was initialized");
        }
    }

    测试代码1:

    public class Example5 {
    
        public static void main(String[] args) {
            int hours = NewbornBaby.hoursOfSleep;
        }
    
        static {
            System.out.println("Example5 was initialized");
        }
    }

    输出结果:

    Example5 was initialized
    NewParent was initialized

    NewbornBaby调用的字段不是本身的,是父类的,因此发生了被动引用,NewbornBaby不进行初始化,也不需要被加载。只会导致Example5和NewParent发生初始化。那么NewParent初始化是因为是NewbornBaby父类初始化还是被调用了字段而初始化呢?看下面例子
    测试代码2:

    public class Temp {
        static int tempValue = (int) (Math.random()*3.0);
        static {
            System.out.println("Temp was initialized");
        }
    }
    public class Example5 {
    
        public static void main(String[] args) {
            int hours = Temp.tempValue;
        }
    
        static {
            System.out.println("Example5 was initialized");
        }
    }

    测试结果:

    Example5 was initialized
    Temp was initialized

    可见是因为字段被调用了而发生了初始化。

    接下来看一个主动引用的例子
    测试代码3:

    public class Example5 {
    
        public static void main(String[] args) {
            int hours = NewbornBaby.hoursOfCrying;
        }
    
        static {
            System.out.println("Example5 was initialized");
        }
    }

    输出结果:

    Example5 was initialized
    NewParent was initialized
    NewbornBaby was initialized

    NewbornBaby调用自身的字段,因此发生了主动引用,初始化NewbornBaby,但是初始化子类之前,父类必须被初始化,因此NewParent也被初始化。

    如果一个自动既是静态的又是final的,并且使用一个编译时常量表达式初始化,使用这样的字段就不是对该字段所在类的主动使用。Java编译器会把这样的字段解析成常量的本地拷贝。
    测试代码4:

    public class Angry {
        static final String greeting = "hello world!";
        static {
            System.out.println("Angry is initialized");
        }
    }
    public class Example6 {
        public static void main(String[] args) {
            String str = Angry.greeting;
        }
    
        static {
            System.out.println("Example6 was initialized");
        }
    }

    测试结果:

    Example6 was initialized

    类Angry未执行初始化过程

    展开全文
  • U-boot初始阶段流程分析

    千次阅读 2016-07-06 21:32:58
    U-boot的初始化主要分为两个阶段 第一阶段:主要是SOC内部的初始化,板级的初始化比较少,所以移植的修改量比较小。此阶段由汇编语言编写,代码主体分布在start.S和lowlevel_init.S中 第二阶段:主要是板级的初始...
  • Java虚拟机 类初始阶段

    千次阅读 2013-06-10 18:37:39
    本文只介绍在什么情况下对类进行初始化。 Java虚拟机规范对何时进行类的初始化做了严格规范,有且只有四种情况: 1. 虚拟机启动时,指定的主类。  包含main方法的类。 2. 遇到new、getstatic、putstatic、...
  • Debug的话在构造函数第一行打印语句都不执行,那么说明不是构造函数本身的问题,回想起之前看的类的生命周期,在构造函数之前那就是初始阶段了,也就是类加载时候自动执行的。 于是我就把目光集中在静态初始化...
  • 我们下面从三个部分来分析Spring MVC的源代码 ...1.初始阶段 我们首先找到DispatcherServlet这个类,必然是寻找init()方法。然后,我们发现其init方法其实在父类 HttpServletBean中,其源码如下: in
  • 学习FreeRTOS(2):初始阶段的中断状态 分析FreeRTOS的Cortex-M4F移植版(portable/GCC/ARM_CM4F)在初始阶段CPU中断状态的变化。复位后中断默认处于开启状态,当创建第一个任务时中断被关闭,开启调度器时...
  • 大型网站的技术挑战主要来自于庞大的用户,高并发的访问和海量的数据,任何简单的业务一旦需要处理数以P计的数据和面对数以亿计的用户,问题就会变得很棘手。大型网站架构主要是解决这类问题。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 439,520
精华内容 175,808
关键字:

初始阶段是什么意思