精华内容
下载资源
问答
  • 2019-10-16 19:56:49

    前言
    在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
    最后,博主并不是什么大牛,也会犯错!如有不正之处欢迎指正!感激不尽!

    更多相关内容
  • 代码块是什么?该如何使用?

    千次阅读 2022-01-23 17:43:25
    代码块又叫初始化块,属于类中的成员,即使类的一部分 类似于方法,将逻辑语句封装在方法提中,通过{ }包围起来。但和方法不同,没有方法名,没有返回值,没有参数,只有方法体,而且不用通过对象或类显示调用,而是...

    1、代码块的基本介绍

    代码块又叫初始化块,属于类中的成员,即使类的一部分 类似于方法,将逻辑语句封装在方法提中,通过{ }包围起来。但和方法不同,没有方法名,没有返回值,没有参数,只有方法体,而且不用通过对象或类显示调用,而是在加载类的时候或者创建对象的时候隐式调用。

    基本语法
    [修饰符]{
    代码
    };

    注意:
    1、修饰符可以选,要写的话也只能写 static
    2、代码块分为两类,使用static的叫静态代码块,没有static的叫做普通代码块
    3、代码中可以为任意逻辑语句例如:输入,输出,方法调用,循环,判断
    4、 ; 号可以写上也可以省略

    2、代码块的好处

    1、对构造器功能的一种补充
    2、如果多个构造器中都有重复的语句,可以放到代码块中,提高代码的复用性

    三个构造器都有重复的语句,看起来特别的多余

    public class codeblock01 {
    
        public static void main(String[] args) {
        book book = new book("数据结构与算法");
    	System.out.println("========================");
        book book1 = new book("kali从入门到入狱", 100, "呀吖呀");
        }
    
    }
    
    class book{
        private String name;
        private double price;
        private String author;
        //3个构造器,构成了重载
    
        public book(String name) {
            System.out.println("书被打开了");
            System.out.println("书被合上了");
            System.out.println("构造器public book(String name)被调用");
            this.name = name;
        }
    
        public book(String name, double price) {
            System.out.println("书被打开了");
            System.out.println("书被合上了");
            this.name = name;
            this.price = price;
        }
    
        public book(String name, double price, String author) {
            System.out.println("书被打开了");
            System.out.println("书被合上了");
            System.out.println("构造器public book(String name, double price, String author)被调用");
            this.name = name;
            this.price = price;
            this.author = author;
        }
    }
    

    可以把一样的语句放到一个代码块中即可当我们不管调用哪个构造器,创建对象,都会调用代码块中的代码

    3、普通代码块

    
    public class codeblock01 {
        public static void main(String[] args) {
        book book = new book("数据结构与算法");
    	System.out.println("========================");
        book book1 = new book("kali从入门到入狱", 100, "呀吖呀");
        }
    
    }
    
    class book{
        private String name;
        private double price;
        private String author;
        //3个构造器,构成了重载
        //三个构造器都有重复的语句,看起来特别的多余
        //可以把一样的语句放到一个代码块中即可
        {
            System.out.println("书被打开了");
            System.out.println("书被合上了");
        }
        public book(String name) {
            //System.out.println("书被打开了");
            //System.out.println("书被合上了");
            System.out.println("构造器public book(String name)被调用");
            this.name = name;
        }
    
        public book(String name, double price) {
            //System.out.println("书被打开了");
            //ystem.out.println("书被合上了");
            this.name = name;
            this.price = price;
        }
    
        public book(String name, double price, String author) {
            //System.out.println("书被打开了");
            //System.out.println("书被合上了");
            System.out.println("构造器public book(String name, double price, String author)被调用");
            this.name = name;
            this.price = price;
            this.author = author;
        }
    }
    

    这个代码的运行结果都是:
    运行结果

    说明:代码块的调用是优先于构造器的!

    4、静态代码块

    static代码块叫静态代码块,作用是对类进行初始化它随着类的加载进行初始化,而且随着类的加载而被执行并且只会执行一次,如果是普通代码块,每次创建一个对象就执行一次。

    先看一段代码

    public class codeblock02 {
        public static void main(String[] args) {
            A a = new A();
            
        }
    }
    class A{
    
        //静态代码块
        static {
            System.out.println("A的静态代码块正在被执行");
        }
    }
    

    执行结果为
    执行结果为

    得到结论
    创建对象实例的时候也就是new的时候。

    我们在让A类去继承B类

    public class codeblock02 {
        public static void main(String[] args) {
            A a = new A();
    
        }
    }
    class A extends B{
    
        //静态代码块
        static {
            System.out.println("A的静态代码块正在被执行");
        }
    }
    class B {
        static {
            System.out.println("B的静态代码块正在被执行");
        }
    }
    

    执行结果

    得到结论
    创建子类对象实例,父类也会被加载,父类先被加载,子类后被加载。

    看这段代码

    public class codeblock02 {
        public static void main(String[] args) {
            System.out.println(C.n1);
    
        }
    }
    class C{
        public static int n1 = 10000;
        static {
            System.out.println("C的静态代码块正在被执行");
        }
    }
    
    

    执行结果为
    执行图片

    得到结论
    使用类的静态成员时,例如:静态成员,静态方法。

    看这段代码

    public class codeblock02 {
        public static void main(String[] args) {
            D d = new D();
            D d1 = new D();
    
        }
    }
    
    class D{
        static {
            System.out.println("D的静态代码块被调用");
        }
        {
            System.out.println("D的普通代码块被调用");
        }
    }
    

    输出的结果
    输出的结果
    说明
    静态代码块作用是对类进行初始化它随着类的加载进行初始化,而且随着累的加载而被执行并且只会执行一次
    如果是普通代码块,每次创建一个对象就执行一次。

    public class codeblock02 {
        public static void main(String[] args) {
            System.out.println(D.n1);
        }
    }
    
    class D{
        public static int n1 = 10000;
        static {
            System.out.println("D的静态代码块被调用");
        }
        {
            System.out.println("D的普通代码块被调用");
        }
    }
    

    输出结果为
    输出结果

    说明
    普通代码块需要在new对象的时候才会被调用,而且是每次创建新对象就会被调用。
    而静态代码块,只要类加载了就会被调用。

    5、类什么时候被加载!!

    • 1、创建对象实例的时候也就是new的时候
    • 2、创建子类对象实例,父类也会被加载,父类先被加载,子类后被加载
    • 3、使用类的静态成员时,例如:静态成员,静态方法

    6、创建一个对象时,在一个类中,调用顺序是怎么样的

    1. 先调用静态代码块和静态属性初始化。静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码和多个静态变量初始化,就按照定义的顺序执行
    2. 调用普通代码块和普通属性的初始化。普通代码块和普通属性的优先级一样,这个和上面的一样
    3. 最后在调用构造方法

    看代码

    public class codeblock03 {
        public static void main(String[] args) {
            AS as = new AS();
        }
    
    }
    class AS{
    
    
        static {
            System.out.println("AS的静态代码块被调用");
        }
        private static int n1 = getN1();
    
        public static int getN1(){
            System.out.println("getN1方法被调用");
            return 10000;
        }
        private int n2 = getN2();
    
        public int getN2(){
            System.out.println("getN2方法被调用");
            return 90000;
        }
    
        {
            System.out.println("AS的普通代码块被调用");
        }
    
    
        public AS(){
            System.out.println("无参构造器被调用");
        }
    }
    

    运行结果为

    运行结果

    7、存在继承关系时候调用的顺序为

    1. 父类的静态代码块和静态属性(优先级一样)
    2. 子类的静态代码块和静态属性(优先级一样)
    3. 父类的普通代码块和普通属性初始化
    4. 父类的构造方法
    5. 子类的普通代码块和子类的普通属性初始化
    6. 子类的构造方法

    注意: 静态代码块只能直接调用静态成员普通代码块可以调用任意成员

    public class codeblock04 {
        public static void main(String[] args) {
            ZL zl = new ZL();
        }
    }
    
    class ZL extends FL{
        private static int A = getA();
        private int A1 = getA1();
    
        public static int  getA(){
            System.out.println("子类的静态方法被调用");
            return 111;
        }
    
        public int getA1(){
            System.out.println("子类的普通方法被调用");
            return 222;
        }
    
        static {
            System.out.println("子类的静态代码块被调用");
        }
    
        {
            System.out.println("子类的普通代码块被调用");
        }
    
        public ZL(){
            System.out.println("子类的构造器被调用");
        }
    }
    
    class FL{
        private static int B = getB();
        private int B1 = getB1();
    
        public static int getB(){
            System.out.println("FL父类的静态方法被调用");
            return 888;
        }
    
        public int getB1(){
            System.out.println("FL父类的普通方法被调用");
            return 999;
        }
    
        static {
            System.out.println("FL父类的静态代码块被调用");
        }
    
        {
            System.out.println("FL父类的普通代码块被调用");
        }
    
        public FL() {
            System.out.println("FL父类的构造器被调用");
        }
    }
    
    

    对代码进行分析
    父类
    子类

    运行结果为:
    运行结果为

    展开全文
  • 【Java基础知识 17】聊一聊同步代码块

    千次阅读 多人点赞 2022-05-08 15:09:12
    以关键字synchronized来修饰的方法就是一种横跨整个方法体的同步代码块,其中该同步代码块的锁就是方法调用所在的对象。静态的synchronized方法以Class对象作为锁。 synchronized(lock){ //访问或修改由锁保护的...

    在这里插入图片描述

    一、什么是内置锁?

    Java提供了一种内置的锁机制来支持原子性:同步代码块。
    同步代码块包含两部分:一个作为锁的对象引用,一个作为由这个锁保护的代码块。以关键字synchronized来修饰的方法就是一种横跨整个方法体的同步代码块,其中该同步代码块的锁就是方法调用所在的对象。静态的synchronized方法以Class对象作为锁。

    synchronized(lock){
    	//访问或修改由锁保护的共享状态
    }
    

    每个Java对象都可以用做一个实现同步的锁,这些锁被称为内置锁。线程在进入同步代码块之前会自动获取锁,并且在退出同步代码块时自动释放锁,而无论是通过正常的控制路径退出,还是通过从代码块中抛出异常退出。获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法。
    Java的内置锁相当于一个互斥体,这意味着最多只有一个线程能持有这种锁。当线程A尝试获取一个由线程B持有的锁时,线程A必须等待或阻塞。直到线程B释放这个锁。如果线程B永远不释放锁,那么A也将永远等待下去。
    由于每次只能有一个线程执行内置锁保护的代码块,因此,由这个锁保护的同步代码块会以原子方式执行,多个线程在执行该代码块时也不会相互干扰。并发环境中的原子性与事务应用程序中的原子性有着相同的含义,一组语句作为一个不可分割的单元被执行。任何一个执行同步代码块的线程,都不可能看到有其它线程正在执行由同一个锁保护的同步代码块。

    二、什么是重入?

    当某个线程请求一个由其他线程持有的锁时,发出请求的线程就会阻塞。然而,由于内置锁是可重入的,因此如果某个线程试图获得一个已经由它自己持有的锁,那么这个请求就会成功。重入意味着获取锁的操作的粒度是线程,而不是调用。重入的一种实现方法是为每个锁关联一个获取计数值和一个所有者线程。当计数值为0时,这个锁被认为是没有被任何线程持有。当线程请求一个未被持有的锁时,JVM将记下锁的持有者,并且将获取计数值置为1。如果同一个线程再次获取这个锁,计数值将递增,而当线程退出同步代码块时,计数器会响应地递减。当计数值为0时,这个锁将被释放。

    package com.guor.util;
    
    public class Father {
        public synchronized void say(){
            System.out.println("我是父类");
        }
    }
    
    package com.guor.util;
    
    public class Son extends Father {
        public synchronized void say(){
            System.out.println(toString()+"call say()");
            super.say();
        }
    
        public static void main(String[] args) {
            Son son = new Son();
            son.say();
        }
    }
    
    

    重入进一步提升了加锁行为的封装性,因此简化了面向对象并发代码的开发。在上面代码中,子类改写了父类的synchronized方法,然后调用父类中的方法,此时如果没有可重入的锁,那么这段代码将产生死锁。由于Father和Son中say方法都是synchronized方法,因此每个say方法在执行前都会获取Father上的锁。然而,如果内置锁不是可重入的,那么在调用super.say时将无法获得Father上的锁,因为这个锁已经被持有,从而线程将永远停顿下去,等待一个永远也无法获得的锁。重入则避免了这种死锁情况的发生。

    三、活跃性与性能

    要确保同步代码块不要过小,并且不要将本应是原子的操作拆分到多个同步代码块中。应该尽量将不影响共享状态且执行时间较长的操作从同步代码块中分离出去,从而在这些操作的执行过程中,其它线程可以访问共享状态。
    在获取与释放锁的操作上都需要一定的开销,因此如果将同步代码块分解得过细,那么通常并不好,尽管这样做不会破坏原子性。当访问状态变量或者在复合操作的执行期间,需要持有锁,但在执行时间较长的因数分解运算之前要释放锁。这样既确保了线程安全性,也不会过多地影响并发性,并且在每个同步代码块中的代码路径都“足够短”。
    要判断同步代码块的合理大小,需要在各种设计需求之间进行权衡,包括安全性、简单性、性能。
    当使用锁时,你应该清楚代码块中实现的功能,以及在执行该代码块时是否需要很长的时间,无论是执行计算密集的操作,还是在执行某个可能阻塞的操作,如果持有锁的时间过长,那么都会带来活跃性或性能的问题。
    当执行时间较长的计算或者可能无法快速完成的操作时(例如网络IO或控制台IO),一定不要持有锁。

    四、对象的共享

    1、可见性

    可见性是一种复杂的属性,因为可见性中的错误总是会违背我们的直觉。在单线程环境中,如果向某个变量写入值,然后在没有其他写入操作的情况下读取这个变量,那么总能得到相同的值。这听起来很自然。然而,当读操作和写操作在不同的线程中执行时,情况却并非如此,这听起来或许有些难以接受。通常,我们无法保证执行读操作的线程能实时地看到其它线程写入的值,优势甚至是不可能的事情。为了确保多个线程之间对内存写入操作的可见性,必须使用同步机制。

    2、非原子的64位操作

    当线程在没有同步的情况下读取变量时,可能会得到一个失效值,但至少这个值是由之前某个线程设置的值,而不是一个随机值。这种安全性保证也被称为最低安全性。
    最低安全性适用于绝大多数变量,但是存在一个例外:非volatile类型的64位数值变量(double和long)。Java内存模型要求,变量的读取操作和写入操作都必须是原子操作,但对于非volatile类型的longdouble变量,JVM允许将64位的读操作或写操作分解为两个32位的操作。当读取一个非volatile类型的long变量时,如果对该变量的读操作和写操作在不同的线程中执行,那么很可能会读取到某个值的高32位和另一个值的低32位。因此,即使不考虑失效数据问题,在多线程程序中使用共享且可变的longdouble类型的变量也是不安全的,除非用关键字volatile来声明它们,或者用锁保护起来。

    3、volatile变量

    Java语言提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此不会将该变量上的操作与其它内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其它处理器不可见的地方,因此在读取volatile类型的变量时总会返回最新写入的值。
    从内存可见性的角度来看,写入volatile变量相当于退出同步代码块,读取volatile变量就相当于进入同步代码块。然而,我们并不建议过度依赖volatile变量提供的可见性。如果在代码中依赖volatile变量来控制状态的可见性,通常比使用锁的代码更加脆弱,也更难以理解。
    加锁机制既可以确保可见性又可以确保原子性,而volatile变量只能确保可见性。
    当满足以下所有条件时,才应该使用volatile变量。

    1. 当变量的写入操作不依赖变量的当前值,或者你能确保只有单个线程更新变量的值。
    2. 该变量不会与其它状态变量一起纳入不变性条件中。
    3. 在访问变量时不需要加锁。

    上一篇:Java学习路线总结,搬砖工逆袭Java架构师

    下一篇:Java基础教程系列

    展开全文
  • VSCode 添加代码块

    千次阅读 2021-04-02 16:28:34
    在iOS开发中,我们经常使用Xcode里面的代码块,来提高开发效率。把平时经常使用到的方法,或者是代码比较多的方法,弄个代码块,就不需要一个一个字符去敲了,非常方便。 那么在使用VSCode的时候,我们也想和使用...

     

    目录

    1.打开VSCode设置

    2.选择代码块文件或者创建代码块

    3.选择需要设置的文件类型

     4.具体使用


    在iOS开发中,我们经常使用Xcode里面的代码块,来提高开发效率。把平时经常使用到的方法,或者是代码比较多的方法,弄个代码块,就不需要一个一个字符去敲了,非常方便。

    那么在使用VSCode的时候,我们也想和使用Xcode一样,设置代码块,方便平时开发调用,该如何去设置呢???请耐心往下看👇

    1.打开VSCode设置

    找到设置里面的“User Snippets”(用户代码片段)

    2.选择代码块文件或者创建代码块

     这里列出了比较常用的文件类型,HTMLJavaScriptVue等后缀的文件,我们选择其中的一个文件类型的.json文件进去设置就可以了

    3.选择需要设置的文件类型

     进入需要设置文件里面去设置Json

     

     

    1. prefix :这个参数是使用代码段的快捷入口,比如这里的log在使用时输入Iog会有智能提示。
    2.  body :这个是代码段的主体.需要设置的代码放在这里,字符串间换行的话使用\r\n换行符隔开.注意如果值里包含特殊字符需要进行转义。多行语句的以逗号,隔开
    3. $1 :这个为光标的所在位置
    4. $2 :使用这个参数后会光标的下一位置将会另起一行,按tab键可进行快速切换,还可以有$3,$4,$5.....
    5. description :代码段描述,在使用时智能提示时的描述

    我上面已经写了两个例子了,第一个是JavaScript,第二个是CSS 的样式Style

     4.具体使用

    我们使用的时候,就是在你设置后缀类型的文件中去使用就可以了,如图,我输入js两个字符,就自动提示出来了我设置的代码块,一回车就自动填充了设置好的代码块,如下图

     

    哈哈😁是不是很简单啊!毫无难度,步骤少,设置简单,赶紧自己动手去试试吧!😁

     

     

     

     

    展开全文
  • 代码块

    千次阅读 2019-05-05 20:41:17
    代码块:就是用{}扩起来的代码。 根据位置和关键字的不同分为普通代码块、构造块、静态代码块、同步代码块。 1、普通代码块:就是直接在方法或语句中定义的代码块。 public class CodeDemo01 { public static void ...
  • Pycharm/VSCode等集成开发环境里的代码直接复制贴到 Word 里,会保持代码高亮的效果。或者使用 Typora/Notepad++ 等软件转化样式再贴到Word。 以及利用现有的 MarkDown 排版工具的代码高亮,然后再贴到Word,比如:...
  • java中静态代码块详解

    千次阅读 2021-02-26 12:43:02
    今天在项目中看到这行代码,静态代码块,很久没用静态代码块了,今天来复习一下,依旧按照为什么?是什么?怎么用?的思想,去学习。【为什么?】先说说代码中为什么要使用这种写法吧,还记得静态代码块的特点吗?...
  • hexo+yilia修改代码块等样式

    千次阅读 2019-11-13 16:03:24
    代码块的样式真的很重要,毕竟咱好歹是一个技术博客,难免会贴一些代码的。
  • Java 多线程 —— 同步代码块(解决线程安全问题)

    千次阅读 多人点赞 2021-10-23 19:59:26
    目录火车站抢票问题同步代码块同步方法(this锁)同步方法,在public的后面加上synchronized关键字this锁静态同步方法 火车站抢票问题 由于现实中买票也不会是零延迟的,为了真实性加入了延迟机制,也就是线程休眠...
  • 五:代码块

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

    千次阅读 多人点赞 2020-05-31 11:22:14
    静态代码块及多种代码块的相关知识
  • latex插入代码块

    千次阅读 2021-12-13 13:57:43
    \usepackage{listings}%插入代码块 在需要添加代码的地方 \begin{lstlisting}[language = Matlab,title={matlab4\_8.m}, numbers=left, numberstyle=\tiny,keywordstyle=\color{blue!70}, commentstyle=\color{...
  • 如何word里面插入代码块

    万次阅读 2021-07-18 16:22:29
    写一些有关编程的技术报告的时候,既要用到word、又要用到代码块,那么如何在word中插入代码块呢?下面小虎就来详细讲述。
  • 在大佬的一篇推文中,看到了一个非常好看的代码块,百度了许久都没有找到具体的实现方法,最后终于在jrs的帮助下成功实现了。 实现 1.进入Vs Code,新建 .md文件 2.输入如下代码: <html> <style> ....
  • MarkDown 代码块

    万次阅读 2020-12-06 16:04:59
    MarkDown 代码块 1、代码行 单行代码引用使用单个符号,反引号(`),就是英文状态下的波浪线。(符号位于 ESC 键下方) `我是代码行` 我是代码行 2、代码块 用三个反引号(`)定义段开始和结束 ````# 显示...
  • Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序阅读目录构造函数构造代码块静态代码块Java类初始化顺序静态代码块:用staitc声明,jvm加载类时执行,仅执行一次构造代码块:类中直接用{}定义...
  • 静态代码块和普通代码块的区别

    千次阅读 2019-12-03 11:11:48
    static{}静态代码块与{}普通代码块之间的区别 //class A package com.my.test; class A { static { System.out.println("A1:父类静态代码区域"); } { System.out.println("A2:父类非静态代码...
  • 静态代码块和非静态代码块什么时候执行? 静态代码块随着类的加载而加载,非静态代码块随着对象的加载而加载 所以静态代码块再调用类的时候执行。非静态代码块创建对象时或者通过反射获取其类信息的时候执行 .........
  • 我主页中的思维导图中内容大多从我的笔记中整理而来,相应技巧可在笔记中查找原题, 有兴趣的可以去 我的主页了解更多计算机学科的精品思维导图整理 本文可以转载,但请注明来处...2.将力扣中的代码以原格式复制到On...
  • 怎么给Typora的代码块设置默认语言?

    千次阅读 多人点赞 2021-08-25 22:21:49
    不知道大家用Typora写笔记的时候,有没有觉得加完代码块后,去填语言很麻烦?像下面这样: 经过一番探索后(网上还真没搜到,哭。。。),发现使用ahk脚本可以解决这个问题。 操作如下: 1、链接下载ahk。...
  • Word中添加代码块

    千次阅读 2021-10-18 22:45:36
    当我们需要在word里面添加一块具有代码高亮、并且带有行号的代码块,而word本身不支持这个功能,我们应该怎么办呢? 可以在CodeInWord(点此进入)网站中,在左侧粘贴你所需要的代码,接着点击高亮键,右边即生成所...
  • 自定义Typora代码块样式

    千次阅读 2021-11-30 16:47:33
    对于代码的颜色自己喜欢比较瞎搞,今天分享如何让自定义Typora代码块颜色 CodeMirror: Theme Demo在这个网站中选择自己想要的代码块主题 Index of /theme/ (codemirror.net)在这个网站中找到对应的CSS文件,点击 ...
  • 例2、利用逗号运算符 由于代码块嵌套到static变量的初始化中,所以可保证代码块仅被执行一次: void initszArrCountryCode() { for (i=0; i; i++) { szArrCountryCode[i] = -1; } } static bool dummy = ...
  • 静态代码块:最早执行,类被载入内存时执行,只执行一次。没有名字、参数和返回值,有关键字static。构造代码块:执行时间比静态代码块晚,比构造函数早,和构造函数一样,只在对象初始化的时候运行。没有名字、参数...
  • Java 实现折叠代码块

    千次阅读 2020-10-16 15:28:32
    折叠代码块 C#中用 #region和#endregion java中用 //region和//endregion
  • 目录例子尝试用途 例子 以引用Markdown的数学公式为例。 ...这是个数学公式,但是想打出源代码(比如说想介绍一下这个代码的使用)的时候却不知道该怎么操作了。...其实有的人想到了,直接在外面...如何引用代码块符号?
  • 1. 静态代码块在类加载时即运行,而且只运行一次,并且优先于各种代码块以及构造函数运行。如果一个类中有多个静态代码块,会按照书写顺序依次执行。静态代码块不能访问普通变量(普通变量只能通过对象来调用)。 2. ...
  • 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 ...
  • word插入漂亮的代码块

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,101,640
精华内容 840,656
关键字:

代码块