（java学习随堂笔记）对象初始化、构造方法、重载、final、finalize()方法、内存回收、枚举类

对象初始化

系统在生成对象时，会为对象分配内存空间，并自动调用构造方法对实例变量进行初始化

对象回收
对象不再使用时，系统会调用垃圾回收程序将其占用的内存回收

构造方法

		方法名与类名相同
		不定义返回类型
		通常被声明为公有的public
		可以有任意多个参数
		主要作用是完成对象的初始化工作
		不能在程序中显式的调用
		在生成一个对象时，会自动调用该类的构造方法为新对象初始化
		若未显式声明构造方法，编译器隐含生成默认的构造方法
	
默认的构造方法：
	没有参数（内部类除外），方法体为空；
	使用默认的构造方法初始化对象时，如果在类声明中没有给实例变量赋初值，则对象的属性值为零或为空；

public class BankAccount {
    String ownerName;
    int accountNumber;
    float balance;
}

public class BankTester {
    public static void main(String[] args) {
        BankAccount myAccount = new BankAccount();
        System.out.println("ownerName="+myAccount.accountNumber);
        System.out.println("accountNumber="+myAccount.balance);
        System.out.println("balance="+myAccount.ownerName);
    }
}

输出：

ownerName=0
accountNumber=0.0
balance=null

自定义构造方法与方法重载

在生成对象时给构造方法传送初始值，为对象进行初始化。

构造方法什么时候被调用：生成一个对象的时候，构造方法会被自动调用，这个时候需要传送实参值。

构造方法可以被重载
方法重载：一个类中有两个及以上同名的方法，但参数表不同。
在方法调用时，可以通过参数列表的不同来辨别应调用那一个方法。

如果在生成类的时候没有声明任何构造方法，那么编译器会生成一个默认的构造方法。
只要显式声明了构造方法，编译器就不再生成默认的构造方法。
也可以显式声明无参数的构造方法，方法体中可以定义默认初始化方式。

public class BankAccount {
    //为BankAccount声明一个有三个参数的构造方法
    public BankAccount(String initName,int initAccountNumber,float initBalance){
        ownerName = initName;
        accountNumber = initAccountNumber;
        balance = initBalance;
    }
    //假设一个新账号的初始余额可以为0，则可以增加一个带有两个参数的构造方法
    public BankAccount(String initName,int initAccountNumber){
        ownerName = initName;
        accountNumber = initAccountNumber;
        balance = 0.0f;
    }
    //无参数的构造方法--自定义默认的构造方法
    public BankAccount(){
        ownerName = ""; //空字符串
        accountNumber = 999999;
        balance = 0.0f;
    }
    String ownerName;
    int accountNumber;
    float balance;
}

声明构造方法时使用this关键字

可以使用this关键字在一个构造方法中调用另外的构造方法
代码更简洁，维护起来更容易
通常用参数个数比较少的构造方法调用参数个数最多的构造方法

public class BankAccount {
    //this关键字的重载构造方法
    public BankAccount(){
        this("",999999,0.0f);
    }
    public BankAccount(String initName,int initAccountNumber){
        this(initName,initAccountNumber,0.0f);
    }
    public BankAccount(String initName,int initAccountNumber,float initBalance){
        ownerName = initName;
        accountNumber = initAccountNumber;
        balance = initBalance;
    }
    String ownerName;
    int accountNumber;
    float balance;
}

用一个构造方法调用本类中的另一个构造方法。

final关键字

使某个属性一经初始化就不可改变。

final变量的初始化
实例变量和类变量（静态变量）都可以被声明为final
final实例变量可以再类中定义是给出初始值，或者在每个构造方法结束之前完成初始化
final类变量（静态变量）必须在声明的同时完成初始化

内存回收

对象的自动回收

无用对象：
离开了作用域的对象；
无引用指向的对象。

Java运行时系统通过垃圾收集器周期性地释放无用对象所使用的的内存。
垃圾收集器：
自动扫描对象的动态存储区，对不再使用的对象左上标记以进行垃圾回收；
作为一个后台线程运行，通常在系统空闲时异步执行

Java运行时系统会在对对象进行自动垃圾回收前自动调用对象的finalize()方法。

finalize()方法

在类java.lang.Object中声明，因此Java中的每一个类都有该方法：
protrcted void finalize() throws throwable

用于释放资源

类可以覆盖（重写）finalize()方法

fianlize()方法有可能在任何时机以任何次序进行，finalize()方法在任何时候进行都不应该影响程序的正确性。

枚举类

当这个类型的对象的可取值是有一定的范围的可列举的。

声明枚举类

[public] enum 枚举类型名称
	[implements 接口名称列表]
{	
	枚举值；
	变量成员声明及初始化；
	方法声明及方法体；
}

关键字 enum

例：

enum Score {
    EXCELLENT,
    QUALIFIED,
    FAILED;
}

public class ScoreTester {
    public static void main(String[] args) {
        giveScore(Score.EXCELLENT);
        giveScore(Score.QUALIFIED);
        giveScore(Score.FAILED);
    }
    public static void giveScore(Score s){
        switch (s){
            case QUALIFIED:
                System.out.println("qualified");
                break;
            case EXCELLENT:
                System.out.println("excellent");
                break;
            case FAILED:
                System.out.println("failed");
                break;
        }
    }
}

枚举类的特点

枚举定义实际上是定义了一个类；
所有枚举类型都隐含继承（扩展）自java.lang.Enum，因此枚举类型不能再继承其他任何类；
枚举类型的类体中可以包括方法和变量；
枚举类型的构造方法必须是保内私有或者私有的。定义在每句开头的常量会被自动创建，不能显式地调用枚举类的构造方法。

枚举类型的默认方法

静态的values()方法用于获得枚举类型的枚举值的数组，返回一个数组，包含所有的枚举值；
toString方法返回枚举值的字符串描述，将枚举值转成字符串类型；
valueOf方法将以字符串形式表示的枚举值转化为枚举类型的对象；
Java valueOf() 方法：（参考网址 https://www.runoob.com/java/number-valueof.html ）
Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。
Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。
Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

public class Test{
public static void main(String args[]){
                Integer x =Integer.valueOf(9);
                Double c = Double.valueOf(5);
                Float a = Float.valueOf("80");              

                Integer b = Integer.valueOf("444",16);   // 使用 16 进制

                System.out.println(x);
                System.out.println(c);
                System.out.println(a);
                System.out.println(b);
        }
}

9
5.0
80.0
1092

Ordinal方法获得对象在枚举类型中的位置索引。

声明了变量和方法的枚举类

public enum Planet {
    MERCURY (3.303E+23,2.4397e6),
    VENUS(4.869E+24,6.0518E6),
    ERATH(5.976E+24,6.378E6),
    MARS(6.421E+23,3.397E6);

    private final double mass;
    private final double radius;

    //构造方法，用参数值初始化mass，radius值
    Planet(double mass,double radius){
        this.mass=mass;
        this.radius=radius;
    }

    private double mass(){
        return mass;
    }
    private double radius(){
        return radius;
    }

    public static final double G=6.673e-11;

    //处理枚举对象的方法
    double surfaceGravity(){
        return G*mass/(radius*radius);
    }
    double surfaceWeight(double otherMass){
        return otherMass*surfaceGravity();
    }

    public static void main(String[] args) {
        if(args.length!=1){
            System.err.println("Usage:java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);//转换成double类型
        double mass = earthWeight/ERATH.surfaceGravity();
        for(Planet p : Planet.values())
            System.out.printf("Your weight on %s is %f%n",p,p.surfaceWeight(mass));
    }
}