zoukankan      html  css  js  c++  java
  • 动手动脑三

    一、对象判等

     1 public class Test {
     2     public static void main(String[] args) {
     3         Foo obj1=new Foo();
     4         Foo obj2=new Foo();
     5         System.out.println(obj1==obj2);
     6     }
     7 }
     8 class Foo{
     9     int value=100;
    10 }

    当“==”施加于原始数据类型变量时,是比较变量所保存的数据是否相等。
    当“==”施加于引用类型变量时,是比较这两个变量是否引用同一对象。
    引用代表地址,所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。


     二、构造函数

      结论:如果类提供了一个自定义的构造方法,将导致系统不再提供默认构造方法。


     三、类字段初始化规律

     1 public class Test {
     2     public static void main(String[] args) {
     3         InitializeBlockClass obj=new InitializeBlockClass();
     4         System.out.println(obj.field);
     5         obj=new  InitializeBlockClass(300);
     6         System.out.println(obj.field);
     7     }
     8 }
     9 class InitializeBlockClass{
    10     {
    11         field=200;
    12     }
    13     public int field=100;
    14     public InitializeBlockClass(int value) {
    15         this.field=value;
    16     }
    17     public InitializeBlockClass() {
    18         
    19     }
    20 }

     类字段的初始化顺序:

    • 执行类成员定义时指定的默认值或类的初始化块,到底执行哪一个要看哪一个“排在前面”。

    • 执行类的构造函数。


    四、静态初始化块的执行顺序

     1 class Root
     2 {
     3     static
     4     {
     5         System.out.println("Root的静态初始化块");
     6     }
     7     {
     8         System.out.println("Root的普通初始化块");
     9     }
    10     public Root()
    11     {
    12         System.out.println("Root的无参数的构造器");
    13     }
    14 }
    15 class Mid extends Root
    16 {
    17     static
    18     {
    19         System.out.println("Mid的静态初始化块");
    20     }
    21     {
    22         System.out.println("Mid的普通初始化块");
    23     }
    24     public Mid()
    25     {
    26         System.out.println("Mid的无参数的构造器");
    27     }
    28     public Mid(String msg)
    29     {
    30         //通过this调用同一类中重载的构造器
    31         this();
    32         System.out.println("Mid的带参数构造器,其参数值:" + msg);
    33     }
    34 }
    35 class Leaf extends Mid
    36 {
    37     static
    38     {
    39         System.out.println("Leaf的静态初始化块");
    40     }
    41     {
    42         System.out.println("Leaf的普通初始化块");
    43     }    
    44     public Leaf()
    45     {
    46         //通过super调用父类中有一个字符串参数的构造器
    47         super("Java初始化顺序演示");
    48         System.out.println("执行Leaf的构造器");
    49     }
    50 }
    51 
    52 public class Test
    53 {
    54     public static void main(String[] args) 
    55     {
    56         new Leaf();
    57     }
    58 }

     结论:

    • 静态初始化块只执行一次。

    • 创建子类型的对象时,也会导致父类型的静态初始化块的执行。

    • 在构造子类对象时,先构造父类对象,静态初始化块优先执行,其次是父类的非静态初始化块,父类的构造函数,然后是子类的非静态初始化块,子类的构造函数。


  • 相关阅读:
    kafka_consumer3->spark_master
    为什么.NET感觉上比Java差一点
    学习Scala: 初学者应该了解的知识
    函数式编程 : 一个程序猿进化的故事
    Scala underscore的用途
    不变(Invariant), 协变(Covarinat), 逆变(Contravariant) : 一个程序猿进化的故事
    Scala Collection简介
    C# on Visual Studio Code
    我的Machine Learning学习之路
    Scala on Visual Studio Code
  • 原文地址:https://www.cnblogs.com/znjy/p/13806331.html
Copyright © 2011-2022 走看看