java常用类Day3

最新推荐文章于 2024-05-06 10:37:06 发布

-沉珠于泉-

最新推荐文章于 2024-05-06 10:37:06 发布

阅读量89

点赞数 1

分类专栏： java学习日志文章标签： java

本文链接：https://blog.csdn.net/m0_55925924/article/details/119216631

版权

java学习日志专栏收录该内容

33 篇文章 0 订阅

订阅专栏

getClass（）方法

public final Class<?> getClass(){} 返回值为class类型
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
    }
}

需要注意的是getClass返回的类型是class

输出结果为

s1与s2属于同一个类型

hashCode（）方法

public int hashCode(){}
返回该对象的哈希码值
哈希值：根据对象的地址或字符串或数字使用hash算法计算出来的int类型数值
一般情况下相同对象返回相同哈希码

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
class Test1 {
    public static void main(String[] args) {
        
        //getClass方法
        
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        
        //判断s1和s2是不是同一个类型
        
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
        
        //hashCode方法
        
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        
        Student s3=s1;
        
        System.out.println(s3.hashCode());
    }
}

不同对象的hashCode值不一样，因为存储的地方是不一样的
这个代码只是将主体与测试类放在了一起，并不方便阅读，分开使得功能更加明了

hashCode输出结果为

460141958
1163157884
460141958

toString（）方法

public String toString（）{}
返回该对象的字符串类型（表现形式）默认情况下这个方法的返回的数据是对象的类型+它的16进制的哈希值
可以根据程序需求覆盖该方法（当默认的方法满足不了需求时，就可以进行方法重写），如：展示对象各个属性值

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
class Test1 {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
        System.out.println("==================================================");

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("==================================================");

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

输出结果为

s1与s2属于同一个类型
==================================================
460141958
1163157884
460141958
==================================================
com.commonClass.ObjectClass.Demo01.Student@1b6d3586
com.commonClass.ObjectClass.Demo01.Student@4554617c

可以看出，前半部分为类的名称（不包括@）后面为哈希值
有人会问为什么跟刚刚的hash值不一样，其实仔细观察就会发现二者其实是一样的，只不过一个是十进制，一个是十六进制

这时候出现了新的问题，要是我不想看见对象的类型及hash值，而是想看到它的一些属性（如s1的姓名，年龄等），那么这时候就需要对方法进行重写

重写规则：

方法名，参数列表，返回类型要与父类的方法一致
子类方法的访问修饰符不能比父类更加严格

重写时可Alt+Insert快捷键，也可直接写方法名，会有提示帮助写

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写toString方法
    @Override
    public String toString() {
        return name+";"+age;
    }
}
class Test1 {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
        System.out.println("==================================================");

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("==================================================");

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

toString输出结果为

更生;20
曹和宇;21

equals（）方法

public boolean equals（Object obj）{} （返回值为布尔值，有一个Object类型的参数）
默认实现为（this==obj），比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同
equals方法覆盖步骤：
1. 比较两个引用是否指向同一个对象
2. 判断obj是否为空（null）
3. 判断两个引用指向的实际对象类型是否一致（判断两个引用是否是同一类型的）（getClass，instanceof等来判断）
4. 强制类型转换
5. 依次比较各个属性值是否相同

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写toString方法
    @Override
    public String toString() {
        return name+";"+age;
    }
}
class Test1 {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
        System.out.println("==================================================");

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("==================================================");

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("==================================================");

        //equals方法   判断两个对象是否相等
        System.out.println(s1.equals(s2));

        Student s4 = new Student("甦",20);
        Student s5 = new Student("甦",20);
        System.out.println(s4.equals(s5));
    }
}

equals输出结果为

false
false

new会在堆里开辟空间，所以二者的地址肯定是不同的。举个例子：跟你年龄相同的人，他跟你在年龄这个属性上是一样的，你俩共同指向相同的年龄，但是你俩仍然是不同的两个个体。跟你同名的人也是如此，你俩始终是两个不同的个体。但是倘若让你等于他，也就相当于让他是你，你是他，这时候你俩便变成了同一个个体，此时地址相同

若想结果为true，同样需要用到方法重写

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写toString方法

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


    //重写equals方法

    @Override
    public boolean equals(Object obj) {
        //1、判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        //2、判断obj是否为null
        if (obj==null){
            return false;
        }
        //3、判断是否是同一个类型(getClass比较笨重，一般不用)
//        if (this.getClass()==obj.getClass()){
//
//        }
        if (obj instanceof Student){
            //4、强制类型转换
            Student s=(Student) obj;
            //5、比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
}
class Test1 {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
        System.out.println("==================================================");

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("==================================================");

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("==================================================");

        //equals方法   判断两个对象是否相等
        System.out.println(s1.equals(s2));

        Student s4 = new Student("甦",20);
        Student s5 = new Student("甦",20);
        System.out.println(s4.equals(s5));
    }
}

相当于这里重写要达到的目的是：我与小明名字相同，年龄相同，本来是两个个体，但现在要遵循新的规则：名字相同年龄相同即为同一个体

此时equals输出的结果变成了

false
true

finalize（）方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc()，通知JVM执行垃圾回收

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写toString方法

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


    //重写equals方法

    @Override
    public boolean equals(Object obj) {
        //判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        //判断obj是否为null
        if (obj==null){
            return false;
        }
        //判断是否是同一个类型(getClass比较笨重，一般不用)
//        if (this.getClass()==obj.getClass()){
//
//        }
        if (obj instanceof Student){
            //强制类型转换
            Student s=(Student) obj;
            //比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}
class Test1 {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("更生",20);
        Student s2 = new Student("曹和宇",21);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> class1 = s1.getClass();//getClass返回值类型为class
        Class<? extends Student> class2 = s2.getClass();//如果class1与class2相等，则说明s1与s2的类型是相同的
        if (class1==class2){
            System.out.println("s1与s2属于同一个类型");
        }else {
            System.out.println("s1与s2不是同一个类型");
        }
        System.out.println("==================================================");

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("==================================================");

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("==================================================");

        //equals方法   判断两个对象是否相等
        System.out.println(s1.equals(s2));

        Student s4 = new Student("甦",20);
        Student s5 = new Student("甦",20);
        System.out.println(s4.equals(s5));
    }
}
class Test2{
    public static void main(String[] args) {
        Student s1 = new Student("A",20);
        Student s2 = new Student("B",20);
        Student s3 = new Student("C",20);
        Student s4 = new Student("D",20);
        Student s5 = new Student("E",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

输出结果为

回收垃圾

注意这里是输出了回收垃圾，但实际上s1-s5并未被回收，因为重写了方法并没有显示出来，想要将这5个对象变成垃圾，将前面的类名去掉即可

new Student("A",20);
new Student("B",20);
new Student("C",20);
new Student("D",20);
new Student("E",20);

此时输出结果为

E对象被回收了
D对象被回收了
C对象被回收了
B对象被回收了
A对象被回收了

包装类

java中基本数据类型是储存在栈中的，如果你定义了一个基本类型变量，尝试写“ 变量. ”就会发现是没有任何方法的。因而为了让基本类型发挥更强大的作用，需要把它们包装一下，也就有了包装类的概念

概念

基本数据类型所对应的引用数据类型
Object可统一所有数据，包装类的默认值是null

包装类对应

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

类型转换与装箱、拆箱

装箱：基本数据类型–>引用数据类型
拆箱：引用数据类型–>基本数据类型

public class Demo01 {
    public static void main(String[] args) {
        //int num=10;
        //类型转换：装箱——基本类型转成引用类型的过程
        int num1=18;//基本类型
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2=Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱——引用类型转成基本类型
        Integer integer3 = new Integer(100);
        int num2=integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5之后，实装了自动装箱和拆箱的功能
        int age=30;
        //自动装箱
        Integer integer4=age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2=integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

输出结果为

装箱
18
18
拆箱
100
自动装箱
30
自动拆箱
30

-沉珠于泉-

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java常用类Day3

getClass（）方法public final Class<?> getClass(){} 返回值为class类型返回引用中存储的实际对象类型应用：通常用于判断两个引用中实际存储对象类型是否一致public class Student { private String name; private int age; public Student() { } public Student(String name, int age) {
复制链接

扫一扫