java基础之toString的使用方法

toString方法，其返回值类型为String类型，用于返回表示对象值的字符串，返回类名和它的引用地址（散列码 hashCode）toString方法是Object类中的一个实例方法，所有的java类都是Object的子类，因此所有的java对象都具有toString方法返回表示对象值得字符串

绝大多数（但不是全部）的toString方法都遵循的格式：类的名字，随后是一对方括号括起来的域值。

格式： 类名[域值]

例： public String toString() {

return "Cat[name=" + name

+ ",age=" + age

+ ",color=" + color

+ "]";

}

但是，最好通过调用getClass().getName()获得类名的字符串，而不要将类名硬加到toString方法中。

例：public String toString() {

return getClass().getName()

+ "[name=" + name

+ ",age=" + age

+ ",color=" + color

+ "]";

}

toString方法也可以供子类调用，如果超类使用了getClass().getName()，那么子类只要super.toString()就可以了。在设计子类的时候，再将子类域的描述添加进去。public class LiCat extends Cat{

//...省略成员变量、方法等

public String toString() {

return super.toString()

+ "[eat=" + eat

+  "]";

}

}

随处可见toString方法的主要原因是：只要对象与一个字符串通过操作符“+”连接起来，java编译就会自动地调用toString方法，以便获得这个对象的字符串描述在调用cat1.toString的地方可以用 “” + cat1 代替。

“” + cat1 这条语句将 一个空串 与 cat1的字符串表示 相连接，这里的cat1就相当于cat1.toString。与toString不同的是，如果x是基本类型（int，float，char，boolean），这条语句照样能够执行。

如果cat1是任意一个对象，并且调用System.out.println(cat1);

println方法就会直接将cat1看作cat1.toString调用，并打印输出得到的字符串。//此处的 cat1 是个对象

String message = "" + cat1;

System.out.println(message); //相当于System.out.println("" + cat1);也相当于下一条代码

System.out.println(cat1); //也相当于下一条代码

System.out.println(cat1.toString());

//基本数据类型

int q = 1;

System.out.println("a = " + q); //相当于下一条代码

System.out.println(q);

返回类名和它的引用地址

Object类定义了toString方法，用来打印输出对象所属的类名和散列码（引用地址） Object aa = new Object();

System.out.println(aa.toString());

//输出：java.lang.Object@15db9742

java.lang.Object@15db9742 是你new的对象转成字符串的值,返回的是getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

也就是，默认的类的toString()方法会输出：这个类的类名+@+对象哈希码的无符号十六进制值数组的toString

数组也继承了Object类的toString方法，数组类型将按照旧的格式打印

例： int[] a = {2,3,5,7,11,13};

String s1 = "" + a;

System.out.println(s1);

//输出：[I@15db9742

字符串“ [I@15db9742 ”（前缀 [I 表明是一个整型数组 ）。那么我们要怎么让它返回表示对象值得字符串呢？

我们可以使用Arrays.toString方法

例： int[] b = {2,3,5,7,11,13};

String s2 = Arrays.toString(b);

System.out.println(s2);

//输出：[2, 3, 5, 7, 11, 13]

要想打印多维数组（就是数组的数组），那么就需要使用Arrays.deepToString方法

例： int[][] c = {

{1,2,3},

{4,5,6},

{7,8,9}

};

String s3 = Arrays.deepToString(c);

System.out.println(s3);

//输出：[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

下面是本次笔记中超类、子类、测试类的所有代码（注意：超类、子类、测试类不在同一个Class文件中）

超类：

tostring/Cat.javapackage tostring;public class Cat {

//定义成员变量（域），注意private（私有的），封装性

private String name;

private int age;

private String color;

//构造方法

public Cat() {

}

//构造方法的重载

public Cat(String name,int age,String color) {

this.name = name;

this.age = age;

this.color = color;

}

//set方法（修改器）

public void setName(String name) {

this.name = name;

}

public void setAge(int age) {

this.age = age;

}

public void setColor(String color) {

this.color = color;

}

//get方法（访问器）

public String getName() {

return this.name;

}

public int getAge() {

return this.age;

}

public String getColor() {

return this.color;

}

// 不建议使用

// public String toString() {

// return "Cat[name=" + name

// + ",age=" + age

// + ",color=" + color

// + "]";

// }

public String toString() {

return getClass().getName()

+ "[name=" + name

+ ",age=" + age

+ ",color=" + color

+ "]";

}

}

子类：（extends 用于继承的关键词）

tostring/LiCat.javapackage tostring;public class LiCat extends Cat{

//成员变量

private String eat;

//构造方法

public LiCat() {

super();

}

public LiCat(String name,int age,String color,String eat) {

super(name,age,color);

this.eat = eat;

}

//get、set方法

public String getEat() {

return eat;

} public void setEat(String eat) {

this.eat = eat;

}

//子类将父类的方法覆盖

public String toString() {

return super.toString()

+ "[eat=" + eat

+  "]";

}

}

测试类：

tostring/CatTest01.javapackage tostring;import java.util.Arrays;public class CatTest01 { public static void main(String[] args) {

LiCat cat1 = new LiCat("小白",11,"白色","鱼");

// Cat cat1 = new Cat();

// cat1.setName("小白");

// cat1.setAge(11);

// cat1.setColor("白色");

//返回表示对象值的字符串

//此处的 cat1 是个对象

String message = "" + cat1;

System.out.println(message); //相当于System.out.println("" + cat1);也相当于下一条代码

System.out.println(cat1); //也相当于下一条代码

System.out.println(cat1.toString());

//输出三行：a.LiCat[name=小白,age=11,color=白色][eat=鱼]

//基本数据类型

int q = 1;

System.out.println("a = " + q); //相当于下一条代码

System.out.println(q);

//输出a = 1和1

//返回类名和它的引用地址

Object aa = new Object();

System.out.println(aa.toString());

//输出：java.lang.Object@15db9742

//

int[] a = {2,3,5,7,11,13};

String s1 = "" + a;

System.out.println(s1);

//输出：[I@15db9742

//打印出一维数组

int[] b = {2,3,5,7,11,13};

String s2 = Arrays.toString(b);

System.out.println(s2);

//输出：[2, 3, 5, 7, 11, 13]

//输出多维数组

int[][] c = {

{1,2,3},

{4,5,6},

{7,8,9}

};

String s3 = Arrays.deepToString(c);

System.out.println(s3);

//输出：[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

}

}

JAVA中有一个根类Object，Object是是所有类的父类；  如果在申明中没有使用extends来继承Object，系统会默认

public class a{

}

等价于：

public class a extends Object{

s

}

系统默认的引入java.lang这个包，所以在编译的时候不用在引入这个包 ,由于a是继承的Object这个类  那么a这个类拥有Object这个类的所有方法 Obejct中有一个toString的方法； package toString的方法;

public class TesttoString {

public static void main(String[] args) {

A a = new A();

//打印输出a  此时相当于输出a.toString（）；

System.out.println(a);

}

}

class A{

}

运行结果：

toString的方法.A@158f9d3

分析：toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的外汇返佣信息表达式。建议所有子类都重写此方法。Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于： getClass().getName() + '@' + Integer.toHexString(hashCode())

下面对A类中的toString进行重写，使其返回一个字符串： package toString的方法;

public class TesttoString {

public static void main(String[] args) {

A a = new A();

//打印输出a  此时相当于输出a.toString（）；

System.out.println(a);

}

}

class A{

//在A类中重写一个toString方法

//在重写toString()方法的时候to不能使大写

public String toString(){

return"我是重写的toString()方法";

}

}

运算结果：

我是重写的toString()方法

分析：如果不想使用默认的toString方法我们可以在类中重写其方法，该对象的字符串表示形式。

Object类是JDK默认提供的一个类，所有类默认继承Object类。

Object类是所有类的父类，使用Object可以接受所有类的对象。

那么如何体现（证明），Object类是所有类的父类呢？

如果可以发生向上转型，则可以说明Object类是所有类的子类：

//默认继承（并没有写extends Object ）

class Person{}

class Student{}

public class Test1 {

public static void main(String[] args) {

//将一个Person类的对象给Object（向上转型）

//即：Object obj = new Person();

fun(new Person());

fun(new Student());

}

public static void fun(Object obj){

System.out.println(obj);

}

}

此处系统输出（pringt/println）输出对象时，默认调用对象的toString()方法。2.取得对象信息toString();

  使用系统输出输出对象时，默认输出的是一个地址编码。

  而使用系统输出输出String常量时，输出的是字符串内容。

  本质原因在于Object类提供的toString（）有没有被类所覆写。class Person {

private String name;

private int age;    public Person(String name, int age) {

this.age = age;

this.name = name;

}

}public class Test1 {

public static void main(String[] args) {

fun(new Person("fwb",20) );

fun("Hello");

}

public static void fun(Object obj) {

System.out.println(obj.toString()); // 默认输出对象调用的就是toString()方法}}

}

}

覆写toString()方法：

class Person {

private String name;

private int age;    public Person(String name, int age) {

this.age = age;

this.name = name;

}    public String toString() {

return "姓名为：" + this.name + "年龄为：" + this.age;

}

}public class Test1 {

public static void main(String[] args) {

fun(new Person("fwb",20) );

fun("Hello");

}

public static void fun(Object obj) {

System.out.println(obj.toString()); // 默认输出对象调用的就是toString()方法}}

}

}

————————————————

原文链接：https://blog.csdn.net/qq_45640831/article/details/102703375