精华内容
下载资源
问答
  • 的生命周期从类 加载、连接、初始化 开始,到类 卸载结束; 二、几个阶段: 加载:查找并加载类二进制数据。(把类.class文件二进制数据读入内存,存放在运行时数据区方法区;类加载最终结果是...

    一、概要:

    类的生命周期从类的 加载、连接、初始化 开始,到类的 卸载结束;

     

    二、几个阶段:

    加载:查找并加载类的二进制数据。(把类的.class文件的二进制数据读入内存,存放在运行时数据区的方法区;类加载的最终结果是产生 堆区中描述对应类的Class对象);

    连接:包括验证、准备和解析三个子阶段;

       验证:确保补加载类的正确性;

       准备:为类的静态变量分配内存,并设定默认值;

       解析:把类中的符号引用转换为直接引用;

    初始化:给类中的静态变量赋予正确的初始值;

      

    类的加载时机:并不需要等到某个类被主动使用时才加载,虚拟机会预测某个类将要被使用就加载它;

    类的初始化时机

      a. 创建类(new、反射、克隆、反序列化)

      b. 使用静态方法、非静态变量

      c. Class.forName("ATest");  获取描述类的Class对象;

      另:初始化子类,父类被先初始化。虚拟机的启动类,使用命令 java Sample(也算是创建类);

      注:

        使用能在编译期能得知的final static修饰的常量,不会导致类的初始化;

        public static final int a = 2*3;//编译时常量,不会导致类初始化;

        public static final int a b = (int)(Math.random()*10)/10+1; // 不是编译时常量,会初始化;

     

        只有当程序访问的静态变量或静态方法的确在当前类或接口中定义时,才可以看作是对类或接口的主动使用;(如用子类引用调用父类静态方法或变量,只会初始化父类

        调用ClassLoader.loadClass()方法加载一个类时,只会加载,但不会初始化;

     

    子类父类初始化过程:

    先对这个类进行加载和连接-> 如果有直接父类,先加载连接初始化这个父类->重复以上步骤直到所有父类初始化,初始化当前类;

    (先加载连接当前类,再加载连接初始化父类,再初始化当前类)

    class Base {
        static {
            System.out.println("init Base");
        }
    }
    
    class Sub extends Base {
        static {
            System.out.println("init Sub");
        }
    }
    
    public class ATest extends Sub {
        static {
            System.out.println("init ATest");
        }
    
        public static void main(String args[]) {
            System.out.println("main methos");
        }
    }
    结果:
    init Base
    init Sub
    init ATest
    main methos
    View Code

     

    三、类加载器

      除了Java虚拟机自带的根类加载器以外,其余的类加载器有且只有一个父加载器;

      Java虚拟机自带以下几种加载器:

      (Bootstrap)类加载器:没有父类加载器。负责加载虚拟机核心类,sun.boot.class.path路径下类库,java.lang.*; 实现依赖于底层操作系统,没有继承java.lang.ClassLoader;

      扩展(Extension)类加载器:父加载器为根加载器;加载java.ext.dirs下的类库 和 JDK目录下jre/lib/ext目录下类库;继承于java.lang.ClassLoader;

      系统(System)类加载器:也称应用类加载器,父加载器为扩展类加载器;加载classpath路径下指定的类库;继承于java.lang.ClassLoader,也是自定义加载器的默认父类

     

    父亲委托机制

      类加载过程中,会先从最顶层加载器(一般是根加载器)开始往下,先判断父类加载器能不能加载,能加载则往下传递返回加载的类;不能加载则继续往下判断,如果都不能加载,则会抛出ClassNotFoundException异常;

      加载器之间的父子关系实际上是指加载器对象之间的包装关系,而不是类之间的继承关系;

     

    命名空间:

      命名空间由该加载器及所有父加载器所加载的类组成;

      唯一性:在同一个命名空间中,不会出现类的完整名字(包名+类名)相同的两个类;

      同一命名空间有以下关系:

        同一命名空间的类是相互可见的;(可见是指可以直接使用其类名,不可见的类之间可以通过反射来获取类信息);

        子加载器的命名空间所含所有父加载器的命名空间,所有子类加载器的类能看见父加载器的类;但父加载器不能看见子加载器的类;

    运行时包: 

      包名相同,且属于同一个类加载器;

      同一运行时包的类才能包可见;如用户自己定义了一个java.lang.Spy,并由自己定义的类加载器加载,由于java.lang.Spy和核心类库java.lang.*由不同的类加载器加载,它们不在同一运行时包,Spy不能访问java.lang.*下的包可见类;

     

    用户自定义类加载器:

      扩展java.lang.ClassLoader类,然后覆盖它的findClass(String name)方法;

      可通过 this.getClass().getClassLoader()获取类对应的加载器

     

    类的卸载:(清除对应类的Class对象 和 类的二进制数据结构)

      由Java虚拟自带的三个类加载器加载的类不能卸载;(虚拟机会始终引用这3个类加载器,类加载器中有一个集合,又会一直引用其加载的类的Class对象)

      用户自定义的类加载器加载的类可以被卸载;

      

      

     

     整理自孙卫琴《Java面象对象编程》

    转载于:https://www.cnblogs.com/mzzcy/p/7234199.html

    展开全文
  • 我们前面所讲的一切其实都只是为了一个目标那就是能正确发布一个线程安全的对象。 一:线程封闭 这个很好理解如果一个变量是在一个线程中完成的状态改变,那么这个变量肯定是线程安全的。 我们常使用的是栈封闭和...


    我们前面所讲的一切其实都只是为了一个目标那就是能正确发布一个线程安全的对象。

    一:线程封闭

    这个很好理解如果一个变量是在一个线程中完成的状态改变,那么这个变量肯定是线程安全的。

    我们常使用的是栈封闭和ThreadLocal类。

    在java运行时内存区中有一个虚拟机栈,栈封闭说的就是这个栈,这个栈是线程私有的,它的生命周期与线程相同。虚拟机栈描述描述的是java方法执行的内存模型:每个方法被执行的时候会同时创建一个栈帧用于存储局部变量、操作数栈等。每一个方法被调用直至执行完成的过程,就对应着一个栈帧在虚拟机栈中的从入栈到出栈的过程。

    那么我们定义在被调用方法的内部的局部变量就被封闭在栈中了,这样的变量只要不将该变量的引用发布出去那么它一定是线程安全的。

    	public int getBadNum(List<String> paralist)
    	{
    		List<String> localList;
    		int num = 0;
    		localList = paralist;
    		for(String t:localList){
    			if("bad".equals(t)){
    				++num;
    			}
    		}
    		return num;
    		
    	}

    该方法中num无论如何都不会破坏栈的封闭性,我们也看到localList是一个局部对象,一个对象的引用指向了它,而它被封闭在线程中所以那个引用也会被封闭在线程中执行完成。但是如何一旦把localList对象发布出去那么封闭性将被破坏。其它外部方法会怎么使用它我们就不能确定了。

    ThreadLocal变量我们在代码中很少使用了,因为它的特性会降低代码的可重用性,并在类之间引入隐含的耦合性,因此在使用时要格外小心,我们这里就不讲它的实例了。

    二:不可变对象

    不可变对象有以下几个条件。

           对象创建以后其状态就不能修改。

           对象的所有域都是final的类型。

           对象是正确创建的。

    事实上我们经常会使用这样的不可变对象在程序启动时对其进行初始化,然后多线程并发访问,这里最关键的是正确创建对象并初始化,所以一定是保证所有的对象不能发生逸出,通常的做法是在所有这样的变量初始化完成在启动并发访问线程,这一点一定要保证。

    三:安全发布常用模式

          1: 在静态初始化函数中初始化一个对象的引用。

          

    public class MongoDBTools {
    	
    protected Logger logger = LoggerFactory.getLogger(MongoDBTools.class);
    	
    	private MongoClient configClient;
    	private DB configDB;
    	private Map<String, MongoTemplate> shardMongoTemplateMap = new HashMap<String, MongoTemplate>();
    	
    	private MongoDBTools() {
    		init();			
    	}
    	
    	private static class SingletionHolder {
    		private static MongoDBTools appConfigTools = new MongoDBTools();
    	}
    	
    	public static MongoDBTools getInstance() {
    		return SingletionHolder.appConfigTools;
    	}
    	
    	@SuppressWarnings("deprecation")
    	public void init() {
    		
    	}
    
    	
    	
    }
    


    我们使用getInstance方法获得的就是利用static域初始化好的单例对象。

            2: 将对象的引用保存到volatile类型的域或是AtomicReferance对象中。

    这种方式有很大的局限性,一般只适用于只读共享模式。

            3:将对象的引用保存到某个正确构造的对象的final类型域中。

    这是方式我们经常会用但是如果是可变状态的对象的发布就一定要通过锁来处理了。

    package com.uskytec.ubc.interf.webservice;
    
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @author gaoxu
     *
     */
    public class ConcurrentHashMapInstance {
    	
    	static ConcurrentHashMap<?, ?>  chm = null;
    	
    	/**获取ConcurrentHashMap的全局对象
    	 * @return
    	 */
    	public synchronized static ConcurrentHashMap<?, ?> getCHM(){
    		
    		if(chm==null){
    			chm = new ConcurrentHashMap<String, Boolean>();
    		}
    		
    		return chm;
    		
    	}
    
    }


    利用java提供的ConcurrentHashMap并发对象可以实现线程安全共享。
          4:将对象的引用保存到一个由锁保护的域中。

    package com.uskytec.ubc.foundation.queue;
    
    import java.util.HashMap;
    
    /**路由cache
     * @author GaoXu
     *
     */
    public class RouteCache {
    	
    	private static RouteCache instance = null;
    	
    	public synchronized static RouteCache getInstance()
    	{
    		if (instance == null)
    			instance = new RouteCache();
    		return instance;
    	}
    	private final static HashMap<String,Object> routeCache = new HashMap<String,Object>();
    
    	/**
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public synchronized int add(String key,Object value)
    	{
    		routeCache.put(key, value);
    		return 1;
    	}
    	
    	/**
    	 * @param key
    	 * @return
    	 */
    	public synchronized Object get(String key)
    	{
    		
    		    if (routeCache != null)
    			    return routeCache.get(key);
    		    return null;
    	}
    }
    
    实例中的routeCache是一个可变状态的对象,所以我们采用线程安全共享的方式发布出来,针对它的操作一律采用公有接口提供操作。
    

    掌握好这些发布策略我们就能更好的编写线程安全共享对象,同时也可以安全的实现并发任务的执行。



    
    展开全文
  • 第一个原因是在对象生命周期中初始化是最重要一步;每个对象必须正确初始化后才能正常工作。第二个原因是__init__()参数值可以有多种形式。因为有很多种方式为__init__()提供参数值,对于对象创建有大量用例,...

    __init__()方法意义重大的原因有两个。第一个原因是在对象生命周期中初始化是最重要的一步;每个对象必须正确初始化后才能正常工作。第二个原因是__init__()参数值可以有多种形式。

    因为有很多种方式为__init__()提供参数值,对于对象创建有大量的用例,我们可以看看其中的几个。我们想尽可能的弄清楚,因此我们需要定义一个初始化来正确的描述问题区域。

    在我们接触__init__()方法之前,无论如何,我们都需要粗略、简单地看看在Python中隐含的object类的层次结构。

    在这一章,我们看看不同形式的简单对象的初始化(例如:打牌)。在这之后,我们还可以看看更复杂的对象,就像包含集合的hands对象以及包含策略和状态的players。

    隐含的超类——object

    每一个Python类都隐含了一个超类:object。它是一个非常简单的类定义,几乎不做任何事情。我们可以创建object的实例,但是我们不能用它做太多,因为许多特殊的方法容易抛出异常。

    当我们自定义一个类,object则为超类。下面是一个类定义示例,它使用新的名称简单的继承了object:

    class X:

    pass

    下面是和自定义类的一些交互:

    >>> X.__class__

    >>> X.__class__.__base__

    我们可以看到该类是type类的一个对象,且它的基类为object。

    就像在每个方法中看到的那样,我们也看看从object继承的默认行为。在某些情况下,超类特殊方法的行为是我们所想要的。在其他情况下,我们需要覆盖这个特殊方法。

    基类对象的init()方法

    对象生命周期的基础是创建、初始化和销毁。我们将创建和销毁的高级特殊方法推迟到后面的章节中,目前只关注初始化。

    所有类的超类object,有一个默认包含pass的__init__()实现,我们不需要去实现__init__()。如果不实现它,则在对象创建后就不会创建实例变量。在某些情况下,这种默认行为是可以接受的。

    我们总是给对象添加属性,该对象为基类object的子类。思考以下类,需要两个实例变量但不初始化它们:

    class Rectangle:

    def area(self):

    return self.length * self.width

    Rectangle类有一个使用两个属性来返回一个值的方法。这些属性没有初始化。这是合法的Python代码。它可以有效的避免专门设置属性,虽然感觉有点奇怪,但是有效。

    下面是于Rectangle类的交互:

    >>> r = Rectangle()

    >>> r.length, r.width = 13, 8

    >>> r.area()

    104

    显然这是合法的,但也是容易混淆的根源,所以也是我们需要避免的原因。

    无论如何,这个设计给予了很大的灵活性,这样有时候我们不用在__init__()方法中设置所有属性。至此我们走的很顺利。一个可选属性其实就是一个子类,只是没有真正的正式声明为子类。我们创建多态在某种程度上可能会引起混乱以及if语句的不恰当使用所造成的盘绕。虽然未初始化的属性可能是有用的,但很有可能是糟糕设计的前兆。

    《Python之禅》中的建议:

    "显式比隐式更好。"

    一个__init__()方法应该让实例变量显式。

    可怜的多态

    灵活和愚蠢就在一念之间。

    当我们觉得需要像下面这样写的时候,我们正从灵活的边缘走向愚蠢:

    if 'x' in self.__dict__:

    或者:

    try:

    self.x

    except AttributeError:

    是时候重新考虑API并添加一个通用的方法或属性。重构比添加if语句更明智。

    在超类中实现init()

    我们通过实现__init__()方法来初始化对象。当一个对象被创建,Python首先创建一个空对象,然后为那个新对象调用__init__()方法。这个方法函数通常用来创建对象的实例变量并执行任何其他一次性处理。

    下面是Card类示例定义的层次结构。我们将定义Card超类和三个子类,这三个子类是Card的变种。两个实例变量直接由参数值设置,两个变量通过初始化方法计算:

    class Card:

    def __init__(self, rank, suit):

    self.suit = suit

    self.rank = rank

    self.hard, self.soft = self._points()

    class NumberCard(Card):

    def _points(self):

    return int(self.rank), int(self.rank)

    class AceCard(Card):

    def _points(self):

    return 1, 11

    class FaceCard(Card):

    def _points(self):

    return 10, 10

    在这个示例中,我们提取__init__()方法到超类,这样在Card超类中的通用初始化可以适用于三个子类NumberCard、AceCard和FaceCard。

    这是一种常见的多态设计。每一个子类都提供一个唯一的_points()方法实现。所有子类都有相同的签名:有相同的方法和属性。这三个子类的对象在一个应用程序中可以交替使用。

    如果我们为花色使用简单的字符,我们可以创建Card实例,如下所示:

    cards = [AceCard('A', '?'), NumberCard('2','?'), NumberCard('3','?'),]

    我们在列表中枚举出一些牌的类、牌值和花色。从长远来说,我们需要更智能的工厂函数来创建Card实例;用这个方法枚举52张牌无聊且容易出错。在我们接触工厂函数之前,我们看一些其他问题。

    使用init()创建显式常量

    可以给牌定义花色类。在二十一点中,花色无关紧要,简单的字符串就可以。

    我们使用花色构造函数作为创建常量对象的示例。在许多情况下,我们应用中小部分对象可以通过常量集合来定义。小部分的静态对象可能是实现策略模式或状态模式的一部分。

    在某些情况下,我们会有一个在初始化或配置文件中创建的常量对象池,或者我们可以基于命令行参数创建常量对象。我们会在第十六章《通过命令进行复制》中获取初始化设计和启动设计的详细信息。

    Python没有简单正式的机制来定义一个不可变对象,我们将在第三章《属性访问、方法属性和描述符》看看保证不可变性的相关技术。在本示例中,花色不可变是有道理的。

    下面这个类,我们将用于创建四个显式常量:

    class Suit:

    def __init__(self, name, symbol):

    self.name= name

    self.symbol= symbol

    下面是通过这个类创建的常量:

    Club, Diamond, Heart, Spade = Suit('Club','?'), Suit('Diamond','?'), Suit('Heart','?'), Suit('Spade','?')

    现在我们可以通过下面展示的代码片段创建cards:

    cards = [AceCard('A', Spade), NumberCard('2', Spade), NumberCard('3', Spade),]

    这个小示例,这种方法对于单个特性的花色代码来说并不是一个巨大的进步。在更复杂的情况下,会有一些策略或状态对象通过这个方式创建。通过从小的、静态的常量对象中复用可以使策略或状态设计模式更有效率。

    我们必须承认,在Python中这些对象并不是技术上一成不变的,它是可变的。进行额外的编码使得这些对象真正不变可能会有一些好处。

    无关紧要的不变性

    不变性很有吸引力但却容易带来麻烦。有时候被神话般的“恶意程序员”在他们的应用程序中通过修改常量值进行调整。从设计上考虑,这是非常愚蠢的。这些神话般的、恶意的程序员不会停止这样做,因为已经没有更好的方法去更简洁简单的在Python中编码。恶意程序员访问到源码并且修改它仅仅是希望尽可能轻松地编写代码来修改一个常数。

    在定义不可变对象的类的时候最好不要挣扎太久。在第三章《属性访问、方法属性和描述符》中,我们将通过在有bug的程序中提供合适的诊断信息来展示如何实现不变性。

    展开全文
  • 第一个原因是,初始化是最重要步骤在一个对象的生命周期;每个对象都必须正确地初始化,才能正常工作。第二个原因是,__init__()参数值可以有多种形式。因为有很多方法可以提供参数值__init__(),有很多用例创建对象,...

    __init__()方法是重要的有两个原因。第一个原因是,初始化是最重要的步骤在一个对象的生命周期;每个对象都必须正确地初始化,才能正常工作。第二个原因是,__init__()参数值可以有多种形式。因为有很多方法可以提供参数值__init__(),有很多用例创建对象,我们可以看看其中的一些。我们想要尽可能明确,所以我们需要定义一个初始化正确描述问题域。触摸__init__()方法之前,在任何情况下,我们需要有一个粗略的和简单的观察对象类的层次结构隐含在Python。在这一章,我们看到不同形式的简单对象的初始化(例如:打牌)。之后,我们还可以看更复杂的对象,像手中对象包含集合,包含战略和国家的球员。

    这是一个非常简单的类定义和几乎没有做任何事情。我们可以创建一个对象的实例,但我们不能做太多,因为许多特殊的方法容易抛出异常。当我们自定义一个类,对象是超类。下面是类定义的一个例子,它继承了对象与一个新的名字:类X:通过。这里有一些交互定制类:我们可以看到,这个类是一个类类型的对象,和它的基类对象。见每个方法,我们也看看默认行为继承对象。在某些情况下,超类特殊方法的行为就是我们想要的。在其他情况下,我们需要覆盖这个特殊的方法。基类对象的init()方法是基于创建、初始化和销毁。我们推迟先进的特殊方法的创建和销毁以后章节,和目前只专注于初始化。所有类的超类对象__init__()的实现,包括通过默认情况下。

    如果没有实现,没有实例变量创建后将创建对象。在某些情况下,这种默认行为是可以接受的。我们总是向对象添加属性,这是基类的子类对象。考虑下面的类,它需要两个实例变量,但不初始化:类矩形:def区域(自我):返回*矩形类都有一个方法,使用两个属性返回一个值。这些属性是没有初始化。这是合法的Python代码。它可以有效地避免专门设置属性,虽然感觉有点奇怪,但有效。以下是与矩形的交互类:104显然这是合法的,但也是混乱的来源,因此它也是我们需要避免的原因。在任何情况下,这种设计提供了很大的灵活性,所以,有时候我们不需要设置中的所有属性__init__()方法。到目前为止,我们已经非常顺利。一个可选属性实际上是一个子类,但不是正式宣布一个子类。

    尽管未初始化的属性可能是有用的,他们很可能预示着糟糕的设计。\u201CPython的禅\u201D的建议:\u201C显式优于隐式\u201D。一个__init__()方法应该显式的使用实例变量。可怜的多态性是灵活的和愚蠢的想法。当我们觉得有必要写如下,我们正从边缘的愚蠢的灵活性:如果'x\u201D自我。__dict__:或者尝试:除了AttributeError:是时候重新考虑API,并添加一个常见的方法或属性。重构是更明智的if语句。实现超类的init(),我们初始化对象通过实现__init__()方法。当一个对象被创建时,Python首先创建一个空对象,然后调用__init__()方法的新对象。

    以下是卡类定义的层次结构的例子。我们将定义卡超类和三个子类,变异的卡片。两个实例变量直接设定的参数值,并计算了两个变量的初始化方法:卡类:def __init__(自我、等级、套装):=西装=排名,= self._points()类NumberCard(卡):def _points(自我):返回int (), int()类AceCard(卡):def _points(自我):返回1,11类FaceCard(卡):def _points(自我):返回10个,10个在这个例子中,我们提取超类__init__()方法,所以一般在卡初始化父类可以应用到三个子类NumberCard AceCard FaceCard。

    每个子类提供了一个独特的_points()方法的实现。所有子类都有相同的特征:他们有相同的方法和属性。这三个子类的对象在一个应用程序中可以互换使用。如果我们使用简单的字符的西装,我们可以创建一个卡的实例如下:卡= [AceCard (' A ', ' ? '), NumberCard (' 2 ', ' ? '), NumberCard (' 3 ', ' ? '))我们列举一些卡片类型,卡值和套装在列表中。从长远来看,我们需要更聪明的工厂函数来创建卡实例;使用这种方法枚举52张牌很无聊而且容易出错。我们联系工厂函数之前,让我们来看看一些其他问题。使用init()来创建显式常量定义西装类卡片。在21点,衣服并不重要,一个简单的字符串。

    在许多情况下,物体的一小部分在我们的应用程序可以定义常量的集合。少量的静态对象可能是实现这一战略模式或状态模式的一部分。在某些情况下,我们将有一个恒定的对象池中创建初始化或配置文件,或者我们可以创建常量对象基于命令行参数。我们将初步设计的详细信息和启动设计在16章命令\u201C复制\u201D。Python没有一个简单的和正式的机制来定义一个不可变对象。我们将在第三章相关技术,以确保不变性\u201D属性访问方法属性和描述符\u201D。在这个例子中,是有道理的,衣服是不可变的。下面的类,我们将使用它来创建四个明确的常量:类套装:def __init__(自我、名称、符号):namesymbol常数是由这类:俱乐部,钻石,心,铁锹=套装(\u201C俱乐部\u201D、\u201C?

    \u2019),西装(\u2018心\u2019,\u2018?\u2019),西装(\u201C铲\u201D、\u201C?\u201D)现在我们可以通过如下所示的代码片段创建卡片:卡= [AceCard (A,铲)、NumberCard(\u201C2\u201D,铲)、NumberCard(\u201C3\u201D,铲)]这个小例子,这种方法不是一个单一的颜色代码的功能很大的进步。在更复杂的情况下,会有一些策略或国家以这种方式创建的对象。策略或状态设计模式可以更有效的通过重用小,静态常量对象。我们必须承认,这些对象并不是技术上不可变在Python中,它们是可变的。可能会有一些额外的福利编码使这些对象真正不变。

    有时令人难以置信的\u201C恶意的程序员\u201D做出调整修改常量值在他们的应用程序。从设计考虑,这是非常愚蠢的。这些令人难以置信的和恶意的程序员不会停止这样做,因为没有更好的方法来用Python代码更加简洁和简单。一个恶意的程序员访问源代码和修改它来编写代码来修改一个常数尽可能容易。最好不要挣扎太久在定义类的不可变的对象。在第三章\u201C访问属性,属性和方法描述符\u201D,我们将展示如何实现不变性在车程序中通过提供适当的诊断信息。

    展开全文
  • 本书论述运用UML(统一建模语言)和模式进行对象建模方法和技巧,重点讨论了如何使用面向对象的分析和设计技术来建造一个健壮和易于维护系统。 全书叙述清晰、图文并茂、实例丰富,是一部来自于大量经验...
  • 总结了JVM一些经典面试题,分享出我自己解题思路,希望对大家有帮助,有...我答案:栈是线程私有,他的生命周期与线程相同,每个方法在执行时候都会创建一个栈帧,用来存储局部变量表,操作数栈,动态链接...
  • 第一个原因是在对象生命周期中初始化是最重要一步;每个对象必须正确初始化后才能正常工作。第二个原因是__init__()参数值可以有多种形式。 因为有很多种方式为__init__()提供参数值,对于对象创建有大量用例,...
  • 第一个原因是在对象生命周期中初始化是最重要一步;每个对象必须正确初始化后才能正常工作。第二个原因是init()参数值可以有多种形式。因为有很多种方式为init()提供参数值,对于对象创建有大量用例,我们可以看...
  • 容器创建对象,将它们装配在一起,配置它们并管理它们完整生命周期。Spring 容器使用依赖注入来管理组成应用程序组件。容器通过读取提供配置元数据来接收对象进行实例化,配置和组装指 令。该元数据可以通过
  • 面向对象(OO)设计(即OOD)是对系统对象的详细描述,这些对象通过相互协作(静态结构、动态行为)来满足系统需求。设计所描述的仍然是解决方案,只不过在更细层面上,描述了实例变量、方法参数、返回类型以及...
  • 9、下列有关数据库的描述正确的是()。 A、数据库是一个DBF文件 B、数据库是一个关系 C、数据库是一个结构化的数据集合 D、数据库是一组文件 我的答案:C 10、下列说法中,不属于数据模型所描述的内容的是...
  •  SessionBean: Stateless Session Bean 的生命周期是由容器决定,当客户机发出请求要建立一个Bean实例时,EJB容器不一定要创建一个新Bean实例供客户机调用,而是随便找一个现有实例提供给客户机。...
  • maven-基本概念

    2020-08-20 22:51:58
    基于项目对象模型(POM)概念,Maven可以从一个中心资料片管理项目构建,报告和文件。 ##二、Maven默认(别名:build、构建、生成)生命周期 生命周期阶段 描述 validate 验证项目是否正确,并且所有必要...
  • 菜鸡说maven

    2020-08-08 12:18:17
    ​ 简而言之,maven是一个跨平台项目管理工具,基于项目对象模型(POM),使用Java语言开发。使用一小段描述信息,来管理项目构建,报告和文档生成等等。 为什么是maven ​ 多人合作开发软件,保证所有...
  • 不幸的是,虽然关系型数据库历经了约30年的发展,有成熟的理论和大量的实践基础,但是,大多数设计、开发人员在设计数据库结构时仍然是“跟着感觉走”,根据业务的需要和编程的方便,把字段这张表放几个那张表放几个...
  • 8.6.2 有状态Session Bean的生命周期 322 8.6.3 定制Session Bean生命 周期行为 323 8.7 在Session Bean中使用事务 327 8.7.1 容器管理事务 327 8.7.2 Bean管理事务 330 8.8 拦截器 332 8.9 依赖注入 335 8.9.1 ...
  • Android学习31

    2017-01-01 22:14:09
    一、 选择题 1、 Activity对一些资源以及...2、下面的是关于类及其修饰符的一些描述,不正确的是()? A、Abstract类只能用来派生子类,不能用来创建abstract类的对象 B、abstract不能与final同时修饰一个类
  • 软件框架设计艺术

    2014-05-27 11:56:07
    4.5 一个API的生命周期 56 4.6 逐步改善 60 第二部分 设计实战 第5章 只公开你要公开内容 67 5.1 方法优于字段 68 5.2 工厂方法优于构造函数 70 5.3 让所有内容都不可更改 71 5.4 避免滥用...
  • 文章目录选择题判断题简答题简述如何检查数据流图的正确性。简述可行性含义。信息系统可行性分析包括哪些内容?简述系统实施阶段主要任务。系统实施阶段任务有哪些?...简述使用生命周期条件。一般系...
  • 3.7.2 模式结构的正确命名 53 3.7.3 ER概念设计设计选择 54 3.7.4 ER图候选表示法 55 3.8 其他表示法示例:UML类图 55 3.9 高于2度联系类型 57 3.9.1 对二元和三元(或高度)联系选择 ...
  • spring面试

    2019-06-27 22:31:00
    1.什么是spring配置文件? spring配置文件是XML文件,该文件主要包含类信息,他...spring框架核心是spring容器,容器创建对象,将他们装配在一去,配置他们并管理他们完整生命周期。spring容器使用依赖注入来管...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    对象生命周期 顺序图与协作图 相同点 描述对象间交互关系 不同点 顺序图:交互时间顺序 协作图:交互静态链接关系 3D电影动态建模 活动图 -状态变种 活动图 -状态变种 活动图 活动和转移 ...
  • JVM常见面试题解析

    千次阅读 2019-12-01 10:04:17
    总结了JVM一些经典面试题,分享出我自己的解题思路,希望对大家有帮助,有哪里你觉得不正确的话,欢迎指出,后续有空会更新。 1.什么情况下会发生栈内存溢出。 思路: 描述栈定义,再描述为什么会溢出,再说明...
  • 总结了JVM一些经典面试题,分享出我自己的解题思路,希望对大家有帮助,有哪里你觉得不正确的话,欢迎指出,后续有空会更新。 1.什么情况下会发生栈内存溢出。 思路: 描述栈定义,再描述为什么会溢出,再说明一下...
  • JVM整理

    2020-07-05 15:34:57
    栈是线程私有,他的生命周期与线程相同,每个方法在执行时候都会创建一个栈帧,用来存储局部变量表,操作数栈,动态链接,方法出口等信息。局部变量表又包含基本数据类型,对象引用类型 如果线程请求栈深度...
  • 常见JVM面试题整理

    2020-05-22 10:30:12
    栈是线程私有,他的生命周期与线程相同,每个方法在执行时候都会创建一个栈帧,用来存储局部变量表,操作数栈,动态链接,方法出口等信息。局部变量表又包含基本数据类型,对象引用类型 如果线程请求栈深度...
  • 栈是线程私有,他的生命周期与线程相同,每个方法在执行时候都会创建一个栈帧,用来存储局部变量表,操作数栈,动态链接,方法出口等信息。局部变量表又包含基本数据类型,对象引用类型 如果线程请求栈深度...

空空如也

空空如也

1 2 3 4
收藏数 64
精华内容 25
关键字:

对象生命周期描述正确的是