~0828答题

0825

1. static不属于类及类成员的访问控制符

2. public、private、protected属于类及类成员的访问控制符

3. 一个类可以有多个构造方法

4. 最终类不能派生子类，最终方法不能被覆盖

5. 数组一旦被创建后就不能改变其长度

   Java基本数据类型之间发生丢失精度的情况

   1. 浮点数转换为整数：将浮点数（float、double）转换为（byte、int、short、long）时就会发生精度丢失的问题。因为浮点数包含小数，将小数部分截断转换为整数可导致精度丢失
   2. 大范围转换为小范围类型，将一个取值大的数据类型（long）转为范围小的（byte、int、short）就会发生精度丢失
   3. 整数运算时超出范围

0828

public class Test1 {
 
    static int cnt = 6;
 
    static {
        cnt += 9;
    }
 
    public static void main(String[] args) {
        System.out.println("cnt =" + cnt);//输出结果为5
    }
 
    static {
        cnt /= 3;
    }
}

关于构造方法

1. 构造方法的优先级一般比代码块低
2. 构造方法的主要作用是完成对类的对象的初始化工作
3. 一般在创建对象时，系统会自动调用构造方法

进程之间的关系

有关finally语句块的说法

1. 不管catch是否捕获异常，finally语句块都要被执行
2. 在try语句块或catch语句块中执行到System.exit(0)直接退出程序
3. finally块中的return语句会覆盖try中的return返回

能够修饰interface的修饰符

public用来修饰interface

在java中我们使用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的开销

Gadget has-a Sprocket and Gadget has-a Spring and Gadget is-a Widget and Widget has-a
Sprocket表示继承

子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块 执行的先后顺序是？

正确的执行顺序是:
    父类Ｂ静态代码块->
    子类Ａ静态代码块->
    父类Ｂ非静态代码块->
    父类Ｂ构造函数->
    子类Ａ非静态代码块->
    子类Ａ构造函数 
    也就是说非静态初始化块的执行顺序要在构造函数之前。
        
   package leetcode;

/**
 * author:hlc
 * date:2023/8/28
 */

父类
public class SuperClass {
    public SuperClass() {
        System.out.println("Super Class Constructor Method");
    }
    {
        System.out.println("Super Class Block");
    }
}


子类

package leetcode;

public class ObjectInit extends SuperClass {
    private static String STR = "Class Static Variable";

    static {
        System.out.println("Class Static Block:" + STR);
    }

    public ObjectInit() {
        System.out.println("Constructor Method");
    }

    {
        System.out.println("Class Block");
    }
    public static void main(String[] args) {
        @SuppressWarnings("unused")
        ObjectInit a = new ObjectInit();
    }
}

输出结果

class BaseClass {
    public BaseClass() {}
 
    {
        System.out.println("I’m BaseClass class");
    }
 
     static {
         System.out.println("static BaseClass");
     }
 }
 
 public class Base extends BaseClass {
     public Base() {}
 
     {
         System.out.println("I’m Base class");
     }
 
     static {
         System.out.println("static Base");
     }
 
     public static void main(String[] args) {
         new Base();
     }
 }

static BaseClass
static Base
I’m BaseClass class
I’m Base class

输出结果为

class Person {
    String name = "No name";
    public Person(String nm) {
        name = nm;
    }
}
class Employee extends Person {
    String empID = "0000";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

编译报错【因为在父类中有了有参构造，索引子类实现有参构造的时候，需要通过super调用父类的有参构造，不然会报错】

id main(String args[]) {
Employee e = new Employee(“123”);
System.out.println(e.empID);
}
}

编译报错【因为在父类中有了有参构造，索引子类实现有参构造的时候，需要通过super调用父类的有参构造，不然会报错】