精华内容
下载资源
问答
  • Static静态代码块以及各代码块之间的执行顺序

    万次阅读 多人点赞 2019-10-16 19:56:49
    文章目录代码块的分类1、静态代码块(也叫静态块、静态初始化块)2、构造代码块(也叫构造初始化块)3、代码块(又叫普通代码块、初始化块)执行顺序的代码测试继承中各代码块的执行顺序 代码块的分类 基本上代码...

    前言
    在Java中,Static静态代码块、构造代码块、普通代码块、构造函数的执行顺序是一个java学习者必须掌握的基础,本篇博客旨在让大家能清除了解它们之间的执行顺序。

    代码块的分类

    基本上代码块分为三种:Static静态代码块、构造代码块、普通代码块

    代码块执行顺序静态代码块——> 构造代码块 ——> 构造函数——> 普通代码块

    继承中代码块执行顺序:父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器

    1、静态代码块(也叫静态块、静态初始化块)

    Java静态代码块中的代码会在类加载JVM时运行,且只被执行一次,也就是说这些代码不需要实例化类就能够被调用。一般情况下,如果有些代码必须在项目启动的时候就执行的时候,就需要使用静态代码块,所以静态块常用来执行类属性的初始化!

    关于Static静态代码块的五个小结点

    1、Java静态代码块中的代码会在类加载JVM时运行,且只被执行一次
    2、静态块常用来执行类属性的初始化
    3、静态块优先于各种代码块以及构造函数,如果一个类中有多个静态代码块,会按照书写顺序依次执行
    4、静态代码块可以定义在类的任何地方中除了方法体中【这里的方法体是任何方法体】
    5、静态代码块不能访问普通变量

    针对4中描述静态代码块不能存在任何方法体中的原因其实也是很简单,由于普通方法是通过加载类,然后new出实例化对象,通过对象才能运行这个方法,而静态代码块只需要加载类之后就能运行了。对于静态方法,在类加载的时候,静态方法也已经加载了,但是我们必须要通过类名或者对象名才能访问,也就是说相比于静态代码块,静态代码块是自己主动运行的,而静态方法是被动调用运行的。不管是哪种方法,我们需要明确静态代码块的存在在类加载的时候就自动运行了,而放在不管是普通方法还是静态方法中,都是不能自动运行的。

    针对5中描述静态代码块不能访问普通变量,原因同样简单。普通变量是被实例对象调用的,静态代码块中都不存在其实例对象,谈何调用变量?

    Static静态代码块使用格式

    static{
      ..............
    }
    

    2、构造代码块(也叫构造初始化块)

    听这名字就知道和构造方法离不开!没错,但是还是和构造方法有着本质区别,我们都知道,没个方法中都可以有很多构造方法,每创建一个对象其构造方法就执行一个,而一个构造方法可以创建N个对象,构造方法就比较“高冷”了,而构造代码块就比较“舔狗”了,只要该类实例了一个对象,构造代码就执行一次,利用每次创建对象的时候都会提前调用一次构造代码块特性,所以它可以做统计创建对象的次数功能。当然构造代码块用的相对少!

    构造代码块小结

    1、构造代码块在创建对象时被调用,每次创建对象都会调用一次
    2、构造代码块优先于构造函数执行,同时构造代码块的运行依赖于构造函数
    3、构造代码块在类中定义

    针对2中的“依赖”可理解为如果不实例化对象(也就是不执行构造方法),构造代码块是不会执行的!

    3、代码块(又叫普通代码块、初始化块)

    代码块小结

    1、普通代码块定义在方法体中
    2、普通代码块与构造代码块的格式一致都是{}
    3、普通代码块与构造代码块唯一能直接看出的区别是构造代码块是在类中定义的,而普通代码块是在方法体中定义的

    执行顺序的代码测试

    以上已经讲得差不多了,开始上代码了!

    package com.gx.initializationblock;
    
    public class Initializationblock {
    
        int intA;
        int intB;
    
    
        public Initializationblock() {
            System.out.println("无参构造器00000000");
        }
    
        public Initializationblock(int a) {
            System.out.println("一个参数的构造器");
            
        }
    
    
        {
            intA = 10;
            intB = 15;
    
            System.out.println("构造初始化块11111");
        }
    
        {
            System.out.println("构造初始化块22222");
        }
    
        {
        	
            System.out.println("构造初始化块33333");
        }
    
        //静态初始化块
        static {
            System.out.println("静态初始化块01010101");
        }
    
        static {
            System.out.println("静态初始化块0202020202");
        }
        public void method(){
        	{
        		System.out.println("普通初始化块");
        	}
        }
    }
    

    测试demo

    package com.gx.initializationblock;
    
    /* 初始化块一
    	 * 因为静态块是在类的初始化阶段完成的,
    	 * 因此在创建某个类的第二个对象时,该类的静态块就不会执行了
    	 * 
    	 * 在单个类中,静态初始化块,初始化块,构造器
    	 * 多个类的继承中初始化块、静态初始化块、构造器的执行顺序
    在继承中,先后执行父类A的静态块,父类B的静态块,最后子类的静态块,然后再执行父类A的非静态块和构造器,然后是B类的非静态块和构造器,最后执行子类的非静态块和构造器
     */
    public class Demo1 {
        public static void main(String[] args) {
            Initializationblock initializationblock = new Initializationblock();
            initializationblock.method();
            System.out.println("------------");
            //多打印几个对象的目的是:好看出Static静态代码块只执行一次!!!
            Initializationblock initializationblock2 = new Initializationblock(); //因为静态块是在类的初始化阶段完成的,因此在创建某个类的第二个对象时,该类的静态块就不会执行了
            initializationblock2.method();
            Initializationblock initializationblock3 = new Initializationblock();
            initializationblock3.method();
        }
    }
    

    打印结果

    静态初始化块01010101
    静态初始化块0202020202
    构造初始化块11111
    构造初始化块22222
    构造初始化块33333
    无参构造器00000000
    普通初始化块
    ------------
    构造初始化块11111
    构造初始化块22222
    构造初始化块33333
    无参构造器00000000
    普通初始化块
    构造初始化块11111
    构造初始化块22222
    构造初始化块33333
    无参构造器00000000
    普通初始化块
    

    得出结论:执行顺序静态代码块 > 构造代码块 > 构造函数 > 普通代码块

    继承中各代码块的执行顺序

    啥都不说了,直接撸代码:继承关系为 BaseThree——> BaseTwo——> BaseOne
    BaseOne类

    package com.gx.initializationblock;
    
    public class BaseOne {
    
        public BaseOne() {
            System.out.println("BaseOne构造器");
        }
    
        {
            System.out.println("BaseOne初始化块");
            System.out.println();
        }
    
        static {
            System.out.println("BaseOne静态初始化块");
    
        }
    
    }
    

    BaseTwo类

    package com.gx.initializationblock;
    
    public class BaseTwo extends BaseOne {
        public BaseTwo() {
            System.out.println("BaseTwo构造器");
        }
    
        {
            System.out.println("BaseTwo初始化块");
        }
    
        static {
            System.out.println("BaseTwo静态初始化块");
        }
    }
    

    BaseThree 类

    package com.gx.initializationblock;
    
    public class BaseThree extends BaseTwo {
        public BaseThree() {
            System.out.println("BaseThree构造器");
        }
    
        {
            System.out.println("BaseThree初始化块");
        }
    
        static {
            System.out.println("BaseThree静态初始化块");
        }
    }
    

    测试demo2类

    package com.gx.initializationblock;
    
    /*
         注:这里的ABC对应BaseOne、BaseTwo、BaseThree 
     * 多个类的继承中初始化块、静态初始化块、构造器的执行顺序
         在继承中,先后执行父类A的静态块,父类B的静态块,最后子类的静态块,
         然后再执行父类A的非静态块和构造器,然后是B类的非静态块和构造器,最后执行子类的非静态块和构造器
     */
    public class Demo2 {
        public static void main(String[] args) {
            BaseThree baseThree = new BaseThree();
            System.out.println("-----");
            BaseThree baseThree2 = new BaseThree();
    
        }
    }
    

    运行结果

    BaseOne静态初始化块
    BaseTwo静态初始化块
    BaseThree静态初始化块
    BaseOne初始化块
    
    BaseOne构造器
    BaseTwo初始化块
    BaseTwo构造器
    BaseThree初始化块
    BaseThree构造器
    -----
    BaseOne初始化块
    
    BaseOne构造器
    BaseTwo初始化块
    BaseTwo构造器
    BaseThree初始化块
    BaseThree构造器
    

    多个类的继承中初始化块、静态初始化块、构造器的执行顺序为:先后执行父类A的静态块,父类B的静态块,最后子类的静态块,然后再执行父类A的非静态块和构造器,然后是B类的非静态块和构造器,最后执行子类的非静态块和构造器【注:这里的ABC对应BaseOneBaseTwoBaseThree

    结论:多个类的继承中初始化块、静态初始化块、构造器的执行顺序为:父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器

    如果本文对你有所帮助,请支持一下点个赞呗QnQ
    最后,博主并不是什么大牛,也会犯错!如有不正之处欢迎指正!感激不尽!

    展开全文
  • 代码块

    千次阅读 2019-05-05 20:41:17
    代码块:就是用{}扩起来的代码。 根据位置和关键字的不同分为普通代码块、构造块、静态代码块、同步代码块。 1、普通代码块:就是直接在方法或语句中定义的代码块。 public class CodeDemo01 { public static void ...

    代码块:就是用{}扩起来的代码。
    根据位置和关键字的不同分为普通代码块、构造块、静态代码块、同步代码块(与线程有关,在线程里面分析)。

    1、普通代码块:就是直接在方法或语句中定义的代码块。

    public class CodeDemo01 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		{
    			int num=1;
    			System.out.println("这是普通代码块,里面的局部变量为:"+num);
    		}
    		int x=100;
    		System.out.println("这是普通代码之外,之外的局部变量为:"+x);
    	}
    }
    
    //结果:
    //这是普通代码块,里面的局部变量为:1
    //这是普通代码之外,之外的局部变量为:100
    

    2、构造块:直接写在类中的代码块。

    public class CodeDemo02 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		new Code02();
    		new Code02();
    	}
    }
    class Code02{
    	{
    		System.out.println("这是构造代码块——写在类中的代码块");
    	}
    	public Code02() {
    		System.out.println("实例化时调用");
    	}
    }
    //结果:
    /*这是构造代码块——写在类中的代码块
    实例化时调用
    这是构造代码块——写在类中的代码块
    实例化时调用*/
    

    构造代码块优于构造方法执行
    在此代码里面实例化对象时就会执行构造代码块,可以被执行多次。

    3、静态代码块:用static关键字声明的代码块。

    public class CodeDemo03 {
    	static {	
    		System.out.println("在Main()所在类定义静态代码块");
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		{
    			System.out.println("这是普通代码块");
    		}
    		new Code03();
    		new Code03();
    	}
    }
    class Code03{
    	static {
    		System.out.println("用static修饰的静态代码块");
    	}
    	{
    		System.out.println("这是构造块");
    	}
    	public Code03() {
    		System.out.println("调用无参构造方法时被执行");
    	}
    }
    /*在Main()所在类定义静态代码块
    这是普通代码块
    用static修饰的静态代码块
    这是构造块
    调用无参构造方法时被执行
    这是构造块
    调用无参构造方法时被执行*/
    

    静态代码块随着字节码加载也加载进了JVM,此时main方法还没有执行,因为方法需要JVM调用。即静态代码块优于Main()执行。

    Main()所在类的静态代码块优于Main()执行,在类中定义的静态代码块优于构造块执行,构造块优于构造方法执行。

    即,从快到慢为:
    Main()所在类的静态代码块(且只执行一次)<——Main()
    静态代码块(只执行一次)<——Main()
    类中的静态代码块<——构造块<——构造方法

    展开全文
  • hexo+yilia修改代码块等样式

    千次阅读 2019-11-13 16:03:24
    代码块的样式真的很重要,毕竟咱好歹是一个技术博客,难免会贴一些代码的。


    代码块的样式真的很重要,毕竟咱好歹是一个技术博客,难免会贴一些代码的。因此参考https://cqh-i.github.io的样式进行了调整,下面是HTML的例子,更多具体效果可以参考这篇博客的样式:test-codestyle

    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>html代码块样本</title>
    </head>
    <body>
        <h1>这个样式可还行?</h1>
        <p class="p1" style="font-size:20px;">我的第一个段落。</p>
    </body>
    </html>
    

    说明

    1. 由于每个人可能都修改过样式文件,所以每个人的样式可能都会有所不同。建议修改之前做好备份,防止出现错误难于恢复,可以使用git进行版本管理(备份博客的源码和配置)。
    2. 我的备份文件,详见代码块样式调整备份文件cqh-i.github.io.css为博客https://cqh-i.github.io的代码块样式。main.0cf68a.css为我之前的css文件的备份。

    文中超链接样式

    默认:

    a {
        background: 0 0;
        text-decoration: none;
        color: #08c;
    }
    

    修改(添加内容)后:

    /* 文章中的超链接,鼠标悬浮特效 */
    .article-entry li a:hover, .article-entry p a:hover {
        background: 0 0;
        text-decoration: underline;
        color: #08c;
        /* font-size:18px; */
        font-weight:bold;
        transition:.8s;
    }
    

    再次修改:

    参考:https://css.30secondsofcode.org/snippet/hover-underline-animation

    /* 文章中的超链接,鼠标悬浮特效*/
    .article-entry a{
        display: inline-block;
        position: relative;
        color: #0087ca;
        font-family: lucida console;/* 这种字体的英文比较好看(像代码样式) */
    }
    /* 鼠标悬浮时,变色 */
    .article-entry a:hover{
        color: #d7191a;
        transition:.8s;
    }
    /* 鼠标悬浮时,下划线从中间向两边延伸 */
    .article-entry a:hover::after{
      transform: scaleX(1);
      /* 旋转,与transform连用;这里作用:鼠标悬浮时,底部的下划线从中间扩散到两边。
       bottom right :左到右出现,左到右消失(需配合上面的::after)
      */
      transform-origin: bottom center;
    }
    /* 鼠标移开后,下划线从两边向中间消失 */
    .article-entry a::after{
      content: '';
      position: absolute;
      width: 100%;
      transform: scaleX(0);
      height: 1.5px;
      bottom: 0;
      left: 0;
      background-color: #0087ca;
      /* 详见:https://www.w3school.com.cn/cssref/pr_transform-origin.asp,
      旋转,与transform连用;这里作用:鼠标移开后,底部的下划线从中间开始消失 */
      transform-origin: bottom center;
      transition: transform 0.5s ease-out;
    }
    

    2019年11月8日调整将article-entry换成mid-col,原来只是文章中文的超链接,现在改为右边栏都进行设置。(可能会出现很多负面影响,请自行决定是否更改)。

    行内代码块样式

    默认:

    .article-entry li code,.article-entry p code {
        padding: 1px 3px;
        margin: 0 3px;
        background: #ddd;
        border: 1px solid #ccc;
        font-family: Menlo,Monaco,Andale Mono,lucida console,Courier New,monospace;
        word-wrap: break-word;
        font-size: 14px
    }
    

    参考csdn代码块样式:主要是调整颜色为红色

    .markdown_views code {
        color: #c7254e;
        background-color: #f9f2f4;
        border-radius: -9px;
    }
    

    修改后:

    /* 行内代码块``的样式,参考csdn的
        color: #c7254e;
        background-color: #f9f2f4;
        border-radius: 2px;
        padding: 2px 4px;
    */
    .article-entry li code, .article-entry p code {
    	color: #c7254e;
        background-color: #f9f2f4;
        border-radius: 2px;
        padding:2px 4px;
        margin:0 3px;
        /* background:#ddd; */
        /* border:2px solid #ccc; */
        font-family:Menlo, Monaco, Andale Mono, lucida console, Courier New, monospace;
        word-wrap:break-word;
        /* font-size:14px */
    }
    

    补充:一开始没注意到原来该样式不包含标题中的代码块,添加:

    /* 标题中的代码块样式 */
    .article-entry code {
        /* background:#eee;
        padding:0 .3em;
        border:none */
        color: #c7254e;
        background-color: rgba(249,242,244,.7);
        border-radius: 2px;
        padding: 2px 4px;
        margin: 0 3px;
        font-family: Menlo,Monaco,Andale Mono,lucida console,Courier New,monospace;
        word-wrap: break-word
    }
    

    代码块主要样式文件

    代码块简单设置

    参考:Hexo 基于yilia主题及其它插件优化

    1.修改代码块的样式

    直接修改编译好的文件。路径为: theme/yilia/source/main.0cf68a.css:

    (1)修改代码背景色,
    搜索 .article-entry .highlight, 修改background后面的颜色
    将 pre{background:#272822;
    改为 pre{background:#1a0139;
    
    (2)修改行号颜色,
    搜索 .article-entry .highlight .gutter pre .line
    将.article-entry .highlight .gutter pre .line{color:#666
    改为.article-entry .highlight .gutter pre .line{color:#fc0000
    
    (3)修改代码字体颜色 
    搜索 .article-entry .highlight .line
    将.article-entry .highlight .line{color:#fff;
    修改为.article-entry .highlight .line{color:#00ff0d;
    

    效果图:

    个人感觉还不是很满意,有待优化。

    2.代码块行号显示错乱

    修改yilia/source/main.0cf68a.css的内容:将white-space:pre-wrap; 删除,这个问题是自动换行造成的,使用不自动换行的white-space:pre;样式代码块部分会自动出现底部滚动条,行号错乱问题就没有了。

    3.重点调整

    不知道是hexo还是yilia主题自带的是使用highlight.js进行代码高亮的,但是好像是内置的,因为我不会写源码,只能更改生成的文件:yilia/source/main.0cf68a.css,按照识别的关键字自定义颜色,这里是我的一些配置,你也可以自己使用F12进行调试。(当然网上也有许多替换自指定的highlight.js进行代码高亮的教程)。

    特别注意:高亮的前提是语言要写对,不然只能当做普通文本进行识别。

    /* 代码块样式之评论:黄色 */
    pre .comment {
        color:#ffec8b
    }
    /* 代码块样式之类的参数、函数的关键字、关键字:蓝色 */
    pre .class .params, pre .function .keyword, pre .keyword, pre .literal {
        color:#66d9ef
    }
    /* 代码块样式之css的属性值、函数名、参数、标签:白色 */
    pre .css .value, pre .doctype, pre .function, pre .params, pre .tag {
        color:#fff
    	/* color:#66d9ef; */
    }
    /* 代码块样式之HTML或者xml的头部元素:红色(颜色较浅) */
    pre .meta{
        color:#f78da1;
    }
    /* 代码块样式之HTML的标签:红色 */
    pre .tag .name {
        /* color:#dc3958; */
    	 color:#ff6481;
    }
    /* 代码块样式之:色 */
    pre .at_rule, pre .at_rule .keyword, pre .css~* .tag, pre .preprocessor, pre .preprocessor .keyword, pre .title{
        color:#fa9400
    }
    /* 代码块样式之属性、类、函数的title:绿色 */
    pre .attr,pre .attribute, pre .built_in, pre .class, pre .css~* .class, pre .function .title {
        color:#a6e22e
    }
    /* 代码块样式之字符串、属性值:猪肝色 */
    pre .string, pre .value {
        color:#e6db74
    }
    /* 代码块样式之数字:粉红色 */
    pre .number {
        color:#ffe4b5
    }
    pre .css~* .id, pre .id {
        color:#fd971f
    }
    

    文章内的超链接和引用块超出页面的问题

    参考:css自动换行如何设置?url太长会撑开页面

    当页面进行缩放时,说明这两个区域可能会超出页面。

    使用下面这两个属性进行截断:

    /* 如果超长,自动截断 */
    word-wrap:break-word;
    word-break:break-all;
    

    具体如下:

    a {
        background:transparent;
        text-decoration:none;
        color:#08c;
    	/* 如果超长,自动截断 */
        word-wrap:break-word;
        word-break:break-all;
    }
    .article-entry blockquote {
        background:#ddd;
        border-left:5px solid #ccc;
        padding:15px 20px;
        margin-top:10px;
        border-left:5px solid #657b83;
        background:#f6f6f6;
        /* 如果超长,自动截断 */
        word-wrap:break-word;
        word-break:break-all;
    }
    

    左侧边栏的菜单

    导航超链接样式:

    /* 这个字体不错font-family: STCaiyun,STXingkai; */
    .left-col #header .header-menu {
        font-family: STCaiyun,STXingkai;
        line-height: 31px;
        text-transform: uppercase;
        float: none;
        min-height: 150px;
        margin-left: -12px;
        -webkit-box-pack: center;
        -webkit-box-align: center;
        margin-top: 10px;
        margin-bottom: 10px;
    }
    

    主页‘展开全文’按钮样式

    样式参考:http://ianlunn.github.io/Hover/hvr-shutter-in-horizontal按钮,示例:https://codepen.io/yansheng836/pen/QWWmEro

    1.添加class

    修改H:\Hexo\themes\yilia\layout\_partial\article.ejs,查找index && theme.show_all_link,找到如下内容

          <% if (index && theme.show_all_link){ %>
            <p class="article-more-link">
              <a class="article-more-a" href="<%- url_for(post.path) %>"><%= theme.show_all_link %> >></a>
            </p>
          <% } %>
    

    class="article-more-a中添加hvr-shutter-in-horizontal

          <% if (index && theme.show_all_link){ %>
            <p class="article-more-link">
              <a class="article-more-a  hvr-shutter-in-horizontal" href="<%- url_for(post.path) %>"><%= theme.show_all_link %> >></a>
            </p>
          <% } %>
    

    2.修改样式

    修改H:\Hexo\themes\yilia\source\main.0cf68a.css,查找.article-more-link a

    .article-more-link a {
        background:#4d4d4d;
        color:#fff;
        font-size:12px;
        padding:5px 8px;
        line-height:16px;
        border-radius:2px;
        transition:background .3s
    }
    .article-more-link a:hover {
        background:#3c3c3c
    }
    

    修改为:

    /* 《展开全文按钮 */
     .article-more-link a {
        color:#fff;
        font-size:12px;
        padding:5px 8px;
        line-height:16px;
        border-radius:2px;
        /* Prevent highlight colour when element is tapped */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        /* Smooth fonts */
        -webkit-font-smoothing: antialiased;
        -moz-osx-font-smoothing: grayscale;
    }
    /* Shutter In Horizontal ,from : http://ianlunn.github.io/Hover/ */
     .hvr-shutter-in-horizontal {
        display: inline-block;
        vertical-align: middle;
        -webkit-transform: perspective(1px) translateZ(0);
        transform: perspective(1px) translateZ(0);
        box-shadow: 0 0 1px rgba(0, 0, 0, 0);
        position: relative;
    	/* 在鼠标悬浮时为:蓝色 */
        background: #2098D1;
        -webkit-transition-property: color;
        transition-property: color;
        -webkit-transition-duration: 0.4s;
        transition-duration: 0.4s;
    }
    .hvr-shutter-in-horizontal:before {
        content:"";
        position: absolute;
        z-index: -1;
        top: 0;
        bottom: 0;
        left: 0;
        right: 0;
    	/* 在默认情况下为:灰褐色 */
        background: #4d4d4d;
        -webkit-transform: scaleX(1);
        transform: scaleX(1);
        -webkit-transform-origin: 50%;
        transform-origin: 50%;
        -webkit-transition-property: transform;
        transition-property: transform;
        -webkit-transition-duration: 0.4s;
        transition-duration: 0.4s;
        -webkit-transition-timing-function: ease-out;
        transition-timing-function: ease-out;
    }
    .hvr-shutter-in-horizontal:hover, .hvr-shutter-in-horizontal:focus, .hvr-shutter-in-horizontal:active {
        color: white;
    }
    .hvr-shutter-in-horizontal:hover:before, .hvr-shutter-in-horizontal:focus:before, .hvr-shutter-in-horizontal:active:before {
        -webkit-transform: scaleX(0);
        transform: scaleX(0);
    }
    /* 展开全文按钮》 */
    

    文章首发于:hexo+yilia修改代码块等样式

    展开全文
  • Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序阅读目录构造函数构造代码块静态代码块Java类初始化顺序静态代码块:用staitc声明,jvm加载类时执行,仅执行一次构造代码块:类中直接用{}定义...

    Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序

    静态代码块:用staitc声明,jvm加载类时执行,仅执行一次
    构造代码块:类中直接用{}定义,每一次创建对象时执行。
    执行顺序优先级:静态块,main(),构造块,构造方法。

    构造函数

    public HelloA(){//构造函数
        }

    关于构造函数,以下几点要注意:
    1.对象一建立,就会调用与之相应的构造函数,也就是说,不建立对象,构造函数时不会运行的。
    2.构造函数的作用是用于给对象进行初始化。
    3.一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。

    构造代码块

    {//构造代码块    
    }

    关于构造代码块,以下几点要注意:

    1. 构造代码块的作用是给对象进行初始化。
    2. 对象一建立就运行构造代码块了,而且优先于构造函数执行。这里要强调一下,有对象建立,才会运行构造代码块,类不能调用构造代码块的,而且构造代码块与构造函数的执行顺序是前者先于后者执行
    3. 构造代码块与构造函数的区别是:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。也就是说,构造代码块中定义的是不同对象共性的初始化内容。

    静态代码块

    static {//静态代码块    
    }

    关于静态代码块,要注意的是:

    1. 它是随着类的加载而执行,只执行一次,并优先于主函数。具体说,静态代码块是由类调用的。类调用时,先执行静态代码块,然后才执行主函数的。
    2. 静态代码块其实就是给类初始化的,而构造代码块是给对象初始化的
    3. 静态代码块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    4. 一个类中可以有多个静态代码块
    复制代码
    public class Test{
    staitc int cnt=6;
    static{
          cnt+=9;
    }
    public static void main(String[] args) {
          System.out.println(cnt);
    }
    static{
          cnt/=3;
    }
    }
    运行结果:
    5
    复制代码

    Java类初始化顺序

    ## 对于一个类的情况

    例子1:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
        }
    }
    运行结果:
    A的静态代码块
    复制代码

    例子2:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();    
        }
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    复制代码

    例子3:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();
            HelloA b=new HelloA();
        }
    
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    A的构造代码块
    A的构造函数
    复制代码

    对于一个类而言,按照如下顺序执行:

    1. 执行静态代码块
    2. 执行构造代码块
    3. 执行构造函数

    对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。

    例子4:

    复制代码
     1 public class InitialOrderTest {
     2         /* 静态变量 */
     3     public static String staticField = "静态变量";
     4         /* 变量 */
     5     public String field = "变量";
     6         /* 静态初始化块 */
     7     static {
     8         System.out.println( staticField );
     9         System.out.println( "静态初始化块" );
    10     }
    11         /* 初始化块 */
    12     {
    13         System.out.println( field );
    14         System.out.println( "初始化块" );
    15     }
    16         /* 构造器 */
    17     public InitialOrderTest()
    18     {
    19         System.out.println( "构造器" );
    20     }
    21 
    22 
    23     public static void main( String[] args )
    24     {
    25         new InitialOrderTest();
    26     }
    27 }
    复制代码

    运行以上代码,我们会得到如下的输出结果:

    1. 静态变量

    2. 静态初始化块

    3. 变量

    4. 初始化块

    5. 构造器

    ## 对于继承情况

    例子5:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
    }
    public class HelloB extends HelloA{
        public HelloB(){//构造函数
            System.out.println("B的构造函数");    
        }
        {//构造代码块
            System.out.println("B的构造代码块");    
        }
        static {//静态代码块
            System.out.println("B的静态代码块");        
        }
        public static void main(String[] args) {
            HelloB b=new HelloB();        
        }
    }
    运行结果:
    A的静态代码块
    B的静态代码块
    A的构造代码块
    A的构造函数
    B的构造代码块
    B的构造函数
    复制代码

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

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

     

    例子6:

    复制代码
     1 class Parent {
     2         /* 静态变量 */
     3     public static String p_StaticField = "父类--静态变量";
     4          /* 变量 */
     5     public String    p_Field = "父类--变量";
     6     protected int    i    = 9;
     7     protected int    j    = 0;
     8         /* 静态初始化块 */
     9     static {
    10         System.out.println( p_StaticField );
    11         System.out.println( "父类--静态初始化块" );
    12     }
    13         /* 初始化块 */
    14     {
    15         System.out.println( p_Field );
    16         System.out.println( "父类--初始化块" );
    17     }
    18         /* 构造器 */
    19     public Parent()
    20     {
    21         System.out.println( "父类--构造器" );
    22         System.out.println( "i=" + i + ", j=" + j );
    23         j = 20;
    24     }
    25 }
    26 
    27 public class SubClass extends Parent {
    28          /* 静态变量 */
    29     public static String s_StaticField = "子类--静态变量";
    30          /* 变量 */
    31     public String s_Field = "子类--变量";
    32         /* 静态初始化块 */
    33     static {
    34         System.out.println( s_StaticField );
    35         System.out.println( "子类--静态初始化块" );
    36     }
    37        /* 初始化块 */
    38     {
    39         System.out.println( s_Field );
    40         System.out.println( "子类--初始化块" );
    41     }
    42        /* 构造器 */
    43     public SubClass()
    44     {
    45         System.out.println( "子类--构造器" );
    46         System.out.println( "i=" + i + ",j=" + j );
    47     }
    48 
    49 
    50         /* 程序入口 */
    51     public static void main( String[] args )
    52     {
    53         System.out.println( "子类main方法" );
    54         new SubClass();
    55     }
    56 }
    复制代码

    结果:

    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    子类main方法
    父类--变量
    父类--初始化块
    父类--构造器
    i=9, j=0
    子类--变量
    子类--初始化块
    子类--构造器
    i=9,j=20

    子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。静态变量、静态初始化块,变量、初始化块初始化了顺序取决于它们在类中出现的先后顺序。

    ### 分析

    • (1)访问SubClass.main(),(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类(也就是extends所要表示的意思),于是它再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推。

    • (2)执行根基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化。

    • (3)当所有必要的类都已经装载结束,开始执行main()方法体,并用new SubClass()创建对象。

    • (4)类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数。基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分。

    • (5)对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分。

    原博客:

    Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序

    静态代码块:用staitc声明,jvm加载类时执行,仅执行一次
    构造代码块:类中直接用{}定义,每一次创建对象时执行。
    执行顺序优先级:静态块,main(),构造块,构造方法。

    构造函数

    public HelloA(){//构造函数
        }

    关于构造函数,以下几点要注意:
    1.对象一建立,就会调用与之相应的构造函数,也就是说,不建立对象,构造函数时不会运行的。
    2.构造函数的作用是用于给对象进行初始化。
    3.一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。

    构造代码块

    {//构造代码块    
    }

    关于构造代码块,以下几点要注意:

    1. 构造代码块的作用是给对象进行初始化。
    2. 对象一建立就运行构造代码块了,而且优先于构造函数执行。这里要强调一下,有对象建立,才会运行构造代码块,类不能调用构造代码块的,而且构造代码块与构造函数的执行顺序是前者先于后者执行
    3. 构造代码块与构造函数的区别是:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。也就是说,构造代码块中定义的是不同对象共性的初始化内容。

    静态代码块

    static {//静态代码块    
    }

    关于静态代码块,要注意的是:

    1. 它是随着类的加载而执行,只执行一次,并优先于主函数。具体说,静态代码块是由类调用的。类调用时,先执行静态代码块,然后才执行主函数的。
    2. 静态代码块其实就是给类初始化的,而构造代码块是给对象初始化的
    3. 静态代码块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    4. 一个类中可以有多个静态代码块
    复制代码
    public class Test{
    staitc int cnt=6;
    static{
          cnt+=9;
    }
    public static void main(String[] args) {
          System.out.println(cnt);
    }
    static{
          cnt/=3;
    }
    }
    运行结果:
    5
    复制代码

    Java类初始化顺序

    ## 对于一个类的情况

    例子1:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
        }
    }
    运行结果:
    A的静态代码块
    复制代码

    例子2:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();    
        }
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    复制代码

    例子3:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();
            HelloA b=new HelloA();
        }
    
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    A的构造代码块
    A的构造函数
    复制代码

    对于一个类而言,按照如下顺序执行:

    1. 执行静态代码块
    2. 执行构造代码块
    3. 执行构造函数

    对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。

    例子4:

    复制代码
     1 public class InitialOrderTest {
     2         /* 静态变量 */
     3     public static String staticField = "静态变量";
     4         /* 变量 */
     5     public String field = "变量";
     6         /* 静态初始化块 */
     7     static {
     8         System.out.println( staticField );
     9         System.out.println( "静态初始化块" );
    10     }
    11         /* 初始化块 */
    12     {
    13         System.out.println( field );
    14         System.out.println( "初始化块" );
    15     }
    16         /* 构造器 */
    17     public InitialOrderTest()
    18     {
    19         System.out.println( "构造器" );
    20     }
    21 
    22 
    23     public static void main( String[] args )
    24     {
    25         new InitialOrderTest();
    26     }
    27 }
    复制代码

    运行以上代码,我们会得到如下的输出结果:

    1. 静态变量

    2. 静态初始化块

    3. 变量

    4. 初始化块

    5. 构造器

    ## 对于继承情况

    例子5:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
    }
    public class HelloB extends HelloA{
        public HelloB(){//构造函数
            System.out.println("B的构造函数");    
        }
        {//构造代码块
            System.out.println("B的构造代码块");    
        }
        static {//静态代码块
            System.out.println("B的静态代码块");        
        }
        public static void main(String[] args) {
            HelloB b=new HelloB();        
        }
    }
    运行结果:
    A的静态代码块
    B的静态代码块
    A的构造代码块
    A的构造函数
    B的构造代码块
    B的构造函数
    复制代码

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

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

     

    例子6:

    复制代码
     1 class Parent {
     2         /* 静态变量 */
     3     public static String p_StaticField = "父类--静态变量";
     4          /* 变量 */
     5     public String    p_Field = "父类--变量";
     6     protected int    i    = 9;
     7     protected int    j    = 0;
     8         /* 静态初始化块 */
     9     static {
    10         System.out.println( p_StaticField );
    11         System.out.println( "父类--静态初始化块" );
    12     }
    13         /* 初始化块 */
    14     {
    15         System.out.println( p_Field );
    16         System.out.println( "父类--初始化块" );
    17     }
    18         /* 构造器 */
    19     public Parent()
    20     {
    21         System.out.println( "父类--构造器" );
    22         System.out.println( "i=" + i + ", j=" + j );
    23         j = 20;
    24     }
    25 }
    26 
    27 public class SubClass extends Parent {
    28          /* 静态变量 */
    29     public static String s_StaticField = "子类--静态变量";
    30          /* 变量 */
    31     public String s_Field = "子类--变量";
    32         /* 静态初始化块 */
    33     static {
    34         System.out.println( s_StaticField );
    35         System.out.println( "子类--静态初始化块" );
    36     }
    37        /* 初始化块 */
    38     {
    39         System.out.println( s_Field );
    40         System.out.println( "子类--初始化块" );
    41     }
    42        /* 构造器 */
    43     public SubClass()
    44     {
    45         System.out.println( "子类--构造器" );
    46         System.out.println( "i=" + i + ",j=" + j );
    47     }
    48 
    49 
    50         /* 程序入口 */
    51     public static void main( String[] args )
    52     {
    53         System.out.println( "子类main方法" );
    54         new SubClass();
    55     }
    56 }
    复制代码

    结果:

    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    子类main方法
    父类--变量
    父类--初始化块
    父类--构造器
    i=9, j=0
    子类--变量
    子类--初始化块
    子类--构造器
    i=9,j=20

    子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。静态变量、静态初始化块,变量、初始化块初始化了顺序取决于它们在类中出现的先后顺序。

    ### 分析

    • (1)访问SubClass.main(),(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类(也就是extends所要表示的意思),于是它再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推。

    • (2)执行根基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化。

    • (3)当所有必要的类都已经装载结束,开始执行main()方法体,并用new SubClass()创建对象。

    • (4)类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数。基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分。

    • (5)对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分。

    原博客:https://www.cnblogs.com/Qian123/p/5713440.html

    展开全文
  • 静态代码块和普通代码块的区别

    千次阅读 2019-12-03 11:11:48
    static{}静态代码块与{}普通代码块之间的区别 //class A package com.my.test; class A { static { System.out.println("A1:父类静态代码区域"); } { System.out.println("A2:父类非静态代码...
  • 五:代码块

    千次阅读 2020-10-09 19:25:06
    在程序中使用“{}”定义的结构就称为代码块,而后根据代码块出现的位置以及定义的关键词的不同,代码块可以分为:普通代码块、构造代码块、静态代码块和同步代码块,其中对于同步代码块会在多线程中进行讲解。...
  • 怎么给Typora的代码块设置默认语言?

    千次阅读 多人点赞 2021-08-25 22:21:49
    不知道大家用Typora写笔记的时候,有没有觉得加完代码块后,去填语言很麻烦?像下面这样: 经过一番探索后(网上还真没搜到,哭。。。),发现使用ahk脚本可以解决这个问题。 操作如下: 1、链接下载ahk。...
  • 静态代码块:最早执行,类被载入内存时执行,只执行一次。没有名字、参数和返回值,有关键字static。构造代码块:执行时间比静态代码块晚,比构造函数早,和构造函数一样,只在对象初始化的时候运行。没有名字、参数...
  • 目录例子尝试用途 例子 以引用Markdown的数学公式为例。 ...这是个数学公式,但是想打出源代码(比如说想介绍一下这个代码的使用)的时候却不知道该怎么操作了。...其实有的人想到了,直接在外面...如何引用代码块符号?
  • MarkDown 代码块

    千次阅读 2020-12-06 16:04:59
    MarkDown 代码块 1、代码行 单行代码引用使用单个符号,反引号(`),就是英文状态下的波浪线。(符号位于 ESC 键下方) `我是代码行` 我是代码行 2、代码块 用三个反引号(`)定义段开始和结束 ````# 显示...
  • 变种面试题 原因: 冷知识 case4:子类和父类有`同名同类型`的`静态`变量的时候 case5:静态代码块属于类的,并且优先于main方法执行(有难度) 注解对执行顺序的影响 继续补充:子类默认调用`父类构造函数`问题 ...
  • 例2、利用逗号运算符 由于代码块嵌套到static变量的初始化中,所以可保证代码块仅被执行一次: void initszArrCountryCode() { for (i=0; i; i++) { szArrCountryCode[i] = -1; } } static bool dummy = ...
  • 1. 静态代码块在类加载时即运行,而且只运行一次,并且优先于各种代码块以及构造函数运行。如果一个类中有多个静态代码块,会按照书写顺序依次执行。静态代码块不能访问普通变量(普通变量只能通过对象来调用)。 2. ...
  • Java 实现折叠代码块

    千次阅读 2020-10-16 15:28:32
    折叠代码块 C#中用 #region和#endregion java中用 //region和//endregion
  • java静态代码块与非静态代码块比较

    千次阅读 2018-10-23 00:20:45
    得出结论1:非静态代码块不会在调用方法与成员时执行.     结论2:非静态代码块在创建实例时...结论4:静态代码块优先非静态代码块优先构造函数,无论如何访问类(实例化,调用函数,成员),都会执行静态代码块 ...
  • Typora代码块字体修改

    千次阅读 2020-03-19 16:32:44
    升级了 Linux 系统,发现 Typora 代码块中的字体不是等宽的,看起来很别扭 :>_<: 得改! 按照官方文档,需要在 themes 目录下添加 base.user.css 文件,写入用户自定义的样式。比如针对上述需求,我增加了如下...
  • Obsidian 代码块高亮

    千次阅读 2021-07-14 11:18:02
    使用插件 Syntax Highlight 效果 安装方式 Open Settings > Third-party plugin Make sure Safe mode is off Click Browse community plugins Search for “Syntax Highlight” Click Install ...
  • Static代码块(静态代码块

    千次阅读 2019-08-20 10:06:56
    静态代码块的格式是: public class 类名称{ static{ //静态代码块的内容 } } 特点:当第一次用到本类时,静态代码块执行唯一的一次 静态内容总是优先于非静态,所以静态代码块比构造方法先执行 静态...
  • java中静态代码块详解

    万次阅读 多人点赞 2019-04-17 18:05:42
    今天在项目中看到这行代码,静态代码块,很久没用静态代码块了,今天来复习一下, 依旧按照为什么?是什么?怎么用?的思想,去学习。 【为什么?】 先说说代码中为什么要使用这种写法吧, 还记得静态代码块的...
  • 构造代码块与静态代码块1.构造代码块:每次创建对象时执行 2.静态代码块:JVM加载类(加载在运行之前)时执行,静态代码块只执行一次 3.public static B t1 = new B();也是静态代码块 4.执行顺序:静态代码块>...
  • Latex 插入代码块

    千次阅读 2020-10-30 19:25:19
    Latex 插入代码块 导言栏代码如下(Mac版): \usepackage{listings} \usepackage{xcolor} \lstset{ language=Matlab, %代码语言使用的是matlab frame=shadowbox, %把代码用带有阴影的框圈起来 rulesepcolor=\...
  • word插入漂亮的代码块

    万次阅读 多人点赞 2021-04-09 21:27:41
    前言 在写毕业论文的时候不可避免...缺点:代码块在word文档中没有分隔与突出的效果。 适用场景:作为技术文档非常实用,方便技术人员查看。 借助网页的渲染格式 方式最简单,借助某些帮助网址即可。 原本流传较广的
  • 详解java中的四种代码块

    万次阅读 多人点赞 2018-03-09 16:52:07
    详解java中的四种代码块 转载 2017-12-07 作者:krisll 我要评论 这篇文章主要介绍了详解java中的四种代码块,具有一定借鉴价值,需要的朋友可以参考下。 在java中用{}括起来的...
  • python 动态执行代码块

    千次阅读 2019-10-24 14:03:24
    exec() 无返回值,可以动态执行复杂的代码块 eval() 有返回值,只能执行简单的表达式代码块 在这里先简单的对exec()进行介绍,eval()后期再进行更新 exec()执行样例: # -*- coding: utf-8 -*- if __name__ == '__...
  • welcome to my blog 折叠当前代码块ctrl - 展开当前代码块ctrl = 折叠所有代码块ctrl shift - 展开所有代码块ctrl shift +
  • C语言代码块

    万次阅读 多人点赞 2018-10-26 08:12:48
    代码块: #include #include int main() { int a,b,c,max,min; scanf("%d,%d,%d",&a,&b,&c); max=a>b?a:b; min=a; if(c>max) max=c; else if(c) min=c; printf("%d,%d\n",max,min); } 九、求一年中的某...
  • Markdown使用技巧总结:代码块折叠

    千次阅读 2020-04-09 11:00:44
    md文件中代码块折叠的源码如下:
  • Java使用同步代码块

    千次阅读 2019-05-26 20:25:19
    为了解决线程安全问题,Java的多线程支持引入了同步监视器来解决这个问题,使用 同步监视器的通用方法就是同步代码块。 同步代码块的语法格式如下: synchronized(obj) { //同步代码块 } } obj叫做同步监视...
  • java静态代码块代码块执行顺序

    千次阅读 2019-04-12 16:07:52
    java静态代码块代码块执行顺序 先执行static方法,再执行普通方法,最后执行构造方法。 eg: package other; class B { public B() { super(); System.out.println("构造器B"); } { System.out.println...
  • 无论是内联的代码还是单独的代码块,都需要使用它,只是个数的差别,比如 ` 和 ```````````。 那么如何能够在代码片中输入反引号(backtick)呢? 方法是:用两个反引号来包裹。 本文内容内联代码中包含反引号内联...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,011,360
精华内容 804,544
关键字:

代码块