java学习打卡（23.3.26）（自用）

书籍：《Java核心技术卷I 基础知识》

内容：第五章 5.3-5.6

主要内容：ArrayList，对象包装器，枚举类

笔记： 

C5_2.java

import java.util.ArrayList;

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

        //泛型数组列表
        ArrayList<Employee> staff = new ArrayList<>(); //自动调节数组容量

        //添加
        staff.add(new Employee("Mizuki", 114514, 1919, 8, 10));
        staff.add(new Employee("Kal'tsit", 10000, 0, 1, 1));

        //访问与设置(get & set)
        Employee e = staff.get(1);
        System.out.println(e.toString());
        Employee a = new Employee("Mostima", 23333, 1919, 1, 5);
        staff.add(1, a);
        e = staff.get(1);
        System.out.println(e.toString());

        //删除元素
        staff.remove(1);
        e = staff.get(1);
        System.out.println(e.toString());

        staff.add(new Employee("Qiushunan", 50000, 2000, 1, 1));

        for (Employee ee : staff) {
            ee.raise_salary(10);
        }

        //可以大概估计数量并赋值
        ArrayList<Employee> staff2 = new ArrayList<>(100);
        //也可以使用以下方法分配数组大小
        staff.ensureCapacity(50);

        // staff.size()是元素数目，等价于数组a的a.length;
        System.out.println(staff.size());

        //一旦能够确认数组列表的大小不再发生变化,就可以调用 trimToSize 方法.这个方法将存储区域的大小调整为当前元素数量所需要的存储空间数目.垃圾回收器将回收多余的存储空间.
        //注意：一定要确认不会添加新元素时调用 trimToSize ,添加新元素就需要花时间再次移动存储块.


        for (Employee r : staff) {
            System.out.println(r.toString());
        }

        Employee b = new Employee("Yunzhou", 23000, 1999, 12, 12);
        staff.set(1, b); //设置

        System.out.println("reset No.1:");
        for (Employee r : staff) {
            System.out.println(r.toString());
        }

        //对象包装器与自动装箱
        /*
        所有基本类型的都有与之对应的类，包括Integer,Long,Float,Double,Short,Byte,Character,Void,Boolean
         */
        System.out.println();
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);//会自动转换成如下表达,称作自动装箱
        list.add(Integer.valueOf(1));
        list.add(4);
        list.add(5);
        list.add(1);
        list.add(4);
        int n = list.get(2);
        //自动升为Double
        Integer q = 1;
        Double w = 2.0;
        System.out.println(true ? q : w);//打印出1.0

        //static String toString(int i)以一个新String对象的形式返回给定数值i的十进制表示
        //static String toString(int i, int radix)返回数值i的基于给定radix参数进制的表示。

    }
}

Employee.java

import java.time.*;
import java.util.*;

//类：Employee
public class Employee {

    private String name;
    private LocalDate hireDay;
    private double salary;//private确保只有只有Employee类自身的方法可以访问这些实例域


    public Employee(String n, double s, int y, int m, int d) {
        name = n;
        this.salary = s;
        hireDay = LocalDate.of(y, m, d);
    }// 构造器，与类同名

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }

    public void setHireDay(LocalDate hireDay) {
        this.hireDay = hireDay;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() == obj.getClass()) return false;
        Employee other = (Employee) obj;

        return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
    }

    public int hashcode() {
        return Objects.hash(name, salary, hireDay);
    }

    @Override
    public String toString() {
        return getClass().getName() + "[name = " + name + ", salary = " + salary + ", hireDay = " + hireDay + "]";
    }

    public void raise_salary(double per) {
        double raise = salary * per / 100;
        salary += raise;
    }
}
// 该类可以派生出多个类，组成一个继承层次
//判断是否该设计继承关系的规则："is-a"规则，它表明子类的每个对象也就是超类的对象。“is-a”规则也可表示为置换法则，表明程序中出现的超类对象的任何地方都可以被子类对象置换

停更一下，最近要开始学前端