day1Java基础知识（一）

Java基础知识
⭐了解
⭐⭐掌握
⭐⭐⭐必会

语法基础

面向对象特性？⭐

封装：将对象的 属性和行为封闭起来通过接口来外界联系用户不知道内部细节。提高安全性，降低了耦合
继承：子类继承了父类的数据属性和行为，并且可以根据自己的需求拓展出新行为。提高代码的可用性。
多态：指不同对象对同一个消息对不同对象采取不同的行为
抽象：对具体的事物进行抽象概念

/**
 * 以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。
 */

public class Person{
 private String name;
    private int gender;
    private int age;

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender == 0 ? "man" : "woman";
    }

    public void work() {
        if (18 <= age && age <= 50) {
            System.out.println(name + " is working very hard!");
        } else {
            System.out.println(name + " can't work any more!");
        }
    }



}

/**
 * Dog是Animal的子类它继承了父类非private的属性和方法
 * Dog可以当成Animal用，也就是说父类（Animal ）引用了子类对象（Dog）
 * 即**向上转型**
 */
Animal animal = new Dog();

//下面代码中Dog,Sheep都属于Animal，且都有动物的共同行为eat,只不过
吃的食物不同。这就是多态。
public class Animal{
public void eat{
System.out.println("Animal eat...");
}
}

public class Dog extends Animal{
public void eat{
System.out.println("Dog eat meat ");
}
}
public class Sheep extends Animal{
public void eat{
System.out.println("Sheep eat grass");
}
}

public class Home{
  public static void  main(String[] args){
List<Animal> animal= new ArrayList<>();
        animal.add(new Dog ());
        animal.add(new Sheep ());
        for(Animal animals: animal) {
            animal.eat();
        }

}
}

a = a + b 与 a += b 的区别

+=会强制类型升级

重载和重写的区别（必会）

发生在同一个类中 方法名必须相同，参数类型不同.个数不同.顺序不同，
方法返回值和访问修饰符可以不同，发生在编译时

重写： 发生在父子类中，方法名.参数列表必须相同，返回值范围小于等于父类，
抛出的异
常范围小于等于父类，
访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能
重写该方法。

Java 中==和 equals 的区别（必会）

== 基本数据类型 内容是否相同
引用数据类型 地址是否相同
equals
equals只能比较引用数据类型，且Object类的equals默认情况下是比较的是地址值，无意义，子类一般会重写，改为比较：属性值
equals()方法存在于Object类中，而Object类是所有类的直接或间接父类。
注意：String、Integer、Date 这些类库中 equals 被重写，比较的是内容而不是地址！
== 和equals的区别
1.==是运算符可以对基本类型直接使用，而equals是一种非静态的方法，需要对象调用。
2.==比较基本数据的是值，引用类型的是地址值
3.equals只能比较引用数据类型，且Object类的equals默认情况下是比较的是地址值，无意义，子类一般会重写，改为比较：属性值
面试题：请解释字符串比较之中 “ == ” 和 equals() 的区别？
答： ==：比较的是两个字符串内存地址（堆内存）的数值是否相等，属于数值比较；
equals()：比较的是两个字符串的内容，属于内容比较。

对equals()和hashCode()的理解?

有没有可能两个不相等的对象有相同的 hashcode?有可能
两个相同的对象会有不同的 hash code 吗?不可能

final、finalize 和 finally 的不同之处?

final用来修饰变量、方法和类，如修饰变量初始化后不可改变（被final修饰不可变的是变量的引用，而不是引用指向的内容，引用指向的内容是可以改变的）修饰方法不可被重写，修饰类不可被继承
finally用在try-catch代码块中，用了将一定要执行的代码发在finlly块中
finalize 是object 的一个方法用来在垃圾回收器在确定对象没有被引用时后将该对象清除出去。

常用api-String

string底层是char数组
不变性：String 是只读字符串，是一个典型的 immutable 对象，对它进行任何操作，其实都是创
建一个新的对象，再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并
频繁访问时，可以保证数据的一致性。
常量池优化：String 对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象时，
会直接返回缓存的引用。
final：使用 final 来定义 String 类，表示 String 类不能被继承，提高了系统的安全性。

String、StringBuffer、StringBuilder 三者之间的区别（必会）

1. 可变性

String 不可变
StringBuffer 和 StringBuilder 可变
2. 线程安全

String 不可变，因此是线程安全的
StringBuilder 不是线程安全的
StringBuffer 是线程安全的，内部使用 synchronized 进行同步
如果要操作少量的数据用 = String
单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

String str="a"与 String str=new String(“a”)一样吗？

不一样，一个分配到常量池一个分配到堆内存

String s = new String(“abc”);创建了几个字符串对象

两个，一个静态区的"abc"一个new创建在堆上的对象

如何将字符串反转？

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

// StringBuffer reverse
StringBuffer stringBuffer = new StringBuffer();
stringBuffer. append("abcdefg");
System. out. println(stringBuffer. reverse()); // gfedcba
// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder. append("abcdefg");
System. out. println(stringBuilder. reverse()); // gfedcba

数组有没有 length()方法？String 有没有 length()方法

数值有length属性没有length方法，String有length方法没length属性

String 类的常用方法都有那些？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

在使用 HashMap 的时候，用 String 做 key 有什么好处？

HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置，因为字符串是不可变的，所以
当创建字符串时，它的 hashcode 被缓存下来，不需要再次计算，所以相比于其他对象更快。

Date相关

自动装箱与拆箱

你不能直接地向集合(Collections)中放入原始类型值，因为集合只接收对象。通常这种情况下你的做法是，将这些原始类型的值转换成对象，然后将这些转换的对象放入集合中。

int 和 Integer 有什么区别

int是原始类型 不能放入集合
Integer 是包装类 可以放入集合

Integer a= 127 与 Integer b = 127相等吗

对于对象引用类型：==比较的是对象的内存地址。
对于基本数据类型：比较的是值。
如果整型字面量的值在-128到127之间，那么自动装箱时不会new新的Integer对象，而是直接引用常量
池中的Integer对象，超过范围 a1b1的结果是false

public static void main(String[] args) {
Integer a = new Integer(3);
Integer b = 3; // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false 两个引用没有引用同一对象
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
System.out.println(b == c); // true
Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); // false
Integer a2 = 127;
Integer b2 = 127;
System.out.println(a2 == b2); // true
}

异常处理

Throwable 是 Java 语言中所有错误与异常的超类。 Error 类及其子类：程序中无法处理的错误，表示运行应用程序中出现了严重的错误。Exception 程序本身可以捕获并且可以处理的异常。Exception 这种异常又分为两类：运行时异常和编译时异常。

可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）区别？

可查异常
通常是我们程序允许的，可预料的 ，而且一旦发生这种异常状况，就必须采取某种方式进行处理。除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

不可查异常
包括运行时异常（RuntimeException与其子类）和错误（Error）。

error和exception有什么区别

error 表示系统级的错误，是java运行环境内部错误或者硬件问题，只能退出程序
exception 表示是程序错误，是程序可以处理的

运行时异常和一般异常有何不同

运行时异常（runtimeException）我们一般不处理，当出现这类异常的时候程序会由虚拟机接管。比
如，我们从来没有去处理过NullPointerException，而且这个异常还是最常见的异常之一。
出现运行时异常的时候，程序会将异常一直向上抛，一直抛到遇到处理代码，如果没有catch块进行处
理，到了最上层，如果是多线程就有Thread.run()抛出，如果不是多线程那么就由main.run()抛出。抛
出之后，如果是线程，那么该线程也就终止了，如果是主程序，那么该程序也就终止了。
其实运行时异常的也是继承自Exception，也可以用catch块对其处理，只是我们一般不处理罢了，也就
是说，如果不对运行时异常进行catch处理，那么结果不是线程退出就是主程序终止。
如果不想终止，那么我们就必须捕获所有可能出现的运行时异常。如果程序中出现了异常数据，但是它
不影响下面的程序执行，那么我们就该在catch块里面将异常数据舍弃，然后记录日志。如果，它影响
到了下面的程序运行，那么还是程序退出比较好些。

一般异常（checkedException）主要是指IO异常、SQL异常等。对于这种异常，JVM要求我们必须对其
进行cathc处理，所以，面对这种异常，不管我们是否愿意，都是要写一大堆的catch块去处理可能出现
的异常

Java中异常处理机制的原理

Java通过面向对象的方式对异常进行处理，对象里有中包含有异常信息调用这个对象的方法可
以捕获到这个异常并对异常进行处理。Java的异常处理是通过5个关键词来实现的：try catch throw
throws finally。
一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws），我们可以通过它的类型
来捕捉它，或最后由缺省处理器来处理它（finally）。
try：用来指定一块预防所有异常的程序
catch：紧跟在try后面，用来捕获异常
throw：用来明确的抛出一个异常
throws：用来标明一个成员函数可能抛出的各种异常
finally：确保一段代码无论发生什么异常都会被执行的一段代码。

你平时在项目中是怎样对异常进行处理的

（1）尽量避免出现runtimeException 。例如对于可能出现空指针的代码，带使用对象之前一定要判断
一下该对象是否为空，必要的时候对runtimeException
也进行try catch处理。
（2）进行try catch处理的时候要在catch代码块中对异常信息进行记录，通过调用异常类的相关方法获
取到异常的相关信息，返回到web端，不仅要给用户良好的用户体验，也要能帮助程序员良好的定位异常出现的位置及原因。例如，以前做的一个项目，程序遇到异常页面会显示一个图片告诉用户哪些操作导致程序出现
了什么异常，同时图片上有一个按钮用来点击展示异常的详细信息给程序员看的。

空指针异常的原因

1、没有对你new出来的对象进行实例化，或者你去数据库里查询一个空的对象，就是空指针

2、空指针的异常NullPointer 无非是因为对象为null的情况下去调用该对象所拥有的方法或者成员变量造成的

解决办法：

在调用有可能为空的变量的时候，最好做一下非空的判断。

final、finally、finalize的区别

（1）、final用于声明变量、方法和类的，分别表示变量值不可变，方法不可覆盖，类不可以继承
（2）、finally是异常处理中的一个关键字，表示finally{}里面的代码一定要执行
（3）、finalize是Object类的一个方法，在垃圾回收的时候会调用被回收对象的此方法。

try()里面有一个return语句，那么后面的finally{}里面的code会不会被执行，什么时候执行，是在return前还是return后？

会执行，会执行return 后在返回之前发现finally会执行finally里面的代码后在返回

你曾经自定义实现过异常吗？怎么写的?

throw和throws有什么区别？

throw关键字用来在程序中明确的抛出异常，相反，throws语句用来表明方法不能处理的异常。每一个
方法都必须要指定哪些异常不能处理，所以方法的调用者才能够确保处理可能发生的异常，多个异常是用逗号分隔的。

异常处理的时候，finally代码块的重要性是什么？

无论是否抛出异常，finally代码块总是会被执行。就算是没有catch语句同时又抛出异常的情况下，
finally代码块仍然会被执行。最后要说的是，finally代码块主要用来释放资源，比如：I/O缓冲区，数据
库连接。

异常的使用的注意地方？

不要将异常处理用于正常的控制流（设计良好的 API 不应该强迫它的调用者为了正常的控制流而使用异
常）。
对可以恢复的情况使用受检异常，对编程错误使用运行时异常。
避免不必要的使用受检异常（可以通过一些状态检测手段来避免异常的发生）。
优先使用标准的异常。
每个方法抛出的异常都要有文档。
保持异常的原子性
不要在 catch 中忽略掉捕获到的异常。

请列出 5 个运行时异常？

NullPointerException
IndexOutOfBoundsException
ClassCastException
ArrayStoreException 当你试图将错误类型的对象存储到一个对象数组时抛出的异常
BufferOverflowException 写入的长度超出了允许的长度

类

类与接口

抽象类和接口的对比

相同点
接口和抽象类都不能实例化
都位于继承的顶端，用于被其他实现或继承
都包含抽象方法，其子类都必须覆写这些抽象方法
不同点

普通类和抽象类有哪些区别？

普通类不能包含抽象方法，抽象类可以包含抽象方法。
抽象类不能直接实例化，普通类可以直接实例化。

抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛
盾，所以 final 不能修饰抽象类

创建一个对象用什么关键字？对象实例与对象引用有何不同？

new关键字，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈
内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个
对象可以有n个引用指向它（可以用n条绳子系住一个气球）

Java中，什么是构造方法？什么是构造方法重载？什么是复制构造方法？

new关键字，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈
内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个
对象可以有n个引用指向它（可以用n条绳子系住一个气球）

Java支持多继承么？

Java中类不支持多继承，只支持单继承（即一个类只有一个父类）。 但是java中的接口支持多继承，，
即一个子接口可以有多个父接口。（接口的作用是用来扩展对象的功能，一个子接口继承多个父接口，
说明子接口扩展了多个功能，当类实现接口时，类就扩展了相应的功能）。

变量与方法

成员变量与局部变量的区别有哪些

变量：在程序执行的过程中，在某个范围内其值可以发生改变的量。从本质上讲，变量其实是内存中的
一小块区域
成员变量：方法外部，类内部定义的变量
局部变量：类的方法中的变量。
成员变量和局部变量的区别

在Java中定义一个不做事且没有参数的构造方法的作用

Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类
中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没
有用super()来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参
数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？

帮助子类做初始化工作。

一个类的构造方法的作用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为什么？

主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不
带参数的构造方法。

构造方法有哪些特性？

名字与类名相同；
没有返回值，但不能用void声明构造函数；
生成类的对象时自动执行，无需调用。

静态变量和实例变量区别

静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程
中，JVM只为静态变量分配一次内存空间。
实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内
存中，创建几次对象，就有几份成员变量。

静态变量与普通变量区别

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存
中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象
的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化

静态方法和实例方法有何不同？

静态方法和实例方法的区别主要体现在两个方面：

1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而
   实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访
   问实例成员变量和实例方法；实例方法则无此限制

在一个静态方法内调用一个非静态成员为什么是非法的？

由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问
非静态变量成员。

什么是方法的返回值？返回值的作用是什么？

方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结
果）。返回值的作用:接收出结果，使得它可以用于其他的操作！

Object根类

equals()和hashcode()的联系

hashCode()是Object类的一个方法，返回一个哈希值。如果两个对象根据equal()方法比较相等，那么
调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值。
如果两个对象根据eqaul()方法比较不相等，那么产生的哈希值不一定相等(碰撞的情况下还是会相等
的。)

a.hashCode()有什么用?

将对象放入到集合中时，首先判断要放入对象的hashcode是否已经在集合中存在，不存在则直接放入
集合。如果hashcode相等，然后通过equal()方法判断要放入对象与集合中的任意对象是否相等：如果
equal()判断不相等，直接将该元素放入集合中，否则不放入

a==b与a.equals(b)有什么区别

如果a 和b 都是对象，则 ab 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会
返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例
如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。
基本类型比较用，比较的是他们的值。默认下，对象用==比较时，比较的是内存地址，如果需要比较
对象内容，需要重写equal方法。

什么是内部类？内部类的优点

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个
属性，与其他属性定义方式一致。

内部类的分类有哪些

内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

内部类有哪些应用场景

1. 一些多算法场合
2. 解决一些非面向对象的语句块。
3. 适当使用内部类，使得代码更加灵活和富有扩展性。
4. 当某个类除了它的外部类，不再被其他的类使用时。

局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？

以上例子，为什么要加final呢？是因为生命周期不一致， 局部变量直接存储在栈中，当方法执行结束
后，非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局
部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这
个问题。

重写与重载

构造器（constructor）是否可被重写（override）

构造器（constructor）是否可被重写（override）
构造器不能被继承，因此不能被重写，但可以被重载。

重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行
时的多态性。
重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法
返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分
重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父
类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

JDK 中常用的包有哪些

java.lang：这个是系统的基础类；
java.io：这里面是所有输入输出有关的类，比如文件操作等；
java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；
java.net：这里面是与网络有关的类；
java.util：这个是系统辅助类，特别是集合类；
java.sql：这个是数据库操作的类。

import java和javax有什么区别

刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来说使用。然而随着时
间的推移，javax 逐渐的扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包将是太
麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准API的一部分。
所以，实际上java和javax没有区别。这都是一个名字。

泛型

为什么需要泛型？

泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

泛型类如何定义使用？

从一个简单的泛型类看起：class Point{ // 此处可以随便写标识符号，T是type的简称
private T var ; // var的类型由T指定，即：由外部指定
public T getVar(){ // 返回值的类型由外部决定
return var ;
}
public void setVar(T var){ // 设置的类型也由外部决定
this.var = var ;
}
}
public class GenericsDemo06{
public static void main(String args[]){
Point p = new Point() ; // 里面的var类型为String类型
p.setVar(“it”) ; // 设置字符串
System.out.println(p.getVar().length()) ; // 取得字符串的长度
}
}

泛型接口如何定义使用？

泛型方法如何定义使用？

泛型的上限和下限？

如何理解Java中的泛型是伪泛型？

注解

注解的作用？

生成文档，通过代码里标识的元数据生成javadoc文档。编译检查，通过代码里标识的元数据让编译器在编译期间进行检查验证。编译时动态处理，编译时通过代码里标识的元数据动态处理，例如动态生成代码。运行时动态处理，运行时通过代码里标识的元数据动态处理，例如使用反射注入实例

注解的常见分类？

Java自带的标准注解，包括@Override、@Deprecated和@SuppressWarnings，分别用于标明重写某个方法、标明某个类或方法过时、标明要忽略的警告，用这些注解标明后编译器就会进行检查。元注解，元注解是用于定义注解的注解，包括@Retention、@Target、@Inherited、@Documented@Retention用于标明注解被保留的阶段@Target用于标明注解使用的范围@Inherited用于标明注解可继承@Documented用于标明是否生成javadoc文档自定义注解，可以根据自己的需求定义注解，并可用元注解对自定义注解进行注解

写10个常用的注解

https://blog.csdn.net/m0_56902859/article/details/130232050

反射

什么是反射？

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射的使用？

Class类对象的获取 @Test
public void classTest() throws Exception {
// 获取Class对象的三种方式
logger.info(“根据类名: \t” + User.class);
logger.info(“根据对象: \t” + new User().getClass());
logger.info(“根据全限定类名:\t” + Class.forName(“com.test.User”));
// 常用的方法
logger.info(“获取全限定类名:\t” + userClass.getName());
logger.info(“获取类名:\t” + userClass.getSimpleName());
logger.info(“实例化:\t” + userClass.newInstance());
}
Constructor类及其用法Field类及其用法Method类及其用

getName、getCanonicalName与getSimpleName的区别?

getSimpleName：只获取类名getName：类的全限定名，jvm中Class的表示，可以用于动态加载Class对象，例如Class.forName。getCanonicalName：返回更容易理解的表示，主要用于输出（toString）或log打印，大多数情况下和getName一样，但是在内部类、数组等类型的表示形式就不同了