精华内容
下载资源
问答
  • Java实例初始化详解

    千次阅读 2014-06-01 16:41:14
    The body of a class declares members (fields and methods and nested classes and interfaces), instance and static ...类***声明成员(变量,方法,内部类和接口),实例和静态初始化和构造器。 At the beginni

    原文地址:http://java.dzone.com/articles/instance-initializers-java

    英文标题:Java Instance Initializers in Java Explained


    类的主体声明了成员(变量,方法,内部类和接口)、实例初始化、静态初始化和构造器。在对象生命周期之初,Java虚拟机(JVM)在堆上分配足够的存储空间以容纳对象的实例变量。但是当这些存储空间刚被分配的时候,里面包含的数据是无法预测的。如果存储空间就这样被使用,对象的行为也将是不可预测的。为了避免这样的境地,Java保证这块存储空间在被任何代码使用之前至少被初始化为可预测的默认值。


    初始化很重要,因为一直以来,没有初始化的数据都是bug的主要来源。例如,由于未初始化的数据导致的错误经常出现在C代码中,因为C没有内置的机制强制实现适当的数据初始化。C程序员必须总是记住在分配了内存之后要初始化数据,然后再使用。对比之下,Java语言拥有内置的机制来帮助你确保恰当地初始化新创建对象占据的存储空间。通过恰当地使用这种机制,你可以防止你的设计中创建的某个对象进入无效的初始状态。


    Java语言拥有三种专门用来保证恰当地进行对象初始化的机制:实例初始化(也称为实例初始化块),实例变量初始化和构造器。(实例初始化和实例变量初始化统称为“initializers”)所有三种机制都会在对象创建时自动执行。当你使用new操作为新对象分配内存或者Class类的newInstance()方法,java虚拟机会确保在你使用新分配的存储空间之前执行初始化代码。如果你设计了类并且初始化和构造器总是令新创建对象产生有效状态,就不会有任何人可以创建和使用还没有恰当地初始化的对象。


    当Java创建对象时,按照如下顺序来初始化对象:


    1. 设置成员变量为默认值(0,false,null)
    2. 调用对象的构造方法(但是不执行构造方法体)
    3. 执行父类的构造方法
    4. 使用初始化和初始化块来初始化变量
    5. 执行构造方法体

    让我们看一个例子。


    public class InstanceInitializers1 {
      int i = 10;
      {
        System.out.println(i);
        i = 8;
      }
    
      public static void main(String[] args) {
        new InstanceInitializers1();
      }
    }

    正如你所料,输出结果是10。

    Java 1.1引入了实例初始化, 也称为实例初始化块。在以下场景,实例初始化是实例变量初始化的有用的备选:

    1. 初始化代码必须捕获异常;
    2. 执行某些无法用实例变量初始化表达式表示的运算。


    当然,你也可以将这些代码写入到构造器中。但是在一个拥有多个构造器的类中,你将不得不在每个构造其中重复这些代码。使用实例初始化,你可以只写一遍代码,无论哪个构造器用来创建对象,它都会执行。实例初始化在匿名内部类中也很有用,因为匿名内部类无法声明构造器。



    实例初始化内部的代码可能不会返回。除了匿名内部类,实例初始化只有在类的每个构造器都显示抛出已检查异常的情况下才能抛出异常。而匿名内部类的实例初始化可以抛出任何异常。当你写了初始化代码(无论实例变量初始化还是实例初始化),你必须确定没有引用任何处于正在初始化的变量后面声明的实例变量。也就是说,你不能在initializer中进行前向引用。如果你不遵守这条规则,编译器会给你一个错误信息并拒绝生成class文件。当一个对象被创建,initializers按文本顺序执行--在源码中出现的先后顺序。这条规则防止initializers使用还没有被初始化的实例变量。


    实例变量首先被初始化为默认值,然后实例初始化块才执行,但是我们不能进行前向引用(forwark reference)。如果你违反了这条规则,编译器会给出报错信息并且拒绝产生class文件。例如:


    public class InstanceInitializers2 {
     {
      System.out.println(i);
      i = 8;
     }
     int i = 10;
     
     public static void main(String[] args) {
      new InstanceInitializers1();
     }
    }


    因为前向引用,上面的代码无法通过编译。但是,用下面的代码片,你可以看到前向引用和默认值初始化。



    public class Initializers1 {
     int j = getI();
     int i = 10;
     
     public static void main(String[] args) {
      System.out.println(new Initializers1().j);
     }
     public int getI() {
      return i;
     }
    }


    你认为输出会是什么?

    会打印出0。因为当getI方法被调用的时候,i的值是0(默认值)。


    实例初始化块可以抛出异常,但是每个构造器都必须声明抛出指定的异常或者其父类。让我们看一个例子。


    import java.io.*;
     
    public class InitializerException {
     {
      if(true) {
       System.out.println("A");
       throw new FileNotFoundException();//A checked exception
      }
     }
     
     public InitializerException() throws FileNotFoundException {
     }
     
     public static void main(String[] args) throws Exception {
      new InitializerException();
     }
    }


    如果实例初始化不能正常完成会导致编译时错误。如果具名类的实例初始化可以抛出一个被检查异常,会引起编译时错误,除非异常或者其父类被显示声明在每个构造器上并且类至少有一个显示声明的构造器。匿名类中的实例初始化可以抛出任何异常。


    我们需要一个if(true)[代码片,因为JLS上说明:“一个break、continue、return或者throw语句无法正常完成”,所以我们使用if来避免无法通过编译。
    展开全文
  • java静态初始化块、实例初始化

    千次阅读 2017-12-02 14:19:41
    public class Demo1 { public Demo1() { System.out.println("父类构造器"); } static{ System.out.println("父类... System.out.println("父类实例初始化块"); } public void method() { System.out.prin
    public class Demo1 {
    	public Demo1() {
    		System.out.println("父类构造器");
    	}
    	static{
    		System.out.println("父类静态初始化块");
    	}
    	{
    		System.out.println("父类实例初始化块");
    	}
    	public void method() {
    		System.out.println("父类方法");
    	}
    }


    public class Demo2 extends Demo1{
    	public Demo2() {
    		System.out.println("子类构造器");
    	}
    	static {
    		System.out.println("子类静态初始化块");
    	}
    	{
    		System.out.println("子类实例初始化块");
    	}
    	public static void main(String[] args) {
    		new Demo2().method();
    	}
    }
    输出结果:

    父类静态初始化块
    子类静态初始化块
    父类实例初始化块
    父类构造器
    子类实例初始化块
    子类构造器
    父类方法


    由此可知:

    1、当实例化子类的时候,先加载父类,静态初始化块在类加载的时候就被加载,因此先输出:父类静态初始化块。

    2、加载完父类时加载子类,接着输出:子类静态初始化块。

    3、继续加载父类,输出:父类实例化初始化块。

    4、加载父类的构造器,输出:父类构造器。

    5、加载子类,输出:子类实例化快。

    6、加载子类构造器,输出:子类构造器。

    7、调用父类的方法,输出:父类方法。

    展开全文
  • 主要介绍了Java实例初始化方法及顺序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 首先有三个概念需要了解: ...实例初始化:是指执行实例初始化块里面的内容。 三.构造方法:一个名称跟类的名称一样的方法,特殊在于不带返回值。 我们先来看一段程序结果: package com; class Book
     
    

    首先有三个概念需要了解:

    一.静态初始化:是指执行静态初始化块里面的内容。
    二.实例初始化:是指执行实例初始化块里面的内容。
    三.构造方法:一个名称跟类的名称一样的方法,特殊在于不带返回值。
    我们先来看一段程序结果:

    package com;
    
    class Book{     
        public static int booksum=0;//静态变量     
         
        static{//这是静态初始化块
            print();     
            System.out.println("this is static block");     
        }     
         
        {//实例初始化块     
            System.out.println("初始化块:"+booksum);     
        }     
         
        public Book(){//构造方法     
            System.out.println("this is Book's constructor~");     
            booksum+=1;     
        }     
         
        public static void print(){//静态方法     
            System.out.println("this is static method~");     
        } 
        
        public static void main(String []args){
        	//Book book=new Book();
        }
    }

    执行结果:
    this is static method~
    this is static block
    如果把 
      public static void main(String []args){
        	//Book book=new Book();
        }
    的注释去掉的话,运行结果为:
    this is static method~
    this is static block
    初始化块:0
    this is Book's constructor~
    总结:

    仅从代码执行的角度来探讨Java加载类、创建对象的过程,并没有深入到JVM的机制中去。

    1.一个对象第一次被创建时,先要加载该对象所属的类,即对应的.class文件,当然如果类已经加载,再次创建该类的对象时,就不再需要重新加载类了。而一个类加载的时候,有三个部分需要加载,一个是静态变量,再然后是静态方法,然后是静态初始化块。 (见到第一次执行结果就知道了,由于没有创建实例所以初始化块不执行)

    2.然后开始创建该类的实例了,当然如果静态方法跟静态初始化对象中有对象的创建时,就继续加载该对象的类,当然已经加载了该对象的类的话就不需要再次加 载了。那么对象实例的创建过程是什么呢?首先是成员变量的引入,然后是实例初始化块,之后才是构造方法,构造方法执行完成之后才算把这个对象给创建出来了。

    在这个过程中,真正可以编写执行代码的地方有三个,静态初始化、实例初始化以及构造方法。从以上的分析中我们可以看到,这三个代码块的执行顺序是先类的静态初始化,再实例初始化,最后执行构造方法。也就是说,静态初始化是属于类加载的过程,所以它只执行一次,而实例初始化是每个对象创建时都会执行一次,而构造方法跟实例初始化其实也差不多,不过它在实例初始化之后执行,而且构造方法可以重载多个,执行哪个构造方法是根据你的选择来的。
    可以把main () 函数加一条语句看看:

       public static void main(String []args){
        	Book book=new Book();
        	Book book1=new Book();
        }
    此时执行结果为:

    this is static method~
    this is static block
    初始化块:0
    this is Book's constructor~
    初始化块:1
    this is Book's constructor~
    这说明实例初始化是每个对象创建时都会执行的。



    展开全文
  • 主要介绍了Java初始化块详解及实例代码的相关资料,在Java中,有两种初始化块:静态初始化块和非静态初始化块,需要的朋友可以参考下
  • 在本篇文章里我们针对Java中的实例初始化块(IIB)做想详细分析,有需要的朋友们可以跟着学习参考下。
  • 主要介绍了Java初始化实例化中的2个“雷区”,大家要注意,感兴趣的小伙伴们可以参考一下
  • Java实例初始化是什么?

    千次阅读 2014-04-03 12:52:24
    在这篇文章中,首先用一个例子来说明什么是实例变量的初始化,实例初始化和静态初始化。然后再解释实例初始化是怎样运行的。 1.执行顺序 看看下面的类,你知道哪一个最先被执行? public class Foo { //...
    在这篇文章中,首先用一个例子来说明什么是实例变量的初始化,实例初始化和静态初始化。然后再解释实例初始化是怎样运行的。
    1.执行顺序

    看看下面的类,你知道哪一个最先被执行?

    public class Foo {
     
    	//instance variable initializer
    	String s = "abc";
     
    	//constructor
    	public Foo() {
    		System.out.println("constructor called");
    	}
     
    	//static initializer
    	static {
    		System.out.println("static initializer called");
    	}
     
    	//instance initializer
    	{
    		System.out.println("instance initializer called");
    	}
     
    	public static void main(String[] args) {
    		new Foo();
    		new Foo();
    	}
    }
    输出:
    
    static initializer called
    instance initializer called
    constructor called
    instance initializer called
    constructor called
    2.Java实例初始化是怎样运行的?
    上面的实例初始化包含一个print语句。要了解它是如何运行的,我们可以把它作为一个变量赋值语句(例如b = 0),那么这将不难理解。
    而不是

    int b = 0
    ,你可以写成
    int b;
    b = 0;

    3.实例初始化什么时候有用?
    使用实例初始化是罕见的,但它仍然可以成为有用的替代实例变量初始化的一个选择,如果:
    (1)初始化代码必须处理异常;
    (2)执行无法用实例变量初始化来的计算。
    当然,这样的代码可以写在构造函数里。但是,如果一个类有多个构造函数,你就必须在每个构造函数里重复这段代码。
    用实例初始化,你可以只编写一次代码,无论什么构造函数被用来创建对象,都将会被执行。(我想这只是一个概念,它没有经常被使用。)
    还有一种实例初始化很有用的情况是是匿名内部类,不能声明任何构造函数。(这会是放置日志功能的一个好地方呢?)

    相关文章:Object initialization in Java

    原文:

    What is Instance Initializer in Java?


    展开全文
  • Java实例变量初始化

    千次阅读 2018-04-11 10:04:08
    即调用对象的实例初始化方法,在java的class文件中称之为()方法,类似于类初始化的()方法。 一个()方法可能包含三种代码: 调用另一个()方法 实现对任何实例变量的初始化 构造方法体的代码 实际上,一般有下面的情况...
  • 这三个我们也常称作:...1.在本类的main函数中实例化本类对象时: /** * @Author: QianQian * @CreateDate: 2019/12/4 11:04 * 构造函数,构造代码块,静态代码块 */ public class Test { static { System.o...
  • public class People { public static int num=0;//静态变量 String name; static//静态初始化块 { System.out.println(num+":静态初始化块");... System.out.println(num+":实例初始化块");
  • 主要介绍了Java初始化List方法代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 首先看看Java初始化触发的条件: (1)在使用new实例化对象,访问静态数据和方法时,也就是遇到指令:new,getstatic/putstatic和invokestatic时; (2)使用反射对类进行调用时; (3)当初始化一个类时,父类...
  • 主要介绍了简单了解java类的初始化以及类的实例化,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 过一段时间可能就得去找实习,今天在宿舍翻开以前常放在枕头边的大砖头《Java编程思想》打算重温下之前学的知识点,看到有关java初始化的一些知识,综合之前看过的网页和书籍,记下自己对java实例变量初始化的理解,...
  • Java类的实例化的初始化过程

    千次阅读 2015-12-07 18:03:56
    Java类的实例化的初始化过程/* ... * (静态变量->静态初始化块)->main->(实例变量->实例初始化块)->构造器 */public class NewInstanceTest1 { public static void main(String[] args) { System.out.pri
  • Java成员初始化

    千次阅读 2018-01-18 19:29:38
    Java的成员初始化方式包括:默认初始化(自动初始化)、指定初始化、构造器初始化、静态块初始化(静态子句)、实例初始化(非静态实例初始化) 1.默认初始化:即只进行成员变量的定义,不进行主动的初始化操作,由...
  • 主要介绍了java对象初始化代码详解,涉及实例变量的初始化,类变量的初始化等相关介绍几代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 深入理解Java对象的创建过程:类的初始化实例

    万次阅读 多人点赞 2017-05-18 14:17:45
    Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。...本文试图对JVM执行类初始化实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象的创建过程。
  • @java类的加载顺序 Java类的加载顺序 父类静态代变量、 父类静态代码块、 子类静态变量、 子类静态代码块、 父类非静态变量(父类实例成员变量)、 父类构造函数、 子类非静态变量(子类实例成员变量)、 子类构造...
  • java 初始化实例化的区别

    千次阅读 2018-10-19 10:20:47
     A a(指定一个类型为A的引用A)=new A()(实例化,初始化就是执行A的构造函数,见上,如无则调用默认的); } 那么A a;是实例化,a=new A();是初始化创建一个对象。对吗?  初始化是赋值,实例化是  只有 A a;...
  • Java初始化

    千次阅读 2017-10-31 16:04:20
    Java初始化块 1.类初始化块 // 类初始化块只执行一次 public class A { static { System.out.println("Hello World"); } public static void main(String[] args) { A a = new A(); A a...
  • 主要通过实例解析Java中的构造器初始化,代码很简单,叙述很明确,需要的朋友可以了解下。
  • java的map实例化时初始化赋值

    千次阅读 2019-08-10 15:08:39
    java的map实例化时初始化赋值 解决方法: HashMap<String, String> ext = new HashMap<String, String>(){ { 初始化赋值:http://www.yayihouse.com/yayishuwu/chapter/2084 } }; ...
  • 主要介绍了Java类的加载连接和初始化,结合具体实例形式分析了java类的加载、连接、初始化相关原理与实现技巧,需要的朋友可以参考下
  • 该题目源自微信公众号(程序员的那些事)的推送:携程 Java 工程师的一道面向对象面试题题目是这样的:求下面程序的输出:public class Base { private String baseName = "base"; public Base() { callName(); ...
  • 主要介绍了Java类继承关系中的初始化顺序,结合实例形式详细对比分析了Java非继承关系中的初始化与继承关系中的初始化相关原理与操作技巧,需要的朋友可以参考下
  • 类的初始化:是完成程序执行前的准备工作。在这个阶段,静态的(变量,方法,代码块)会被执行。同时在会开辟一块存储空间用来存放静态的数据。初始化只在类加载的时候执行一次。类的实例化:是指创建一个对象的过程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 611,295
精华内容 244,518
关键字:

java实例初始化

java 订阅