1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有些对象对应的类中已经重新了toString方法 打印的时候就是输出对象内容，没有重写的就是输出对象的地址值。
在打印对象的时候就会调用toString方法。
2.我们为什么要重写equals（）方法？
因为如果不重写比较的就是两个对象的地址值而不是对象的具体内容，那么equals就意义不大效果等于==。
3.==和equals（）的区别？
==在对比基本数据类型的时候是比较值是否相等，而在对比引用类型时，是比较两个对象的地址值。
equals比较两个对象的内容是否相等。如果对象对应的类里没有重写equals方法那么比较的也是两个对象的地址值。
4.String和StringBuilder的区别？
String字符串是一个常量一旦创建内容不可改变，StringBuilder是一个容器，内容和长度随时可以改变。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
将基本类型变成对应的引用类型可以进行对象创建使用。
自动装箱：从基本类型自动转换为对应的包装类对象
自动拆箱：从包装类对象自动转换为对应的基本类型

今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
toString:
如果不重写，默认使用的是从Object类中继承过来的方法，打印的是地址值；重写了之后，打印的是对象内容
打印对象在有重写toSring的时候会打印对象内容
打印对象没有重写toSring的时候会打印对象地址值
对象在被输出的情况下回隐示的调用toString();

2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；重写了之后，比较的是对象的内容
和toSting();一样没有重写比较的是地址值.
不一样的是toString()未重写是打印地址;重写打印对象内容
equals()未重写比较的是地址值;重写是比较对象的内容

3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容

4.String和StringBuilder的区别？
StringBuider只会创建一个对象，节省程序的资源
String内容一旦赋值不可改变 改变需要重新定义String内容 会有多个对象 占用程序资源

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

包装类就是基本数据类型对应的引用数据类型
好处：能够使用方法进行对基本数据类型的操控
区别在于一个是基本数据类型;一个是引用数据类型
拆箱：包装类->基本数据类型
装箱：基本数据类型->包装类
自动拆箱：在进行集合比较的时候自动完成
自动装箱：在进行集合存储的时候自动完成

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象是调用了toString()方法，所以直接打印对象的话就是地址值，通过覆盖重写对象打印就是对象的内容
对象在直接打印的时候会调用toString()方法

2.我们为什么要重写equals（）方法？
如果不重写equals（）方法的话，会比较地址值，所以需要重写equals（）方法，比较对象的内容

3.==和equals（）的区别？
==如果是基本数据类型进行比较，比较的是数据值，引用数据类型进行比较，比较的是对象的地址值

equals（）是只能引用类型进行比较，重写之前，默认比较地址值，重写之后，是比较对象的内容

4.String和StringBuilder的区别？
String类的对象内容不可改变，每次构建新的String类，既耗时，又浪费空间
StringBuilder类的对象长度内容可以改变

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型
自动装箱是从基本类型自动转换为对应的包装类对象。
自动拆箱是从包装类对象自动转换为对应的基本类型

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
     不重写的话，默认使用的是object继承过来的方法，打印的是地址值，重写之后打印的是对象的内容。
     需要按照对象的属性得到想应的字符串表现形式就会调用toString()方法。
2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是从object继承过来的方法，比较的是地址值；重写之后，比较的就是对象的内容
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值。
比较引用类型，比较的是地址值。
equals()
只能用于引用类型
重写之前，比较的是地址值，底层就是==。
重写之后，比较的是对象的内容。
4.String和StringBuilder的区别？
String：每当进行字符串拼接时，总会在内存创建一个新的对象。
StringBuilder:它是一个类型于String的字符串缓冲区，可以装很多字符串，并且能过对其中的字符串进行各种操作，字符串拼接时数组直接加入新内容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：可以像对象一样操作，可以做更多的功能，提高效率。
与基本类型的区别：包装类位于java.lang包中，可以像对象一样操作，而基本类型不能。
自动装箱和自动拆箱：基本类型与包装类的装箱、拆箱动作都可以自动完成。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）A.如果类没有重写toString()方法，那么打印对象就是打印对象的地址值
     B.如果类中重写了toString()方法，那么打印对象就是按照重写的格式打印对象内容。
（2）当我们需要获取该对象的字符串表示时，就需要调用对象的toString方法。

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

3.==和equals（）的区别？
  A.==在基础类型比较的是数值，在引用类型中比较的是地址值；
  B.equals()方法在没有重写的时候，比较的是两个对象的地址值，如果重写了，比较的是两个对象的内容。

4.String和StringBuilder的区别？
  A.String中的字符串的长度是固定的，不可改变的，若要进行字符串拼接会产生多个字符串常量。
  B.StringBuilder是字符串缓冲区,可以对字符串进行多次拼接，不会创建多个字符串，效率提高。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
  A.包装类是用来包装基本数据类型的类，方便对基本数据类型的数据进行各种方法的操作。
  B.包装类的内容是基本数据类型，但本身是引用数据类型。
    自动装箱指的是，java编译器自行把基本数据类型转换成相对应的包装类。
    自动拆箱指的是，java编译器自行把包装类转换为相对应的基本数据类型。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为打印对象的时候默认调用toString方法，而没有指定父类，则默认使用Object类的toString方法，打印的就是地址值，
而有的类重写了toString方法，将对象以字符串的形式打印出来。当打印对象名的时候会调用toString方法。
2.我们为什么要重写equals（）方法？
因为Object类中的equals方法底层是用==进行两个对象的对比，对比的是地址值，只要不是同一个对象，结果必然为false，
这种比较的结果没有实际意义。我们希望的是对两个对象的内容进行比较，所以需要重写equals()方法。
3.==和equals（）的区别？
==：
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals：
只能对比引用数据类型，重写前，对比的是对象的地址值
重写后的equals方法对比的是对象的内容。
4.String和StringBuilder的区别？
String创建的字符串长度固定
StringBuilder创建的字符串长度可以变化
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多的功能
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
      因为有的对象重写了根类Object中的toString()方法，而有的对象没有重写，重写了就可以对对象内部的属性值进行比较或者打印，
没有重写默认用继承根类Object中的toString()方法如果打印或者进行操作都只是地址值。
      在打印这个对象的时候会会调用toString()方法。

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

3.==和equals（）的区别？
     ==进行基本数据类型比较比较的是数据值，进行引用数据比较比较的是地址值
     equals（）只能进行引用数据类型的比较。重写之前，比较的是地址值，底层就是==

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


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


5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
      包装类就是基本数据类型对应的引用数据类型。
      自动装箱和自动拆箱是由编译器自动完成。
      区别：基本数据类型运行效率高但用法单一，包装类是把基本数据类型包装成一个引用数据类型能实现更多的用途和功能

陈开明：

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有的类有重写toString()方法，会覆盖原有方法，重写打印输出内容。有的类没有重写toString(）方法，这样子会调用Object父类的方法，直接打印地址值。直接打印输出对象名时候，系统自动调用toString()方法。
2.我们为什么要重写equals（）方法？
因为Object类的equals（）方法只是比较两个对象是否为同一个对象，即两个对象是否指向同一个地址值。而有时候，我们想比较的是两个对象的内容是否相同。
3.==和equals（）的区别？
==比较基本数据类型时候，比较的是具体值；比较引用数据类型时候，是比较两个对象的地址值是否相同；equals()只能比较引用数据类型。未重写之前是比较地址值，重写后是比较对象内容。
4.String和StringBuilder的区别？
String类是长度固定的字符串类，他们的值在创建之后不能修改，字符串的底层是一个被final修饰的字节数组。StringBuilder是字符串缓冲区，是一个长度可以变化的字符串，底层也是数组。StringBuilder在内存中始终是一个数组，占用空间少，效率高。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是将基本类型数据封装成类，赋予各种成员方法，使得基本类型的数据也能像对象一样有各种功能方法。基本数据类型是不能像对象一样，调用各种功能方法。
自动装箱：将基本数据类型转换为包装类型。
自动拆箱：将包装类型转换为基本数据类型。

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在打印时，如果没对toString方法进行重写的话，默认使用从Object类继承过来的方法，此时打印出来的是地址值；
而如果有对toString进行重写的话，那么打印出来的就是对象重写方法的内容.
当需要用到对象的地址值或者内容的时候，就会调用到toString（）方法。

2.我们为什么要重写equals（）方法？
不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的是地址值，而如果想进行方法内容的比较就需要进行重写；
3.==和equals（）的区别？
==:
比较基本类型:比较的是数据值;
比较引用类型:比较的是地址值;
equals:
只能比较引用数据类型
没有重写,比较的是两个对象的地址值;
有进行重写,比较的是两个对象的内容.

4.String和StringBuilder的区别？

String：底层是被final修饰的数组，是一个不变的常量；
                在进行相加时，内存会出现多个字符串，占用多，效率低；
   StingBuilder：底层是数组，但没有被final修饰，长度可变；
                          在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
   包装类就是基本数据类型对应的引用数据类型，区别：包装类是引用数据类型，能够使用方法进行对基本数据类型的操作。
   自动装箱：[自动]进行基本类型转换为包装类
   自动拆箱：[自动]进行包装类转换为基本类型

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印的是地址值是继承了Object类的to String
打印的是对象内容是重写了to String方法
打印对象的是时候调用toString()方法
2.我们为什么要重写equals（）方法？
因为equals（）方法如果不重写比较的是地址值，重写以后才能比较对象的内容。
3.==和equals（）的区别？
==


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


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


equals()

只能比较引用数据类型

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


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



4.String和StringBuilder的区别？
String：每创建一个String就会有一个新的对象产生新的地址值，浪费程序资源。
StringBuilder：StringBuider只会创建一个对象，节省程序的资源
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型。
区别：能够使用方法进行对基本数据类型的操控
自动拆箱和自动装箱：在进行集合存储和比较的时候自动完成

1.（1）打印对象时，其实是调用了对象的toString方法，而这个方法要么对象所在的类中没有，子类没有向上找，则程序调用Object类中的toString方法，打印的是地址值；要么所在的类重写了这个方法，打印出了其中的内容。
（2）对象会在被通过对象名直接打印的时候默认调用toString方法。
2.在没有重写equals方法的情况下，父类Object中自带的equals方法底层其实是使用==运算符进行比较，也就是比较地址值。一般equals方法应该被用来比较对象的属性，比较地址值大部分情况下是没有意义的，所以应该重写。
3.（1）==比较运算符在比较基本数据类型的时候是比较值，比较引用数据类型的时候是比较两个对象的地址值。
（2）equals方法只能比较引用类型数据，子类重写的情况下比较的是对象的属性，没有重写的情况下默认调用Object里的==运算符，即比较地址值。   
4.（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方法，如果该对象的类没有重写toString方法，那么打印出来的是对象的类型+@+内存地址值；如果该对象的类重写了toString方法，那么打印出来的是对象的内容。直接打印对象的名字，会调用对象的toString方法。

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

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

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

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

李伟斌

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为所有类都是Object类的子类，继承Object类，默认情况下是使用Object类中的toString方法，打印的是地址值。
       如果要打印对象内容必须重写Object类中的toString方法，为其添加打印对象内容的功能。
       使用打印输出语句系统会自动调用toString方法。
2.我们为什么要重写equals（）方法？
答：因为默认情况下时调用Object类中的equals（）方法，比较的是地址值，这样比较没有多大意义。为使其能够比较对象内容，我们将重写Object类中的equals（）方法，为其添加比较对象内容的功能。
3.==和equals（）的区别？
答：==对基本数据类型来说比较的是值，对引用数据类型来说比较的是地址值；
      equals（）： equals只用于引用数据类型，使用Object类中的默认方法的话比较的是地址值，如果重写  equals（）的话，可以为其添加比较对象内容的功能。
4.String和StringBuilder的区别？
答：String指字符串，而StirngBuilder指字符串容器。若要使用到很多个数的字符串拼接时，建议使用StirngBuilder，已提高软件性能。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类是指将基本数据类型包装起来的类
      包装类能使用关于包装类的相关方法，这是基本数据类型没有的。
      自动装箱：自动将基本数据类型转换成包装类
      自动拆箱：自动将包装类转换成基本数据类型。

今天我学习到了Object类是java所有的超类  也可以叫父类  所有类都直接或者间接的继承了Object类
为什么要重写Object类中的tostring()和equals()方法呢
tostring:  如果不重写,默认使用的是从Object类中继承过来的方法,比较的是对象的地址值,重写之后,打印的是对象内容
equals:如果不成写,默认使用的是从Object类中继承过来的方法,比较的是对象的地址值;重写了之后,比较的是对象的内容
标准类中,建议重写这两个方法.
今天还学习到了==和equlas()方法的区别
==:  比较基本数据类型,  比较的是数据值  比较应用数据类型,比较的是对象的地址值
equals:只能比较引用数据类型   重写之前,比较的是地址值,底层就是==  重写之后,比较的是对象的内容
Objects类可以解决什么问题呢:  可以解决对象调用equals方法,出现的空指针异常的问题
Date类的两个构造方法(毫秒值站日期对象):getTime():将一个日期对象,转为对象的毫秒值表示
DateFormat类的作用:DateFormat用于将日期对象格式化成指定的字符串表示,或者将一个字符串解析成Date对象
格式化:将日期对象->字符串
解析:字符串->日期对象
Calendar类的作用,如何创建Calendar类,常用的方法是
解决日期类表示不完全问题,Calendar类是一个抽象类,需要调用Calendar,getlnstance()获取抽象类的实例.
public int  get(int field):返回给定日历字段的值
public void set(int  field , int  value):将给定的日历字段设置为给定值
public abstract  void add(int field,int  amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量
public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象
包装类的概念和好处:包装类就是基本数据类型对应的引用数据类型  好处是:能够使用方法进行对基本数据类型的操控
拆箱和装箱的概念,以及自动拆箱和自动装箱  拆箱:包装类->基本数据类型  装箱:基本数据类型->包装类
自动拆箱和自动装箱:在进行集合存储和比较的时候自动完成

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印地址值是因为没有重写boject类中的对象，打印对象内容是因为重写了boject类中的对象。
对象会在被通过对象名直接打印的时候默认调用toString方法。

2.我们为什么要重写equals（）方法？
因为重写之后可以对比对象的内容，没重写是比较地址值
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值

equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容

4.String和StringBuilder的区别？
String：String定义的字符串是常量，在被创建后就不能修改。
底层是一个被final修饰的数组，所以无法改变
StringBuilder：可以看成是一个能修改的Sting常量
底层是一个未被final修饰的数组，所以长度可变，可以修改。


5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型

包装类和基本类型有什么区别是：
基本类型的使用方便，但是缺少对应的方法来进行操作；
而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型

自动拆箱：包装类转【自动】换为基本数据类型
自动装箱：基本数据类型【自动】转为包装类

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
调用了toString方法的重写打印的就会是内容,未调用的会打印出地址值;
2.我们为什么要重写equals（）方法？
如果未重写equals方法,比较的是默认的地址值,重写后比较的是对象的内容
3.==和equals（）的区别？
==:
对于基本数据类型:比较的是值
对于引用数据类型:比较的是地址值
equals:
只能用于比较引用类型,如果未重写则比较的是地址值,重写后比较的是内容
4.String和StringBuilder的区别？
string长度不可变
stringbuilder长度可变
stringbuilder效率会更高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
使基本类型能够在仅仅使用引用数据类型的场合中变得可以使用,例如集合中;
自动装箱指的是基本数据类型自动变为包装类,
自动拆箱指的是包装类自动转换为基本类型

今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容

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


2.我们为什么要重写equals（）方法？
如果未重写equals方法,比较的是默认的地址值,重写后比较的是对象的内容
3.==和equals（）的区别？
==:
对于基本数据类型:比较的是值
对于引用数据类型:比较的是地址值
equals:
只能用于比较引用类型,如果未重写则比较的是地址值,重写后比较的是内容

4.String和StringBuilder的区别？
string长度不可变
stringbuilder长度可变
stringbuilder效率会更高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
使基本类型能够在仅仅使用引用数据类型的场合中变得可以使用,例如集合中;
自动装箱指的是基本数据类型自动变为包装类,
自动拆箱指的是包装类自动转换为基本类型

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
对象默认继承了Object类的toString()，打印的是地址值
对象继承了重写的toString()方法的父类，打印的是内容
直接打印对象就会调用toString()方法

2.我们为什么要重写equals（）方法？
对象调用equals（）方法比较的是对象的地址值，重写后比较对象的内容

3.==和equals（）的区别？
基础数据类型使用==比较的是数据值，引用数据类型使用==比较的是地址值
基础数据类型不能使用equals（）方法，equals底层是==，重写后比较对象内容

4.String和StringBuilder的区别？
StringBuilder类：字符串缓冲区,可以提高字符串的效率
String长度不可改变，StringBuilder会自动维护数组的扩容

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
基于基本数据类型创建的类，包装类的对象可以做更多的功能
JDK1.5之后出现的新特性，基本类型的数据和包装类之间可以自动的相互转换

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）打印对象时，其实是调用了对象的toString方法，而这个方法要么对象所在的类中没有，子类没有向上找，则程序调用Object类中的toString方法，打印的是地址值；要么所在的类重写了这个方法，打印出了其中的内容。
（2）对象会在被通过对象名直接打印的时候默认调用toString方法。


2.我们为什么要重写equals（）方法？
如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容

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

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