发表于： 2020-11-29 23:13:17
1 1259
今天完成的事情：
Object:所有类的父类
子类
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Objects;
public class Employee {
private String name;
private double salary;
private Date hireDay;
public Employee(String n, double s, int year, int month, int day){
name = n;
salary = s;
GregorianCalendar calendar = new GregorianCalendar(year, month-1, day);
hireDay = calendar.getTime();
}
public String getName(){
return name;
}
public double getSalary(){
return salary;
}
public Date getHireDay(){
return hireDay;
}
public void raiseSalary(double byPercent){
double raise = salary * byPercent/100;
salary += raise;
}
@Override
public boolean equals(Object otherObject){
//检测this和otherObject是否引用同一个对象,这个this是指的是什么？
if (this == otherObject) return true;
//如果显式参数为null，则必须返回false
if(otherObject == null) return false;
//如果类不匹配（意思是只有两个对象属于同一个类的时候，才有可能相等），它们就不相等,getClass()是返回一个对象所属的类
if (getClass() != otherObject.getClass()) return false;
//现在我们知道otherObject是非空雇员
Employee other = (Employee) otherObject;
//测试字段是否具有相同的值
return Objects.equals(name, other.name) && salary == other.salary &&
Objects.equals(hireDay, other.hireDay);
}
public int hashCode(){
return Objects.hash(name, salary, hireDay);
}
// public String toString(){
// return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
// }
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", salary=" + salary +
", hireDay=" + hireDay +
'}';
}
}
父类
import java.util.GregorianCalendar;
public class Manager extends Employee {
private double bonus;
public Manager(String n, double s, int year, int month, int day){
super(n, s, year, month, day);
bonus = 0;
}
public double getSalary(){
double baseSalary = super.getSalary();
return baseSalary + bonus;
}
public void setBonus(double b){
bonus = b;
}
public boolean equals(Object otherObject){
if(!super.equals(otherObject)) return false;
Manager other = (Manager) otherObject;
//super.equals检查this和other是否属于同一类
return bonus == other.bonus;
}
public int hashCode(){
return super.hashCode() + 17 * new Double(bonus).hashCode();
}
public String toString(){
return super.toString() + "[bonus=" + bonus + "]";
}
}
测试类
/**
* 5.2 Object:所有类的超类
* Object类存在的意义是什么？
* 给其他的类添加上equals方法，hashCode方法，toString方法。
* 为什么 Java 的开发者认为所有的类都需要这几个方法？
*
* 5.2.1 equals方法
* 1.equals方法检测一个对象是否等于另一个对象（值相等）
*
* 5.2.2 相等测试与继承
* 1.equals方法的特性：自反性；对称性；传递性；一致性；对于任意非空引用X，X。equal（null）应该返回false
* 2.不属于同一个类时，哪怕值相等，依然返回false
*
*
* 5.2.3 hashCode 方法
* 1.散列码是由对象导出的一个整型值。
* 2.相同的输入一定得到相同的输出；不同的输入大概率得到不同的输出。
* 3.Equals与hashCode的定义一致，Equals相等，hashCode也相同。反之亦然。
*
* 5.2.4 toString方法
* 1.目的：返回表示对象值得字符串
* 2.子类可以通过super调用父类toString方法
* 3.toString方法可以用于调试
*/
public class EqualsTest {
public static void main(String[] args) {
//父类
Employee hei1 = new Employee("小黑", 8000, 2020, 11, 1);
Employee hei2 = hei1;
Employee hei3 = new Employee("小黑", 8000, 2020, 11, 1);
Employee hong = new Employee("小红", 80000, 2015, 11, 1);
System.out.println("hei1 == hei2: " + (hei1 == hei2));
System.out.println("hei1 == hei3: " + (hei1 == hei3));
System.out.println("hei1.equals(hei3): " + hei1.equals(hei3));
System.out.println("hei1.equals(hong): " + hei1.equals(hong));
System.out.println("hong.toString(): " + hong);
System.out.println( hei1.equals(null));//null
//子类
Manager yan1 = new Manager("小黑", 8000, 2020, 11, 1);;
Manager yan = new Manager("小研", 80000, 2012, 11, 1);
Manager boss = new Manager("小研", 80000, 2012, 11, 1);
boss.setBonus(5000);
boss.getSalary();
System.out.println("boss.toString(): " + boss.getSalary());
System.out.println("boss.toString(): " + boss);//为什么这里Salary的值没有变成85000？
System.out.println("yan.equals(boss): " + yan.equals(boss));
System.out.println("yan1.equals(hei1): " + yan1.equals(hei1));
System.out.println("hei1.hashCode(): " + hei1.hashCode());
System.out.println("hei3.hashCode(): " + hei3.hashCode());
System.out.println("hong.hashCode(): " + hong.hashCode());
System.out.println("yan.hashCode(): " + yan.hashCode());
}
}
结果
5.3 泛型数组列表
import java.util.ArrayList;
/**
* 5.3 泛型数组列表
* 什么是泛型？
* 泛型就是编写模板代码来适应任意类型；定义一种模板，例如ArrayList<T>，然后在代码中为用到的类创建对应的ArrayList<类型>
* ArrayList是一个采用类型参数的泛型类。
* 为什么要采用泛型数组列表？
* 解决在运行时动态更改数组大小。
* 使用ArrayList的好处
* 1.不必指出数组的大小，可以自适应大小
* 2.可使用add将任意多的元素添加到数组中
* 3.使用size()来代替数组中的length()计算数组的长度
* 4.可使用get,set方法
*
* 5.3.2 类型化与原始数组列表的兼容性
* 一眼看过
*
* 5.4 对象包装器与自动装箱
* 装箱和拆箱有什么用？
* 1.对象包装器类（Integer, Long, Float, Double, Short, Byte, Character, Void, Boolean）
* 2.对象包装器类是不可变的，即一旦构造了包装器，就不允许更改包装在其中的值。同时，对象包装器是final，所以不能定义它们的子类。
* 3.自动拆箱和自动装箱请看下面程序
* 4.装箱和拆箱是编译器认可的，而不是虚拟机
*
* 5.5 参数数量可变的方法（变参）
* 扫了一眼
*
* 5.7 反射（跳过）
*
* 5.8 继承设计的技巧
* 1.将公共方法和变量放在父类
*
* 2.不要使用受保护的变量（protected）
*
* 3.使用继承实现“ is - a” 关系
*
* 4.除非所有继承的方法都有意义，否则不要使用继承。
*
* 5.在覆盖方法时，不要改变预期的行为。
*
* 6.使用多态，而非类型信息（这里指的是if,switch等等）。
*
* 7.不要过多的使用反射。
*/
public class ArrayListTest {
public static void main(String[] args) {
//用三个员工对象填充员工数组列表
ArrayList<Employee> staff = new ArrayList<>(100);
// staff.ensureCapacity(100);
staff.add(new Employee("小黑", 8000, 2020, 11, 1));
staff.add(new Employee("小光", 8000, 2020, 11, 1));
staff.add(new Employee("小红", 80000, 2015, 11, 1));
System.out.println(staff.size());//3
staff.set(0, new Employee("小光", 8000, 2020, 11, 1));
Employee S = staff.get(2);
System.out.println(S);
for (Employee e : staff)
e.raiseSalary(10);
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary" + e.getSalary() +
",hireDay" + e.getHireDay());
//5.4 对象包装器与自动装箱
ArrayList<Integer> list = new ArrayList<>();//类型实参不能为基本类型int等等
list.add(4);//会自动装箱， == list.add(Integer.valueOf(4))
int c = list.get(1);//自动拆箱， == int n = list.get(i).intValue();
/// System.out.println(c);//报错，索引越界异常
}
}
结果：
5.6 枚举类
/**
* 5.6 枚举类
* 为什么要使用枚举？
* 为了让编译期自动检查出所有可能的潜在错误。
*
* 1.enum的构造方法要声明为private，字段强烈建议声明为final；
*
* 通过enum定义的枚举类，和其他的class有什么区别？
* 答案是没有任何区别。enum定义的类型就是class，只不过它有以下几个特点：
*
* 定义的enum类型总是继承自java.lang.Enum，且无法被继承；
* 只能定义出enum的实例，而无法通过new操作符创建enum的实例；
* 定义的每个实例都是引用类型的唯一实例；
* 可以将enum类型用于switch语句。
*
*
*/
import com.sun.glass.ui.Size;
import java.util.Scanner;
public class EnumTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("输入大小：（SMALL, MEDIUM, LARGE ,EXTRA_LARGE）");
String input = in.next().toUpperCase();
Size size = Enum.valueOf(Size.class, input);
System.out.println("size= " + size);
System.out.println("缩写= " + size.getAbbreviation());
if (size == Size.EXTRA_LARGE)
System.out.println("");
}
enum Size{
SMALL("S"),MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");
private String abbreviation;
private Size(String abbreviation)
{
this.abbreviation = abbreviation;
}
public String getAbbreviation(){
return abbreviation;
}
}
}
结果：
接口：
/**
* 第六章 接口与内部类
* 什么是接口？为什么要用到接口？接口的作用是什么？
* 接口：主要用来描述功能，不给出具体的实现。
*
* 在抽象类中，抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现，这样，多态就能发挥出威力。
* 如果一个抽象类没有字段，所有方法全部都是抽象方法：就可以把该抽象类改写为接口：interface
*
* 6.1 接口
* 1.接口定义的所有方法默认都是public abstract的，这个一般不用写出来
*
* 2.当一个具体的class去实现一个interface时，需要使用implements关键字。比如：
* public class Employee implements Comparable<Employee>
* 之后需要对接口中的方法进行实现，例子：
* public int compareTo(Employee other){
* return Double.compare(salary, other.salary);
* }
*
* 3.一个类可以实现多个interface。一般很少这样做
*/
import java.util.Arrays;
public class EmployeeSortTest {
public static void main(String[] args) {
Employee[] staff = new Employee[3];
staff[0] = new Employee("小红", 40000);
staff[1] = new Employee("小光", 80000);
staff[2] = new Employee("小黑", 70000);
//根据薪水排序
Arrays.sort(staff);
for (Employee e : staff)
System.out.println("name= " + e.getName() + ",salary=" + e.getSalary());
}
}
XXXXX
public class Employee implements Comparable<Employee>{
private String name;
private double salary;
public Employee(String n, double s){
name = n;
salary = s;
}
public String getName(){
return name;
}
public double getSalary(){
return salary;
}
public void raiseSalary(double byPercent){
double raise = salary * byPercent/100;
salary += raise;
}
public int compareTo(Employee other){
return Double.compare(salary, other.salary);
}
}
明天计划的事情：
复习接口和继承，开始任务二
遇到的问题：
太困了，精神不好
收获：以上
返回列表
评论