java程序是如何初始化的

显示全部楼层 · 2021-1-11 04:13:09

核心Java在Java中初始化过程整个序列没有说话,只是说当顺序构造器,作者似乎认为路径许多,混乱。我认为这是确保它是比较好的。所以现在我的学习经验写详细的过程:
　　过程如下:
　　1在类声明在视图中没有静态元素(静态的,元素,我将做什么,例如)
　　代码:
　　static int x = 1,
　　{
　　//block
　　float sss = 333.3; String str = "hello";
　　}
　　或者比如
　　static {
　　//(static block),
　　int x = 2;
　　double y = 33.3;
　　}
　　如果有static element则首先执行其中语句,但注意static element只执行一次,在第二次创建类的对象的时候，就不会去执行static element的语句.
　　2.查看此类是否为启动运行类,若为启动运行类,则执行main()方法里的语句对应语句
　　3.若不是启动运行类,则按代码的排版先后顺序继续执行非static element的变量赋值以及代码块.
　　4.最后执行构造方法,如果在被调用的构造方法里面有this关键字(注意,如果你考虑要调用其他构造方法,则应该把this写在最前面,不然会产生错误),则先调用相应构造方法主体,调用完之后再执行自己的剩下语句.
　　疯狂java视频 android视频：http://www.fkjava.org/video.html
　　复制内容到剪贴板
　　代码:
　　/** *//**
　　*
　　* @author livahu
　　* Created on 2006年9月6日, 下午17:00
　　*/
　　class FirstClass ...{
　　FirstClass(int i) ...{
　　System.out.println("FirstClass(" + i + ")");
　　}
　　void useMethod(int k) ...{
　　System.out.println("useMethod(" + k + ")");
　　}
　　}
　　class SecondClass ...{
　　static FirstClass fc1 = new FirstClass(1);
　　FirstClass fc3 = new FirstClass(3);
　　static ...{
　　FirstClass fc2 = new FirstClass(2);
　　}
　　...{
　　System.out.println("SecondClass's block, this block is not static block.");
　　}
　　SecondClass() ...{
　　System.out.println("SecondClass()");
　　}
　　FirstClass fc4 = new FirstClass(4);
　　}
　　public class InitiationDemo ...{
　　SecondClass sc1 = new SecondClass();
　　...{
　　System.out.println("Hello Java World!");
　　}
　　public static void main(String[] args) ...{
　　System.out.println("Inside main()");
　　SecondClass.fc1.useMethod(100);
　　InitiationDemo idObj = new InitiationDemo();
　　}
　　static SecondClass sc2 = new SecondClass();
　　}
　　运行结果:
　　引用:
　　FirstClass(1)
　　FirstClass(2)
　　FirstClass(3)
　　SecondClass's block, this block is not static block.
　　FirstClass(4)
　　SecondClass()
　　Inside main()
　　useMethod(100)
　　FirstClass(3)
　　SecondClass's block, this block is not static block.
　　FirstClass(4)
　　SecondClass()
　　Hello Java World!

千问 · 2021-1-11 04:13:09

在博创华宇写的初始化，当然也就指的是变量。变量可以是内置的变量或者我们创建的类的对象。
　　有人说，本来初始化本来就是一件很简单的事情，的确，但是java作为一门面向对象语言，由于具有继承、多态，静态、动态绑定等多种特性，所以其初始化的情景可谓是五花八门。现在就一步一步的分析其初始化过程。下面就是几个小原则。优先级依次递减。
　　1、静态块优先
　　程序首先会执行静态块的内容，这也就有了不写main方法就跑hello world的小故事，相信说到这里，大家就有了思路。我们都知道静态类型是和类绑定的而不是和具体实例对象绑定。也就是说，引用一个静态变量的方式往往是MyClass.xxx.这个特点决定了其在编译的阶段就已经分配好了固定的空间。
　　2、父类优先
　　由于继承的特性，当导出类（子类）的对象被创建的时候，程序将向上追溯到最初的父类，执行其初始化的操作。然后一次向下调用子类的构造函数。按照这个思路，那么每一个实例第一个要初始化的必定是Object类了。
　　3、成员变量优先
　　一定要注意，成员变量按照其声明的顺序会被初始化，并且立刻被初始化为二进制的0,这个动作发生在所有事件之前，也就是编译器会立刻将分配给对象的空间初始化。一会的小例子将证明这一点。
　　最后就是调用类的构造方法了。
　　下面有一个不错的例子，为了演示成员变量最早被初始化为0了，我们将在父类的构造函数中调用子类的方法（利用了多态）。
　　package fruit;
　　import vege.Inner;

　　/**
　　* @author Octobershiner
　　*/
　　public class Fruit {
　　//static block
　　static {
　　System.out.println("In Fruit static");
　　}
　　private Inner i = new Inner(); //a private member
　　public Fruit(){
　　System.out.println("Before Fruit Constructor");
　　show();//由于多态的特性，此处子类Apple覆写的方法会被调用
　　System.out.println("After Fruit Constructor");
　　}
　　public void show(){
　　System.out.println("show:Fruit.");
　　}
　　public static void main(String[] args) {
　　// TODO code application logic here
　　new Apple(3);
　　}
　　}
　　现在父类中须要初始化的有
　　静态块
　　一个Inner类私有成员
　　构造函数
　　现在我们看子类的代码
　　package fruit;
　　public class Apple extends Fruit{
　　//静态块
　　static{
　　System.out.println("In Apple static");
　　}
　　private int weight = 1; //初始化为1 注意区别这里和初始化为0
　　public Apple(int para_weight){
　　System.out.println("Before Apple Constructer: weight = "+weight);
　　weight = para_weight;
　　System.out.println("Apple Constructor: weight="+weight);
　　}
　　@Override
　　public void show(){
　　System.out.println("show apple: weight =" + weight);
　　}
　　}
　　子类须要初始化的有
　　静态块
　　私有成员weight
　　构造函数
　　那么当我们运行的时候会有怎样的结果呢？猜想。。。。。
　　下面就是执行的结果：

　　Look! 首先执行父类的静态块，之后是子类的静态块，这两个应该没有什么问题。接下来就是对父类成员变量的初始化了。首先是父类的私有成员Inner对象，打印了一条“ Inner Constructor”。
　　接下来就是父类的构造函数，可见由于java的多态性，Fruit的构造方法调用了其子类Apple的show方法，并且我们可以清晰的看到，此刻Apple类中weight变量的值是0！说明，类的成员变量无论是否赋值，在各种初始化之前早已被设置为二进制0了。
　　于是乎我想起了很多关于java的书都在说。。“如果类的私有变量没有赋值，就会被设置为0”。。这句话显然把时间弄混了。。。应该是编译器早已初始化了私有变量，均为0，之后才会执行到赋值语句。
　　父类的构造函数结束之后，再次回到子类，初始化私有变量（也就是我们常说的赋值语句，因为初始为0的工作早做完了）。所以我们才会看到“Before Apple Constructor weight = 1”,执行完构造函数后，我们就看到了weight终于变成了我们创建对象是传进的3了，呼，初始化结束。
　　总结
　　那么总结一下就是这样的：
　　编译器初始化所有的已分配的空间为二进制0（这是我们的私有变量都会为0，刚才的例子）
　　执行父类静态代码执行子类静态代码
　　初始化父类成员变量（我们常说的赋值语句）
　　初始化父类构造函数
　　初始化子类成员变量
　　初始化子类构造函数