程序员成长日记之（一）从渣渣到菜鸡

day_05《Think in Java》读书笔记（初始化与清理）

5.1 用构造器确保初始化
使用idea编写，有个很方便的alt+insert，但是为什么要使用构造器，构造器是做什么的；
每一次调用某个类的对象时候，都要对类进行初始化（得到相应的空间，Java一般是在堆中开辟类对象的空间），可以假设有一个初始化类的方法，这样做每次都要调用该方法，很多编程语言中引入构造器（constructor）的概念，是我们写的每个类的对象都会得到初始化；

1. 构造器名与类名完全一致；
2. 构造器没有任何类型返回值，（也就是连void都没有）
3. 常用构造器：无参构造器、全参构造器、缺主键参构造器；（web开发常用的就这几个，也有特殊的）

5.2 方法重载

public class Tree {
    int height;
    Tree() {
        System.out.println("种下一个树苗");
        height = 0;
    }
    Tree(int initialHeight) {
        height = initialHeight;
        System.out.println("树"+height+"尺高");
    }
    void info(){
        System.out.println("树"+height+"尺高");
    }
    void info(String s){
        System.out.println(s+"：树"+height+"尺高");
    }
}
class Overloading{
    public static void main(String[] args) {
        new Tree();
        for (int i=0;i<3;i++){
            Tree tree=new Tree(i);
            tree.info();
            tree.info("方法重载");
        }
    }
}
//种下一个树苗
//树0尺高
//树0尺高
//方法重载：树0尺高
//树1尺高
//树1尺高
//方法重载：树1尺高
//树2尺高
//树2尺高
//方法重载：树2尺高

5.2.1 区分重载方法
参数列表是区分重载方法的唯一标识，个数、类型、顺序，只要有一个不同他们就不同；

5.2.2 涉及基本类型的重载
如果传入的实际参数小于重载方法声明的形式参数，是数据类型会被提升；char类型会直接被提升为int。
如果传入的实际参数大于重载方法声明的形式参数，则必须进行窄化转换；

5.2.3 以返回值区分重载方法
不可行；方法调用时会产生混淆；

5.3 默认构造器
“无参构造器”；如果不主动创建没系统会自动创建迷人构造器；但是如果创建了其他构造器，系统则不会主动创建默认构造器；

5.4 this关键字
this关键字指向的是当前对象的引用
作用：this.属性名称；指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题

class Test{
    public static void main(String [] args){
        //调用无参构造函数，
        Person p1 = new Person();
        p1.setAge(20);
        p1.setName("张三");
        p1.setGender("男");
        System.out.println(""+p1.getName()+" 今年"+p1.getAge()+"岁 性别为："+p1.getGender());
    }
}
class Person{
    private String name;
    private int age;
    private String gender;
    Person(){}
    Person(String name,int age,String gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;//此处不使用this输出为空，运行时输出错误
    }
    public int getAge(){
        return age;
    }
    public void setGender(String gender){
        this.gender = gender;
    }
    public String getGender(){
        return gender;
    }
}
//不适用this则输出：null 今年0岁 性别为：null
//张三 今年20岁 性别为：男

5.4.1 在构造造器调用构造器

public class Flower {
    int petalCount = 0;
    String s="inital Value";

    public Flower(String ss) {
        System.out.println("String构造器"+ss);
    }

    public Flower(int petals) {
        petalCount = petals;
        System.out.println("int构造器"+petals);
    }

    public Flower(int petals, String s) {
        this(petals);
        //this(s);//第一：不能调用两个构造器！！！
        this.s=s;//第二：由于参数s与数据成员s名字相同，避免歧义，使用this.s,区分使用“this”！！！
        System.out.println("int && String args");
    }
    void printPetalCount(){
    	//this(11);//第三：除了构造器之外禁止在其他方法中调用构造器！！！
        System.out.println("default");
    }
    Flower(){
        this(47,"hi");
        System.out.println("default...");
    }

    public static void main(String[] args) {
        Flower x=new Flower();
        x.printPetalCount();
    }
}
//int构造器47
//int && String args
//default...
//default

5.4.2 static的含义
	static没有this方法；
	在static方法内部不能调用非静态方法，反之可以；
	类似于“全局方法”，但是Java中禁止全局方法，在类中置入static方法就可以访问其他static方法方法和static域；

5.5 清理：终结处理和垃圾回收
不使用new：java允许在类中定义一个finalize()方法：一点垃圾回收准备号释放对象内存，首先调用该方法，并且在下一次回收动作发生时，才会真正的回收对象占用的内存。
但是 1、对象可能不被回收；2、垃圾回收不等于析构函数（垃圾回收不一定发生）3、垃圾回收只与内存有关

5.5.1 finalize用途
5.5.2 必须实施清理
5.5.3 终结条件

5.6 成员初始化
基本数据类型都有默认值；
5.6.1 指定初始化
初始化正确性取决于初始化顺序，与编译方式无关；

public class Flower {
    int j = g(i);//！！！
    int i = f();

    int f() {
        return 1;
    }

    int g(int n) {
        return n * 10;
    }

}
//Error:(2, 13) java: 非法前向引用

5.7 构造器初始化

public class Counter{
	int i;
	Counter(){
		i=7;
	}
}
//先初始化为0；在初始化为7

5.7.1 初始化顺序
	在类的内部，变量定义的先后顺序决定了初始化的顺序；
5.7.2 静态数据的初始化
	无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能应用于局部变量，因此它只能作用于域。
	如果没有初始化：1、基本数据类型为默认值；2、对象引用为null；
5.7.3 显示静态初始化
	java允许将多个静态初始化动作组织恒一个特殊的“静态块”；
	只执行一次：首次生成这个类的对象，或首次访问属于这个类的静态数据时；
5.7.4 非静态实例初始化
	初始化每一个对象的非静态变量；

5.8 数组初始化
基本数据类型[ ] 数组名 = {元素1，元素2，… …，元素n }；花括号赋值等价于new为数组创建空间；
基本数据类型 数组名[ ] ；
5.8.1 可变参数
1.在方法中定义可变参数后，我们可以像操作数组一样操作该参数；
2.如果该方法除了可变参数还有其它的参数，可变参数必须放到最后；
3.调用使用了可变参数的方法时：
a.可以不写参数，即传入空参；
b.可以直接在里边写入参数，参数间用逗号隔开；
c.可以传入一个数组；
4.拥有可变参数的方法可以被重载，在被调用时，如果能匹配到参数定长的方法则优先调用参数定长的方法。
5.可变参数可以兼容数组参数，但数组参数无法兼容可变参数。

public class VariableParameter {
    //求若干个整型数中的最大值
    public int getMax(int... items){
        //定义可变参数items
        int max = Integer.MIN_VALUE;
        //次数为int能表示的最小值，值为-2147483648
        for(int item : items){
            max = item > max? item : max;
            //取大值
        }
        return max;
    }
    //返回比number大的数的个数
    public int getLagerNum(int number,int... items){
        //若除了可变长参数还有其它参数，可变长参数一定要放在最后
        int sum = 0;
        for(int item : items){
            if(item > number){
                sum++;
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        VariableParameter vp = new VariableParameter();
        System.out.println("最大值："+vp.getMax());  
        //可以不写参数
        System.out.println("最大值："+vp.getMax(2,1,4,7,2,-1,3,3));
        //可以在参数中直接写入若干个参数
        System.out.println("最大值："+vp.getMax(-1,4,5,0,1));
        //可以在参数中直接写入若干个参数
        System.out.println("比number大的数的个数："+ vp.getLagerNum(9, 1,11,5,14,-1,9,21));
        //9为number，后边的是items
        int a[] = new int[] {1,11,5,14,-1,9,21};
        System.out.println("比number大的数的个数："+vp.getLagerNum(9,a));
        //items也可以用数组替代
    }
}

原文链接：https://blog.csdn.net/u012116457/article/details/45114861

5.9 枚举类型
	enum关键字；元素需要大写，逗号隔开；适合和switch组合使用；
	static value()方法按照enum声明顺序，产生数组；