王佳盛
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
能打印出内容的对象是因为在类中对toString（）方法进行了重写；
打印出地址值的对象是因为使用了默认的toString（）方法；
使用打印输出语句直接打印对象的时候就会调用toString（）方法。

2.我们为什么要重写equals（）方法？
equals（）没有重写，默认比较的是地址值。跟==差不多，没有实际意义。

3.==和equals（）的区别？
==
        基本类型：比较的是值；
        引用类型：比较的是地址值；
equals
        只能比较引用类型；
        没有重写的话，默认比较地址值；只有重写了才可以比较对象内容。

4.String和StringBuilder的区别？
String
        由于String类的对象不可变，所以每当字符串拼接时，都会创建新的String对象来保存拼接后的结果，比较浪费内存。
StringBuilder
        StringBuilder的长度可以改变，并且在进行字符串拼接时，不会创建新的对象。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：将基本数据类型包装起来的类。
装箱：把基本类型的数据，包装到包装类中；
拆箱：在包装类中取出基本数据类型的数据。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）打印对象时，其实是调用了对象的toString方法，而这个方法要么对象所在的类中没有，子类没有向上找，则程序调用Object类中的toString方法，打印的是地址值；要么所在的类重写了这个方法，打印出了其中的内容。
（2）对象会在被通过对象名直接打印的时候默认调用toString方法。
2.我们为什么要重写equals（）方法？
在没有重写equals方法的情况下，父类Object中自带的equals方法底层其实是使用==运算符进行比较，也就是比较地址值。一般equals方法应该被用来比较对象的属性，比较地址值大部分情况下是没有意义的，所以应该重写。
3.==和equals（）的区别？
（1）==比较运算符在比较基本数据类型的时候是比较值，比较引用数据类型的时候是比较两个对象的地址值。
（2）equals方法只能比较引用类型数据，子类重写的情况下比较的是对象的属性，没有重写的情况下默认调用Object里的==运算符，即比较地址值。   
4.String和StringBuilder的区别？
（1）StringBuilder支持内容可变的String，而String的对象一旦被创建就永远不能被更改。
（2）StringBuilder和String一样都是数组，但是StringBuilder没有被final修饰，可以改变长度，String被final修饰，不能改变长度。
（3）StringBuilder如果超出长度范围会自动扩容，String则不会。
（4）StringBuilder在进行字符串拼接时不会产生多个字符串对象，而String在进行字符串拼接时会产生多个对象。
（5）StringBuilder可以拼接任意类型的数据并返回它自身，因此可以不需要接收返回值而不丢失拼接结果；String如果不进行接收则会丢失拼接结果。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
（1）基本数据类型的数据使用方便但是没有对应的方法来操作这些数据。使用包装类来将这些基本数据类型的数据包装起来，就可以把基本数据类型当做对象，调用方法来操作这些基本数据。
（2）自动装箱：基本数据类型自动转为包装类，在使用ArrayList的时候会自动发生。
（3）自动拆箱：包装类转为基本数据类型，在使用运算符的时候自动发生。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在没有重写toString方法时，打印对象默认调用的是Object父类继承过来的toString方法，因此打印出来的是地址值，重写toString方法，打印出来就会按照重写的方式打印出对象内容。
重写了toString方法后，在我们需要打印对象内容时，写个打印函数调用 对象名 就可以打印对象内容。

2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是Object类中继承过来的方法 ，比较的是对象的地址值；
重写了之后，比较的是对象的内容。

3.==和equals（）的区别？
(1)==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
(2)equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String:String定义的字符串是常量，它们的值在创建之后不能修改；
       字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
StringBuilder:也被称为字符串缓冲区，可以提供字符串的操作效率（看成一个长度可以变化的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度;
              StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据类型的数据使用起来非常方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类。
基本类型没有方法可以操作用来操作基本类型的数据，而在包装类中可以定义方法来操作基本类型数据。
自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的相互转换。比如int类型的数据在集合调用add方法时，不会因为和Integer类型不同而报错，这之中的自动类型转换就叫做自动装箱，Integer自动转换为int类型的数据就叫做自动拆箱。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：对于引用类型来说，Object类中的toString()方法输出的是对象的地址值，
重写了Object类中的toString()方法的输出的是对象的内容。

2.我们为什么要重写equals（）方法？
答：因为Object类中的equals()比较的是对象的地址值，而一般情况两个对象的地址值是
不同的，所以这样比较没意义。而重写了equals()方法之后比较的是对象的内容。

3.==和equals（）的区别？
答：
==：基本数据类型比较的是数据的值；引用类型比较的是对象的地址值
equals：Object类中的equals方法比较的是对象的地址值，
                重写了Object类中的equals方法比较的是对象的内容。

4.String和StringBuilder的区别？
答：
String类是代表字符串，字符串的长度不可改变
StringBuilder类是字符串缓冲区，长度可变的字符序列

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：把基本类型的数据包装起来的就是包装类
包装类：对基本类型的数据进行操作
自动装箱：自动从基本类型转换为对应的包装类对象
自动拆箱：自动从包装类对象转换为对应的基本类型

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

1.如果对象有重写object1的toString方法，那么打印出来的是对象内容，如果没有重写，那么默认打印对象的地址。
2.当对象想打印输出的时候，会调用toString()方法

2.我们为什么要重写equals（）方法？

如果没有重写object的equals（）方法，那么默认比较的是两个数的地址值，没有任何意义，所以需要重写

3.==和equals（）的区别？

当是基本类型的时候，==比较的数值；
当是引用类型的时候，==比较的是地址值
equals（）方法只能引用类型调用，没重写比较的是地址值，重写后比较的内容；

4.String和StringBuilder的区别？

1.String底层是被final修饰的数组，是一个长量，长度不能改变。
2.字符串缓冲区,可以提高字符串的效率(长度可以变化的字符串)，底层也是数组，但没有被final修饰，可以改变长度，默认16个长度，如果超过，自动扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

1.使用一个类，将基本类型包装起来，在类中可以定义一些方法来操作基本类型的数据。
2.装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
  拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在没有重写toString方法时，打印对象默认调用的是Object父类继承过来的toString方法，因此打印出来的是地址值，重写toString方法，打印出来就会按照重写的方式打印出对象内容。
重写了toString方法后，在我们需要打印对象内容时，写个打印函数调用 对象名 就可以打印对象内容。

2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是Object类中继承过来的方法 ，比较的是对象的地址值；
重写了之后，比较的是对象的内容。

3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String:String定义的字符串是常量，它们的值在创建之后不能修改；
       字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
StringBuilder:也被称为字符串缓冲区，可以提供字符串的操作效率（看成一个长度可以变化的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度;
              StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据类型的数据使用起来非常方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类。
基本类型没有方法可以操作用来操作基本类型的数据，而在包装类中可以定义方法来操作基本类型数据。
自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的相互转换。比如int类型的数据在集合调用add方法时，不会因为和Integer类型不同而报错，这之中的自动类型转换就叫做自动装箱，Integer自动转换为int类型的数据就叫做自动拆箱。

黄志斌：
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在没有重写toString方法时，打印对象默认调用的是Object父类继承过来的toString方法，所以打印出来的是地址值，重写toString方法后，打印出来的就是按照重写的方式打印出的对象内容。
重写了toString方法后，在我们需要打印对象内容时，调用对象名就可以打印对象内容。

2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是Object类中继承过来的方法 ，比较的是对象的地址值；
重写了之后，比较的是对象的内容。

3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String:String定义的字符串是常量，它们的值在创建之后不能修改；
字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
StringBuilder:也被称为字符串缓冲区，可以提供字符串的操作效率（看成一个长度可以变化的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度;
StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据类型的数据使用起来非常方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类。
基本类型没有方法可以操作用来操作基本类型的数据，而在包装类中可以定义方法来操作基本类型数据。
自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的相互转换。比如int类型的数据在集合调用add方法时，不会因为和Integer类型不同而报错，这之中的自动类型转换就叫做自动装箱，Integer自动转换为int类型的数据就叫做自动拆箱。

叶凌青
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为默认调用的object的toString方法，打印的就是地址值
有些类重写了object的toString方法，所以打印出重写的内容
对象在打印对象名的时候回调用toString方法
2.我们为什么要重写equals（）方法？
因为默认调用的是object的equals（）方法，比较的是引用类型的地址值是否相同
我们重写equals方法使其比较对象的内容是否相等
3.==和equals（）的区别？
== 比较的基本数据类型的是数值  比较引用类型的是地址值
而equals只能比较引用数据类型
如果默认调用object的equals方法，比较的是引用类型的地址值
如果我们重写了equals方法，比较的是内容是否相等
4.String和StringBuilder的区别？
String的实例是不可更改的，所以有时候我们做字符串的拼接的时候，可能会产生很多个对象，从而造成浪费
StringBuider相当于在后面做拼接，一直都返回的是同一个对象。所以不会造成浪费。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本类型对应的引用类型，相当于基本类型包着一层，自动装箱指的是 基本数据类型——>包装类  自动拆箱 指的是 包装类——>基本数据类型

陈鹏涛
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在没有重写toString方法时，打印对象默认调用的是Object父类继承过来的toString方法，因此打印出来的是地址值，重写toString方法，打印出来就会按照重写的方式打印出对象内容。
重写了toString方法后，在我们需要打印对象内容时，写个打印函数调用 对象名 就可以打印对象内容。

2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是Object类中继承过来的方法 ，比较的是对象的地址值；
重写了之后，比较的是对象的内容。

3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String:String定义的字符串是常量，它们的值在创建之后不能修改；
       字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
StringBuilder:也被称为字符串缓冲区，可以提供字符串的操作效率（看成一个长度可以变化的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度;
              StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据类型的数据使用起来非常方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类。
基本类型没有方法可以操作用来操作基本类型的数据，而在包装类中可以定义方法来操作基本类型数据。
自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的相互转换。比如int类型的数据在集合调用add方法时，不会因为和Integer类型不同而报错，这之中的自动类型转换就叫做自动装箱，Integer自动转换为int类型的数据就叫做自动拆箱。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在没有重写toString方法时，打印对象默认调用的是Object父类继承过来的toString方法，因此打印出来的是地址值，重写toString方法，打印出来就会按照重写的方式打印出对象内容。
重写了toString方法后，在我们需要打印对象内容时，写个打印函数调用 对象名 就可以打印对象内容。

2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是Object类中继承过来的方法 ，比较的是对象的地址值；
重写了之后，比较的是对象的内容。

3.==和equals（）的区别？
(1)==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
(2)equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String:String定义的字符串是常量，它们的值在创建之后不能修改；
       字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
StringBuilder:也被称为字符串缓冲区，可以提供字符串的操作效率（看成一个长度可以变化的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度;
              StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据类型的数据使用起来非常方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类。
基本类型没有方法可以操作用来操作基本类型的数据，而在包装类中可以定义方法来操作基本类型数据。
自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的相互转换。比如int类型的数据在集合调用add方法时，不会因为和Integer类型不同而报错，这之中的自动类型转换就叫做自动装箱，Integer自动转换为int类型的数据就叫做自动拆箱。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
类中没有重写toString方法时,打印对象打印的就是地址值,重写后打印的是重写的内容
使用对象名调用或使用输出语句输出对象名的时候,通过该对象调用了其toString()方法。

2.我们为什么要重写equals（）方法？
没有重写equals方法时,使用的是从Object类中继承的equals方法,该方法底层使用this与传入的形参==比较,
比较的是地址值,要比较对象的属性相等必须重写equals方法.

3.==和equals（）的区别？
==:
比较基本数据类型时,比较的是数据值,比较引用数据类型时,比较的是地址值
equals():
只能比较引用数据类型,没被重写时比较的是地址值

4.String和StringBuilder的区别？
String类型的字符串创建后长度就不可变,底层是一个final修饰的字符数组,进行字符串拼接时较浪费资源
StringBulider创建的字符串长度可变,默认长度为16,随着内容增加长度也会增加

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
8种基本类型都有对应的包装类,包装类中有许多操作基本类型数据的方法
自动装箱:
从基本类型转换成包装类时可以自动转换
自动拆箱:
从包装类转换至基本类型时可以自动转换

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

答：这主要取决于是否对类的toString方法进行冲重写，因为所有类的直接或者间接父类都是Object类，Object类中的toString方法是打印出对象的地址值，当子类对toString方法进行重写打印内容时，子类的对象打印输出的就是对象内容，而如果子类没有重写toString，则打印对象输出的就是地址值。
对象在类创建对象的时候就会调用toString方法。

2.我们为什么要重写equals（）方法？

答：因为Object类的equals方法比较的时两个对象的地址值，正常情况下，两个对象的地址值是不同的，所以这种比较时没有意义的，而我们需要的是比较对象的内容属性，因此需要对equals方法进行重写，才能对两个对象的属性进行比较。

3.==和equals（）的区别？

答：==在基本数据类型之间，比较的是数值，在引用数据类型之间，比较的是地址值。
equals()在没有重写之前比较的是两个对象之间的地址值，当子类重写equals方法后，比较的是子类对象的属性是否相同。

4.String和StringBuilder的区别？

答：String类创建的是长度不可该表的字符串，这种字符串是常量，在进行拼接操作时会产生很多的String对象，占用大量的内存。在进行少量字符串时比Stringbuilder创建的容器少占内存。
StringBuilder类创建的是容器，可以装很多的字符串，在进行拼接时，直接在容器中加入字符串。StringBuilder还可以自动扩容。在进行大量字符串拼接时比String拼接好用。


5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

答：包装类是用来包装基本数据类型的类，方便对基本数据类型的数据进行各种方法的操作。
包装类的内容是基本数据类型，但本身是引用数据类型。
自动装箱指的是，java编译器自行把基本数据类型转换成相对应的包装类。
自动拆箱指的是，java编译器自行把包装类转换为相对应的基本数据类型。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

Object类的toString方法是打印地址值，只要对象类没有重写toString方法，都是默认打印地址值;只要对象有重写toString

方法，打印的都是对象内容。

直接使用对象的时候就会调用toString方法

2.我们为什么要重写equals（）方法？

equals()方法默认的是地址值比较，没有意义，需要进行重写，来比较对象的属性内容

3.==和equals（）的区别？

==比较基本数据类型比较的是数据值；比较引用数据类型时，比较的是地址值。

equals：只能比较引用数据类型，重写前比较的是地址值，重写后比较的是对象的内容

4.String和StringBuilder的区别？

String中的字符串长度是常量,它们的值在创建之后不可变的，若要进行字符串拼接会产生多个字符串常量，占用内存，效率低。

StringBuilder是字符串缓冲区,可变字符序列可以对字符串的内容进行拼接追加字符串，不会创建多个字符串对象节省内存占用空间，效率高

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类就是基本类型的包装起来，变成引用数据类型，以便给某些对象使用。基本类型不能在集合中使用。

自动装箱就是JVM会自动转换基本数据类型为包装类型

自动拆箱就是JVM会自动转换包装类型为基本数据类型。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
   默认使用的是从Object类中继承过来的方法，打印的是地址值；重写了之后，打印的是对象内容。直接打印对象的名字，会调用对象的toString方法。

2.我们为什么要重写equals（）方法？
    如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；重写了之后，比较的是对象的内容

3.==和equals（）的区别？

    ==  

比较基本数据类型，比较的是数据值

比较引用数据类型，比较的是对象的地址值

   
equals()

只能比较引用数据类型

重写之前，比较的是地址值，底层就是==

重写之后，比较的是对象的内容


4.String和StringBuilder的区别？
   String字符串是常量，他们的值在创建之后不能更改；
StringBuilder是字符串缓冲区，占用空间少，效率高，底层也是一个数组，但是没有被final修饰，其初始容量为 16 个字符，如果超出了StringBuilder的容量，会自动的扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
    包装类就是基本数据类型对应的引用数据类型
    区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
   自动装箱：即自动进行基本类型转换为包装类的操作；
   自动拆箱：即自动进行包装类转换为基本类型的操作；

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象,如果没有重写toString方法，那么打印出来的是对象的类型+@+内存地址值；如果该对象的类重写了toString方法，那么打印出来的是对象的内容。
直接打印对象名，会调用对象的toString方法。

2.我们为什么要重写equals（）方法？
equals()方法用于比较两个对象地址值是否相等。在没有重写的情况下，只要不是同一个对象，结果必然为false，这种比较的结果没有实际意义。我们希望的是对两个对象的内容进行比较，所以需要重写equals()方法。

3.==和equals（）的区别？
==运算符可以比较基本数据类型的数据值，也可以比较引用数据类型的地址值；
equals()方法只能对引用数据类型进行比较。在没有重写equals方法的情况下，比较的是对象的地址值；重写后可以比较对象的属性内容。

4.String和StringBuilder的区别？
String字符串是常量，它的值在创建之后不能更改；
StringBuilder是字符串缓冲区，占用空间少，效率高，底层也是一个数组，但是没有被final修饰，其初始容量为 16 个字符，如果超出了StringBuilder的容量，会自动的扩容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本类型数据对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多方法
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果自定义的类中没有重写toString方法，那么打印的就是地址值，因为从Object类中继承下来的toString方法打印的就是对象的地址值；
如果有对toString方法进行重写，打印的就是对象的内容
对象打印时会调用toString方法
2.我们为什么要重写equals（）方法？
由于从Object继承下来的equals方法只是简单的==，那么对于引用类型比较的只是对象的地址值，所以当需要比较两个对象的内容时，就需要对equals方法进行重写
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String底层是byte数组，所以值在创建之后不能更改，每当进行字符串拼接时，总是会在内存中创建一个新的对象
StringBuilder是字符串缓冲区，由于它是一个容器，可以装很多字符串，拼在后面，所以只会创建一个对象，节省程序的资源
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：Java中提供的对基本数据类型进一步包装产生的引用类型，能够像操作对象一样来操作基本类型
区别：基本类型没有对象方法的概念，包装类是引用类型，可以实例化对象，调用方法
自动装箱：从基本类型转换为对应的包装类对象
自动拆箱：从包装类对象转换为对应的基本类型

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

        原因：在打印时，如果没对toString方法进行重写的话，那会默认使用从Object类继承过来的方法，而此时打印出来的是地址值；而如果有对toString进行重写的话，那么打印出来的就是对象内容；
        使用场景：想要返回对象的属性内容时，可将其进行调用重写；
2.我们为什么要重写equals（）方法？

        如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？

        ==：
                基本数据，比较数据值；
                引用数据，比较地址值；
        equals（）：只能比较引用数据；
                重写：比较对象的属性内容；
                不重写：比较地址值；
4.String和StringBuilder的区别？

        String：
                底层是被final修饰的数组，是一个不变的常量；
                在进行相加时，内存会出现多个字符串，占用多，效率低；
        StingBuilder：
                底层是数组，但没有被final修饰，长度可变；
                在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

        包装类：基本数据所对应的引用数据类型；
        区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
        自动装箱：即自动进行基本类型转换为包装类的操作；
        自动拆箱：即自动进行包装类转换为基本类型的操作；

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有些对象有toString方法,有些没有,打印类对象时自动调用toString()方法
2.我们为什么要重写equals（）方法？
因为有的时候equals()不能满足我们的需要
3.==和equals（）的区别？
==判断的是地址值或者基本类型的内容是否相等,而equals()判断的是内容是否相等
4.String和StringBuilder的区别？
String长度是固定的,长度不能发生改变,StringBuilder是变长的,长度会随着内容的增加而增加
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是将基本类型包装起来的类,数组集合中不能直接存放基本类型,只能存放引用类型,自动装箱就是将基本类型包装成包装类型,
自动拆箱就是将包装类型转化成基本类型

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：打印地址值时是因为类中没有重写toString（），当类重写了toString（）方法时，打印的则是对象内容；在直接输出对象时，会默认调用对象的toString（)方法，在打印属性内容，或者遍历的时候也会调用toString（）方法。
2.我们为什么要重写equals（）方法？
答：如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；而重写了之后，比较的是对象的内容。
3.==和equals（）的区别？
答：==    在比较基本数据类型时，比较的是数据值；在比较引用数据类型时，比较的是对象的地址值
equals()   只能比较引用数据类型；重写之前，比较的是地址值，底层就是==；重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
答: String类的对象内容不可改变，在进行字符串拼接时，会在内存中创建一个新的对象，如果经常改变字符串的内容最好不要用String,因为每次生成对象都会对系统性能产生影响。
StringBuilder是字符串缓冲区，通过方法调用可以改变该字符串序列的长度和内容。也可以装很多字符串，并且能够对其中的字符串进行各种操作。StringBuilder的内部拥有一个数组用来存放字符串内容，在进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动维护数组的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类就是基本数据类型对应的引用数据类型；
区别：包装类是对象,拥有方法和字段，对象的调用都是通过引用对象的地址，产生对象时直接用引用指向这个对象（引用变量是在存在栈内存中，对象是在堆内存中的，堆中分配内存）；而基本类型是直接存储数值；另外，包装类是引用传递，而基本类型是值传递;
自动拆箱和自动装箱是在进行集合存储和比较的时候自动完成

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？如果对象对应的类及其父类没有重写toString方法，则打印的是地址值
若有重写toString方法，则打印的是对象内容
通过对象调用toString方法时 以及对象在被打印时会默认隐含调用了toString方法
2.我们为什么要重写equals（）方法？
因为自定义的类，系统无法判断通过哪些属性判断是否相同，这时候就需要重写equals()方法，给系统判断定义是否相同的标准
3.==和equals（）的区别？
==比较的是两个对象的地址值是否相同，equals（）比较的是两个对象的内容是否相同。
4.String和StringBuilder的区别？
一、String创建的是字符串对象，StringBuilder创建的是是一个字符串缓存区
二、String创建的字符串的内容长度是不可改变，StringBuilder创建的字符串缓冲区长度和内容都是可以改变的。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？


包装类是对基本数据类型的包装，将其包装成引用类型
包装类型属于引用类型，不属于基本数据类型
自动装箱：自动将基本数据类型转换成对应的包装类（引用数据类型）
自动拆箱：自动将包装类（引用数据类型）转换成对应的基本数据类型