Java对象初始化

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量68 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/xiaoxiaoyihan/p/4934839.html
版权

自动初始化(默认值)

一个类的所有基本数据成员都会得到初始化，运行下面的例子可以查看这些默认值:

class Default{
    boolean t;
    char c;
    byte b;
    short s;
    int i;
    long l;
    float f;
    double d;
    public void show() {
        System.out.println("基本类型   初始化值\n"+
                        "boolean<----->" + t +"\n" +
                        "char<----->" + c +"\n" +
                        "byte<----->" + b + "\n" +
                        "short<----->" + s + "\n" +
                        "int<----->" + i + "\n" +
                        "long<----->" + l + "\n" +
                        "float<----->" + f + "\n" +
                        "double<----->" + d + "\n"
        );

    }
}
public class InitValue {
    public static void main(String[] args) {
        Default d = new Default();
        d.show();
    }
}

【运行结果】:

基本类型   初始化值
boolean<----->false
char<----->
byte<----->0
short<----->0
int<----->0
long<----->0
float<----->0.0
double<----->0.0

其中，char类型的默认值为空(null)。

对于非基本数据类型而言，对象的句柄也会被初始化：

class Person {
    private String name;
    // setter
}
class Default {
    Person p;
    public void show() {
        System.out.println("Person<----->" + p);
    }
}
public class InitValue {
    public static void main(String[] args) {
        Default d = new Default();
        d.show();
    }
}

【运行结果】:

Person<----->null

可见，句柄初始化值为null。这就是说，如果没有为p指定初始化值就调用类似于p.setName的方法，就会出现异常。

规定初始化

如果需要自己为变量赋一个初始值，可以在定义变量的同时赋值。

class Default{
    boolean t = true;
    char c = 'A';
    byte b = 47;
    short s = 0xff;
    int i = 24;
    long l = 999;
    float f = 1.2f;
    double d = 1.732;
    public void show() {
        System.out.println(
                        "boolean<----->" + t +"\n" +
                        "char<----->" + c +"\n" +
                        "byte<----->" + b + "\n" +
                        "short<----->" + s + "\n" +
                        "int<----->" + i + "\n" +
                        "long<----->" + l + "\n" +
                        "float<----->" + f + "\n" +
                        "double<----->" + d + "\n"
        );

    }
}
public class InitValue {
    public static void main(String[] args) {
        Default d = new Default();
        d.show();
    }
}

甚至可以通过一个方法来进行初始化；

class Person {
    int i = set();
    //...
}

这些方法也可以使用自变量:

class Person {
    int i;
    int j = set(i);
    //...
}

构建器初始化

构建器进行初始化的优点是可以在运行期决定初始化值。例如:

class Person {
    int age;
    Person() {
        age = 89;
    }
}

age首先会初始化为0，然后变成89。对于所有基本类型以及对象的句柄，这种情况都是成立的。

初始化顺序

在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那么变量仍然会在调用任何方法(包括构造函数)之前得到初始化。例如：

class Pet {
    Pet(int age) {
        System.out.println("Pet(" + age + ")");
    }
}

class Person {
    Pet t1 = new Pet(1);

    Person() {
        System.out.println("---Person()---");
        t3 = new Pet(33);
    }

    Pet t2 = new Pet(2);
    void show() {
        System.out.println("show----running");
    }
    Pet t3 = new Pet(3);
}


public class OrderOfInitialization {
    public static void main(String[] args) {
        Person p = new Person();
        p.show();
    }
}

【运行结果】:

Pet(1)
Pet(2)
Pet(3)
---Person()---
Pet(33)
show----running

上例中，虽然t1、t2、t3的定义遍布于类中，但是初始化的先后顺序是由t1、t2、t3的定义顺序决定的(自己动手调换t1、t2、t3看看结果)，且初始化优先于构建器执行，当调用Person的构建器时，t3重新初始化。

静态数据的初始化

如果数据是静态的(static)，同样的过程也会执行。若属于基本类型，而且未对其进行初始化，就会自动获得自己的标准基本类型初始值；若它是指向一个对象的句柄，除非创建一个对象同它连接起来，否则得到一个空值(null)。如果在定义时初始化，采取的方式与非静态值是不同的，这是因为static只有一个存储区域。例如：

class Bowl {
    Bowl(int marker) {
        System.out.println("Bowl(" + marker + ")");
    }
    void f(int marker) {
        System.out.println("f(" + marker + ")");
    }
}

class Table {
    static Bowl b1 = new Bowl(1);
    Table() {
        System.out.println("Table()");
        b2.f(1);
    }
    void f2(int marker) {
        System.out.println("f2(" + marker + ")");
    }
    static Bowl b2 = new Bowl(2);
}

class Cupboard {
    Bowl b3 = new Bowl(3);
    static Bowl b4 = new Bowl(4);
    Cupboard() {
        System.out.println("Cupboard()");
        b4.f(2);
    }
    void f3 (int marker) {
        System.out.println("f3(" + marker + ")");
    }
    static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
    public static void main(String[] args) {
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        t2.f2(1);
        t3.f3(1);
    }
    static Table t2 = new Table();
    static Cupboard t3 = new Cupboard();
}

【运行结果】:

Bowl(1)
Bowl(2)
Table()
f(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)

静态代码块

Java允许将其他static初始化工作划分到类内一个特殊的代码块中，这种代码块的形式为static关键字，后面跟着一个方法主体，称为静态代码块。静态代码块只有在第一次生成那个类的对象或首次访问属于那个类的static成员时执行。例如：

class Person {
    Person(int age) {
        System.out.println("Person(" + age + ")");
    }
    void f(int age) {
        System.out.println("f(" + age + ")");
    }
}

class Persons {
    static Person p1;
    static Person p2;
    static {
        p1 = new Person(1);
        p2 = new Person(2);
    }
    Persons() {
        System.out.println("Persons()");
    }
}

public class ExplicitStatic {
    public static void main(String[] args) {
        System.out.println("Inside main()");
        Persons.p1.f(18);//1
    }
    static Persons x = new Persons();//2
    static Persons y = new Persons();//2
}

在标记为1的行内访问static对象p1的时候，或在行1被注释而行2未被注释是，用于Persons的static初始化模块就会运行。若1和2都被注释掉，则用于Persons的静态代码块不会执行。

静态属性和静态代码块执行的先后顺序

class Person {
    Person(int age) {
        System.out.println("Person("+age+")");
    }
}
class Persons {
    static Person p = new Person(2); // 1
    static {
        p = new Person(3);
    }
    static Person p = new Person(2); // 2

}
public class CompStaticInit {
    public static void main(String[] args) {

    }
    static Persons x = new Persons();
}

根据注释1保留2，注释2保留1的结果分析可知，静态属性和静态代码块的执行顺序取决于编码的顺序。谁在前面就先执行谁。

非静态属性的初始化

class Animal {
    Animal(int age) {
        System.out.println("Animal(" + age + ")");
    }
    void f(int age) {
        System.out.println("f(" + age + ")");
    }
}
public class NotStaticInit {
    Animal a1;
    Animal a2;
    {
        a1 = new Animal(1);
        a2 = new Animal(2);
        System.out.println("a1 & a2 initialized");
    }
    NotStaticInit() {
        System.out.println("NotStaticInit");
    }
    public static void main(String[] args) {
        System.out.println("Inside main()");
        NotStaticInit x = new NotStaticInit();
    }
}

类似于静态代码块，匿名代码块与非静态属性的初始化顺序取决于编码顺序。

继承中的对象初始化过程

class Insect {
    int i = 1;
    int j;

    Insect() {
        prt("i = " + i + ", j = " + j);
        j = 2;
    }

    static int x1 = prt("static Insect.x1 initialized");

    static int prt(String s) {
        System.out.println(s);
        return 3;
    }
}

public class Beetle extends Insect {
    int k = prt("Beeklt.k initialized");

    Beetle() {
        prt("k = " + k);
        prt("j = " + j);
    }

    static int x2 = prt("static Bootle.x2 initialized");
    static int prt(String s) {
        System.out.println(s);
        return 4;
    }

    public static void main(String[] args) {
        prt("Beetle constructor");
        Beetle b = new Beetle();
    }
}

【运行结果】:

static Insect.x1 initialized
static Bootle.x2 initialized
Beetle constructor
i = 1, j = 0
Beeklt.k initialized
k = 4
j = 2

对Beetle运行Java时，发生的第一件事情是装载程序到外面找到那个类。在装载过程中，装载程序发现一个基础类，所以随之将其载入。无论是否生成基础类的对象，这一过程都将执行。如果基础类含有另一个基础类，则另一个基础类随即也会载入，以此类推。接下来就在根基础类中执行static初始化，再在下一个衍生类中执行，以此类推。这是因为衍生类的初始化可能要依赖于对基础类成员的初始化。

当类都装载完毕，就能创建对象。首先，这个对象中的所有基本数据类型都会设置成为他们的默认值，对象句柄设为null。然后执行基础类的构建器。这种情况是自动完成的（衍生类的构造函数中默认调用了super()，也可以通过super指定基类的构建器）。基础类构建器完成后，衍生类实例变量就会按本来的顺序得到初始化，然后执行构建器的剩余的主体部分。

总结对象创建的过程:

  • 静态只在类加载的时候执行且只执行一次；
  • 非静态只有在实例化的时候执行，每次创建对象都执行；
  • 静态在非静态之前执行，基类静态优先于衍生类静态执行；
  • 静态属性和静态代码块的执行属性取决于它们在类中的位置，谁在前先执行谁；
  • 非静态属性和构造块的执行顺序取决于它们在类中的位置，谁在前执行谁。

转载于:https://www.cnblogs.com/xiaoxiaoyihan/p/4934839.html

weixin_30536513
关注
JAVA对象初始化步骤
weixin_44027397的博客
02-03 1270
文章目录前言一、对象初始化步骤二、实例三、特殊案例四、枚举类初始化 前言 在面向对象的编程语言中，了解对象初始化的步骤有利于我们更好地写成代码。 一、对象初始化步骤 父类静态变量、静态代码块初始化 子类静态变量、静态代码块初始化 父类变量、代码块初始化 父类构造方法 子类变量、代码块初始化 子类构造方法 注意: 1:所有的静态变量，静态代码块只会在第一次创建对象时进行初始化 2:变量和代码块的初始化过程是按照在类中定义的顺序执行的，如变量a，代码块b，变量c，则初始化过程为a->b->
java 初始化一个实体对象_Java 对象初始化
weixin_42407617的博客
02-13 1644
编译并运行该程序会有以下输出：Static BlockEmployee Company:china softNon-Static BlockEmployee phone:0755-51595599Employee(String)Empoloyee()下面我们来对结果做分析：1在代码34行实例化对象时，先对给静态变量分配内存空间并初始化，然后执行静态块。因此，在这里会输出：StaticB...
关于java返回值对象BO设置初始值的问题
lettuce_的博客
01-20 1152
最近在项目中创建返回对象BO时,会自动生成初始的默认值,例如: private String idCard = null; private Long province = -1l; private Long city = -1l; private Long district = -1l; private Integer isAdministrator = -1; 原因是在后续使用...
JAVA对象初始化顺序
m0_37253781的博客
07-17 1168
JAVA对象初始化顺序
Java 对象初始化和类初始化的区别、new一个对象的详细过程、类加载、类初始化、实例初始化
qq_42603181的博客
04-14 2606
Java 初始化的深认知（第二篇）Java 类初始化和对象初始化明解Java中new一个对象的详细过程，JVM执行了那些操作new一个对象的详细过程什么时候需要初始化一个类获得类的资源初始化对象 Dog dog = new Dog()创建一个对象时jvm在干什么：Java 对象的使用：对对象的访问定位类加载过程（第一次使用该类）双亲委派机制更多知识 首先，大家看一下这段代码的执行顺序，你是否理解的如注释所写： //父类Animal class Animal { /*8、执行初始化*/ pri
Java程序初始化顺序
weixin_53379612的博客
11-24 1375
Java初始化顺序
JAVA之对象初始化过程详解及面试题
hzqing的博客
07-20 3795
一个朋友在JAVA面试题中遇到了对象的初始化问题，发现自己只能靠敲代码，查看运行结果才能做出来。真是丢人呀。所以今天通过测试，在巩固一下基础，顺便写写笔记。 对象的初始化流程如下： 初始化父类的静态成员初始化父类的静态代码块初始化子类的静态成员初始化子类的静态代码块初始化父类的非静态成员初始化父类的非静态代码块初始化父类的构造方法初始化子类的非静态成员初始化子类的非静态代码块初始化
java如何对对象进行初始化_Java怎么为对象进行初始化
weixin_42520580的博客
02-25 1633
Java怎么为对象进行初始化发布时间：2020-06-25 14:37:49来源：亿速云阅读：86作者：Leah本篇文章为大家展示了Java怎么为对象进行初始化，代码简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。一：初始化类首先创建某个对象时：Dog dog = new Dog();首次访问某个类的静态方法或者静态字段时:Dog.staticFields;Jav...
java基础对象的初始化和实例化
caoyanzhi的博客
09-12 1505
一：对象初始化 1：main方法所在的类需要加载和初始化 比如上面的mian方法里面是空运行也会有值打印 2：子类初始化的适合父类会先初始化 从上面结果也能看出 3：一个类的初始化就是执行<clinit>()指令查看.class <clinit>()执行其实就是加载static变量、代码块和方法 按照代码顺序执行 且只执行一次 这也就是单例饿汉式安全的原因 二：实例初始化 实例初始化就是执行<init>()指令 实例化几次就会执行几...
图解Java对象初始化过程以及方法调用
12-22
1：虚拟机加载OOPDemo类（省略详细加载过程(装载、链接、初始化)），提取类型信息（具体保存哪些类型信息查看博文：Java虚拟机体系结构），存储到方法区中，对应图中的绿色矩形区域。 　2：通过保存在方法区的字节...
深入介绍Java对象初始化
09-01
Java对象初始化是一个重要的概念，它涉及到对象生命周期的早期阶段，确保对象在被使用前具备了正确的状态。在Java中，对象初始化的过程分为几个步骤，包括默认初始化、显式初始化和构造器初始化。 **默认初始化**是...
java对象初始化顺序验证示例
09-04
Java对象初始化顺序是一个重要的编程概念，它涉及到类的继承、构造函数、成员变量初始化和非静态初始化块。在这个示例中，我们通过一个简单的代码片段来验证这些规则。首先，让我们详细解析一下给出的代码： ```...
java对象初始化代码详解
08-28
Java 对象初始化代码详解 Java 对象初始化代码详解主要介绍了 Java 对象初始化代码详解，涉及实例变量的初始化，类变量的初始化等相关介绍几代码示例，具有一定参考价值，需要的朋友可以了解下。 一、Java 对象...
“礼让”原则学习Java对象初始化顺序.pdf
12-27
"Java 对象初始化顺序学习指南" 在学习 Java 编程语言时，对象初始化顺序是一个非常重要的知识点，但是许多学生却感到困惑和困难。事实上，Java 对象初始化顺序并不难理解，只需要掌握“礼让”原则和 JVM 的执行...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 144
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 821
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 886
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
java 对象初始化
11-10
Java对象初始化是指在创建对象时，为对象的成员变量赋予初始值的过程。Java中对象的初始化可以通过以下两种方式实现： 1.使用构造方法初始化对象：在Java中，每个类都可以定义一个或多个构造方法，用于初始化对象。构造方法的名称必须与类名相同，且没有返回值。在创建对象时，会自动调用与之对应的构造方法来初始化对象。例如： ```java public class Person { private String name; private int age; // 构造方法 public Person(String name, int age) { this.name = name; this.age = age; } // getter和setter方法 // ... } // 创建对象并初始化 Person p = new Person("Tom", 18); ``` 2.使用对象初始化块初始化对象：对象初始化块是在类中定义的一段代码块，用于在创建对象时初始化对象。对象初始化块的代码会在构造方法之前执行。例如： ```java public class Person { private String name; private int age; // 对象初始化块 { this.name = "Tom"; this.age = 18; } // 构造方法 public Person(String name, int age) { this.name = name; this.age = age; } // getter和setter方法 // ... } // 创建对象并初始化 Person p = new Person("Jerry", 20); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值