JAVA常量定义时就要初始化吗？

Posted 2023-04-23

参考技术A

不一定哦，可以进行初始化，这时可以给常量一个定值，也可以不初始化，在程序运行时，把值赋给常量，具体细节如下：

1.用final关键字修饰的常量：例如
class A

final int i;//或者final int i=10;
public A()

i=10;

2.用static和final关键字同时修饰的常量就必须得再定义时初始化，例如：
class A

static final int i=10;

我举得例子你可以去试着编译一下，都是正确的。
其实可以从关键字的含义来理解是否得一定义就初始化：常量都是用final来修饰的，所以只要在包含它类实例化对象的时候初始化就行了，什么都不影响。但是如果前面加个static表明类装载时这个常量必须是有个状态的（被赋予了值，初始化了），所以如果用static就必须定义时初始化。

Java中各个重要定义

继承

子类可以继承父类的所有方法和属性（包括“私有的”，不管是否是final）；

但是子类 不能直接调用 父类的私有方法和属性。

通过反射，子类可以调用父类的私有方法和属性。

final

1. 数据

声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。

• 对于基本类型，final 使数值不变；
• 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。

final int x = 1;
x = 2;  // cannot assign value to final variable ‘x‘
final A y = new A();
y.a = 1;

 

2. 方法 

声明方法不能被子类覆盖。

 

3. 类

声明类不允许被继承。

重载（overload）和重写（override）

方法重写的前提： 必须要存在继承的关系。

方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。

什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。

重写（覆盖）的规则： 

1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载. 
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。 
3、重写的方法，子类的返回值类型必须要小于或者 等于父类的返回值类型； 
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类； 
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法（此时也可能叫重载？），并没有对其进行重写； 
6、静态方法不能被重写为非静态的方法（会编译出错）； 
7、父类方法被final时，无论该方法被public、protected及默认所修饰，子类均不能重写该方法。

 

方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。
重载的规则： 
1、在使用重载时一般是只能相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，个数，或者是顺序； 

也有特例是通过返回值区分，但是这种方法不是百分之百可以，例如

void f() {}  
int f() { return 1; }
// 在int x =f()中，确实可以区分重载方法，但是直接使用f()则不行

所以我们只说区分方法重载只能是相同方法名，不同参数形式来实现。

2、不能通过访问权限、返回类型、抛出的异常进行重载； 
3、方法的异常类型和数目不会对重载造成影响。

 super

代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法，不仅仅是用来调用父类的构造函数

多态

概念：向上转型和目的是，和向下转型和目的

前期绑定（面向过程只有前期绑定）和后期绑定（动态绑定，运行时绑定）

　以下不具有多态性：

1.子类覆盖父类的private方法

2.子类和父类具有相同名字的成员变量（具有名字的域），某个域的访问是在编译期进行，而任何域访问操作都是将由编译器解析，此时子类和父类相同名字的域实质上是两个不同的储存空间，所以此时子类对象转型为父类引用时候不是多态性（实际上很少发现，因为通常父类的成员都是private，只能通过调用方法来访问）

3.某个父类方法是静态的，不具有多态性、

构造器和多态：构造器不具备多态性，因为实际上是static方法，此声明是隐式的

在继承中代码的执行顺序为：1.父类静态对象，父类静态代码块

                                               2.子类静态对象，子类静态代码块

                                               3.父类非静态对象，父类非静态代码块

                                               4.父类构造函数

                                               5.子类非静态对象，子类非静态代码块

                                               6.子类构造函数

 自动拆装箱

出处：https://www.nowcoder.com/questionTerminal/643b145a860f457d8a150869e1a17eba
自动拆装箱JDK需在1.5上
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，当然如果此时是new的一个对象如：Integer a=new Integer（1）和Integer b=new Integer（1），a==b返回的是false，因为堆中指向不同的地址值。

3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

int a=257;
Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(a==b);//true
//System.out.println(a.equals(b));  编译出错，基本型不能调用equals()
System.out.println(b.equals(257.0));//false，先257.0进行封装，再进行3的比较
System.out.println(b==c);//false
System.out.println(b2==c2);//true