Java基础提高(一)初始化

2017-04-26 本文已影响74人 RonaldoWang

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

打好基础是关键，笔者准备老老实实搞搞基础了，不仅为了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{}只执行一次。