代码块,执行顺序,类加载,创建对象

这篇具有很好参考价值的文章主要介绍了代码块,执行顺序,类加载,创建对象。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  1. 代码块又称初始化块,属于类中的成员【即 是类的一部分】,类似于方法,将逻辑语句封装在方法体中,通过{}包围起来
  2. 和方法不同,没有方法名,没有返回值,没有参数,只有方法体,而且不用通过对象或类显示调用,而是加载类时,或创建对象时隐式调用。
  3. 基本语法
    1. [修饰符]{代码};
    2. 注意说明:修饰符可选,要写的话只能写static
    3. 有static是静态代码块,没有static就是非静态代码块
    4. 代码部分可以是任何逻辑语句
    5. ;号可以写上,也可以省略。
  4. 解释:
    package com.hspedu.codeblock_;
    
    public class CodeBlock01 {
        public static void main(String[] args) {
            Movie movie = new Movie("你好,李焕英");
        }
    }
    class Movie{
        private String name="战狼";
        private double price;
        private String director;
    
        //3个构造器重载
        //1.下面3个构造器都有相同的语句,冗余
        //2.这时就把相同的语句,放在一个代码块中,解决冗余
        //3.这样当我们不管调用那个构造器都会先调用代码块
        //4.代码块的调用优先与构造器
        {
            System.out.println("电影屏幕打开...");
            System.out.println("广告开始...");
            System.out.println("电影正式开始...");
        }
        public Movie(String name) {
            System.out.println(name+"Movie(String name)");
            this.name = name;//这条语句就是把战狼改成了你好,李焕英
            System.out.println(name);//你好,李焕英
            System.out.println(this.name);//你好,李焕英
        }
    
        public Movie(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public Movie(String name, double price, String director) {
            this.name = name;
            this.price = price;
            this.director = director;
        }
    }
    /*
    电影屏幕打开...
    广告开始...
    电影正式开始...
    你好,李焕英Movie(String name)
    你好,李焕英
    你好,李焕英
     */
    
  5. 代码块使用细节(非常重要

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

    2. 类什么时候加载

      1. 创建对象实例时(new)

      2. 创建子类对象实例,父类也会被加载

      3. 使用类的静态成员时(静态属性,静态方法)

      4. package com.hspedu.codeblock_;
        
        public class CodeBlockDetail01 {
            public static void main(String[] args) {
                //类什么时候加载
                //1.创建对象实例化(new)
                //AA aa = new AA();//代码块被执行
                //2.创建子类对象实例,父类也会被加载
                //继承的本质,先加载父类,在加载子类
                AA aa1 = new AA();
                /*
                BB 的静态代码块1被执行....
                AA 的静态代码块1被执行....
                 */
                //3.使用类的静态成员时(静态属性,静态方法)
                System.out.println(Cat.n1);//先加载Cat类
                /*//没有继承Animal时的输出
                Cat 的静态代码1被执行...
                9999
                 */
                //当Cat继承Animal后,先加载父类
                /*
                Animal 的静态代码1被执行...
                Cat 的静态代码1被执行...
                9999
                 */
        
        
            }
        }
        class Animal{
            static {
                System.out.println("Animal 的静态代码1被执行...");
            }
        }
        class Cat extends Animal{
            public static int n1 = 9999;//静态属性
            //静态代码块
            static {
                System.out.println("Cat 的静态代码1被执行...");
            }
        }
        
        class BB {//父类
        
            //静态代码块
            static {
                System.out.println("BB 的静态代码块1被执行....");
            }
        }
        
        class AA extends BB {
            //静态代码块
            static {
                System.out.println("AA 的静态代码块1被执行....");
            }
        }
        

        继承的本质,先加载父类,在加载子类

    3. 普通的代码块,在创建对象实例时,会被隐式的调用。被创建一次,就会调用一次。如果只是使用类的静态成员时,普通代码块并不会执行

    4. 创建一个对象时,在一个类调用顺序是:(重点,难点

      1. 调用静态代码块和静态属性初始化(静态代码块和静态属性初始化优先级一样,如果有多个静态代码块和多个静态变量初始化,则按他们定义的顺序调用)

      2. 调用普通代码块和普通属性的初始化(同上括号)

      3. 调用构造方法

      4. package com.hspedu.codeblock_;
        
        public class CodeBlockDetail02 {
            public static void main(String[] args) {
                A a = new A();
            }
        }
        class A{
            //非静态属性初始化
            private int n2 = getN2();
            //静态属性初始化
            private static int n1 = getN1();
            //普通代码块
            {
                System.out.println("A 普通代码块01");
            }
        
            //静态代码块
            static {
                System.out.println("A 静态代码块01");
            }
            public static int getN1(){
                System.out.println("getN1被调用....");
                return 100;
            }
            public int getN2(){
                System.out.println("getN2被调用....");
                return 200;
            }
            //无参构造器
            public A(){
                System.out.println("A(),构造器最后被调用");
            }
        
        }
        /*
        getN1被调用....
        A 静态代码块01
        getN2被调用....
        A 普通代码块01
        A(),构造器最后被调用
         */
        

        静态,普通,构造器,(多的话就按顺序排就行了)

    5. 构造器里面代码的执行顺序

      1. package com.hspedu.codeblock_;
        
        public class CodeBlockDetail03 {
            public static void main(String[] args) {
                new BBB();//在创建对象时的步骤
                //1.进行类的加载(这个时候就是对静态代码块,静态初始化的)
                //2.创建对象
            }
        }
        class AAA{
        
            //无参构造器
            public AAA(){
                //隐藏的命令
                //1.super()
                //2.调用本类的普通代码块
                System.out.println("AAA() 构造器被调用....");
            }
        }
        class BBB extends AAA{
            {
                System.out.println("BBB的普通代码块...");
            }
        
            public BBB(){
                //隐藏的命令
                //1.super()//到AAA的构造器
                //2.调用本类的普通代码块(代码块不会被继承)
                System.out.println("BBB() 构造器被调用....");
            }
        }
        /*
        执行的顺序1.BBB无参构造器的隐藏的第一个命令
        2.super()到BBB的父类AAA,AAA的无参构造器里也有隐藏的命令,
        但AAA的父类是Object没有执行的内容所以执行AAA的类的代码块,
        但AAA类也没有代码块,所以执行输出System.out.println("AAA() 构造器被调用....");。
        3.轮到BBB类隐藏的第二条命令,调用本类的代码块
        System.out.println("BBB的普通代码块...");
        4.执行输出System.out.println("BBB() 构造器被调用....");
         */
        /*
        AAA() 构造器被调用....
        BBB的普通代码块...
        BBB() 构造器被调用....
         */
        

        super(),调用普通代码块

    6. 创建一个子类对象时(继承关系),他们的静态代码块,静态属性初始化普通代码块,普通属性初始化构造方法的调用顺序如下:

      1. 父类的静态代码块和静态属性(是属性,不是成员。优先级一样,按定义顺序执行)(在类加载的时候执行

      2. 子类的静态代码块和静态属性(优先级一样,按定义顺序执行)(在类加载的时候执行

      3. 父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)(创建对象)

      4. 父类的构造方法

      5. 子类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)

      6. 子类的构造方法

    7. 静态代码块只能直接调用静态成员(静态属性和静态方法),普通代码块可以调用任意成员文章来源地址https://www.toymoban.com/news/detail-409919.html

到了这里,关于代码块,执行顺序,类加载,创建对象的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包