精华内容
下载资源
问答
  • 执行顺序:(优先级从高到低。)静态代码块>...static块,普通代码块,构造代码块执行顺序class A{public A(){System.out.println("Hello A");}{System.out.println("block A");}static{System.ou...

    执行顺序:(优先级从高到低。)静态代码块>mian方法>构造代码块>构造方法。

    其中静态代码块只执行一次。构造代码块在每次创建对象是都会执行。

    static块,普通代码块,构造代码块执行顺序

    class A{

    public A(){

    System.out.println("Hello A");

    }

    {

    System.out.println("block A");

    }

    static{

    System.out.println("static A");

    }

    }

    public class B extends A{

    public B(){

    System.out.println("Hello B");

    }

    {

    System.out.println("Block B");

    }

    static{

    System.out.println("static B");

    }

    public static void main(String[] args) {

    B d = new B();

    }

    }

    输出:

    static A

    static B

    block A

    Hello A

    Block B

    Hello B

    思考一下:静态代码块> 普通代码块 > 构造代码块

    示例2:

    package zqd.demo;

    class A{

    static{

    System.out.println("1");

    }

    public A(){

    System.out.println("2");

    }

    {

    System.out.println("3");

    }

    }

    class B extends A{

    {

    System.out.println("c");

    }

    static{

    System.out.println("a");

    }

    public B(){

    System.out.println("b");

    }

    }

    public class Hello{

    public static void

    main(String[] args){

    A ab = new B();

    ab = new B();

    }

    }

    输出:

    1

    a

    3

    2

    c

    b

    3

    2

    c

    b

    原文:https://www.cnblogs.com/liqiang0728/p/11072345.html

    展开全文
  • 1、简单认为JAVA静态代码块在类被加载时就自动执行 是错误的class MyClass1 {static {//静态块System.out.println("static block ");}}public class Main {Class[] classArray = {MyClass1.class//这样引用该类,...

    1、简单认为JAVA静态代码块在类被加载时就会自动执行  是错误的

    class MyClass1 {

    static {//静态块

    System.out.println("static block ");

    }

    }

    public class Main {

    Class[] classArray = {

    MyClass1.class//这样引用该类,必然需要将该类加载到虚拟机中

    };

    public static void main(String[] args){

    System.out.println("hello word");//执行结果:并没有输出" static bolck"

    }

    }

    2、正解:static块真正的执行时机

    一个类的运行分为以下步骤:

    装载

    连接

    初始化

    装载阶段

    通过类型的完全限定名,产生一个代表该类型的二进制数据流

    解析这个二进制数据流为方法区内的内部数据结构

    创建一个表示该类型的java.lang.Class类的实例

    补充:如果一个类装载器在预先装载的时遇到缺失或错误的class文件,它需要等到程序首次主动使用该类时才报告错误

    连接阶段

    验证,确认类型符合Java语言的语义,检查类之间的二进制兼容性(如final的类不用拥有子类等),另外还需要进行符号引用的验证

    准备,Java虚拟机为类变量分配内存,设置默认初始值

    解析(可选的) ,在类型的常量池中寻找类,接口,字段和方法的符号引用,把这些符号引用替换成直接引用的过程

    当一个类被主动使用时,Java虚拟就会对其初始化

    如下六种情况为主动使用:

    当创建某个类的新实例时(如通过new或者反射,克隆,反序列化等)

    当调用某个类的静态方法时

    当使用某个类或接口的静态字段时

    当调用Java API中的某些反射方法时,比如类Class中的方法,或者java.lang.reflect中的类的方法时

    当初始化某个子类时

    当虚拟机启动某个被标明为启动类的类(即包含main方法的那个类)

    Java编译器会收集所有的类变量初始化语句和类型的静态初始化器,将这些放到一个特殊的方法中:clinit

    3、实际上,static块的执行发生在“初始化”的阶段

    初始化阶段,jvm主要完成对静态变量的初始化,静态块执行等工作

    执行static块的几种情况:

    第一次new A()的过程会打印"";因为这个过程包括了初始化

    第一次Class.forName("A")的过程会打印"";因为这个过程相当于Class.forName("A",true,this.getClass().getClassLoader())

    第一次Class.forName("A",false,this.getClass().getClassLoader())的过程则不会打印 ""因为false指明了装载类的过程中,不进行初始化。不初始化则不会执行static块

    展开全文
  • 构造方法,构造代码块,静态代码块执行顺序静态代码块:用static声明,jvm加载类时执行,仅执行类中直接用{}定义,每次创建对象时执行同级别的变量(static和普通变量)的执行顺序由代码执行顺序决定(从上到下也就是...

    构造方法,构造代码块,静态代码块的执行顺序

    静态代码块:用static声明,jvm加载类时执行,仅执行一次

    类中直接用{}定义,每次创建对象时执行

    同级别的变量(static和普通变量)的执行顺序由代码执行顺序决定(从上到下也就是代码书写顺序)

    package com.rumenz;

    public class Rumenz {

    private Integer id=100;

    private static String name="入门小站";

    {

    System.out.println("构造代码块。。。");

    System.out.println("变量 id:"+id);

    }

    static {

    System.out.println("静态变量name:"+name);

    System.out.println("静态代码块。。。");

    }

    public Rumenz() {

    System.out.println("构造方法。。。。");

    }

    public static void main(String[] args) {

    Rumenz r=new Rumenz();

    }

    }

    执行Rumenz r=new Rumenz();输出

    静态变量name:入门小站

    静态代码块。。。

    构造代码块。。。

    变量 id:100

    构造函数。。。。

    不执行Rumenz r=new Rumenz();输出

    静态变量name:入门小站

    静态代码块。。。

    构造方法

    public Rumenz() {

    System.out.println("构造方法。。。。");

    }

    对象一旦创建就会调用与之相对应的构造方法

    不创建对象就不会调用构造方法

    构造函数的作用是给对象初始化

    对象创建一次,构造函数只调用一次,而普通方法可以被调用很多次

    构造代码块

    {

    System.out.println("构造代码块。。。");

    }

    给对象进行初始化.

    对象一创建就会执行构造代码块,而且先于构造方法执行.

    构造代码块每一次创建对象都会执行,但是创建对象时调用不通的构造方法会得到不同的对象,也就是说构造代码块用于初始化对象通用的属性或者功能.

    静态代码块

    static {

    System.out.println("静态代码块。。。");

    }

    由jvm加载类时执行,而且只执行一次.

    静态代码块是给类进行初始化,构造代码块是给对象进行初始化

    静态代码块中的变量属于局部变量

    原文: [https://rumenz.com/rumenbiji/ constructor-static-code-block.html](https://rumenz.com/rumenbiji/ constructor-static-code-block.html)

    展开全文
  • 静态代码块 static { System.out.println("静态代码块"); } ...普通代码块每次创建对象时都会调用一 执行顺序:静态代码块>普通代码块>构造方法 public class test { //普通代码块 {

    静态代码块

    static {
            System.out.println("静态代码块");
        }
    
    静态代码块只在第一次创建该对象时调用一次,以后再创建该对象不在调用
    一个类中有多个静态代码块时,会按照书写顺序依次执行
    

    普通代码块

    {
        System.out.println("匿名代码块");
    }
    
    普通代码块每次创建对象时都会调用一次
    

    执行顺序:静态代码块>普通代码块>构造方法

    public class test {
        //普通代码块
        {
            System.out.println("普通代码块");
        }
        //静态代码块
        static {
            System.out.println("静态代码块");
        }
        public test(){
            System.out.println("构造方法");
        }
        public static void main(String[] args) {
            test t1 = new test();
            System.out.println("-----------");
            test t2 = new test();
        }
    }
    

    执行结果:

    在这里插入图片描述

    父类子类中的执行顺序:

    首先执行父类静态代码块的内容,再去执行子类的静态代码块的内容,
    执行完父类和子类的静态代码块后,先执行父类中的普通代码块、构造方法,
    最后去执行子类中的普通代码块、构造方法。
    

    总之一句话,静态代码块内容先执行,接着执行父类普通代码块和构造方法,然后执行子类普通代码块和构造方法

    public class Person {
        //普通代码块
        {
            System.out.println("父类的普通代码块");
        }
        //静态代码块
        static {
            System.out.println("父类的静态代码块");
        }
        public Person() {
            System.out.println("Person的构造方法");
        }
    }
    
    public class Student extends Person{
        //普通代码块
        {
            System.out.println("子类的普通代码块");
        }
        //静态代码块
        static {
            System.out.println("子类的静态代码块");
        }
        public Student() {
            System.out.println("Student的构造方法");
        }
    }
    
    public class test {
        public static void main(String[] args) {
            Student s1 = new Student();
            System.out.println("-----------");
            Student s2 = new Student();
        }
    }
    

    执行结果:

    在这里插入图片描述

    展开全文
  • java代码 编译后的class文件 可以看出普通代码块被移到构造器原有代码前面。故普通代码块语句先于构造器执行
  • 普通代码块:类中方法的方法体,普通代码块和一般语句的执行顺序由他们在代码中出现的次序决定,先出现先执行。 构造代码块:构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先...
  • java静态代码块和代码块执行顺序先执行static方法,再执行普通方法,最后执行构造方法。eg:package other;class B {public B() {super();System.out.println("构造器B");}{System.out.println("普通的代码块B");}...
  • 下面小编就为大家带来一篇Java 普通代码块静态代码块执行顺序(实例讲解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧如下所示:class B {public B() {super();System.out....
  • 构造器与类同名且没有返回值,用来初始化类属性;...属性...public Contruction(){}//无参构造器,不写,系统自动添加}1.2:有参构造器public class Contruction {private int i;public Contruction( int i)...
  • } } 结果: 静态属性被初始化 静态代码块被初始化 初始化代码块被初始化 非静态属性被初始化 构造方法被初始化 所以综上所述:执行顺序: 【静态属性---->静态代码块】---->【初始化代码块---->非静态属性】---->...
  • 类中存在属性、普通方法、构造方法、普通代码块、静态代码块。 在编译期间JVM怎么处理代码,那些代码执行。做了一个测试进行比较。 先说一下普通代码块。就是在java类中用{},进行包裹的函数代码。例如: 静态...
  • 1.静态代码块 ①、格式 在java类中(方法中不能存在静态代码块)使用static关键字和{}声明...如果一个类中有多个静态代码块按照书写顺序依次执行。后面在比较的时候通过具体实例来证明。 ③、静态代码块的作用.
  • 父类静态(代码块,变量赋值二者按顺序执行)子类静态父类构造代码块父类构造方法子类构造代码块子类构造方法普通方法在实列调用的时候执行,肯定位于上面之后了//父类Apublic class A {A() {System.out.println("A...
  • 先看一个例子: ... System.out.println("A1:父类静态代码区域"); } { System.out.println("A2:父类非静态代码区域"); } public A() { System.out.println("A3:父类构造器"); } } //class
  • Java面试题之关于静态代码块与普通代码块和构造方法的执行顺序问题静态代码块mysql驱动中静态代码块普通代码块构造方法面试题执行流程执行结果 静态代码块 静态代码块是写在java类中的,其语法为 static { // 这里...
  • System.out.println("构造代码块"); } TestStatic() { System.out.println("构造函数代码块"); } //类级别的初始化,只是在类加载的时候做一 static { System.out.println("static静态代码块"); } } ...
  • 关于静态代码块、构造代码块、构造方法、普通代码块执行顺序? 静态代码块 static{} 在java中使用static关键字声明的代码块。 静态块用于初始化类,为类的静态属性初始化。 每个静态代码块只会执行。 由于...
  • 普通代码块: 定义在方法体内部,按顺序在方法内部执行。 应用场景: 在方法中进行功能拆分时使用。 代码例子: public void blockTest() { { System.out.println("我是普通代码块1的输出。"); } System....
  • 调用构造方法创建对象的时候,在构造方法的代码块之前执行,可用于构造方法的通用初始化,即每个构造方法都有的代码且最先执行 public class codeBlock { static { System.out.println("静态代码块
  • 一、代码块:静态代码块:static...先执行静态代码块,且在类加载时执行,并且只执行,若有多个静态代码块,则按照静态代码块在代码中的顺序来执行静态代码块。再执行普通(构造代码块)代码块,先于构造方法...
  • 执行的流程中出现的 代码块,我们称其为普通代码块。 ---- 构造代码块 在类中的成员代码块, 我们称其为构造代码块,在每次对象创建时执行执行在构造方法之前。 ---- 静态代码块 在类中使用static修饰的成员代码...
  • 1、先来看下面代码: ... System.out.println("静态代码块"); } { System.out.println("构造代码块"); } public Code(String name) { this.name = name; System.out.println("有参构造代码块"+name);
  • 代码块 代码块:又称初始化块,属于类中的成员。与方法类似,将逻辑语句封装于方法体内,但没有方法名,没有返回,没有参数,只有方法体。...static修饰的为,随着类的加载而执行,并且只会执行 ...
  • 普通代码块:无修饰符,可以调用类所有成员 二、构造方法: 方法名与类名相同,没有返回值,但不能写void 基本语法:`[修饰符] 类名(形参列表) {方法体} 1. 在同一个类中的调用顺序 A) 新建一个类取名...
  • 本文介绍了Android代码块执行顺序分析总结,分享给大家,具体如下:子类、父类变量,代码块,以及构造方法的加载顺序,是我们在程序开发中时不时遇到的一个问题,也是比较容易混淆的。基础准备:变量: 成员变量(叫...
  • classB{publicB(){super();System.out.println("构造...}{System.out.println("普通代码块B");}static{System.out.println("静态代码块B");}}publicclassClassAextendsB{publicClassA(){super();System.out.printl...
  • 14.1.介绍 相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化的操作 场景:如果多个构造器中都有重复的语句,可以抽取到初始化中,提高代码的重用性
  • 1.普通代码块public static void main(String[] ...*普通代码块执行顺序由他们在代码中出现的次序决定--“先出现先执行”* */{System.out.println("这里是普通代码块A");}//new A();{System.out.println("这里是普...
  • //执行顺序:(优先级从高到低。) 静态代码块>mian方法>构造代码块>...*普通代码块执行顺序由他们在代码中出现的次序决定--“先出现先执行” * */ {  System.out.println("这里是普通代码块A")

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 294,125
精华内容 117,650
关键字:

普通代码块会执行几次