精华内容
下载资源
问答
  • Java构造块

    2013-05-09 17:12:00
    java构造块是为了在运行构造方法之前做一些公共的操作,将创建对象的一些公共的操作提取到构造块里面是不错的选择,例如初始化变量,这个在构造方法里面也可以实现,就是在构造方法里面调用方法初始化变量,但是...

    java构造块

    java构造块是为了在运行构造方法之前做一些公共的操作,将创建对象的一些公共的操作提取到构造块里面是不错的选择,例如初始化变量,这个在构造方法里面也可以实现,就是在构造方法里面调用方法初始化变量,但是这样的话,构造方法不简明,并且不如用构造块,因为采用构造块的方式,编译器会直接将构造块的代码插入到构造方法里面。

    采用构造块的效果如下:(在每一个构造方法里面的开始加入了构造块的代码)


    public BB() {
    		count++;
    		System.out.println("调用BB的无参构造函数");
    	}
    
    	public BB(int a) {
    		count++;
    		System.out.println("调用BB的构造函数BB(int a)");
    	}



    package com.wangbiao.second;
    
    public class TestBuildingBlock {
    
    	public static void main(String[] args) {
    
    		BB b=new BB();
    		b=new BB("a");
    		b=new BB(1);
    		System.out.println(BB.getCount());
    //		调用BB的无参构造函数
    //		调用BB的无参构造函数
    //		调用BB的构造函数BB(int a)
    //		3
    		
    		
    		
    		
    		
    	}
    }
    
    class AA {
    	public AA() {
    		System.out.println("调用父类的构造函数");
    	}
    }
    
    class BB extends AA{
    	private static int count=0;
    	
    	{
    		count++;
    	}
    
    	public BB() {
    		System.out.println("调用BB的无参构造函数");
    	}
    
    	public BB(int a) {
    		System.out.println("调用BB的构造函数BB(int a)");
    	}
    
    	public BB(String str) {
    		this();
    		//super();
    	}
    
    	public static int getCount() {
    		return count;
    	}
    
    }

    上面代码目的就是记录对象的个数,运行的结果,刚开始的时候我以为会是4,但是结果是3。

    因为我认为,调用了BB(String str)构造方法的时候,按照我们认为的构造块代码可以认为是加在构造方法开头,就应该也count++,然后再调用本来的无参构造方法,再count++.加上前面的两次count++,结果就是4,不过java的构造块,为我们解决了这个问题。,当碰到this关键字调用本类的构造方法的时候,Java不会将构造块的代码插入带有this关键字调用本类构造方法的构造方法的。


    转载于:https://my.oschina.net/u/617909/blog/129316

    展开全文
  • java构造块与静态块

    千次阅读 多人点赞 2018-04-07 12:19:33
    Java类里普遍存在静态快,构造块,构造函数,具体什么关系呢?静态块:用static申明,JVM加载类时执行,仅执行一次构造块:类中直接用{}定义,每一次创建对象时执行public class Study_static { public static char...

    最近,在面试题或者面试上老是,提到静态块,静态变量,就仔细了解了下。

    Java类里普遍存在静态快,构造块,构造函数,具体什么关系呢?

    静态块:用static申明,JVM加载类时执行,仅执行一次

    构造块:类中直接用{}定义,每一次创建对象时执行

    public class Study_static {
    	public static char text = 'a';  //静态对象
    	
    	public Study_static(){         //构造函数
    		System.out.println('c');
    	}
    	
    	{                              //构造块
    		System.out.println('b');
    	}
    	
    	static{                         //静态块
    		System.out.println(text);
    	}
    	public static void main(String[] args){
    		Study_static a = new Study_static();
    		
    	}
    }

    输出结果:

    执行顺序优先级:静态块>main()>构造块>构造方法

    所以先执行静态块,再tudy_static a = new Study_static();该语句创建对象,则又会调用构造块,输出构造块,再执行构造函数。

    然而,这里的静态块,并不是仅仅静态块,而是静态域,包含了静态变量,静态块,这两者的执行顺序就是按照位置顺序进行。

    总结:

    1.静态块其实就是给类初始化的,而构造代码块是给对象初始化的。

    2.静态代码块只会运行一次

    3.静态块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    一个类中可以有多个静态代码块,执行顺序按照位置决定。

    那么对于继承情况呢?

    public class Study_static {
    	public static char text = 'a';  //静态对象
    	
    	public Study_static(){         //构造函数
    		System.out.println('c');
    	}
    	
    	{                              //构造块
    		System.out.println('b');
    	}
    	
    	static{                         //静态块
    		System.out.println(text);
    	}
    }
    public class Study_static2 extends Study_static{
    	public static String text2 = "a1";
    	
    	public Study_static2(){
    		System.out.println("c2");
    	}
    	
    	{
    		System.out.println("b2");
    	}
    	
    	static{
    		System.out.println(text2);
    	}
    	public static void main(String[] args){
    		Study_static2 a = new Study_static2();
    		
    	}
    }

    结果:

    当涉及到继承时,按照如下顺序执行:

    1. 执行父类的静态代码块,并初始化父类静态成员变量
    2. 执行子类的静态代码块,并初始化子类静态成员变量
    3. 执行父类的构造代码块,执行父类的构造函数,并初始化父类普通成员变量
    4. 执行子类的构造代码块, 执行子类的构造函数,并初始化子类普通成员变量








    展开全文
  • java构造块的学习

    2019-09-16 15:22:23
    2、构造块 3、静态代码块 package hello_world; public class Demo { /** * 构造块 */ { System.out.println("通用构造块"); } public Demo() { System.out.println("构造方法一"); } public ...

    代码块包括以下三点
    1、普通代码块
    2、构造块
    3、静态代码块

    package hello_world;
    
    public class Demo {
    	
    	/**
    	 * 构造块
    	 */
    	{
    		System.out.println("通用构造块");
    	}
    	
    	public Demo() {
    		System.out.println("构造方法一");
    	} 
    	
    	public Demo(int i) {
    		System.out.println("构造方法二");
    	} 
    
    	public Demo(int i,int j) {
    		System.out.println("构造方法三");
    	} 
    	public static void main(String[] args) {
    		new Demo();   //实例化一个对象 
    		new Demo(1);
    		new Demo(1,2);
    	}
    }
    
    展开全文
  • 咋们话不多说,直接上代码 class A{ A(){ System.out.println("构造函数")... System.out.println("静态"); } } 运行试试,看看会打印出什么,哈哈 public class Demo { public static void main(String[] args)

    咋们话不多说,直接上代码

    class A{
        A(){
            System.out.println("构造函数");
        }
        {
            System.out.println("构造快");
        }
        static {
            System.out.println("静态块");
        }
    }
    

    运行试试,看看会打印出什么,哈哈

    public class Demo {
        public static void main(String[] args) {
           A a = new A();
        }
    }
    
    静态块
    构造快
    构造函数
    

    看出来了吗?

    静态块是跟随着类模板加载的,就像人的眼睛一样,人在哪里,必然眼睛就在哪里,所以第一个是静态块。而构造块是在构造函数运行时除super()方法外首先运行的。

    如果是继承,结果会是什么呢?

    class Parent{
    	static int time = 7;
        Parent(){
            System.out.println("Parent构造函数");
        }
        {
            System.out.println("Parent构造快");
        }
        static {
            System.out.println("Parent静态块");
        }
    }
    class Sun extends Parent{
    	static int time1 = 7;
        Sun(){
            System.out.println("Sun构造函数");
        }
        {
            System.out.println("Sun构造快");
        }
        static {
            System.out.println("Sun静态块");
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
           Sun a = new Sun();
        }
    }
    
    Parent静态块
    Sun静态块
    Parent构造快
    Parent构造函数
    Sun构造快
    Sun构造函数
    

    这是怎么回事呢?为啥和我们想象的不一样啊

    这是因为生活中是先有父亲然后才有儿子,代码中也是一样的,当 new Sun() 的时候实例父亲对象已经存在,结合上面的总结,就可以得出答案。
    执行顺序:

    • 父类静态(不区分方法和字段,直接按照先后顺序)
    • 子类的静态
    • 父类的构造快
    • 父类的构造方法
    • 子类的构造快
    • 子类的构造方法

    现在你懂了吗

    面试也会偶尔会问哦。。。。。

    展开全文
  • 构造块:直接写在类中的代码块 静态代码垮:使用static关键字声明的代码块 静态代码块先于构造块,构造方法执行,而且只在类加载时候执行一次,后面在类实例化的时候会先执行构造块,而且每 执行实例化一个对象,...
  • java代码执行顺序
  • public class Test{ public int i=print("why"); { print("构造块"); } private static int print(String str){ ...为什么每次实例化对象时,调用构造块的同时也会调用构造块前面的那个赋值语句?
  • 看下面一段代码,求执行顺序: class A { public A() { System.out.println("1A类的构造方法"); } ... System.out.println("...3A类的静态"); } } public class B extends A { public...
  • Java 构造代码

    2018-06-28 14:39:42
    * 构造代码,会编译进所有的构造方法 * @author jack * 构造代码的注意事项: * java编译器 .java源文件的时候,会把成员变量的声明语句放到类的最前面; * 成员变量的初始化操作都是在构造方法中完成的; ...
  • java 构造代码

    2019-12-05 16:22:06
    代码: 1)普通代码:顺序执行;...3)静态代码:static修饰的代码,优于构造代码执行,多个静态代码顺序执行;其他的特征和静态方法类似。 用代码包起来的变量作用域问题: ...
  • java代码构造块

    2017-12-30 17:10:27
    java 中存在着代码构造块,在创建对象的时候会被调用,如下 class test { int num; //代码构造块 { num = 2; } } 除了在类定义中加入构造块,在创建类的时候也可以加上新的构造块,如下 class test { int ...
  • java构造代码

    2017-11-27 12:17:35
    构造代码
  • java 静态代码块 构造块 构造方法 class className{  static{ }//静态代码块  { }//构造代码块  public className(){} //构造方法 } ...
  • Java 静态块、构造块、构造函数执行顺序
  • Java构造代码

    2018-12-10 22:10:16
    构造代码类似于静态代码,在调用函数构造器的时候插入到构造函数前边  构造器可以做类的初始化赋值,不需要显示调用,可以给构造函数"减负" 内部类的构造函数并不会调用外部的构造代码 package ...
  • 主要介绍了Java构造代码,静态代码,结合实例形式分析了Java构造代码,静态代码的功能、原理、用法及操作注意事项,需要的朋友可以参考下
  • 构造代码 构造函数之间的调用 static关键字
  • java构造块静态块

    2016-12-01 09:41:13
    构造块在构造方法之前执行
  • java 构造块 与 kotlin init 的区别 koltin 的init 块可以访问 构造器中的参数 。但是java构造块 无法访问构造函数的 参数。 Kotlin和java 构造器的区别 java 可以有多个构造器 ,而且互相之间可以没有依赖,但是...
  • 静态块、构造块、构造函数的执行顺序
  • 2.构造块 定义在类中的代码块,不加任何修饰符 { } 在对象产生时,优先于构造方法执行,有几个对象产生,就调用几次构造块。 用于在构造方法执行前完成一些属性的初始化操作 3.静态代码块 A.非主类中的静态代码块 ...
  • Java构造代码的使用

    千次阅读 2018-07-29 13:11:15
    Java中,代码{}分为好几种,其中一种就是构造代码,何为构造代码呢?简单来说就是用{}包起来的代码片段,在创建对象时会被调用,每次创建对象时都会被调用。  在刷题的时候,发现有这样一种用法: ...
  • java构造代码的使用

    2018-11-08 21:40:00
    一、构造代码 形式: 只用{}包围的代码。 作用:给所有对象进行统一的初始化。 执行顺序:创建对象时,会先执行构造代码,然后再执行构造函数。 构造代码构造函数的比较: 相同点:都是给对象进行...
  • java构造代码详解

    万次阅读 多人点赞 2017-02-06 15:58:53
    简介首先说一下,Java中有哪些代码.普通代码就是在方法后面使用"{}"括起来的代码片段,不能单独执行,必须调下其方法名才可以执行. 静态代码在类中使用static修饰,并使用"{}"括起来的代码片段,用于静态变量的初始...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,763
精华内容 3,905
关键字:

java构造块

java 订阅