Java基础提高篇(一)初始化

冰冻三尺非一日之寒,滴水石穿非一日之功

打好基础是关键，笔者准备老老实实搞搞基础了，不仅为了7月份的实习面试，还是为了自我能力的提升，基础的重要性不可忽视。

牢骚发完了，进入正题吧。

1.用构造器进行初始化

构造器采用与类相同的名称，因此“每个方法首字母小写”的编码风格不适合用在构造器中

构造器是一种特殊类型的方法，因为它没有返回值。这与返回值为空（Void）不同。

默认构造器是没有形式参数的，他的作用是创建一个默认对象。如果类中没有构造器，那么编译器会自动帮你创建一个默认构造器。

但是，如果你在类中已经定义了一个构造器（无论是否有参数），那么编译器就不会帮你自动创建默认构造器了。

2.方法重载

为了让方法名相同而让形式参数不同(独一无二的参数类型)的构造器同时存在，必须用到方法重载。要对明显相同的概念使用了不同的名字，就会令人困惑，好在有了方法重载，可以为二者使用了相同的名字。

class NBA{
public NBA() {
System.out.println("这是无参构造");
}
public NBA(String team) {
System.out.println("这是有一个参数的构造"+team);
}
}

public class Demo1 {
public static void main(String[] args) {
new NBA();
new NBA("火箭");
}
}

2.1基本类型的重载

如果传入的数据类型（实参）小于方法中声明的形参类型，那么数据类型就会被提升。反之，需要将实参进行窄化。

2.2不能以返回值区分方法重载

有时候，我们并不关心方法的返回值，

int i(){
return 0;
}
float i(){
return '0';
}

编译不过去。当调用i()时，Java并不知道该调用哪个

this关键字

this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。如果在方法内部调用同一个类中的另一个方法时，就不必用this，直接调用即可

只有当需要明确指出对当前对象的引用时，才需要使用this关键字。

class NBA {
int i;

public NBA increment() {
i++;
return this;
}

public void print() {
System.out.println(i);
}
}

public class Demo1 {
public static void main(String[] args) {
new NBA().increment().increment().print();
}
}

在构造器中调用构造器

class NBA {
int i;
NBA(String team){
System.out.println(team);
}
NBA(int year){
System.out.println(year);
}
NBA(String team,int year){
this(team);  //只能在构造器的第一行调用其它构造器
// this(year);   //在构造器中调用1个的构造器
}

public void print() {
// this();//在非构造器中不能调用构造器
System.out.println(i);
}
}

public class Demo1 {
public static void main(String[] args) {
new NBA("火箭", 20);
}
}

尽管this可以调用一个构造器，但却不能调用二个

构造器必须置于最始处

除构造器之外，编译器禁止在其他任何方法中调用构造器。

static含义

static方法就是没有this的方法，在static方法的内部不能调用非静态方法（类加载器将会去加载类，而static修饰的方法是属于类的，因此，static方法同时也被加载，而非静态方法需要对象，此时还没有生成对象，所以static方法的内部不能调用非静态方法），反之，可行。在没有创建对象的前提下，仅仅通过类本身来调用static方法，这正是static主要用途。static方法可以访问其他static域和方法。

面向对象的思想是“向对象发送消息”，而由于static方法就是没有this的方法，所以并不是面向对象思想，因此，尽量少用static.

清理:终结处理和垃圾回收

在Java中，对象并非总是被垃圾回收

垃圾回收只与内存有关

如果jvm并未面临内存耗尽的情形，它就不会去执行垃圾回收以恢复内存的。

关于垃圾回收机制建议看《深入理解Java虚拟机》，这本书是我的下月计划。

成员初始化

java尽力保证：所有变量在使用前都能得到恰到的初始化。

而类的数据成员，即字段，都会有一个初始值。

class A{}
class NBA {
int i;
float f;
boolean b;
char c;
byte by;
short s;
long l;
double d;
A a;
void print(){
System.out.println(i);  // 0
System.out.println(f);  // 0.0
System.out.println(b);  //false
System.out.println(c);  //
System.out.println(by); // 0
System.out.println(s);  // 0
System.out.println(l);  // 0
System.out.println(d);  // 0.0
System.out.println(a);  // null
}
}

public class Demo1 {
public static void main(String[] args) {

new NBA().print();
}
}

初始化顺序

在类的内部，变量定义的先后顺序决定了初始化的顺序。即使变量定义散布于方法定义（包括构造器）之间，它们也会在任何方法被调用之前得到初始化。

class CBA{
CBA(String team){
System.out.println(team);
}
}
class NBA {
CBA cba = new CBA("上海哔哩哔哩");   //在构造器方法前
NBA(){
System.out.println("NBA构造器");
}
CBA cba2 = new CBA("浙江稠州银行");   //在构造器方法后
void f(){
System.out.println("普通方法");
}
CBA cba3 = new CBA("北京首钢");//在普通方法后
}

public class Demo1 {
public static void main(String[] args) {
new NBA().f();
}
}

输出：
上海哔哩哔哩
浙江稠州银行
北京首钢
NBA构造器
普通方法

静态数据的初始化

无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能应用于局部变量，因此它只能作用于域。

class WCBA{
WCBA(){
System.out.println("WCBA构造器");
}
}
class CBA{
static WCBA wcba= new WCBA();
CBA(String team){
System.out.println(team);
}
}
class NBA {

NBA(){
System.out.println("NBA构造器");
}
}

public class Demo1 {
public static void main(String[] args) {
new CBA("浙江");
new NBA();
}
static CBA cba3=new CBA("上海");
}

结果:

WCBA构造器
上海
浙江
NBA构造器

初始化的顺序是先静态对象（如果他们尚未因前面的对象创建过程而被初始化），然后是非静态对象。

在main（）方法执行之前，先执行静态对象，也就是cba3,需要加载CBA类，同理，CBA类取加载WCBA,执行WCBA的构造，再执行CBA构造，最后执行main方法，值得注意的是，new CBA(“浙江”),直接输出浙江二字，并没有再去执行static WCBA wcba= new WCBA();充分说明了static只执行一次。

显示的静态初始化

静态块也执行一次，当首次生成该类对象时，或者首次访问属于那个类的静态数据成员时。

class CBA{

CBA(String team){
System.out.println(team);
}
void f(){
System.out.println("CBA");
}
}
class NBA {
static CBA cba1;
static CBA cba2;
static{
cba1=new CBA("上海bilibili");
cba2=new CBA("上海bilibili2");
}
NBA(){
System.out.println("NBA构造器");
}
}

public class Demo1 {
public static void main(String[] args) {
NBA.cba1.f();
//new NBA().cba1.f();这句话也行
}
}

输出:

上海bilibili
上海bilibili2
CBA

非静态实例初始化

用于初始化每个对象的非静态变量

class CBA{
CBA(String team){
System.out.println(team);
}
void f(){
System.out.println("CBA");
}
}
class NBA {
CBA cba1;
CBA cba2;
{
cba1=new CBA("上海bilibili");
cba2=new CBA("上海bilibili2");
}

}

public class Demo1 {
public static void main(String[] args) {
new NBA().cba1.f();
new NBA().cba1.f();
}
}

输出：

上海bilibili
上海bilibili2
CBA上海bilibili
上海bilibili2
CBA

可以看到，{}块每次都会执行，而static{}只执行一次。