精华内容
下载资源
问答
  • 先看结论:一个类的实例化过程:1,首先会执行类中static代码块(不管代码块是否在类的开头还是末尾处),如果这个类有父类,同样会优先查找父类中的static代码块,然后是当前类的static。(staitc类加载到内存中时就...

    重温java基础,以免自己以后犯原则性错误,这是最基本,最基础的东西。

    1ee452d8d2a7a0b61505f9458b07463d.bmp

    先看结论:

    一个类的实例化过程:

    1,首先会执行类中static代码块(不管代码块是否在类的开头还是末尾处),如果这个类有父类,同样会优先查找父类中的static代码块,然后是当前类的static。(staitc类加载到内存中时就已经分配空间,赋值了)

    2,然后会从父类的第一行开始执行,直至代码末尾处,中间不管是有赋值还是method调用,都会按顺序一一执行(method),普通代码块{ }...

    也就是说在new对象的时候,先给私有数据成员分配存储空间赋值(从上往下执行),接着才执行构造方法里的代码。

    3,其次才是父类的构造函数,执行带参数或不带参数的构造函数,依赖于实例化的类的构造函数有没有super父类的带参或不带参的构造函数,上边试验二三已经证明。

    4,然后会从子类(当前类)的第一行开始执行,直至代码末尾处,中间不管是有赋值还是method调用,都会按顺序一一执行(method),普通代码块{ }...

    5,其次会是子类(当前类)的构造函数,按顺序执行。

    6,最后是类方法的调用执行,如果子类覆盖了父类的method,执行时会先执行子类覆盖的method,method内如果有super.method(),才会调用父类的同名method,否则不会。

    代码部分:

    A.java

    public class A {

    int a1 = 8;

    int a2 = getA2();

    {

    int a3 = 9;

    System.out.println("top of A() a1=" + a1 + " a2=" + a2 + " a3=" + a3);

    }

    public A() {

    this(66);

    System.out.print("A 构造函数\n");

    }

    {

    System.out.println("below A()..has start");

    }

    public A(int num) {

    System.out.print("A 带参数构造函数: " + num + "\n");

    }

    static {

    System.out.println("I`m a static {} from class A..");

    }

    int getA2() {

    System.out.println("getA2..");

    return 7;

    }

    public void methodA() {

    System.out.println("methodA");

    }

    public static void method() {

    System.out.println("hahaha");

    }

    public static void method1() {

    System.out.println("hahaha");

    }

    }

    B类

    public class B extends A {

    int b1 = 0;

    int b2 = getB2();

    {

    int b3 = 5;

    System.out.println("top of B() b1=" + b1 + " b2=" + b2 + " b3=" + b3);

    }

    public B() {

    this(33);

    // super(44);//添加super语句,会导致实例化时直接执行父类带参数的构造函数

    System.out.print("B 构造函数\n");

    }

    public B(int num) {

    // 添加super语句,会导致实例化时直接执行父类带参数的构造函数

    // 前提是带参数的构造函数B会被运行(new实例化或this)

    // super(77);

    System.out.print("B 带参数构造函数:" + num + "\n");

    }

    {

    System.out.println("below B()..has start");

    }

    static {

    System.out.println("I`m a static {} from class B..");

    }

    int getB2() {

    System.out.println("getB2..");

    return 33;

    }

    @Override

    public void methodA() {

    System.out.println("methoaA int class B");

    super.methodA();

    }

    }

    测试类一:

    public class mymain {

    /**

    * @param args

    */

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    System.out.println("main app run..");

    B b = new B();

    //B b = new B(22);

    b.methodA();

    }

    }

    实验一

    思考一下打印输出的顺序?

    打印输出结果:

    main app run..

    I`m a static {} from class A..

    I`m a static {} from class B..

    getA2..

    top of A() a1=8 a2=7  a3=9

    below A()..has start

    A 带参数构造函数: 66

    A 构造函数

    getB2..

    top of B() b1=0 b2=33 b3=5

    below B()..has start

    B 带参数构造函数:33

    B 构造函数

    methoaA int class B

    methodA

    分析:B类无参的构造函数中的this语句并没有影响到父类A类的构造函数执行顺序

    **********************************分割线***********************************

    实验二

    public class mymain {

    public static void main(String[] args) {

    A.method();

    A.method1();

    }

    }

    结果:

    I`m a static {} from class A..

    method   hahahah

    method1   hahahah

    static成员变量 以及static代码块在代码加载后就执行了。 而且加载只加载了一次。

    展开全文
  • 1,首先会执行类中static代码块(不管代码块是否在类的开头还是末尾处),如果这个类有父类,同样会优先查找父类中的static代码块,然后是当前类的static。(staitc类加载到内存中时就已经分配空间,赋值了) 2,...

    重温java基础,以免自己以后犯原则性错误,这是最基本,最基础的东西。


    先看结论:



    一个类的实例化过程:

    1,首先会执行类中static代码块(不管代码块是否在类的开头还是末尾处),如果这个类有父类,同样会优先查找父类中的static代码块,然后是当前类的static。(staitc类加载到内存中时就已经分配空间,赋值了


    2,然后会从父类的第一行开始执行,直至代码末尾处,中间不管是有赋值还是method调用,都会按顺序一一执行(method),普通代码块{ }...

    也就是说在new对象的时候,先给私有数据成员分配存储空间赋值(从上往下执行),接着才执行构造方法里的代码。


    3,其次才是父类的构造函数,执行带参数或不带参数的构造函数,依赖于实例化的类的构造函数有没有super父类的带参或不带参的构造函数,上边试验二三已经证明。


    4,然后会从子类(当前类)的第一行开始执行,直至代码末尾处,中间不管是有赋值还是method调用,都会按顺序一一执行(method),普通代码块{ }...


    5,其次会是子类(当前类)的构造函数,按顺序执行。


    6,最后是类方法的调用执行,如果子类覆盖了父类的method,执行时会先执行子类覆盖的method,method内如果有super.method(),才会调用父类的同名method,否则不会。


    代码部分:

    A.java

    public class A {
    
    	int a1 = 8;
    	int a2 = getA2();
    	{
    		int a3 = 9;
    		System.out.println("top of A() a1=" + a1 + " a2=" + a2 + "  a3=" + a3);
    	}
    
    	public A() {
    		this(66);
    		System.out.print("A 构造函数\n");
    	}
    
    	{
    		System.out.println("below A()..has start");
    	}
    
    	public A(int num) {
    		System.out.print("A 带参数构造函数: " + num + "\n");
    	}
    
    	static {
    		System.out.println("I`m a static {} from class A..");
    	}
    
    	int getA2() {
    		System.out.println("getA2..");
    		return 7;
    	}
    
    	public void methodA() {
    		System.out.println("methodA");
    	}
    	
    	public static void method() {
    		System.out.println("hahaha");
    	}
    	
    	public static void method1() {
    		System.out.println("hahaha");
    	}
    	
    }


    B类

    public class B extends A {  
      
        int b1 = 0;  
        int b2 = getB2();  
        {  
            int b3 = 5;  
            System.out.println("top of B() b1=" + b1 + " b2=" + b2 + " b3=" + b3);  
      
        }  
      
        public B() {  
            this(33);  
            // super(44);//添加super语句,会导致实例化时直接执行父类带参数的构造函数  
            System.out.print("B 构造函数\n");  
        }  
      
        public B(int num) {  
            // 添加super语句,会导致实例化时直接执行父类带参数的构造函数  
            // 前提是带参数的构造函数B会被运行(new实例化或this)  
            // super(77);  
      
            System.out.print("B 带参数构造函数:" + num + "\n");  
        }  
      
        {  
            System.out.println("below B()..has start");  
        }  
        static {  
            System.out.println("I`m a static {} from class B..");  
        }  
      
        int getB2() {  
            System.out.println("getB2..");  
            return 33;  
      
        }  
      
        @Override  
        public void methodA() {  
            System.out.println("methoaA int class B");  
            super.methodA();  
      
        }  
      
    }  
    
    
    

    测试类一:

    public class mymain {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println("main app run..");
    		B b = new B();
    //		B b = new B(22);
    		b.methodA();
    	}
    
    }

    实验一

    思考一下打印输出的顺序?

    打印输出结果:

    main app run..

    I`m a static {} from class A..

    I`m a static {} from class B..

    getA2..

    top of A() a1=8 a2=7  a3=9

    below A()..has start

    A 带参数构造函数: 66

    A 构造函数

    getB2..

    top of B() b1=0 b2=33 b3=5

    below B()..has start

    B 带参数构造函数:33

    B 构造函数

    methoaA int class B

    methodA


    分析:B类无参的构造函数中的this语句并没有影响到父类A类的构造函数执行顺序

    **********************************分割线***********************************


    实验二

    public class mymain {
    	public static void main(String[] args) {
    		A.method();
    		A.method1();
    	}
    
    }


    结果:

    I`m a static {} from class A..
    method   hahahah
    method1   hahahah

    static成员变量 以及static代码块在代码加载后就执行了。 而且加载只加载了一次。


    展开全文
  • 重温java基础,以免自己以后犯原则性错误,这是最基本,最基础的东西。 直接上代码: A.java public class A { int a1 = 8; int a2 = getA2(); { int a3 = 9; System.out.println("top of A() a1=" + a1 + ...

    一、java 静态代码块 静态方法区别


          一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的. 静态方法在类加载的时候 就已经加载 可以用类名直接调用
    比如main方法就必须是静态的 这是程序入口
    两者的区别就是:静态代码块是自动执行的;
    静态方法是被调用的时候才执行的.

    静态方法
    (1)在Java里,可以定义一个不需要创建对象的方法,这种方法就是静态方法。要实现这样的效果,只需要在类中定义的方法前加上static关键字。例如:

    public static int maximum(int n1,int n2)

    使用类的静态方法时,注意:
        a 在静态方法里只能直接调用同类中其他的静态成员(包括变量和方法),而不能直接访问类中的非静态成员。这是因为,对于非静态的方法和变量,需要先创建类的实例对象后才可使用,而静态方法在使用前不用创建任何对象。

        b 静态方法不能以任何方式引用this和super关键字,因为静态方法在使用前不用创建任何实例对象,当静态方法调用时,this所引用的对象根本没有产生。

    (2)静态变量是属于整个类的变量而不是属于某个对象的。注意不能把任何方法体内的变量声明为静态,例如:
        fun(){
           static int i=0;//非法。
        }

    (3)一个类可以使用不包含在任何方法体中的静态代码块,当类被载入时,静态代码块被执行,且只被执行一次,静态块常用来执行类属性的初始化。例如:
        static {
        }

    类装载步骤
    在Java中,类装载器把一个类装入Java虚拟机中,要经过三个步骤来完成:装载、链接和初始化,其中链接又可以分成校验、准备和解析三步,除了解析外,其它步骤是严格按照顺序完成的,各个步骤的主要工作如下:

    装载:查找和导入类或接口的二进制数据;
    链接:执行下面的校验、准备和解析步骤,其中解析步骤是可以选择的;
    校验:检查导入类或接口的二进制数据的正确性;
    准备:给类的静态变量分配并初始化存储空间;
    解析:将符号引用转成直接引用;
    初始化:激活类的静态变量的初始化Java代码和静态Java代码块。
    初始化类中属性是静态代码块的常用用途,但只能使用一次。

    二、静态代码块的初始化顺序

    <p>class Parent {
     static String name = "hello";
     {
        System.out.println("parent block");
     }
     static {
        System.out.println("parent static block");
     } 
     public Parent() {
        System.out.println("parent constructor");
     }
    }  </p><p>class Child extends Parent {
     static String childName = "hello";
     {
        System.out.println("child block");
     }
     static {
        System.out.println("child static block");
     } public Child() {
        System.out.println("child constructor");
     }
    }</p><p>public class StaticIniBlockOrderTest { 
      public static void main(String[] args) {
        new Child();// 语句(*)
      }
    }</p>

    问题:当执行完语句(*)时,打印结果是什么顺序?为什么?
    解答:当执行完语句(*)时,打印结果是这样一个顺序 :

    parent static block
    child static block
    parent block
    parent constructor
    child block
    child constructor

    分析:

          当执行new Child()时,它首先去看父类里面有没有静态代码块,如果有,它先去执行父类里面静态代码块里面的内容,当父类的静态代码块里面的内容执行完毕之后,接着去执行子类(自己这个类)里面的静态代码块,当子类的静态代码块执行完毕之后,它接着又去看父类有没有非静态代码块,如果有就执行父类的非静态代码块,父类的非静态代码块执行完毕,接着执行父类的构造方法;父类的构造方法执行完毕之后,它接着去看子类有没有非静态代码块,如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法,这个就是一个对象的初始化顺序。

    总结:
          对象的初始化顺序:首先执行父类静态的内容,父类静态的内容执行完毕后,接着去执行子类的静态的内容,当子类的静态内容执行完毕之后,再去看父类有没有非静态代码块,如果有就执行父类的非静态代码块,父类的非静态代码块执行完毕,接着执行父类的构造方法;父类的构造方法执行完毕之后,它接着去看子类有没有非静态代码块,如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话,静态代码块内容先执行,接着执行父类非静态代码块和构造方法,然后执行子类非静态代码块和构造方法。

    注意:子类的构造方法,不管这个构造方法带不带参数,默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法,那么子类必须用supper关键子来调用父类带参数的构造方法,否则编译不能通过。

     

    本文转自:http://blog.csdn.net/mad1989/article/details/7782817

    展开全文
  • public class qqqq extends Parent{public static void main(String[] ...}}class Parent{static{System.out.println("父类的静态块执行");}{System.out.println("父类的非静态块执行");}public Parent(){System.out...

    public class qqqq extends Parent{

    public static void main(String[] args) {

    new Child();

    }

    }

    class Parent{

    static{

    System.out.println("父类的静态块执行");

    }

    {

    System.out.println("父类的非静态块执行");

    }

    public Parent(){

    System.out.println("父类的构造函数执行");

    }

    }

    class Child extends Parent{

    static{

    System.out.println("子类的静态快执行");

    }

    {

    System.out.println("子类的非静态块执行");

    }

    public Child(){

    System.out.println("子类的构造函数执行");

    }

    }

    输出:

    父类的静态块执行

    子类的静态快执行

    父类的非静态块执行

    父类的构造函数执行

    子类的非静态块执行

    子类的构造函数执行

    java 子类、父类中静态代码块、字段,非静态代码块、字段以及构造函数的初始化顺序和次数

    一个类中的数据初始化顺序是面试官非常喜欢出的面试题之一,本文用一个实例来介绍java中子类.父类中静态代码块.字段,非静态代码块.字段以及构造函数的执行顺序和次数. 一.包结构

    Java子类对于父类中static方法的继承

    今天看到了Java中子类继承父类的一个相关讨论,在网上综合了各家的观点,写下了一篇简短的总结. 问题如下,在父类中含有staic修饰的静态方法,那么子类在继承父类以后可不可以重写父类中的静态方法呢? ...

    No&period;4&period;测试子类继承父类各代码块和构造方法的执行顺序

    Son子类 public class Son extends Parent { static String y ="son的static属性"; public static voi ...

    C&num;基础知识之父子类,实例、静态成员变量,构造函数的执行顺序(经典示例)

    父子类.示例.静态成员变量.构造函数的概念的基础理解完全可以利用下面的示例诠释,非常经典,直接上代码: public class ShowInfo { public ShowInfo(string i ...

    Java拾遗&lpar;一&rpar;&colon;浅析Java子类和父类的实例化顺序 及 陷阱

    本文主要介绍Java里经常使用的子类和父类的变量实例化顺序及陷阱,并结合一个Android实例来探讨此问题.日后编程中应尽量避免此陷阱. 首先看以下一段代码: 定义一个虚类Server.java pa ...

    Java继承--子父类中的构造函数

    子父类中的构造函数的特点: 1.在子类构造对象时,发现,访问子类构造函数时,父类构造函数也运行了.   原因是:在子类的构造函数中第一行有一个默认的隐式语句. super(); 类似于this(); ...

    Java子类访问父类的私有成员变量

    /**子类会继承父类所有的属性和方法. * 但是根据不同的权限标识符,子类不可见父类的私有变量,但可以通过父类的公共方法访问私有变量 * 所以对于重名变量,子类和父类都各有一份. * 对于子类和父类中 ...

    java 中 this 和 super 说明及在构造器中super&lpar;&rpar;和this&lpar;&rpar;相互调用执行顺序

    this this 表示当前对象 使用上细分的话,this有 this. 和this()的使用情况 ,下面我们开始细撸 this . 使用场景一: 在成员方法中,this.变量名 指带当前对象的变量, ...

    Asp&period;Net WebAPI中Filter过滤器的使用以及执行顺序

    转发自:http://www.cnblogs.com/UliiAn/p/5402146.html 在WEB Api中,引入了面向切面编程(AOP)的思想,在某些特定的位置可以插入特定的Filter进行 ...

    随机推荐

    CWMP开源代码研究5——CWMP程序设计思想

    声明:本文涉及的开源程序代码学习和研究,严禁用于商业目的. 如有任何问题,欢迎和我交流.(企鹅号:408797506) 本文介绍自己用过的ACS,其中包括开源版(提供下载包)和商业版(仅提供安装包下载 ...

    如何让你的UWP应用程序无缝调用几何作图

    有时候需要编辑一些几何图形,如三角形,圆锥曲线等,在UWP应用中加入这些几何作图功能是件费时间又很难做好的事.其实Windows 10 应用商店中已有一些专业的几何作图工具了,那么能借来一用吗?答案是 ...

    EL表达式概述

    E L(Expression Language) 目的:为了使JSP写起来更加简单.表达式语言的灵感来自于 ECMAScript 和 XPath 表达式语言,它提供了在 JSP 中简化表达式的方法. ...

    JS——JavaScript Confirm

    function show_confirm(){var r=confirm("Press a button!");if (r==true) { alert("You pr ...

    在网页中使用H1标记的须注意的事项

    H1标签是网站排名非常重要的一个因素,因此我们一定要正确使用它. 本文为你介绍H1标签使用的七大注意事项: 1.每个页面都应该有H1标签,H1标签是每个网页不可缺少的要素. 2.使用H1标签的内容应该 ...

    redis学习心得之一【安装redis初体验】

    在linux下安装redis 说起这个比mysql的安装过程简单多乐,它不需要configure,只需要解压之后make就可以,无需make install ~$ wget http://redis. ...

    &lbrack;Android学习笔记&rsqb;Context简单理解

    一.Context是什么?上下文对象,可以理解为一个程序的运行的环境,从中可以获取当前程序的资源:getResources,getAssets 二.常见的Context有哪些?Application ...

    css 小知识

    关于P,NP,NPC和NP-hard的通俗解释

    这些概念以前老是犯糊涂,今天整清楚.摘要:P: Polynomial SolvableNP: Non-determinstic Polynomial Solvable 0)词语解释:Polynomia ...

    final对于访问效率的影响

    在能够通过编译的前提下,无论局部变量声明时带不带final关键字修饰,对其访问的效率都一样. 并且:重复访问一个局部变量比重复访问一个成员或静态变量快:即便将其final修饰符去掉,效果也一样. 例如 ...

    展开全文
  • 一、继承中的构造方法的执行顺序 创建对象时,会先自动调用父类构造函数,再自动调用子类的构造函数。 解释:super()表示父类构造函数并会调用于参数相对应的父类中的构造函数。子类中,它在调用父类中空参数...
  • 只在其第一个对象创建时调用,即便是创建了同一个类的多个对象,例如main()函数里b1,b2创建了同一个类的两个对象,但是grandmaMotherClass的构造函数只被执行了一次2, 再执行父类构造函数(c++中如果有多个,...
  • 实例化子类时,父类与子类中的静态代码块、实例代码块、静态变量、实例变量、构造函数的执行顺序是怎样的?代码执行的优先级为:firest:静态部分...父类构造函数5.子类实例变量与父类代码块(取决于代码书写顺序...
  •  * 另:父类构造方法中用到的方法如果已被子类重写,那么在构造子类对象时在调用父类构造函数中使用子类重写的方法    */     int  i =  0 ;    switch (i) {    case   0 :    ...
  • 实例化子类时,父类与子类中的静态代码块、实例代码块、静态变量、实例变量、构造函数的执行顺序是怎样的? 代码执行的优先级为: firest:静态部分 ...second:实例化过程 ...4.父类构造函数...
  • Java类的初始化顺序Java 父类构造函数,父类静态成员变量,父类普通成员变量,父类静态代码块,父类代码块,子类构造函数 子类静态成员变量,子类普通成员变量,子类静态代码块,子类代码块执行顺序没有继承情况下1....
  • 被static修饰的变量,块,方法都是会在类被加载的时候就会执行,而且是先与构造函数执行。 public class A { { System.out.println("A 初始化块"); } static{ System.out.println("A 静态块"); ...
  • 来吧,直接上代码~ /** * Created by gjj on 2018-04-18. */ public class Father { static{ System.out.println("父类静态代码块"...父类构造代码块"); } public Fathe...
  • 实例化子类时,父类与子类中的静态代码块、实例代码块、静态变量、实例变量、构造函数执行顺序是怎样的? 代码执行的优先级为: firest:静态部分 second:实例化过程 详细顺序为: 1.父类静态代码块...
  • 只在其第一个对象创建时调用,即便是创建了同一个类的多个对象,例如main()函数里b1,b2创建了同一个类的两个对象,但是grandmaMotherClass的构造函数只被执行了一次 2, 再执行父类构造函数(c++中如果有多个,...
  • 1.java源码 public class Test03 { public static void main(String[] args) { new B(); } } class A{ static{ System.out.println("我是A静态代码块"); } { //这个是构造代码块 System.out.println("我
  • 1.子类继承父类的方法属性,并重写父类的方法,子类修饰符不能比父类方法的修饰符的范围狭窄。...继承中的构造方法的执行顺序父类构造函数,子类也写构造方法的时候必须显示的调用父类的构造方
  • 当你知道了这些都指的是什么了,直接在程序里面写一遍不就行了,运行完记住顺序。 所以重点是记住代码都是什么样子的,怎么写的 package shunxu; public class shunxun { static class a { { System.out.println...
  • 1.父类静态代码块 ( java虚拟机加载类时,就会执行该块代码,故只执行... 父类构造函数(每次new,每次执行)6.子 类 属性对象初始化7.子类普通代码块(每次new,每次执行 )8.子 类构造函数(每次new,每次执行)9.子类重写...
  • java静态/动态成员变量、初始化块,父类/子类构造函数执行顺序问题package job;public class TestConsSeq {public static void main(String[] args) {/** 几大原则* 一、静态成员变量(Static)* 1、静态成员变量为类...
  • 1、虚拟机是优先加载含有main函数的类,会对此类优先加载,故要先加载类,才能执行main函数。 注:注意类加载时机,调用类的常量不加载。 2、加载类时候,若牵扯到父类子类,则一般要先调用父类,如果从子类调用...
  • 父类 public class People { private String name; private static People people = new People(); private static int n = 10; private int age = setAge(); { System.out.println("初始化...
  • class a{ static String abc="123"; static { System.out.println("I am a"); } { System. out .println( "这是父类的构造... System.out.println("这是a的无参构造函数"); } } class b extends a{ int ccc;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 737
精华内容 294
关键字:

java父类构造函数执行顺序

java 订阅