目录

一、object类的使用

equals 

tostring 

二、单元测试方法的使用

 三、包装类的使用

基本数据类型转换为包装类 

 包装类转换为基本数据类型

自动装箱与自动拆箱

包装类和基本数据类型转换为字符类型

将字符类型转换为基本数据类型和包装类 

一、object类的使用

1.Object类是所有Java类的根父类

2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类 

使用代码证明： 

package zhuyuan;

public class objecttest {
    public static void main(String[] args){
        Order order=new Order();
        System.out.println(order.getClass().getSuperclass());
    }
}
class Order{

}

 3.Objuct类中的功能（属性，方法）就具有通用性。

属性：无

方法：equals()/toString()/getClass()/hashCode()/clone()/finalize()/wait()/notify()/notifyAll()

4.Object类只声明了一个空参的构造器

	方法名称	类型	描述
1	public Object()	构造	构造器
2	public boolean equals(Object obj)	普通	对象比较
3	public int hashCode()	普通	取得Hash码
4	public String toString()	普通	对象打印时使用

equals 

 问题==与equals的区别

1.==是一个运算符，既可以比较基本类型也可以比较引用类型。

>对于基本类型就是比较值

>对于引用了类型就是比较内存地址，判断两个引用对象引用的是否是同一个对象实体。

equals方法的使用

2.equals的话，它是属于java.lang.Object类里面的方法，只适用于引用数据类型。如果该方法没有被重写过，默认也是==;

补充：==符号使用时，必须保证符号左右两边的变量类型一致。

我们可以看到String等类的equals方法是被重写过的

 

3.具体要看自定义类里面有没有重写Object的equals方法来判断

4.通常情况下，重写equals方法，会比较类中的响应属性是否都相等。像String/Date/File/包装类等都重写了object类中的equals()方法，充协议后，比较的不是两个引用的地址是否相同，而是比较两个对象的实体内容是否相同。

以下是==对于基本数据类型的使用 

package zhuyuan;

public class equalstest {
    public static void main(String[] args){
        int i=10;
        int j=10;
        double d=10.0;

        System.out.println(i==j);
        System.out.println(i==d);
        char c=10;
        System.out.println(i==c);

        char c1='A';
        char c2=65;
        System.out.println(c1==c2);
    }
}

 

以下是==对于引用数据类型的使用。 

package zhuyuan;

public class equalstest {
    public static void main(String[] args){
        //引用类型
        Customer cust1=new Customer("Tom",21);
        Customer cust2=new Customer("Tom",21);
        System.out.println(cust1==cust2);
    }
}
class Customer{
    String name;
    int age;
    public Customer(String name,int age){
        this.name=name;
        this.age=age;
    }
}

 

 以下是对于equals的简单测试

package zhuyuan;

import java.util.Date;

public class equalstest {
    public static void main(String[] args){
        //引用类型
        Customer cust1=new Customer("Tom",21);
        Customer cust2=new Customer("Tom",21);
//        System.out.println(cust1==cust2);
        String str1=new String("atzhuyuan");
        String str2=new String("atzhuyuan");

        System.out.println(str1==str2);
        //两个对象的地址值不同，返回fasle
        System.out.println(cust1.equals(cust2));
        System.out.println(str1.equals(str2));

        Date date1=new Date(32432525324L);
        Date date2=new Date(32432525324L);
        System.out.println(date1==date2);
        System.out.println(date1.equals(date2));
    }
}
class Customer{
    String name;
    int age;
    public Customer(String name,int age){
        this.name=name;
        this.age=age;
    }
}

 

 5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实体内容”是否相同。那么，我们就需要对Object类中的equals()进行重写。

>重写的原则：比较两个对象的实体内容是否相同。

>对称性：如果x.equals(y)返回时TRUE，俺么y.equals(x)也应该返回时TRUE

>自反性：x.equals(x)必须返回TRUE

>传递性：如果x.equals(y)返回的是TRUE，而且y.equals(z)返回时TRUE，那么z.equals(x)也应该返回是TRUE

>一致性：如果x.equals(y)返回是TRUE，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是TRUE

在任何情况下，x.equals(null),永远返回是false

x.equals(和x不同类型的队形）永远返回是false

package zhuyuan;

import java.util.Date;

public class equalstest {
    public static void main(String[] args){
        //引用类型
        Customer cust1=new Customer("Tom",21);
        Customer cust2=new Customer("Tom",21);
        String str1=new String("atzhuyuan");
        String str2=new String("atzhuyuan");
        System.out.println(str1.equals(str2));
    }
}
class Customer{
    String name;
    int age;
    public Customer(String name,int age){
        this.name=name;
        this.age=age;
    }
    //重写的原则，比较两个对象的实体内容（即name和age）是否相同
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if(obj instanceof Customer){
            Customer cust=(Customer) obj;
            //比较两个对象的每个属性是否都相同
            if(this.age==cust.age&& this.name.equals(cust.name))
            {
                return true;
            }else{
                return false;
            }
        }
        return false;
    }

}

 

当然，在我们实际的使用过程中，我们也可以使用自动生成的方式生成我们的equal方法。 

首先点击我们的代码中的生成  

然后选中我们的equals()和hashCode()方法 

然后编译器就会自动生成代码。 

运行结果 

 

tostring 

toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

>在进行String与其他类型数据的连接操作时，自动调用toString()方法

>可以根据需要在用户自定义类型中重写toString()方法

>基本类型数据转换为String类型时，调用了对应包装类的toString()方法。

1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

2. Object类中tostring()的定义： public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }

3.像String/Date/File/包装类等都重写了Object类中toString()方法 使得在调用对象的tostring()时，返回“实体内容”的信息。

4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的实体内容。

package zhuyuan;

import java.util.Date;

public class tostringtest {
    public static void main(String[] args){
        Customer cust1=new Customer("Tom",21);
        System.out.println(cust1.toString());
        
        String str=new String("AA");
        System.out.println(str);
        
        Date date=new Date(353372171);
        System.out.println(date);

    }

}

在我们还未重写前其返回的结果是地址值 

下面为我们重新写的代码 

public String toString() {
        return "Customer[name="+name+",age="+age+"]";
    }

 

当然我们也可以采用自动生成的方法：点击代码

 

再选中生成

 

  

 再进行一些函数的勾选就能够生成我们的代码

二、单元测试方法的使用

就是想测试那一块的代码就测试哪一块的代码

java中的Junit单元测试

首先我们的idea需要安装Junit插件，打开我们的偏好设置

 找到JUnitGenerator V2.0，安装

 然后找到我们JUnit Generator设置，改成如下形式

 点击右上角齿轮，然后找到project Struct选项

 在我们的library中点击加号，选择Java

 将我们的包导入进来

链接: https://pan.baidu.com/s/1zcmB6f36zFIxyifFvD2bMg?pwd=gldi 提取码: gldi

 再点击我们右边的加号，将我们另一个包也导入

 最后就是这个样子

 按command+shift+t调出我们如下的界面，点击Creat New Test

 在下面的选项中勾选我们想要测试的类

 成功生成我们要测试的类

 想要运行的话直接右键运行想要运行的部分。

 三、包装类的使用

针对八种基本数据类型定义和相应的引用类型-包装类（封装类）

有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

基本数据类型	包装类
byte	Byte	父类：Number
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

包装类的使用

1.java提供了8种基本类型对应的包装类，使得基本数据类型的变量具有类的特征

2.基本数据类型、包装类、String三者之间的互相转换 

基本数据类型转换为包装类 

在jdk1.9之前采用

Integer in1=new Integer(num1)之类的方法来将我们的基本数据类型转换为包装类

但是在jdk1.9之后我们采用

.valueOf的方法来创建。 

package zhuyuan;
import org.junit.Test;
public class Wrappertest {
    //基本数据类型--》包装类：调用包装类的构造器
    @Test
    public void test1(){
        int num1=10;

        Integer in1=Integer.valueOf(num1);
        System.out.println(in1.toString());
        
        Integer in2 =Integer.valueOf("123");
        System.out.println(in2.toString());
        
        Float f1=Float.valueOf(12.3f);
        System.out.println(f1.toString());
        
        Boolean b1=Boolean.valueOf(true);
        Boolean b2=Boolean.valueOf("123");
        Boolean b3=Boolean.valueOf("true123");
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        
        Order order=new Order();
        System.out.println(order.isMale);
        System.out.println(order.isFemale);
    }
}
class Order{
    boolean isMale;
    Boolean isFemale;
}

 从上面的代码可以注意到我们的boolean的默认值为false，Boolean的默认值为null

 包装类转换为基本数据类型

我们的包装类所定义的基本数据类型是无法进行加减乘除运算的，所以我们在有些时候需要调用包装类中的方法来得到具体的参数值。

 @Test
    public void test2(){
        Integer int1=Integer.valueOf(12);
        int i1=int1.intValue();
        System.out.println(i1+12);
        
        Double f1=Double.valueOf(12.1111);
        System.out.println(f1);
        
    }

自动装箱与自动拆箱

 在正常情况下，我们的10是基本数据类型int，而不是包装类Integer，不是继承于object类的，但是在我们下面测试的时候，我们发现居然可以实现int与Integer之间的自动转化。这是由于我们jdk5.0之后的新特性。

>自动装箱

//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],

//保存了从-128~127范围的整数。如果我们的使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率。

    @Test
    public void test3(){
        int num1=10;
        method(num1);
    }
    public void method(Object obj){
        System.out.println(obj);
    }

 所以我们只需要这样写就可以了，不需要再采用上面的繁琐的方法来讲我们的基本数据类型转换为包装类。下面的代码就是自动装箱的演示

int num1=10;
Integer int1=num1;

 下面是自动拆箱的代码，就是编译器能够自动地将我们int1的包装类转换为num3的基本数据类型。

int num3=int1;

包装类和基本数据类型转换为字符类型

使用下面的两种方法都能够将我们的包装类或者基本数据类型转换为字符类。

>一种是直接进行连接运算

>一种是直接采用String.valueOf的方法来讲我们的数据转换为字符类型。

@Test
    public void test4(){
        int num1=10;
        //方式1：连接运算
        String str1=num1+"";
        //方式2：调用string的valueof的方法
        float f1=12.3f;
        String str2=String.valueOf(f1);//"12.3"

        Double d1=Double.valueOf(12.4);
        String str3=String.valueOf(d1);
        System.out.println("str1="+str1);
        System.out.println("str2="+str2);
        System.out.println("str3="+str3);
    }
    

将字符类型转换为基本数据类型和包装类 

使用XXX.parseXXX(str)的形式可以将我们的字符串类型转换为我们的基本数据类型或者包装类，其中Boolean只要不是不看大小写的true其余情况全部都是false。 

@Test
    public void test5(){
        String str1="123";
        int num2=Integer.parseInt(str1);
        System.out.println(num2+120);
        //可能会报NumberFormatException的错误。
        String str2="true";
        boolean b1=Boolean.parseBoolean(str2);
        System.out.println(b1);

        String str3="true1";
        boolean b2=Boolean.parseBoolean(str3);
        System.out.println(b2);
        
    }

暑期编程PK赛 得CSDN机械键盘等精美礼品！