黑马程序员技术交流社区
标题: 【厦门JavaEE就业6期-每日总结】Object类、常用API [打印本页]
作者: 厦门校区 时间: 2019-3-19 18:20
标题: 【厦门JavaEE就业6期-每日总结】Object类、常用API
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
2.我们为什么要重写equals（）方法？
3.==和equals（）的区别？
4.String和StringBuilder的区别？
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
作者: 郑海波 时间: 2019-3-19 18:45
本帖最后由 郑海波 于 2019-3-19 20:20 编辑
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类型的数据就叫做自动拆箱。
作者: 陈伟彬 时间: 2019-3-19 18:46
本帖最后由 陈伟彬 于 2019-3-19 21:33 编辑
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：
原因：在打印时，如果没对toString方法进行重写的话，那会默认使用从Object类继承过来的方法，而此时打印出来的是地址值；而如果有对toString进行重写的话，那么打印出来的就是对象内容；
使用场景：想要返回对象的属性内容时，可将其进行调用重写；
2.我们为什么要重写equals（）方法？
答：
如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？
答：
==：
基本数据，比较数据值；
引用数据，比较地址值；
equals（）：只能比较引用数据；
重写：比较对象的属性内容；
不重写：比较地址值；
4.String和StringBuilder的区别？
答：
String：
底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：
底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：
包装类：基本数据所对应的引用数据类型；
区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
自动装箱：在进行集合的存储时自动完成，即自动进行基本类型转换为包装类的操作；
自动拆箱：在进行集合的比较时自动完成，即自动进行包装类转换为基本类型的操作；
作者: 叶彬彬 时间: 2019-3-19 20:00
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象出现地址值：是因为调用了object类的toString方法
打印对象出现对象内容：是因为重写了toString方法
调用toString方法：执行打印语句的时候
2.我们为什么要重写equals（）方法？
equals()方法比较的是两个对象的地址值，重写equals()能够比较两个对象的内容
3.==和equals（）的区别？
==：可以比较基本数据类型，也可以比较引用数据类型
基本数据类型比较的是数值，引用数据类型比较的是地址值
equals():只能比较引用数据类型
可以比较两个对象的内容，底层原理是 ==
4.String和StringBuilder的区别？
String 的长度是固定不变的
StringBuilder 的长度是可变的
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：就是基本类型进行转换后的引用类型
区别：包装类可以进行和对象一样的操作，基本类型则不行
自动装箱：系统自动将基本类型转换为包装类
自动拆箱：系统自动将包装类转换为基本类型
作者: 吴越 时间: 2019-3-19 20:06
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：打印对象其实就是调用对象的toString方法，如果该对象的类没有重写toString方法，那么打印出来的是对象的类型+@+内存地址值；如果该对象的类重写了toString方法，那么打印出来的是对象的内容。直接打印对象的名字，会调用对象的toString方法。
2.我们为什么要重写equals（）方法？
答：equals()方法用于比较两个对象是否相等。在没有重写的情况下，默认进行的比较是 == 运算符的对象地址比较，只要不是同一个对象，结果必然为false，这种比较的结果没有实际意义。我们希望的是对两个对象的内容进行比较，所以需要重写equals()方法。
3.==和equals（）的区别？
答：==运算符可以比较基本数据类型的数据值，也可以比较引用数据类型的地址值；
equals()方法只能对引用数据类型进行比较。在没有重写equals方法的情况下，比较的是对象的地址值；重写后可以比较对象的属性内容。
4.String和StringBuilder的区别？
答：String字符串是常量，他们的值在创建之后不能更改；
StringBuilder是字符串缓冲区，占用空间少，效率高，底层也是一个数组，但是没有被final修饰，其初始容量为 16 个字符，如果超出了StringBuilder的容量，会自动的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类是基本类型数据对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多的功能
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。
作者: 魏政 时间: 2019-3-19 20:10
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在打印时，如果没对toString方法进行重写的话，那会默认使用从Object类继承过来的方法，而此时打印出来的是地址值；
而如果有对toString进行重写的话，那么打印出来的就是对象内容；
想要返回对象的属性内容时，可将其进行调用重写；
2.我们为什么要重写equals（）方法？
如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？
==：基本数据，比较数据值；
引用数据，比较地址值；
equals（）：只能比较引用数据；
重写：比较对象的属性内容；
不重写：比较地址值；
4.String和StringBuilder的区别？
String：底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据所对应的引用数据类型；
区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
自动装箱：即自动进行基本类型转换为包装类的操作；
自动拆箱：即自动进行包装类转换为基本类型的操作；
作者: 李伟艺 时间: 2019-3-19 20:10
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
当对象所在的类没有重写父类Object中的toString（）方法的时候，再打印的时候就会自动调用父类Object中的toString（）方法，而Object中的toString（）方法打印的就是打印对象的地址值。
当对象所在的类有重写父类Object中的toString（）方法的时候，再打印的时候就不会调用父类Object中的toString（）方法，而是调用的自身类的toString。就会打印对象的内容。
当需要用到对象的地址值或者内容的时候，会使用到toString（）方法。
2.我们为什么要重写equals（）方法？
如果我们不重写equals（）方法的话，再使用equals（）方法的时候，就会调用继承自Object类的equals（）方法。而Object中的equals（）方法是比较两个对象的地址值。如果需要比较两个对象的内容的话，就必须要重写equals（）方法。
3.==和equals（）的区别？
当用“"=="比较两个数据类型时，会比较两个数据类型的内容。而再比较两个引用类型的话，会比较两个引用类型的地址值。
equasl（）方法，无法比较两个数据类型，只能比较两个引用类型。如果当前类没用进行重写的话，equasl（）方法是父类Object类中的方法，会比较两个引用类型的地址值，如果当前类有重写equasl（）方法的话，会比较两个引用类型的内容
4.String和StringBuilder的区别？
String类是被fianl修饰的，所有内容是常量，不可被改变。
StringBuilder内容可变，因为StringBuilder内部是一个数组，可以添加多个字符串。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
在JAVA中有两个类型，一个是基本类型和引用类型。虽然基本类型的运行效率高，但是用法单一，无法像引用类型一样使用方法。为了让基本类型能够有更多的功能，于是就有了将基本类型对应的类，也就是包装类。
装箱就是将数据类型变成包装类，拆箱就是将包装了变成基本类型。由于我们需要经常的进行装箱和拆箱的操作，于是JDK就进行了优化，由系统进行操作。所以就有了自动装箱和自动拆箱。
作者: 黑马6期陈华 时间: 2019-3-19 20:12
本帖最后由 黑马6期陈华 于 2019-3-19 20:15 编辑
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）自动拆箱：包装类转为基本数据类型，在使用运算符的时候自动发生。
作者: java基础6期刘伟 时间: 2019-3-19 20:15
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）打印对象时，其实是调用了对象的toString方法，而这个方法要么对象所在的类中没有，子类没有向上找，则程序调用Object类中的toString方法，打印的是地址值；要么所在的类重写了这个方法，打印出了其中的内容。
（2）对象会在被通过对象名直接打印的时候默认调用toString方法。
2.我们为什么要重写equals（）方法？
如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String：底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据所对应的引用数据类型；
区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
自动装箱：即自动进行基本类型转换为包装类的操作；
自动拆箱：即自动进行包装类转换为基本类型的操作；
作者: 罗加铭 时间: 2019-3-19 20:17
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：打印对象显示内容是因为重写了toString()方法；
对象在输出的时候会调用toString()方法
2.我们为什么要重写equals（）方法？
答：如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同就可以对equals（）重写
3.==和equals（）的区别？
答：==是对象地址比较，只要不是同一个对象，结果必然为false；equals（）其他某个对象是否与此对象“相等”
4.String和StringBuilder的区别？
答：区别StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作
。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：
什么是包装类：将基本类型包装成像对象一样可以进行操作的类称为包装类；
和基本类型有什么区别：和基本类型区别在于包装类可以像对象一样操作；
什么是自动装箱和自动拆箱：
自动装箱:直接把int类型的整数赋值给包装类
自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本类型的数据,再参与计算
作者: 黑马六期-董安平 时间: 2019-3-19 20:47
本帖最后由 黑马六期-董安平 于 2019-3-19 20:57 编辑
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：如果没有重写toString()方法，那么打印对象时，会打印地址值。
而重写toString()方法后，打印对象则是打印对象内容。
对象在需要打印对象时会调用toString()方法.
2.我们为什么要重写equals（）方法？
答：equals()方法默认继承Object类，调用时比较的是对象的地址值；
而重写equals()方法后，调用时比较的是对象的内容。
3.==和equals（）的区别？
答：区别在于
(1).==比较在比较基本数据类型时，比较的是数据值
比较引用数据类型时，比较的时对象的地址值
(2).equals()方法只能比较引用数据类型
重写之前，比较的是对象的地址值，底层就是==
重写之后比较的是对象的内容
4.String和StringBuilder的区别？
答：
String：String定义的字符串是常量，在被创建后就不能修改。
底层是一个被final修饰的数组，所以无法改变
StringBuilder：可以看成是一个能修改的Sting常量
底层是一个未被final修饰的数组，所以长度可变，可以修改。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：
包装类就是将基本数据类型进行封装后的产物，归类在引用数据类型
区别：基本数据类型缺少对应的方法进行操作，而包装类将基本数据类型封装后就能
定义方法，从而操作基本数据类型。
自动装箱：就是自动将基本类型转换为包装类的操作
自动拆箱：就是自动将包装类转换为基本数据类型的操作
作者: Wyt1935 时间: 2019-3-19 20:50
吴元陶：
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象出现地址值：是因为调用了object类的toString方法
打印对象出现对象内容：是因为重写了toString方法
调用toString方法：执行打印语句的时候
2.我们为什么要重写equals（）方法？
equals()方法比较的是两个对象的地址值，重写equals()能够比较两个对象的内容
3.==和equals（）的区别？
==：可以比较基本数据类型，也可以比较引用数据类型
基本数据类型比较的是数值，引用数据类型比较的是地址值
equals():只能比较引用数据类型
可以比较两个对象的内容，底层原理是 ==
4.String和StringBuilder的区别？
String 的长度是固定不变的
StringBuilder 的长度是可变的
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：就是基本类型进行转换后的引用类型
区别：包装类可以进行和对象一样的操作，基本类型则不行
自动装箱：系统自动将基本类型转换为包装类
自动拆箱：系统自动将包装类转换为基本类型
作者: 林志鹏 时间: 2019-3-19 20:55
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）在没有对toString进行重写的时候会默认使用Object类继承的方法这样打印的是地址值，在对toString进行重写的时候打印的是对象内容
（2）直接打印对象的名字会调用对象的toString方法
2.我们为什么要重写equals（）方法？
如果没有覆盖重写equals方法，Object类中默认进行==运算符的对象地址比较不是同一个对象，结果都为false。
盖重写equals方法进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同。
3.==和equals（）的区别？
==
（1）比较基本数据类型的时候比较的数据值
（2）比较引用数据类型的时候比较的是对象地址值
equals():
（1）只能比较引用数据类型，
重写之前比较的是地址值底层就是==
重写之后比较的是对象的内容
4.String和StringBuilder的区别？
String是字符串常量，值在创建之后就不能更改。进行相加的时候内存就会出现多个字符串，占用多效率又低
StringBuilder是字符缓冲区，创建之后初始容量是16超过会自动扩容，底层是一个没有被final修饰的数组，占用空间少，效率高。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本类型数据对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多的功能
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。
作者: 龙舟 时间: 2019-3-19 20:56
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）自动拆箱：包装类转为基本数据类型，在使用运算符的时候自动发生。
作者: 曾伟清 时间: 2019-3-19 20:58
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：创建对象的类中重写了Object中的toString()方法，打印的就是对象内容，否则打印的就是地址值；
直接打印对象时会调用toString()方法。
2.我们为什么要重写equals（）方法？
答：不重写equals（）方法比较的是对象的地址值，重写之后就可以比较对象的内容。
3.==和equals（）的区别？
答：
==：
基本数据类型：比较的是数据值是否相等。
引用数据类型：比较的是地址值是否相等。
equals（）：
只能比较引用数据类型，重写前比较的是地址值是否相等，重写后比较的是内容是否相等。
4.String和StringBuilder的区别？
答：String底层是被final修饰的数组，一旦创建不可改变长度；StringBuilder可以改变，进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动
维护数组的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类就是基本数据类型对应的引用数据类型，区别：包装类是引用数据类型，能够使用方法进行对基本数据类型的操控。
装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。
作者: 刘曾铭 时间: 2019-3-19 21:01
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为在Object类中toString()打印得是地址值，但是在开发当中我们需要打印内容所以在Object类得子类
下我们重写了toString()方法打印对象得内容。在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。
2.我们为什么要重写equals（）方法？
因为没有重写equals()方法得话再Object类中表示==地址值的比较。所以要是
不同对象的话必定是false。
3.==和equals（）的区别？
==是地址值的比较。
equals（）没有重写的话也是地址值的比较；重写的话就是对象内容的比较。
4.String和StringBuilder的区别？
String是不可改变的字符串。
StringBuilder是一个可以改变长度内容的字符串。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
如果想基本类型和对象一样使用就得使用基本类型对应的包装类
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型
作者: 卢勇炜 时间: 2019-3-19 21:02
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会
调用toString()方法？
答:(1)如果在一个类中没有重写toString方法,打印的就是地址值,有重写了
toString方法就能打印出对象内容;
(2)在我们需要返回该对象的字符串表示时,就要调用toString()方法.
2.我们为什么要重写equals（）方法？
答:为了比较两个对象的内容,如果不重写equals()方法,它比较的是地址值,那样没
有意义.
3.==和equals（）的区别？
答: (1) == :
基本数据类型比较的是值,引用数据则比较的是地址值.
比较
内容要重写equals方法;
(2)equals():
只能比较引用数据类型,重写之前比较的是地址值,底层就是==,
重写后比较的是对象的内容;
4.String和StringBuilder的区别？
答:(1)String中的字符串长度是常量,它们的值在创建之后不可变的，若要进行字
符串拼接会产生多个字符串常量。
(2)StringBuilder是字符串缓冲区,可变字符序列可以对字符串的内容进行拼接
追加字符串，不会创建多个字符串对象节省内存占用空间，效率高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答:(1)包装类可以使基本数据类型像对象一样操作
(2)自动装箱：从基本类型自动转换为对应的包装类对象
(3)自动拆箱：从包装类对象自动转换为对应的数据类型
作者: 李煜霖 时间: 2019-3-19 21:03
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类型的数据就叫做自动拆箱。
作者: 厦门第六期刘鹏 时间: 2019-3-19 21:03
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
创建对象的类中重写了Object中的toString()方法，打印的就是对象内容，否则打印的就是地址值；
直接打印对象时会调用toString()方法。
2.我们为什么要重写equals（）方法？
因为没有重写equals()方法得话再Object类中表示==地址值的比较。所以要是
不同对象的话必定是false。
3.==和equals（）的区别？
（1）比较基本数据类型的时候比较的数据值
（2）比较引用数据类型的时候比较的是对象地址值
equals():
（1）只能比较引用数据类型，
重写之前比较的是地址值底层就是==
重写之后比较的是对象的内容
4.String和StringBuilder的区别？
String 的长度是固定不变的
StringBuilder 的长度是可变的
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本类型数据对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多的功能
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。
作者: zhaizhile 时间: 2019-3-19 21:04
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果不重写，默认使用的是从Object类中继承过来的方法，打印的是地址值；重写了之后，打印的是对象内容
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因
此也需要重写它。
2.我们为什么要重写equals（）方法？
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。
3.==和equals（）的区别？
“==”
比较基本数据类型时，比较的是内容
比较引用数据类型时，比较的是地址
equals（）
equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
4.String和StringBuilder的区别？
1. string 对象时恒定不变的，stringBuider对象表示的字符串是可变的。stringBuilder是.net提供的动态创建string的高效方式，以克服string对象恒定性带来的性能影响。
2. 对于简单的字符串连接操作，在性能上stringBuilder并不一定总是优于string。因为stringBuider对象创建代价较大，在字符串目标连接较少的情况下，过度滥用stringBuilder会导致性能的浪费，只有大量的或者无法预知次数的字符串操作，才考虑stringBuilder来实现。事实上，一般连接次数设置100次以内，根本看不出两者的性能差别。
3. 当修改字符串信息时，此时不许创建对象，可以使用stringBuilder对象。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
在JAVA中有两个类型，一个是基本类型和引用类型。虽然基本类型的运行效率高，但是用法单一，无法像引用类型一样使用方法。为了让基本类型能够有更多的功能，于是就有了将基本类型对应的类，也就是包装类。
装箱就是将数据类型变成包装类，拆箱就是将包装了变成基本类型。由于我们需要经常的进行装箱和拆箱的操作，于是JDK就进行了优化，由系统进行操作。所以就有了自动装箱和自动拆箱。
作者: javawjs 时间: 2019-3-19 21:04
王佳盛
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
能打印出内容的对象是因为在类中对toString（）方法进行了重写；
打印出地址值的对象是因为使用了默认的toString（）方法；
使用打印输出语句直接打印对象的时候就会调用toString（）方法。
2.我们为什么要重写equals（）方法？
equals（）没有重写，默认比较的是地址值。跟==差不多，没有实际意义。
3.==和equals（）的区别？
==
基本类型：比较的是值；
引用类型：比较的是地址值；
equals
只能比较引用类型；
没有重写的话，默认比较地址值；只有重写了才可以比较对象内容。
4.String和StringBuilder的区别？
String
由于String类的对象不可变，所以每当字符串拼接时，都会创建新的String对象来保存拼接后的结果，比较浪费内存。
StringBuilder
StringBuilder的长度可以改变，并且在进行字符串拼接时，不会创建新的对象。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：将基本数据类型包装起来的类。
装箱：把基本类型的数据，包装到包装类中；
拆箱：在包装类中取出基本数据类型的数据。
作者: 黑马林伟明 时间: 2019-3-19 21:04
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）自动拆箱：包装类转为基本数据类型，在使用运算符的时候自动发生。
作者: 龚荣章 时间: 2019-3-19 21:04
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类型的数据就叫做自动拆箱。
作者: 黄振明 时间: 2019-3-19 21:05
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：对于引用类型来说，Object类中的toString()方法输出的是对象的地址值，
重写了Object类中的toString()方法的输出的是对象的内容。
2.我们为什么要重写equals（）方法？
答：因为Object类中的equals()比较的是对象的地址值，而一般情况两个对象的地址值是
不同的，所以这样比较没意义。而重写了equals()方法之后比较的是对象的内容。
3.==和equals（）的区别？
答：
==：基本数据类型比较的是数据的值；引用类型比较的是对象的地址值
equals：Object类中的equals方法比较的是对象的地址值，
重写了Object类中的equals方法比较的是对象的内容。
4.String和StringBuilder的区别？
答：
String类是代表字符串，字符串的长度不可改变
StringBuilder类是字符串缓冲区，长度可变的字符序列
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：把基本类型的数据包装起来的就是包装类
包装类：对基本类型的数据进行操作
自动装箱：自动从基本类型转换为对应的包装类对象
自动拆箱：自动从包装类对象转换为对应的基本类型
作者: 陈前凌 时间: 2019-3-19 21:05
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.装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
作者: LIUXIAOMING 时间: 2019-3-19 21:05
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类型的数据就叫做自动拆箱。
作者: 高坂火龙果 时间: 2019-3-19 21:05
黄志斌：
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类型的数据就叫做自动拆箱。
作者: 小翔vvvv 时间: 2019-3-19 21:06
叶凌青
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为默认调用的object的toString方法，打印的就是地址值
有些类重写了object的toString方法，所以打印出重写的内容
对象在打印对象名的时候回调用toString方法
2.我们为什么要重写equals（）方法？
因为默认调用的是object的equals（）方法，比较的是引用类型的地址值是否相同
我们重写equals方法使其比较对象的内容是否相等
3.==和equals（）的区别？
== 比较的基本数据类型的是数值 比较引用类型的是地址值
而equals只能比较引用数据类型
如果默认调用object的equals方法，比较的是引用类型的地址值
如果我们重写了equals方法，比较的是内容是否相等
4.String和StringBuilder的区别？
String的实例是不可更改的，所以有时候我们做字符串的拼接的时候，可能会产生很多个对象，从而造成浪费
StringBuider相当于在后面做拼接，一直都返回的是同一个对象。所以不会造成浪费。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本类型对应的引用类型，相当于基本类型包着一层，自动装箱指的是 基本数据类型——>包装类 自动拆箱 指的是 包装类——>基本数据类型
作者: 开心的小孩 时间: 2019-3-19 21:06
陈鹏涛
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类型的数据就叫做自动拆箱。
作者: 龚荣章 时间: 2019-3-19 21:06
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类型的数据就叫做自动拆箱。
作者: 陈驰煜 时间: 2019-3-19 21:06
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
类中没有重写toString方法时,打印对象打印的就是地址值,重写后打印的是重写的内容
使用对象名调用或使用输出语句输出对象名的时候,通过该对象调用了其toString()方法。
2.我们为什么要重写equals（）方法？
没有重写equals方法时,使用的是从Object类中继承的equals方法,该方法底层使用this与传入的形参==比较,
比较的是地址值,要比较对象的属性相等必须重写equals方法.
3.==和equals（）的区别？
==:
比较基本数据类型时,比较的是数据值,比较引用数据类型时,比较的是地址值
equals():
只能比较引用数据类型,没被重写时比较的是地址值
4.String和StringBuilder的区别？
String类型的字符串创建后长度就不可变,底层是一个final修饰的字符数组,进行字符串拼接时较浪费资源
StringBulider创建的字符串长度可变,默认长度为16,随着内容增加长度也会增加
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
8种基本类型都有对应的包装类,包装类中有许多操作基本类型数据的方法
自动装箱:
从基本类型转换成包装类时可以自动转换
自动拆箱:
从包装类转换至基本类型时可以自动转换
作者: 黄成龙 时间: 2019-3-19 21:08
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编译器自行把包装类转换为相对应的基本数据类型。
作者: 徐代成 时间: 2019-3-19 21:08
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
Object类的toString方法是打印地址值，只要对象类没有重写toString方法，都是默认打印地址值;只要对象有重写toString
方法，打印的都是对象内容。
直接使用对象的时候就会调用toString方法
2.我们为什么要重写equals（）方法？
equals()方法默认的是地址值比较，没有意义，需要进行重写，来比较对象的属性内容
3.==和equals（）的区别？
==比较基本数据类型比较的是数据值；比较引用数据类型时，比较的是地址值。
equals：只能比较引用数据类型，重写前比较的是地址值，重写后比较的是对象的内容
4.String和StringBuilder的区别？
String中的字符串长度是常量,它们的值在创建之后不可变的，若要进行字符串拼接会产生多个字符串常量，占用内存，效率低。
StringBuilder是字符串缓冲区,可变字符序列可以对字符串的内容进行拼接追加字符串，不会创建多个字符串对象节省内存占用空间，效率高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本类型的包装起来，变成引用数据类型，以便给某些对象使用。基本类型不能在集合中使用。
自动装箱就是JVM会自动转换基本数据类型为包装类型
自动拆箱就是JVM会自动转换包装类型为基本数据类型。
作者: 王旭艺 时间: 2019-3-19 21:09
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
默认使用的是从Object类中继承过来的方法，打印的是地址值；重写了之后，打印的是对象内容。直接打印对象的名字，会调用对象的toString方法。
2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；重写了之后，比较的是对象的内容
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String字符串是常量，他们的值在创建之后不能更改；
StringBuilder是字符串缓冲区，占用空间少，效率高，底层也是一个数组，但是没有被final修饰，其初始容量为 16 个字符，如果超出了StringBuilder的容量，会自动的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型
区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
自动装箱：即自动进行基本类型转换为包装类的操作；
自动拆箱：即自动进行包装类转换为基本类型的操作；
作者: 陈志铖 时间: 2019-3-19 21:09
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象,如果没有重写toString方法，那么打印出来的是对象的类型+@+内存地址值；如果该对象的类重写了toString方法，那么打印出来的是对象的内容。
直接打印对象名，会调用对象的toString方法。
2.我们为什么要重写equals（）方法？
equals()方法用于比较两个对象地址值是否相等。在没有重写的情况下，只要不是同一个对象，结果必然为false，这种比较的结果没有实际意义。我们希望的是对两个对象的内容进行比较，所以需要重写equals()方法。
3.==和equals（）的区别？
==运算符可以比较基本数据类型的数据值，也可以比较引用数据类型的地址值；
equals()方法只能对引用数据类型进行比较。在没有重写equals方法的情况下，比较的是对象的地址值；重写后可以比较对象的属性内容。
4.String和StringBuilder的区别？
String字符串是常量，它的值在创建之后不能更改；
StringBuilder是字符串缓冲区，占用空间少，效率高，底层也是一个数组，但是没有被final修饰，其初始容量为 16 个字符，如果超出了StringBuilder的容量，会自动的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本类型数据对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多方法
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。
作者: 廖艺铭 时间: 2019-3-19 21:10
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果自定义的类中没有重写toString方法，那么打印的就是地址值，因为从Object类中继承下来的toString方法打印的就是对象的地址值；
如果有对toString方法进行重写，打印的就是对象的内容
对象打印时会调用toString方法
2.我们为什么要重写equals（）方法？
由于从Object继承下来的equals方法只是简单的==，那么对于引用类型比较的只是对象的地址值，所以当需要比较两个对象的内容时，就需要对equals方法进行重写
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String底层是byte数组，所以值在创建之后不能更改，每当进行字符串拼接时，总是会在内存中创建一个新的对象
StringBuilder是字符串缓冲区，由于它是一个容器，可以装很多字符串，拼在后面，所以只会创建一个对象，节省程序的资源
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：Java中提供的对基本数据类型进一步包装产生的引用类型，能够像操作对象一样来操作基本类型
区别：基本类型没有对象方法的概念，包装类是引用类型，可以实例化对象，调用方法
自动装箱：从基本类型转换为对应的包装类对象
自动拆箱：从包装类对象转换为对应的基本类型
作者: 张广发 时间: 2019-3-19 21:13
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
原因：在打印时，如果没对toString方法进行重写的话，那会默认使用从Object类继承过来的方法，而此时打印出来的是地址值；而如果有对toString进行重写的话，那么打印出来的就是对象内容；
使用场景：想要返回对象的属性内容时，可将其进行调用重写；
2.我们为什么要重写equals（）方法？
如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？
==：
基本数据，比较数据值；
引用数据，比较地址值；
equals（）：只能比较引用数据；
重写：比较对象的属性内容；
不重写：比较地址值；
4.String和StringBuilder的区别？
String：
底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：
底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据所对应的引用数据类型；
区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
自动装箱：即自动进行基本类型转换为包装类的操作；
自动拆箱：即自动进行包装类转换为基本类型的操作；
作者: 余建强 时间: 2019-3-19 21:14
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有些对象有toString方法,有些没有,打印类对象时自动调用toString()方法
2.我们为什么要重写equals（）方法？
因为有的时候equals()不能满足我们的需要
3.==和equals（）的区别？
==判断的是地址值或者基本类型的内容是否相等,而equals()判断的是内容是否相等
4.String和StringBuilder的区别？
String长度是固定的,长度不能发生改变,StringBuilder是变长的,长度会随着内容的增加而增加
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是将基本类型包装起来的类,数组集合中不能直接存放基本类型,只能存放引用类型,自动装箱就是将基本类型包装成包装类型,
自动拆箱就是将包装类型转化成基本类型
作者: 管文祥 时间: 2019-3-19 21:15
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：打印地址值时是因为类中没有重写toString（），当类重写了toString（）方法时，打印的则是对象内容；在直接输出对象时，会默认调用对象的toString（)方法，在打印属性内容，或者遍历的时候也会调用toString（）方法。
2.我们为什么要重写equals（）方法？
答：如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；而重写了之后，比较的是对象的内容。
3.==和equals（）的区别？
答：== 在比较基本数据类型时，比较的是数据值；在比较引用数据类型时，比较的是对象的地址值
equals() 只能比较引用数据类型；重写之前，比较的是地址值，底层就是==；重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
答: String类的对象内容不可改变，在进行字符串拼接时，会在内存中创建一个新的对象，如果经常改变字符串的内容最好不要用String,因为每次生成对象都会对系统性能产生影响。
StringBuilder是字符串缓冲区，通过方法调用可以改变该字符串序列的长度和内容。也可以装很多字符串，并且能够对其中的字符串进行各种操作。StringBuilder的内部拥有一个数组用来存放字符串内容，在进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动维护数组的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类就是基本数据类型对应的引用数据类型；
区别：包装类是对象,拥有方法和字段，对象的调用都是通过引用对象的地址，产生对象时直接用引用指向这个对象（引用变量是在存在栈内存中，对象是在堆内存中的，堆中分配内存）；而基本类型是直接存储数值；另外，包装类是引用传递，而基本类型是值传递;
自动拆箱和自动装箱是在进行集合存储和比较的时候自动完成
作者: 蓝建华 时间: 2019-3-19 21:15
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？如果对象对应的类及其父类没有重写toString方法，则打印的是地址值
若有重写toString方法，则打印的是对象内容
通过对象调用toString方法时 以及对象在被打印时会默认隐含调用了toString方法
2.我们为什么要重写equals（）方法？
因为自定义的类，系统无法判断通过哪些属性判断是否相同，这时候就需要重写equals()方法，给系统判断定义是否相同的标准
3.==和equals（）的区别？
==比较的是两个对象的地址值是否相同，equals（）比较的是两个对象的内容是否相同。
4.String和StringBuilder的区别？
一、String创建的是字符串对象，StringBuilder创建的是是一个字符串缓存区
二、String创建的字符串的内容长度是不可改变，StringBuilder创建的字符串缓冲区长度和内容都是可以改变的。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是对基本数据类型的包装，将其包装成引用类型
包装类型属于引用类型，不属于基本数据类型
自动装箱：自动将基本数据类型转换成对应的包装类（引用数据类型）
自动拆箱：自动将包装类（引用数据类型）转换成对应的基本数据类型
作者: 6期江岳 时间: 2019-3-19 21:18
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有些对象对应的类中已经重新了toString方法 打印的时候就是输出对象内容，没有重写的就是输出对象的地址值。
在打印对象的时候就会调用toString方法。
2.我们为什么要重写equals（）方法？
因为如果不重写比较的就是两个对象的地址值而不是对象的具体内容，那么equals就意义不大效果等于==。
3.==和equals（）的区别？
==在对比基本数据类型的时候是比较值是否相等，而在对比引用类型时，是比较两个对象的地址值。
equals比较两个对象的内容是否相等。如果对象对应的类里没有重写equals方法那么比较的也是两个对象的地址值。
4.String和StringBuilder的区别？
String字符串是一个常量一旦创建内容不可改变，StringBuilder是一个容器，内容和长度随时可以改变。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
将基本类型变成对应的引用类型可以进行对象创建使用。
自动装箱：从基本类型自动转换为对应的包装类对象
自动拆箱：从包装类对象自动转换为对应的基本类型
作者: 庄家琦 时间: 2019-3-19 21:19
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
toString:
如果不重写，默认使用的是从Object类中继承过来的方法，打印的是地址值；重写了之后，打印的是对象内容
打印对象在有重写toSring的时候会打印对象内容
打印对象没有重写toSring的时候会打印对象地址值
对象在被输出的情况下回隐示的调用toString();
2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；重写了之后，比较的是对象的内容
和toSting();一样没有重写比较的是地址值.
不一样的是toString()未重写是打印地址;重写打印对象内容
equals()未重写比较的是地址值;重写是比较对象的内容
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
StringBuider只会创建一个对象，节省程序的资源
String内容一旦赋值不可改变 改变需要重新定义String内容 会有多个对象 占用程序资源
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型
好处：能够使用方法进行对基本数据类型的操控
区别在于一个是基本数据类型;一个是引用数据类型
拆箱：包装类->基本数据类型
装箱：基本数据类型->包装类
自动拆箱：在进行集合比较的时候自动完成
自动装箱：在进行集合存储的时候自动完成
作者: JavaEE06蒋才东 时间: 2019-3-19 21:22
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象是调用了toString()方法，所以直接打印对象的话就是地址值，通过覆盖重写对象打印就是对象的内容
对象在直接打印的时候会调用toString()方法
2.我们为什么要重写equals（）方法？
如果不重写equals（）方法的话，会比较地址值，所以需要重写equals（）方法，比较对象的内容
3.==和equals（）的区别？
==如果是基本数据类型进行比较，比较的是数据值，引用数据类型进行比较，比较的是对象的地址值
equals（）是只能引用类型进行比较，重写之前，默认比较地址值，重写之后，是比较对象的内容
4.String和StringBuilder的区别？
String类的对象内容不可改变，每次构建新的String类，既耗时，又浪费空间
StringBuilder类的对象长度内容可以改变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型
自动装箱是从基本类型自动转换为对应的包装类对象。
自动拆箱是从包装类对象自动转换为对应的基本类型
作者: 钟扬辉 时间: 2019-3-19 21:30
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
不重写的话，默认使用的是object继承过来的方法，打印的是地址值，重写之后打印的是对象的内容。
需要按照对象的属性得到想应的字符串表现形式就会调用toString()方法。
2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是从object继承过来的方法，比较的是地址值；重写之后，比较的就是对象的内容
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值。
比较引用类型，比较的是地址值。
equals()
只能用于引用类型
重写之前，比较的是地址值，底层就是==。
重写之后，比较的是对象的内容。
4.String和StringBuilder的区别？
String：每当进行字符串拼接时，总会在内存创建一个新的对象。
StringBuilder:它是一个类型于String的字符串缓冲区，可以装很多字符串，并且能过对其中的字符串进行各种操作，字符串拼接时数组直接加入新内容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：可以像对象一样操作，可以做更多的功能，提高效率。
与基本类型的区别：包装类位于java.lang包中，可以像对象一样操作，而基本类型不能。
自动装箱和自动拆箱：基本类型与包装类的装箱、拆箱动作都可以自动完成。
作者: 李智梁 时间: 2019-3-19 21:31
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编译器自行把包装类转换为相对应的基本数据类型。
作者: 陈弘帅 时间: 2019-3-19 21:32
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为打印对象的时候默认调用toString方法，而没有指定父类，则默认使用Object类的toString方法，打印的就是地址值，
而有的类重写了toString方法，将对象以字符串的形式打印出来。当打印对象名的时候会调用toString方法。
2.我们为什么要重写equals（）方法？
因为Object类中的equals方法底层是用==进行两个对象的对比，对比的是地址值，只要不是同一个对象，结果必然为false，
这种比较的结果没有实际意义。我们希望的是对两个对象的内容进行比较，所以需要重写equals()方法。
3.==和equals（）的区别？
==：
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals：
只能对比引用数据类型，重写前，对比的是对象的地址值
重写后的equals方法对比的是对象的内容。
4.String和StringBuilder的区别？
String创建的字符串长度固定
StringBuilder创建的字符串长度可以变化
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多的功能
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。
作者: 叶振鹏 时间: 2019-3-19 21:32
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有的对象重写了根类Object中的toString()方法，而有的对象没有重写，重写了就可以对对象内部的属性值进行比较或者打印，
没有重写默认用继承根类Object中的toString()方法如果打印或者进行操作都只是地址值。
在打印这个对象的时候会会调用toString()方法。
2.我们为什么要重写equals（）方法？
如果不重写，默认使用的是从Object类中继承过来的方法，比较的是对象的地址值；重写了之后，比较的是对象的内容
3.==和equals（）的区别？
==进行基本数据类型比较比较的是数据值，进行引用数据比较比较的是地址值
equals（）只能进行引用数据类型的比较。重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String：
底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：
底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型。
自动装箱和自动拆箱是由编译器自动完成。
区别：基本数据类型运行效率高但用法单一，包装类是把基本数据类型包装成一个引用数据类型能实现更多的用途和功能
作者: chenopen 时间: 2019-3-19 21:34
陈开明：
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为有的类有重写toString()方法，会覆盖原有方法，重写打印输出内容。有的类没有重写toString(）方法，这样子会调用Object父类的方法，直接打印地址值。直接打印输出对象名时候，系统自动调用toString()方法。
2.我们为什么要重写equals（）方法？
因为Object类的equals（）方法只是比较两个对象是否为同一个对象，即两个对象是否指向同一个地址值。而有时候，我们想比较的是两个对象的内容是否相同。
3.==和equals（）的区别？
==比较基本数据类型时候，比较的是具体值；比较引用数据类型时候，是比较两个对象的地址值是否相同；equals()只能比较引用数据类型。未重写之前是比较地址值，重写后是比较对象内容。
4.String和StringBuilder的区别？
String类是长度固定的字符串类，他们的值在创建之后不能修改，字符串的底层是一个被final修饰的字节数组。StringBuilder是字符串缓冲区，是一个长度可以变化的字符串，底层也是数组。StringBuilder在内存中始终是一个数组，占用空间少，效率高。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是将基本类型数据封装成类，赋予各种成员方法，使得基本类型的数据也能像对象一样有各种功能方法。基本数据类型是不能像对象一样，调用各种功能方法。
自动装箱：将基本数据类型转换为包装类型。
自动拆箱：将包装类型转换为基本数据类型。
作者: 林奕全 时间: 2019-3-19 21:34
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在打印时，如果没对toString方法进行重写的话，默认使用从Object类继承过来的方法，此时打印出来的是地址值；
而如果有对toString进行重写的话，那么打印出来的就是对象重写方法的内容.
当需要用到对象的地址值或者内容的时候，就会调用到toString（）方法。
2.我们为什么要重写equals（）方法？
不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的是地址值，而如果想进行方法内容的比较就需要进行重写；
3.==和equals（）的区别？
==:
比较基本类型:比较的是数据值;
比较引用类型:比较的是地址值;
equals:
只能比较引用数据类型
没有重写,比较的是两个对象的地址值;
有进行重写,比较的是两个对象的内容.
4.String和StringBuilder的区别？
String：底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型，区别：包装类是引用数据类型，能够使用方法进行对基本数据类型的操作。
自动装箱：[自动]进行基本类型转换为包装类
自动拆箱：[自动]进行包装类转换为基本类型
作者: 林艺彬 时间: 2019-3-19 21:36
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印的是地址值是继承了Object类的to String
打印的是对象内容是重写了to String方法
打印对象的是时候调用toString()方法
2.我们为什么要重写equals（）方法？
因为equals（）方法如果不重写比较的是地址值，重写以后才能比较对象的内容。
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String：每创建一个String就会有一个新的对象产生新的地址值，浪费程序资源。
StringBuilder：StringBuider只会创建一个对象，节省程序的资源
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型。
区别：能够使用方法进行对基本数据类型的操控
自动拆箱和自动装箱：在进行集合存储和比较的时候自动完成
作者: 卢春旭 时间: 2019-3-19 21:38
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）自动拆箱：包装类转为基本数据类型，在使用运算符的时候自动发生。
作者: 陈鉴 时间: 2019-3-19 21:40
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：打印对象其实就是调用对象的toString方法，如果该对象的类没有重写toString方法，那么打印出来的是对象的类型+@+内存地址值；如果该对象的类重写了toString方法，那么打印出来的是对象的内容。直接打印对象的名字，会调用对象的toString方法。
2.我们为什么要重写equals（）方法？
答：equals()方法用于比较两个对象是否相等。在没有重写的情况下，默认进行的比较是 == 运算符的对象地址比较，只要不是同一个对象，结果必然为false，这种比较的结果没有实际意义。我们希望的是对两个对象的内容进行比较，所以需要重写equals()方法。
3.==和equals（）的区别？
答：==运算符可以比较基本数据类型的数据值，也可以比较引用数据类型的地址值；
equals()方法只能对引用数据类型进行比较。在没有重写equals方法的情况下，比较的是对象的地址值；重写后可以比较对象的属性内容。
4.String和StringBuilder的区别？
答：String字符串是常量，他们的值在创建之后不能更改；
StringBuilder是字符串缓冲区，占用空间少，效率高，底层也是一个数组，但是没有被final修饰，其初始容量为 16 个字符，如果超出了StringBuilder的容量，会自动的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类是基本类型数据对应的引用数据类型，和基本类型的区别在于可以通过创建其对象而实现更多的功能
自动装箱：从基本类型自动转换为对应的包装类对象。
自动拆箱：从包装类对象自动转换为对应的基本类型。
作者: omasoo 时间: 2019-3-19 21:42
李伟斌
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.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类是指将基本数据类型包装起来的类
包装类能使用关于包装类的相关方法，这是基本数据类型没有的。
自动装箱：自动将基本数据类型转换成包装类
自动拆箱：自动将包装类转换成基本数据类型。
作者: 黑马林伟明 时间: 2019-3-19 21:47
今天我学习到了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对象
包装类的概念和好处:包装类就是基本数据类型对应的引用数据类型 好处是:能够使用方法进行对基本数据类型的操控
拆箱和装箱的概念,以及自动拆箱和自动装箱 拆箱:包装类->基本数据类型 装箱:基本数据类型->包装类
自动拆箱和自动装箱:在进行集合存储和比较的时候自动完成
作者: 唐彬桂 时间: 2019-3-19 22:35
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印地址值是因为没有重写boject类中的对象，打印对象内容是因为重写了boject类中的对象。
对象会在被通过对象名直接打印的时候默认调用toString方法。
2.我们为什么要重写equals（）方法？
因为重写之后可以对比对象的内容，没重写是比较地址值
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String：String定义的字符串是常量，在被创建后就不能修改。
底层是一个被final修饰的数组，所以无法改变
StringBuilder：可以看成是一个能修改的Sting常量
底层是一个未被final修饰的数组，所以长度可变，可以修改。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型
包装类和基本类型有什么区别是：
基本类型的使用方便，但是缺少对应的方法来进行操作；
而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型
自动拆箱：包装类转【自动】换为基本数据类型
自动装箱：基本数据类型【自动】转为包装类
作者: 沈松宏 时间: 2019-3-19 22:39
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
调用了toString方法的重写打印的就会是内容,未调用的会打印出地址值;
2.我们为什么要重写equals（）方法？
如果未重写equals方法,比较的是默认的地址值,重写后比较的是对象的内容
3.==和equals（）的区别？
==:
对于基本数据类型:比较的是值
对于引用数据类型:比较的是地址值
equals:
只能用于比较引用类型,如果未重写则比较的是地址值,重写后比较的是内容
4.String和StringBuilder的区别？
string长度不可变
stringbuilder长度可变
stringbuilder效率会更高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
使基本类型能够在仅仅使用引用数据类型的场合中变得可以使用,例如集合中;
自动装箱指的是基本数据类型自动变为包装类,
自动拆箱指的是包装类自动转换为基本类型
作者: 沈松宏 时间: 2019-3-19 22:40
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
调用了toString方法的重写打印的就会是内容,未调用的会打印出地址值;
2.我们为什么要重写equals（）方法？
如果未重写equals方法,比较的是默认的地址值,重写后比较的是对象的内容
3.==和equals（）的区别？
==:
对于基本数据类型:比较的是值
对于引用数据类型:比较的是地址值
equals:
只能用于比较引用类型,如果未重写则比较的是地址值,重写后比较的是内容
4.String和StringBuilder的区别？
string长度不可变
stringbuilder长度可变
stringbuilder效率会更高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
使基本类型能够在仅仅使用引用数据类型的场合中变得可以使用,例如集合中;
自动装箱指的是基本数据类型自动变为包装类,
自动拆箱指的是包装类自动转换为基本类型
作者: 黄杰南 时间: 2019-3-20 12:45
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
对象默认继承了Object类的toString()，打印的是地址值
对象继承了重写的toString()方法的父类，打印的是内容
直接打印对象就会调用toString()方法
2.我们为什么要重写equals（）方法？
对象调用equals（）方法比较的是对象的地址值，重写后比较对象的内容
3.==和equals（）的区别？
基础数据类型使用==比较的是数据值，引用数据类型使用==比较的是地址值
基础数据类型不能使用equals（）方法，equals底层是==，重写后比较对象内容
4.String和StringBuilder的区别？
StringBuilder类：字符串缓冲区,可以提高字符串的效率
String长度不可改变，StringBuilder会自动维护数组的扩容
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
基于基本数据类型创建的类，包装类的对象可以做更多的功能
JDK1.5之后出现的新特性，基本类型的数据和包装类之间可以自动的相互转换
作者: 苏森鹏 时间: 2019-3-20 21:31
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）打印对象时，其实是调用了对象的toString方法，而这个方法要么对象所在的类中没有，子类没有向上找，则程序调用Object类中的toString方法，打印的是地址值；要么所在的类重写了这个方法，打印出了其中的内容。
（2）对象会在被通过对象名直接打印的时候默认调用toString方法。
2.我们为什么要重写equals（）方法？
如果不重写equals（）方法，equals会默认使用从Object类继承过来的方法，这样进行比较的两者的地址值，而如果想进行内容的比较就需要进行重写；
3.==和equals（）的区别？
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是对象的地址值
equals()
只能比较引用数据类型
重写之前，比较的是地址值，底层就是==
重写之后，比较的是对象的内容
4.String和StringBuilder的区别？
String：底层是被final修饰的数组，是一个不变的常量；
在进行相加时，内存会出现多个字符串，占用多，效率低；
StingBuilder：底层是数组，但没有被final修饰，长度可变；
在进行相加时，在内存中始终是一个数组，占用少，效率高；如果容量超出，则自动扩容；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：基本数据所对应的引用数据类型；
区别：基本类型的使用方便，但是缺少对应的方法来进行操作；而包装类可以对基本类型进行定义方法，从而进行操作基本数据类型；
自动装箱：即自动进行基本类型转换为包装类的操作；
自动拆箱：即自动进行包装类转换为基本类型的操作；
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |