2021-04-05

package task11;

public class IntegerTest {
public static void main(String[] args) {
//1.d打印Integer类中常用的常量数值
System.out.println(“最大值是：”+ Integer.MAX_VALUE);
System.out.println(“最小值是：”+ Integer.MIN_VALUE);
System.out.println(“所表示的二进制位数是：”+ Integer.SIZE);
System.out.println(“所占字节的个数是：”+ Integer.BYTES);
System.out.println(“对应int类型的Class实例是：”+ Integer.TYPE);
System.out.println("++++++++++++++++++++");
//2.使用构造方法来构造Integer类型的对象并打印
Integer it1 = new Integer(123);
System.out.println(“it1=”+it1);//自动调用它内部已经重写的toString方法 123
Integer it2 = new Integer(456);
System.out.println(“it2=”+it2);//自动调用它内部已经重写的toString方法 456
System.out.println("----------------------------");
//上述方法已经过时，建议使用valueOf方法取代,相当于从int到integer类型的转化，叫做 装箱（打包）
Integer it3 = Integer.valueOf(123);
System.out.println(“it3=”+it3);
//相当于从String到Integer类型的转换
Integer it4 = Integer.valueOf(“456”);
System.out.println(“it4=”+it4); // it4自动调用toString方法得到的是String类型
//获取调用对象中的整数数值，相当于从Integer类型到int类型的转换,叫做 拆箱
int ia = it4.intValue();
System.out.println(“获取到的整数数据是：”+ia);//456 ia得到的是整数类型,拼接完还是字符串
System.out.println("----------------------------");
//3.从java5开始增加了自动装箱和拆箱机制
Integer it5 = 100; //直接通过赋值运算符实现自动装箱
//之前是 Integer it5 = Integer.valueOf(“100”);
int ib = it5; //直接通过赋值运算符实现自动拆箱
//之前是 int ib = it5.intValue();
System.out.println("----------------------------");
//笔试考点
Integer it6 = 128;
Integer it7 = 128;
Integer it8 = new Integer(128);
Integer it9 = new Integer(128);
System.out.println(it6it7); //比较地址 false
System.out.println(it6.equals(it7));//比较内容 true
System.out.println(it8it9); //比较地址 false
System.out.println(it8.equals(it9));//比较内容 true
//在Integer类的内部提供了自动装箱池技术，将-128~127之间的整数已经装箱完毕，
// 当程序中使用该范围之内的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
//因此下面的it10和it11来自同一个池子，所以其地址也是一样的。
Integer it10 = 127;
Integer it11 = 127;
Integer it12 = new Integer(127);
Integer it13 = new Integer(127);
System.out.println(it10it11); //比较地址 true
System.out.println(it10.equals(it11));//比较内容 true
System.out.println(it12it13); //比较地址 false
System.out.println(it12.equals(it13));//比较内容 true
System.out.println("----------------------------");
//5.实现静态方法的调用
int ic = Integer.parseInt(“200”);
System.out.println(“字符串转换为整数的结果是：”+ic);//200
//int id = Integer.parseInt(“200a”);
//System.out.println(“字符串转换为整数的结果是：”+id);//数字格式异常，不能有字母
//算数异常 下标越界异常 空指针异常 类型转换异常 数字格式异常
System.out.println(“根据参数指定的整数获取对应的十进制字符串是：”+Integer.toString(200));
System.out.println(“根据参数指定的整数获取对应的二进制字符串是：”+Integer.toBinaryString(200));//11001000
System.out.println(“根据参数指定的整数获取对应的十六进制字符串是：”+Integer.toHexString(200));//c8
System.out.println(“根据参数指定的整数获取对应的八进制字符串是：”+Integer.toOctalString(200));//310
}
}

package task11;

public class DoubleTest {
public static void main(String[] args) {
//1.在java5之前装箱和拆箱的实现
//实现从 double 到 Double 类型的转换，装箱
Double db1 = Double.valueOf(3.14);
System.out.println("db1= "+ db1);
//实现了从Double到double的转换 拆箱
double d1 = db1.doubleValue();
System.out.println("d1= "+d1);

    System.out.println("----------------------------");
    //2.从java5开始实现自动装箱和拆箱
    Double db2 = 3.14;
    double d2 = db2;
    System.out.println("d2= "+d2);
    System.out.println("db2= "+db2);
    System.out.println("----------------------------");
    //3.实现静态方法和成员方法的调用
    double d3 = Double.parseDouble("13.14");
    System.out.println("d3= "+d3);  // 13.14
    System.out.println("db2对象的判断结果是："+db2.isNaN());

    //是数字就返回false
    Double db3 = Double.valueOf(0/0.0);
    System.out.println("db3对象的判断结果是："+db3.isNaN());
    //不是数字就返回   true


}

}

package task11;

public class BooleanTest {
public static void main(String[] args) {
//1.在java5之前采用方法进行装箱和拆箱
//相当于从boolean类型到Boolean类型的转换， 装箱
Boolean bo1 = Boolean.valueOf(true);
System.out.println("bo1= "+ bo1); // bo1 = true
boolean b1 = bo1.booleanValue(); // b1 = true
System.out.println(“b1= “+b1);
System.out.println(”----------------------------”);
//2.从java5开始支持自动装箱和拆箱
Boolean bo2 = false;
boolean b2 = bo2;
System.out.println(“b2= “+b2); //b2= false
System.out.println(”----------------------------”);
//3.实现从String类型到boolean类型的转换
//该方法的执行原理是：只要参数数值不为true或者TRUE时，结果就是false
boolean b3 = Boolean.parseBoolean(“true”);
System.out.println("b3= "+b3); // b3= true
}
}

package task11;

public class CharacterTest {
public static void main(String[] args) {
//1.在java5之前调用方法实现装箱和拆箱机制
//相当于从char类型到Character类型的转换， 装箱
Character ca1 = Character.valueOf(‘a’);
System.out.println("ca1 = "+ca1);
//从Character类型向char类型的转换，拆箱
char c1 = ca1.charValue();
System.out.println(“c1= “+c1);
System.out.println(”----------------------------”);
//2.从java5开始支持自动装箱和拆箱

    Character ca2 = 'b';
    char c2 = ca2;
    System.out.println("ca2 = "+ca2);
    System.out.println("----------------------------");
    //3.实现字符类型的判断以及转换
    System.out.println(Character.isUpperCase(c2));//判断是否为大写字母
    System.out.println(Character.isLowerCase(c2));//判断是否为小写字母
    System.out.println(Character.isDigit(c2));//判断是否为数字字符
    System.out.println("转换为大写字母是："+Character.toUpperCase(c2));
    System.out.println("转换为小写字母是："+Character.toLowerCase(c2));
}

}

package task11;

import java.util.Objects;

public class Student {
private int id;
private String name;
Student(){}
Student(int id,String name){
setId(id);
setName(name);
}

public int getId() {
    return id;
}
public void setId(int id) {
    if(id>0){
        this.id = id;
    }else{
        System.out.println("学号不合理");
    }
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

//为了比较两个对象的内容，也就是学号信息需要重写该方法
//Student this = s1;
//Object obj = s2;就是多态，父类类型引用指向子类对象 要强转才能引用子类的方法
/*@Override
public boolean equals(Object obj) {
//当调用对象不为空而参数对象为空的时候，则内容一定不相同，就不用判断了
if(obj == null){
return false;
}
//当调用对象和参数对象指向同一个对象时，一定相同
if (obj == this){
return true;
}
//强转之前先判断一下obj是不是指向Student
if (obj instanceof Student) {
//用一个Student的ts接着
Student ts = (Student) obj;

        //return this.getId() == ts.getId();
        //这是以学号为基准判断两个对象是否相等  int是基本数据类型
        //内存的是数据本身，因此==可以判断是否相等
        //return this.getName() == ts.getName();
        //但是String是引用数据类型，里面存放的是地址，使用==是在判断地址
        //也就是是否指向同一块区域，但是即使不指向同一块区域，名字也可以相等
        //也能返回true
        //需要再调用一次equals，用来比较地址里面的内容。
        return this.getName().equals(ts.getName());
        //      String类型引用.equals   xxx

    }
    //否则类型不一致，没有可比性，内容一定不相同
    return false;
}
//为了使得该方法的结果与equals方法的结果保持一致，从而满足java官方的常规协定，需要重写该方法。

@Override
public int hashCode() {

    //return getId();
    int type = 12;
    //return type*31 +getId();
    return type*31 +getName().hashCode();
}
//为了返回更有意义的字符串数据，则需要重写该方法

@Override
public String toString() {
    return "Student[id="+getId()+",name="+getName()+"]";
}*/

/*
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;

    Student student = (Student) o;

    if (id != student.id) return false;
    return name != null ? name.equals(student.name) : student.name == null;
    //非空判断是为了避免空指针异常
}

@Override
public int hashCode() {
    int result = id;
    result = 31 * result + (name != null ? name.hashCode() : 0);
    return result;
}
*/

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return id == student.id &&
            Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(id, name);
}

@Override
public String toString() {
    return "Student{" +
            "id=" + id +
            ", name='" + name + '\'' +
            '}';
}

}