Java初始化的方法有几种？

Question

RT，我想问的是java初始化的方法有哪几种，各有什么好处，哪里会用的到等等。PS1：new关键字就不必提了，提了也不给分。、PS2：关于反射、工厂方法请有自己的见解，有马有真相更好其他的方法一样谢谢

Answer 1

先弱弱的问几个问题
1、这个初始化指什么？
2、创建对象么？
3、构造方法么？
4、像applet生命周期中的init()算不算初始化？抽象工厂用来创建工厂
工厂方法用来创建对象
单例工厂用来保证对象的单一实例不是很明白自己也有点儿晕乎的希望楼主和楼下不要拍砖

Answer 2

LZ指的是java哪种初始化？数组、对象、基本类型？

Answer 3

动态加载也可以的  classload.load()这个应该可以的。。
  你看看  JAVA 的加载机制吧。
   new 是显示加载 
class.forname 还有我上面说的那个方法是 隐形加载

Answer 4

静态工厂：在Java中，构造函数的访问级别通常是public, 它提供了一个构造该类对象的接口。可是你知不知道，把构造函数的级别设为private, 有一些特别用处。public class Handler {
    /**当前类唯一实例**/
    private final static Handler INSTANCE = new Handler();
    
    /**默认无参构造器**/
    private Handler() {    }
    
    /**
     * 用于获取Handler实例
     * @return 返回Handler实例
     */
    public static Handler getInstance()
    {  
            return INSTANCE;
    }
}上面的makeShape（）方法可以返回Shpe的子类对象如下假定：retangle和Circle是Shape的子类 public static Shape makeShape() {
       System.out.println("here is the shape you ordered");
       if (retangle)
             return (new Retangle());
       if (Circle)
            return (new Circle());
   
    }还可以实现只有一个类的对象：public class Handler {
   
    private Handler handler = null;
    private Handler() {
      
    }    public static getHandler() {
        if (!handler)
             handler = new Handler();
       return handler;
    }    public static void main(String args[]) {
         Handler.getHandler();
    }
}当handlerw为空时，那么重新构造一个handler，然后返回；如果已经构造过了，那么就直接返回已经存在的handler。
 
可以方便的拋出异常。请看下列代码public class Test {
        public Test() {
                double x = 1.0/0.0;
        }
        public static void main(String args[]) {
        try {
                Test test = new Test();
        }catch (Exception e){
                System.out.println(e.toString());
        }
  }
}编译，执行，你会发现这个异常不会被捕捉，没有任何输出；即使尝试在构造函数中捕捉异常也不行。看下列代码：public class Test {
        public Test() {
                try {
                System.out.println("trying to throw an exception");
                double x = 1.0/0.0;
                } catch(Exception e) {
                        System.out.println("Exception captured");
                }finally {
                        System.out.println("inside finally");
                }
        }
        public static void main(String args[]) {
                Test test = new Test();
        }
}编译，运行，结果为：
trying to throw an exception
inside finally原因是JVM把构造函数产生的异常丢弃了。试想你正在使用一个第三方的类库提供的类，那个类提供一个共有的构造函数，它允许你通过参数构造一个类的对象，可是如果你的参数不合法，导致在构造函数中产生一个异常，那么你永远不知道具体发生了什么。可向而知那时的错误将会很难查找。

Answer 5

据我所知，三种：
一、构造器；二、静态工厂方法；
    基本细想：通过类中的静态方法返回对象。(如果构造方法私有，称做单例模式）三、通过Class类；
    基本细想：实例化无参构造的类，先通过forName()方法实例化Class对象（即反射操作），然后用Class类中的newInstance()方法；实例化带参数构造的类，需要使用Class类中的getConstructors()方法获取所有的构造，然后同上操作。

Answer 6

哈哈！你还蛮幽默的啊， java我不熟！

Answer 7

不是很懂楼主的意思，大概就new，反射，工厂模式这几种啊，还有就是继承的时候初始化子类的时候会初始化父类，想不出别的了，好像。

Answer 8

除了你说的方法外，还有clone()方法啊，Object类在clone()方法的实现中会创建一个复制的对象，这个对象与原来的对象具有不同的内存地址，不过它们的属性值相同。

Answer 9

单态也是构造器new出来的对象么 只不过封闭了构造

Answer 10

java中对象的初始化讲的最好的书可能是《java编程思想》，可以看看，尤其是初始化顺序。
类的属性分为基本类型属性和对象属性，对象属性初始化为null,初始化顺序就是声明顺序。
之后，初始化的工作就是构造函数了。
还有就是父类和子类的初始化，记着先构造父类再构造子类就ok。

Answer 11

大圣你说的也差不多是new一个对象，不过java编程思想我没有看过。。

Answer 12

+1
不过这个好像只是在某些场合下用才合适，比如需要长时间保存对象时。序列化时调用writeObject，保存对象。反序列化时调用readObject,还原对象。

Answer 13

1、class.forName
2、clone()
3、从流里面读入对象

Answer 14

单例模式初始化对象，老用new不好！！

Answer 15

对象初始化在类被装载、连接和初始化，这个类就随时都可能使用了。对象实例化和初始化是就是对象生命的起始阶段的活动，在这里我们主要讨论对象的初始化工作的相关特点。Java 编译器在编译每个类时都会为该类至少生成一个实例初始化方法--即 "<init>()" 方法。此方法与源代码中的每个构造方法相对应，如果类没有明确地声明任何构造方法，编译器则为该类生成一个默认的无参构造方法，这个默认的构造器仅仅调用父类的无参构造器，与此同时也会生成一个与默认构造方法对应的 "<init>()" 方法.通常来说，<init>() 方法内包括的代码内容大概为：调用另一个 <init>() 方法；对实例变量初始化；与其对应的构造方法内的代码。如果构造方法是明确地从调用同一个类中的另一个构造方法开始，那它对应的 <init>() 方法体内包括的内容为：一个对本类的 <init>() 方法的调用；对应用构造方法内的所有字节码。如果构造方法不是通过调用自身类的其它构造方法开始，并且该对象不是 Object 对象，那 <init>() 法内则包括的内容为：一个对父类 <init>() 方法的调用；对实例变量初始化方法的字节码；最后是对应构造子的方法体字节码。如果这个类是 Object，那么它的 <init>() 方法则不包括对父类 <init>() 方法的调用。

Answer 16

package com.xr.framework.enums;import java.util.Collections;
import java.util.HashMap;
import java.util.Map;public class CachingEnumResolver {
//单态实例　一切问题皆由此行引起
private static final CachingEnumResolver SINGLE_ENUM_RESOLVER = new
CachingEnumResolver();
/*MSGCODE->Category内存索引*/
private static Map CODE_MAP_CACHE;
static {
CODE_MAP_CACHE = new HashMap();
//为了说明问题,我在这里初始化一条数据
CODE_MAP_CACHE.put("0","北京市");
}

//private, for single instance
private CachingEnumResolver() {
//初始化加载数据  引起问题，该方法也要负点责任
initEnums();
}

/**
 * 初始化所有的枚举类型
 */
public static void initEnums() {
// ~~~~~~~~~问题从这里开始暴露 ~~~~~~~~~~~//
if (null == CODE_MAP_CACHE) {
System.out.println("CODE_MAP_CACHE为空,问题在这里开始暴露.");
CODE_MAP_CACHE = new HashMap();
}
CODE_MAP_CACHE.put("1", "北京市");
CODE_MAP_CACHE.put("2", "云南省");

//..... other code...
}

public Map getCache() {
return Collections.unmodifiableMap(CODE_MAP_CACHE);
}

/**
 * 获取单态实例
 * 
 * @return
 */
public static CachingEnumResolver getInstance() {
return SINGLE_ENUM_RESOLVER;
}

public static void main(String[] args) {
System.out.println(CachingEnumResolver.getInstance().getCache());
}
}
 

Answer 17

深入理解JVM一书中有提到类实例化有四种方法，一是你提到的new，剩下三个见我31说的

Answer 18

看了这么多答案，初始化是不是可以这么理解？
1、来自构造器，也就是被创建出来的
2、来自序列化的对象源，这个可能有很多种哈再多想一步哈
任何对象都是一块带着唯一标号的内容
那么初始化应该可以理解为对这个标号和内容进行赋值
如果是这个逻辑的话
那么初始化就是
1、创造一个新的标号并写入内容
2、读取一个现在不存在的标号（存在的话应该是冲突的哈）和它所对应的内容那么初始化也就这两类了吧：）
看法粗浅希望大家指正>,<

Answer 19

3种吧！一个克隆，一个new一个反射

Answer 20

其实说到底还不是两种new 和反射。其它的也都是用这两种方法实现的

Answer 21

你说的也太对了。。没有new就没有对象

Answer 22

归根结底只有一个，在jvm那里，对象就是new出来的，普通变量直接在编译器那里搞定

Answer 23

一个对象的真正的初始化过程应该是：将对象的存储空间初始化为二进制的0.
先递归到最上层的基类去，将最上层的基类作为当前类。
对于当前类：
按声明顺序调用成员变量的初始设置代码。
调用构造函数。
接着将下一层继承类作为当前类，继续步骤3
先看下面的代码：view plaincopy to clipboardprint?
class A {  
    A() {  
        System.out.println("A create");  
    }  
}  
   
class D {  
    D() {  
        System.out.println("D create");  
    }  
}  
   
class B extends A {  
    private D d = new D();  
    B() {  
        System.out.println("B create");  
    }  
}  
   
class C extends B {  
    C(int i) {  
        System.out.println("C create");  
    }  
}  
   
public class Main {              
    public static void main(String[] args) {  
        C c = new C(10);  
    }  
}  
 初始化过程大概是这样的： 先从C递归到B，再从B递归到A。
A没有成员变量，所以A的构造函数被调用。
接到回到B，B有一个D类的成员有初始化，因此D的构造函数被调用。
接着B的构造函数被调用。
最后回到C，C的构造函数被调用。
所以输出应该是：A createD createB createC create

Answer 24

本人菜鸟一个，现在还纠结在配置myeclipse上杯具

Answer 25

http://blog.csdn.net/Nocky/archive/2011/03/26/6280747.aspx

Answer 26

你的这个是Java中类成员的初始化，我问的是对象。。

Answer 27

初始化对象可以用 new 或getInstance()

Answer 28

初始化代码块
static{
//init something
}

Answer 29

注入和new有什么区别吗？？

Answer 30

初始化对象应该只有3种方法
1. new
2. 反射
3. clone1. new 也有很多方式，比如单例，工厂
2. 反射就是loadclass或者forname，结合配置就可以实现多态，用反射的工厂比new更灵活。
3. clone 这是非常危险的方法，不建议使用。碼就不贴了，看完所有单例方式估计就差不多了

Answer 31

单态是指单态设计模式吧？
就是设计出来的类只能产生一个唯一一个对象实例。按照这个原则，这个对象实例必须是一个静态的对象，在定义时通过new初始化的。具体产生方法:
1、 类定义时，定义一个数据成员，static,并且就是这个类的对象，保证类内部只能创建唯一一个实例对象；
2、 定义构造函数，并设置为private，这样就可以不允许类外部创建实例对象；
3、 定义一个public函数，返回这个唯一的实例对象，这样就可以实现类外部访问这个唯一的对象实例。