［JavaSE］Object类包装类

最新推荐文章于 2024-10-23 19:09:30 发布

程序媛阿洁

最新推荐文章于 2024-10-23 19:09:30 发布

阅读量204

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java学习

本文链接：https://blog.youkuaiyun.com/weixin_42645168/article/details/89289443

Java学习专栏收录该内容

28 篇文章

订阅专栏

本文深入讲解Java基础，包括Object类的使用，如toString方法、equals方法的重写，包装类的概念与应用，装箱与拆箱的过程，以及String与基本类型的相互转换。并通过实例解析，帮助读者理解并掌握这些核心概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Object类

定义：Object类是java默认提供的一个类，java里面除了Object类，所有的类都有继承关系。

通俗点讲就是所有类都可以使用Object类接收

toString:取得对象信息

System.out.println()系统输出输出对象时，默认会调用该对象的toString（）


class Person{
    private String name;
    private int age;
    public Person(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(){
        this.age=age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Person per=new Person("张三",20);
        String str=("hello");
        fun(per);
        fun(str);
    }
    public static void fun(Object obj){
        System.out.println(obj.toString());
    }
}
输出结果：
Person@2f4d3709
hello

若自定义类需要进行内容的输出，需要覆写toString()

修改上面的代码如下：


class Person{
    private String name;
    private int age;
    public Person(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(){
        this.age=age;
    }
    public String toString(){
        return "姓名为"+this.name+",年龄为"+this.age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Person per=new Person("张三",20);
        String str=("hello");
        fun(per);
        fun(str);
    }
    public static void fun(Object obj){
        System.out.println(obj.toString());
    }
}
输出结果：
姓名为张三，年龄为20
hello

equals():比较两个对象的内容

package www.JavaSe.Object;

class Person{
    private String name;
    private int 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 Person(String name, int age){
        this.name=name;
        this.age=age;
    }

    }
public class Test {
    public static void main(String[] args) {
        Person per=new Person("张三",20);
        Person per1=new Person("张三",20);
        System.out.println(per.equals(per1));
    }

}
输出结果：false

那么这个时候很多老铁们就会产生疑问了，在String类中equals(）方法是用来比较两个对象的内容的，但是

Object提供的equals（）默认比较两个对象的地址是否相同。

那怎么比较两个对象的内容呢？

 package www.JavaSe.Object;

class Person {
    private String name;
    private int age;
    public Person()
    { }
    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 Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "姓名为" + this.name + "年龄为" + this.age;
    }
    public boolean equals(Object obj) {
        //判断地址是否相等
        if (obj == this) {
            return true;
        }
        //判断传进来的对象不是person对象
        if (!(obj instanceof Person)) {
            return false;
        }
        //此时需要比较两个Person对象的内容
        //需要向下转型转回Person对象后比较两者属性的内容
        Person per = (Person) obj;
        return this.age == per.age && this.name.equals(per.name);
    }
}
public class Test {
    public static void main(String[] args) {
       Object obj=new Person("张三",20);
        System.out.println(obj instanceof Person);
    }
}
输出结果：false

总结：

Object类可以接受所有引用类型，包括接口和数组

Object类是参数统一的最高类型

包装类

引入：为了基本类型和引用类型相统一，包装类和对应的基本类型其实用法都差不多哒～只不过因为是引用类型

作用：可以作为泛型的参数，同时也能表示null

定义：将基本类型封装到类中

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

class IntDemo{
    private int value;
    public IntDemo(int value){
        this.value=value;
    }
    public int intValue(){
        return this.value;
    }
}
class Test{
    public static void main(String[] args) {
        Object obj=new IntDemo(10);
        IntDemo demo=(IntDemo)obj;
        int data=demo.intValue();
        System.out.println(data-1);
    }
}
输出结果：9

分类：

数值型（Number的子类）:Byte/Short/Integer(int)/Long/Float/Double
对象型（Object的子类):Boolean/Character(char)

装箱与拆箱

a装箱：基本数据类型->包装类对象

通过每个包装类的构造方法实现装箱处理

b拆箱：包装类->基本数据类型

利用的是包装类提供的**value方法

eg.Integer提供的intvalue()方法

class Test{
    public static void main(String[] args) {
       //装箱
       Integer integer=new Integer(10);
       //拆箱
        int data=integer.intValue();
        System.out.println(data+100);
    }
}
输出结果:110

JDK1.5以后提供了自动拆装箱机制----在用法上，使用包装类和使用基本类型基本一致。

class Test{
public static void main(String args[]){
Integer integer=10;
System.out.println(integer+100);
}
}
输出结果：110

那么问题来了！

什么时候用包装类？什么时候用基本类型呢？

解决：

强制--所有简单Java类（POJO类---类中只有属性与getter/setter,构造方法）使用包装类
局部变量推荐使用基本类型

包装类进行数值比较使用equals（）

class Test{
    public static void main(String[] args) {
        Integer i1= new Integer(10);
        Integer i2=new Integer(10);
        System.out.println(i1==i2);
    }
}
输出结果：false

class Test{
    public static void main(String[] args) {
        Integer i1= new Integer(10);
        Integer i2=new Integer(10);
        System.out.println(i1.equals(i2));
    }
}
输出结果：true

对于Integer var=?

直接赋值在[-128,127]区间内的赋值，Integer对象在缓存池产生，会复用已有对象。

在这个区间外的所有数据均在堆上产生，不会复用已有对象。

String<->基本类型

String->基本类型

1valueOf方法

２intValue()---new一个字符串对象再转换

       //String->int
        String str1="100";
        //方法一：调用Integer的静态方法valueOf
        int num1=Integer.valueOf(str1);
        //方法二:new了一个字符串对象，再转换成number
        int num2=new Integer(str).intValue();

当字符串中包含非数字，在运行时会抛出NumberFormatException

基本类型->String

1."+"

       //int->String
        int num=10;
        //字符串和number相加就可
        String str=num+" ";

2.通过String类的构造方法

推荐：使用String.valueOf(所有基本类型）

利用包装类解决交换两个数字问题

问题引入：

一般来说，提到交换两个数字，我们都会想到一个经典的三行代码～～

观察下面这段代码：

public class SwapNumber {
    public static void swap(int  x,int y){
        int tmp=x;
        x=y;
        y=tmp;
    }
    public static void main(String[] args) {
        int x=0;
        int y=20;
        swap(x,y);
        System.out.print("x="+x+" y="+y);
    }
}
//输出：
/*
x=0 y=20
*/

很显然输出结果并没有达到我们的预期，这是什么原因呢？

我们来观察以下执行这段代码内存的变化：

本质上只是交换了形参，并没有对实参造成影响（引用的赋值，并不会对原有对象产生影响）

修改代码：（加入自定义的包装类）

package package1128;
class MyInteger{
    private int value;
    public MyInteger(int value) {
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}
public class SwapNumber {
    public static void swap(MyInteger  x,MyInteger y){
        MyInteger tmp=new MyInteger(x.getValue());
        x.setValue(y.getValue());
        y.setValue(tmp.getValue());
    }
    public static void main(String[] args) {
        MyInteger a=new MyInteger(10);
        MyInteger b=new MyInteger(20);
        swap(a,b);
        System.out.print("a="+a.getValue()+" b="+b.getValue());
    }
}

包装类也是不可变对象，如果要修改包装类，需要新建对象