黑马程序员技术交流社区

标题: 【厦门JavaEE就业三期-每日总结】Object类、常用API [打印本页]

作者: 厦门校区 时间: 2018-8-11 20:55
标题: 【厦门JavaEE就业三期-每日总结】Object类、常用API

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

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
2.我们为什么要重写equals（）方法？
3.==和equals（）的区别？
4.String和StringBuilder的区别？
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

作者: 张煜兴 时间: 2018-8-11 21:06
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
  Object的默认toString是打印地址，有些类重写了toString方法，所以可以打印对象内容
  在打印对象时会调用toString()方法

2.我们为什么要重写equals（）方法？
  因为Object的默认equals（）方法是比较两个对象的地址值，在现实生活中没有意义

3.==和equals（）的区别？
  ==对基本数据类型是比较值，对引用类型是比较地址，equals (  ) 比较的是对象地址或对象的内容

4.String和StringBuilder的区别？
  String在拼接时要创建很多新地址，浪费内存，StringBuilder在内存中只占用一个地址,内存利用率和效率高
  String是引用数据类型，StringBuilder是另一个类，两者的方法不一样

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
  包装类是对基本数据类型进行打包的类，是引用数据类型，当在进行包装类和对应的基本数据类型的运算时，根据情况会自动装箱和拆箱

作者: sulaymanfan 时间: 2018-8-11 21:07
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？  toString方法是基类object的方法,如果子类不重写toString方法默认打印的是地址, 对象在调用print方法,货值直接diaoytoString的时候回调用toString方法.
2.我们为什么要重写equals（）方法？
  因为默认的equals方法并不能拿到对象的具体值,所以在判断对象的值是否相等时可更加需求重写equals方法
3.==和equals（）的区别？
== 时在比较地址值
  equals时比较内容

4.String和StringBuilder的区别？
String 的底层是一个被final修饰的字符数组,所以创建后无法更改
StringBuilder 的底层是一个默认大小为16的字符数组,的缓存数组,可以随时更改起大小.

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

  包装类是指,把一些基本数据包装成对应的引用数据类型,使得普通的基本类型可以调用包装类的方法,
  自动装箱时jdk1.5后添加的新特性,自动装箱时可以吧基本数据类型直接转换成对应的包装类,
  自动拆箱时值基本数据类型对应的包装类可以直接被对应的基本数据类型可接受.

作者: Michcale 时间: 2018-8-11 21:09
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为没有重写的toString 方法属于object类,打印的是对像的地址值.而有些方法重写了能打印出对像内容的toString方法,打印的当然是对像.在打印的时候会调用toString()方法.
2.我们为什么要重写equals（）方法？
因为没有重写的equals方法对比的是两个对像的地址值,没有意义
3.==和equals（）的区别？
==是比较运算符,是用于比较基本数据类型的.尔equals比较的是两个对像的内容(有重写equals());
4.String和StringBuilder的区别？
1)类型不同
2)String不能改变长度,.而StringBuilder可以根据需求进行改变长度
3)在运算中StringBuilder跟有效率
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
基本数据类型的对象版,就是包装类.包装类可以创建对像用于调用数据,而基本数据类型不行.
自动装箱:就是将基本数据提升为相应的包装类.自动拆箱:就是将包装类转化为对应的基本数据类型

--------------------------吴齐宾

作者: 黄伟佳 时间: 2018-8-11 21:10
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印地址值和对象内容是因为没有覆盖重写，当对象想要返还对象信息可以调用被重写的toString
2.我们为什么要重写equals（）方法？
不重写的话比较的是地址值，并不是对象内容
3.==和equals（）的区别？
==比较地址值，被重写的equals比较的是对象内容
4.String和StringBuilder的区别？
就是占用内存的关系。当拼接的字符串多了。用StringBuilder可以优化节省内存。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
就是基本类型被打包成对应的类- -。
一个是基本类型数据，一个是类。
就是自动转换，从对应的包装类转换成基本数据类型或者反过来。

作者: 林靖 时间: 2018-8-11 21:11
1.因为有的类重写了toString方法可以打印出对象内容，没重写的打印的是地址值，在打印输出对象名时会默认使用toString方法
2.因为没有重写的方法比较的是两个对象的地址值，没意义。
3.一个是比较运算符，一个是方法。 equals可以比较两个对象的具体内容。
4.类名不同，String不能改变长度，StringBuider长度可变的字符串缓冲区，可用于字符串拼接
5.包装类可用于创建对象，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类。基本数据类型值自动提升为包装类叫做装箱，包装类自动转换为基本数据类型值叫做拆箱。

作者: 黄艺纯 时间: 2018-8-11 21:11
本帖最后由黄艺纯于 2018-8-11 21:15 编辑

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

打印输出的时候调用了对象的toString方法。toString是Object类的方法，Object类是所有类的父类，其toString方法是打印对象的引用，若是内容，则是该类覆盖了该方法。
打印输出对象的时候。

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

因为equals（）是Object的方法，原方法是对两个对象的引用进行比较，没有意义。所以我们要将其覆盖成对内容的比较。

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

引用的比较；
内容的比较。

4.String和StringBuilder的区别？

String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，所以经常改变内容的字符串最好不要用String，因为每次生成对象都会对系统性能产生影响。

StringBuilder又称为可变字符序列，是JDK5.0中新增加的一个类，它是一个类似于String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。即它是一个容器，容器中可以装很多字符串，并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动维护数组的扩容。

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

包装类：基本数据类型对应的引用类型。
区别：1.默认值；
2.存储位置；
3.多出方法的操作。
自动装箱，自动创建对象，省去创建对象的操作。
自动拆箱，自动将包装类型转换为基本数据类型。

作者: liebstch 时间: 2018-8-11 21:13
陈建秋
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？Object类是所有类的父类，所有的对象都继承了它的toString方法。如果这个子类没有重写toString方法那么默认就是输出地址值；如果重写了toString方法，那么就会输出
重写方法里写的内容；当对象在输出方法里输出时，会自动调用toString方法。
2.我们为什么要重写equals（）方法？
每个类都继承了equals方法，如果不重写的话默认是进行地址值比较没什么用处，重写之后可以比较自定义的内容。
3.==和equals（）的区别？
==进行的是地址值比较，equals比较的内容，是equals方法里的内容。
4.String和StringBuilder的区别？
String 类的底层为final修饰的byte数组，内容不可变，当进行字符拼接时会new出多个对象，占用内存。
StringBulider 的底层，是可变数组，当进行字符拼接的时候，它会自动维护数组的长度，在数组内完成操作不用再创建新对象，所以提高了效率。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是把基本类型的数据封装在一个类中；包装类是一个引用类型，它拥有自己的方法，可以在泛型中声明；
自动装箱，就是把基本数据类型转化为包装类对象。
自动拆箱，就是把包装类对象转化为基本数据类型。

作者: 罗荣贵 时间: 2018-8-11 21:15
1.所有的类都是Object的子类，都会继承Object中的tostring方法，而没有改写的此方法打印对象名时候是打印对象的地址值，有些类的对象打印却是内容的原因是这个类有重写了tostring方法，当在打印输出对象的时候都默认调用类中的tostring方法
2.当没有重写equals方法时候，对象调用此方法对比的是对象的地址值是否相同，没有意义
3.==比较是基本数据类型的值的大小和对象的地址是否相等，equals方法重写后可以比较对象的内容是否相同
4.tringBuilder 一个可变的字符序列，用在字符串缓冲区。
String类是一个字符串类，底层是字节数组，每一个字符串创建后对应的底层字节数组的长度不能改变。
5.包装类是把基本数据类型包装一个类，可以作为引用类型来使用基本数据，是一个引用数据类型，当王包装类中添加基本数据类型，或者直接获取包装类中的内容赋值给基本数据类型时，不会发生数据类型不同的错误，此时，是发生了自动装箱和自动拆箱。

作者: 谢君昇 时间: 2018-8-11 21:15
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？当对象重写了toString（）方法的时候打印得是对象内容，否则打印得是地址值。对象在打印语句中会调用toString（）方法；
2.我们为什么要重写equals（）方法？
如果不重写equals（）那么效果和 == 是一样的只能比较地址值，重写后可以比较内容。
3.==和equals（）的区别？
==比较的是地址值，equals（）比较的是内容。
4.String和StringBuilder的区别？
String 一旦创建长度不可改变，每次拼接都会创建新的对象，StringBuilder可改变长度和内容，是一个缓冲区。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类：把基本数据类型放到一个类中，以供使用称为包装类，
区别：包装类可以创建对象来使用
自动装箱：基本数据类型自动转化为包装类
自动拆箱：包装类自动转化为基本数据类型

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

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

杨式贤

作者: 舟sir 时间: 2018-8-11 21:19
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
Object 的toString方法返回的是地址值，所以打印出来是地址，覆盖重写后的toString后返回的是值，打印出来的就是内容；
在打印输出对象的时候都会调用到toString（）方法；

2.我们为什么要重写equals（）方法？
在Object中equals方法在java中比较的是地址哈希值，而我们比较对象时都是比较内容，此时的equals方法没有意义，所以重写用来比较内容
3.==和equals（）的区别？
==在比较基本数据时比较的是值，引用数据类型的时候比较地址值
equals比较的是地址值，可以进行覆盖重写比较内容；
4.String和StringBuilder的区别？
String的底层被final修饰，是一个常量不可修改，每次拼接都会产生新的字符串，占内存，效率低；
StringBuilder 底层也是字符数组，没有被final修饰，长度可变，操作效率高；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是值基本数据类封装的类，一个是基本数据类型一个是引用数据类型；
装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

作者: 郑颖锋 时间: 2018-8-11 21:19
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
Object类时所有类的父类，直接打印对象名，默认是地址值，除非对象中的toSting()方法被改写，才会显示对象内容。
直接打印对象名时就会调用toString()方法。

2.我们为什么要重写equals（）方法？
equals直接使用时默认是比较两个对象的地址值，没有意义。实际情况中我们更多想要的是比较对象的内容，因而要对equals()方法进行重写。

3.==和equals（）的区别？
==比较基本数据类型是比较具体值，引用数据时是比较两个对象的地址值。
equals()方法没有覆盖重写时默认比较两个对象的地址值，当进行覆盖重写时可以比较两个对象的具体内容是否相同。

4.String和StringBuilder的区别？
String是字符串常量，一旦创建，字符串内容不可改变。进行字符串拼接时会创建一个新的内存空间，如果经常改变字符串内容，最好不用String，会对性能造成影响；
StringBuilder又称为可变字符序列，是JDK5.0以后新增的类，它是一个类似于String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。即它是一个容器，容器中可以装很多字符串，并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动维护数组的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类时把基本数据类型包装起来，在类中定义一些方法，因而包装类相当于是引用数据类型，可以使用其中的方法；基本数据类型则不能直接引用方法。
自动装箱是指在使用基本数据类型的数据时会自动转换为包装类，而不用特殊操作(JDK5.0以后)。
自动拆箱是指在使用包装类的数据时会自动转换为基本数据类型，而不用特殊操作(JDK5.0以后)。

作者: zouyitao 时间: 2018-8-11 21:20
邹毅涛

1.为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象时，输出为地址值时，是因为toString方法为Object类方法，没有覆盖重写，是对象内容即是重写了toString方法。直接打印对象名称时，会隐式调用toString方法。
2.我们为什么要重写equals（）方法？
Object类equals方法是比较对象的地址值，对对象类型没有限制，重写equals方法可以更完善代码，让两个对象在相比的时候类型一致且不为空。
3.==和equals（）的区别？
==在基本数据类型中比较的是值，在引用数据类型比较的是地址值。
equals不能比较基本数据类型，如果要比较数据类型需要使用包装类。Object类中的equals方法不会报空指针异常。
4.String和StringBuilder的区别？
String在底层被final修饰的长度不可变数组。String字符串不可变。StringBuider是长度可变的数组。StringBuider效率高。如果超出容量会自动扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是为了解决基本数据类型不能够被直接操作而将其包装成对象。与八个基本数据类型想对应。自动拆箱与自动装箱是基本数据类型可以直接互相转换。

作者: 林嘉志 时间: 2018-8-11 21:21
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果toString方法没有被覆盖重写打印的就是地址值，如果被覆盖重写打印的就是覆盖重写中返回值
2.我们为什么要重写equals（）方法？
因为Object中的equals方法对比的是地址值，所以需要覆盖重写
3.==和equals（）的区别？
==如果比较的是基本数据类型，那么比较的是存储的值是否相等
如果比较的是引用数据类型，比较的是地址值
equals比较的是地址值，如果被重写比较的是内容
不能比较基本数据类型
4.String和StringBuilder的区别？
String创建的字符串不能改变
StringBuilder类似于String的缓冲区，可以对字符串进行操作
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类可以调用方法对基本数据类型进行操作
基本数据类型没有方法课调用
自动将基本数据类型转化为包装类对象
自动将包装类对象转化为基本数据类型

作者: 舟sir 时间: 2018-8-11 21:21
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
Object 的toString方法返回的是地址值，所以打印出来是地址，覆盖重写后的toString后返回的是值，打印出来的就是内容；
在打印输出对象的时候都会调用到toString（）方法；

2.我们为什么要重写equals（）方法？
在Object中equals方法在java中比较的是地址哈希值，而我们比较对象时都是比较内容，此时的equals方法没有意义，所以重写用来比较内容
3.==和equals（）的区别？
==在比较基本数据时比较的是值，引用数据类型的时候比较地址值
equals比较的是地址值，可以进行覆盖重写比较内容；
4.String和StringBuilder的区别？
String的底层被final修饰，是一个常量不可修改，每次拼接都会产生新的字符串，占内存，效率低；
StringBuilder 底层也是字符数组，没有被final修饰，长度可变，操作效率高；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是值基本数据类封装的类，一个是基本数据类型一个是引用数据类型；
装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

作者: 林胜强 时间: 2018-8-11 21:22
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象在没有重写toString方法是比较的都是地址值，比较说明了封装里重写了toString。在打印对象时会调用toString()方法
2.我们为什么要重写equals（）方法？
不重写equals（）方法比较的是地址值。
3.==和equals（）的区别？
==比较的是内容，equals（）比较的是对象地址值（除非重写）。
4.String和StringBuilder的区别？
String在字符串常量区，是内容不可变的，拼接后需要新建对象地址。StringBuilder长度可变。效率更高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：把基本数据类型放到一个类中，以供使用称为包装类，
区别：包装类可以创建对象来使用
自动装箱：基本数据类型自动转化为包装类
自动拆箱：包装类自动转化为基本数据类型

作者: ZNBran 时间: 2018-8-11 21:24
1.在打印对象时会调用toString()方法，打印对象默认调用Object中的toString()方法，toString()方法默认打印地址值，如果对toString()方法进行重写就可以打印对象内容。
2因为Object中默认比较两个对象的地址值只要对象不同结果一定为false。
3==可以进行基本数据类型的比较equals（）则是只能进行引用数据类型比较。
4.StringBuild构建一个单一数组存放所有字符串，可以减少字符串拼接时所占用的内存
5.包装类可以对对应的基本数据类型进行包装扩展了基本类型的操作性。包装类是引用类型。自动装箱就是自动把基本类型包装成对应的包装类，自动拆箱就是在需要应用基本类型时自动把包装类转换成对应的基本类型数据。
周楠

作者: 仰望｀星空 时间: 2018-8-11 21:26
郭林源
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？--->基本数据类型打印的是内容，引用数据类型如果引用对象未对toString()方法进行重写，则打印的是地址值，重写后打印的是内容。打印对象时会调用toString方法
2.我们为什么要重写equals（）方法？--》如果未重写equals方法，比较的是地址值，现实中无意义，重写后可比较内容
3.==和equals（）的区别？--》比较基本数据类型时，都一样，比较引用数据类型时，重写equals方法可比较内容
4.String和StringBuilder的区别？--》拼接字符串时，StringBuilder在类中拼接，不占内存，速度较快，String则会生成新的几个数组
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？--》包装类就是集成了一些基本数据类型，并有方法可管理的类。自动装箱就是基本数据类型转换成引用数据类型，自动拆箱就是引用数据类型转换成基本数据类型

作者: 舟sir 时间: 2018-8-11 21:26
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
Object 的toString方法返回的是地址值，所以打印出来是地址，覆盖重写后的toString后返回的是值，打印出来的就是内容；
在打印输出对象的时候都会调用到toString（）方法；

2.我们为什么要重写equals（）方法？
在Object中equals方法在java中比较的是地址哈希值，而我们比较对象时都是比较内容，此时的equals方法没有意义，所以重写用来比较内容
3.==和equals（）的区别？
==在比较基本数据时比较的是值，引用数据类型的时候比较地址值
equals比较的是地址值，可以进行覆盖重写比较内容；
4.String和StringBuilder的区别？
String的底层被final修饰，是一个常量不可修改，每次拼接都会产生新的字符串，占内存，效率低；
StringBuilder 底层也是字符数组，没有被final修饰，长度可变，操作效率高；
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是值基本数据类封装的类，一个是基本数据类型一个是引用数据类型；
装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

作者: weimengchao 时间: 2018-8-11 21:27
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
是否重写了直接父类或者间接父类的toString()方法，
对象调用，打印调用
2.我们为什么要重写equals（）方法？
根据项目需求进行覆盖重写重新定义什么情况下对象相等
3.==和equals（）的区别？
地址值
内容
4.String和StringBuilder的区别？
String内容不可改变
StringBuilder字符串缓冲区，内容可以改变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
把基本数据类型进行封装成对象，可以调用方法
不用调用方法直接用相应的变量接收

作者: 刘建宝 时间: 2018-8-11 21:29
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
* 当toString没有被重写时，因方法属于object ，打印的是对象的地址值；
* 当toString方法被重写时，在打印对象时会自动调用重写后的toString方法的内容；

2.我们为什么要重写equals（）方法？
3.==和equals（）的区别？
当 == 适用于基本类型和引用类型，equals 只适用于引用类型；
当两者都用于引用类型是，==只是比较两者地址值是否相等，而equals比较的是内容
equals需要覆盖重写方法；
4.String和StringBuilder的区别？
String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象
所以经常改变内容的字符串最好不要用String，因为每次生成对象都会对系统性能产生影响。
StringBuilder又称为可变字符序列，是JDK5.0中新增加的一个类，它是一个类似于String的字符串缓冲区
通过某些方法调用可以改变该序列的长度和内容。
即它是一个容器，容器中可以装很多字符串，并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时
直接在数组中加入新内容，StringBuilder会自动维护数组的扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
将基本类型包装成可以像对象使用的类，叫做包装类；
相对于基本类型，包装类可以有更多的功能，可以创建对象
自动完成从基本类型转化成包装类的过程叫做自动装箱
自动完成从包装类转化成基本类型的过程叫做自动拆箱

作者: 吴鑫佳 时间: 2018-8-11 21:30
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？1
如果改写了toString，就会直接调用toString方法，则打印的就是对象内容。如果没有，就是调用父类Object中的toString方法，也就是打印出内存地址。
在打印输出类名对象的时候会默认调用。
2.我们为什么要重写equals（）方法？
重写equals（）方法比较的是对象的内容，如果不重写则默认的是用==,则比较的是地址值。所以如果要比较对象的内容就一定要重写equals（）方法。
3.==和equals（）的区别？
==比较的是对象的地址值，equals比较的是对象的内容。
4.String和StringBuilder的区别？
String底层是final修饰的数组，所以长度不可改变，对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，而StringBuilder的长度是可变的，通过某些方法调用可以改变该序列的长度和内容，当添加的内容超出范围使会自动维护数组进行扩容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
使用一个类，把基本数据类型的数据装起来，在类中定义一些方法，这个类叫包装类。可以使用类中的方法来操作这些基本类型的数据
基本数据类型自动转换为包装类的对象，这叫自动装箱。包装类的对象自动转化为基本的数据类型，叫自动拆箱。

作者: 陈捷 时间: 2018-8-11 21:31
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
当对象重写了toString（）方法的时候打印得是对象内容，否则打印得是地址值。对象在打印语句中会调用toString（）方法。
2.我们为什么要重写equals（）方法？
因为默认的equals方法比较的是地址值没什么意义,所以在判断对象的值是否相等时需求重写equals方法让方法能够比较内容。
3.==和equals（）的区别？
== 比较地址值
equals 比较内容

4.String和StringBuilder的区别？
String 的底层是一个被final修饰的字符数组,所以创建后无法更改
StringBuilder 的底层是一个可以随时更改起大小的默认大小为16的字符数组。

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

包装类是指,把一些基本数据包装成对应的引用数据类型,使得普通的基本类型可以调用包装类的方法；
自动装箱是指在使用基本数据类型的数据时会自动转换为包装类，而不用特殊操作(JDK5.0以后)；
自动拆箱是指在使用包装类的数据时会自动转换为基本数据类型，而不用特殊操作(JDK5.0以后)。

作者: 练志成 时间: 2018-8-11 21:31
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象如果是内容则说明其类已经重写过tostring方法了，如果不是则没有重写，对象打印输出时默认调用
2.我们为什么要重写equals（）方法？
因为如果没有重写默认对比的是两个对象的地址值。
3.==和equals（）的区别？
对于引用类型来说==对比的是地址值
而equals（）对比的是其内容
4.String和StringBuilder的区别？
string是不可改变的字符串
StringBuilder是可以改变的字符串
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本类转换成引用类，在某些类或者方法中基本类是不可用的，所有出现了包装类，
自动拆装箱是java5后出现的一个新特性，就是不用操作自动类型转换

作者: 罗建辉 时间: 2018-8-11 21:32
问题:
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
2.我们为什么要重写equals（）方法？
3.==和equals（）的区别？
4.String和StringBuilder的区别？
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

回答:
1.在打印对象时是调用对象的toString()方法,当对象有覆盖重写toString()方法时,打印的是对象的值,当没有覆盖重写toString()方法,则打印的是对象的地址值2.equals()方法是比较方法,在Objiectl类中,eauals()方法是比较对象的地址值,与==号作用相同,因此要想比较对象的值需要覆盖重写equals()方法.
3.equals()方法是比较方法,在Objiectl类中,eauals()方法是比较对象的地址值,与==号作用相同,因此要想比较对象的值需要覆盖重写equals()方法,覆盖重写后则比较的是值
4.String 是不可变字符串,其长度是固定的,当其内容发生改变时,则会在内存中开辟新的内存空间 ,StringBuilder 是可变字符串,其长度是可变的,当内容发生改变时,其地址值不会改变,因此 StringBuilder拼接字符串效率高.
5.包装类是包装基本数据类型的类,把基本数据类型的数据变成引用类型的值,基本数据类型无法操作方法,而包装类可以操作相应的方法.
自动装箱是JDK1.5的新特性,属于编译器优化,不需要手动拆箱与装箱

作者: 沈智桂 时间: 2018-8-11 21:35
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
看有没有重写toString(）方法，没有重写打印的就是地址值，重写就是对象内容，在打印对象的时候会调用tostring方法
2.我们为什么要重写equals（）方法？
因为OBject的equals比较的是地址值，没有意义
3.==和equals（）的区别？
两个引用数据类型对象 ==比较的是地址值，equals（）重写完两个对象比较的是内容

4.String和StringBuilder的区别？
string的内容不能变，stringBuider的内容可以变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：把基本数据类型放在一个类中，以供使用称为包装类
区别：包装类可以创建对象来使用
自动装箱：基本数据类型自动转化为包类
自动拆箱：包装类自动转换为基本数据类型

作者: 小悦悦 时间: 2018-8-11 21:37
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为直接打印对象是地址值，而有的对象是对toString方法的重写。通过对象调用的时候会默认自动调用toString方法
2.我们为什么要重写equals（）方法？
直接使用equals（）方法默认比较的是地址值没有意义。
3.==和equals（）的区别？
==比较的是地址值，equals默认的比较的是地址值，重写后比较的是内容。
4.String和StringBuilder的区别？
String内容不可改变，每当拼接一个新的字符串的时候都会重现创建一个新的字符串。
StringBuilder内容和长度可以改变。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是将基本数据类型封装起来的。是引用数据类型，可以使用其基本数据类型。
--李翔

作者: 张剑猛 时间: 2018-8-11 21:39
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为部分类对toString方法进行重写，例如Arrays调用toString打印的是值，在需要打印对象的时候会调用到
2.我们为什么要重写equals（）方法？
对象之前的equals比较的是地址值，现实中没有意义，需要比较内容就必须进行重写，例如String调用equals比较的就是内容。
3.==和equals（）的区别？
对于引用类型==比较地址值，equals比较内容
4.String和StringBuilder的区别？
String内容长度不可改变，StringBuilder字符串缓冲区，内容长度可以改变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
基本类型不能创建对象，通过包装类调用对象，jdk5后基本数据类型和包装类的引用数据类型会再运算后自行发生转换

作者: 丶黑白 时间: 2018-8-11 21:43
余志斌
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
没有重写to String（）方法的时候打印对象是地址值，重写后打印对象是对象内容。打印String 类的时候对象的时候会默认调用to String（）方法。
2.我们为什么要重写equals（）方法？
防止空指针异常，也就是说重写后比较对象是null的时候不会报错，而是返回false
3.==和equals（）的区别？
==是通过比较地址值判断是否是同一个对象，equals是通过比较对象内容判断是否是同一个对象。
4.String和StringBuilder的区别？
String 内容不可变，适用于量级小的拼接运算。
StringBuilder 存在缓冲区，内存中始终是一个数组，适用于量级大的拼接运算。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
由于不能在泛型等地方直接操作基本型，故而将基本类包装成类，称为包装类。区别在于基本型是数据类型，包装类属于类。自动拆装箱是指系统在特定时候会自动将包装类和基本型互相转化，既可以用基本型接受包装类，也可以由包装类对象接受基本型数据。

作者: 李伟javaee03 时间: 2018-8-11 21:46
1. 思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
没有重写toString方法时打印出来的时地址值,重写toString方法后打印出来的为对象内容。
打印输出对象时会默认调用toString方法

2.我们为什么要重写equals（）方法？
在Object类中equals（）默认为地址值比较，无意义。

3.==和equals（）的区别？
==比较的是地址值，equels比较的是内容

4.String和StringBuilder的区别？
String内容不可变，拼接时是创建新的字符串，StringBuilder内容可变，拼接时会发生改变，大量运算时提高效率。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
用一个类将基本数据类型装起来，在类中定义一些方法，这个类叫包装类，包装类是一个引用类型
自动装箱：将基本数据类型变为包装类型
自动拆箱：将包装类型变为基本数据类型

作者: 李志超 时间: 2018-8-11 21:49
思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
根据方法是否被重写（不同的方法具有不同的作用）；想要以字符串形式输出时
2.我们为什么要重写equals（）方法？
重写前是比较地址值；重写后比较内容，更具有实际意义
3.==和equals（）的区别？
==比较的是地址值，equals比较内容
4.String和StringBuilder的区别？
String固定长度内容，且运行多次时需创建多次对象，效率低下；String Builder长度内容可变，且在堆中只占用一个空间，空间不够会自动扩容，效率较高。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
将基本数据类型转换成引用数据类型的类就叫做包装类。一个是基本数据类型，一个是引用数据类型；自动装箱：系统自动将基本数据类型转换成相应包装类。自动拆箱：系统自动将包装类转换成相应的基本数据类型。

作者: 郭生发 时间: 2018-8-11 21:50
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
   看是否该对象的类是否有重写了toString()方法。
   对象在打印输出时默认调用toString()方法。
2.我们为什么要重写equals（）方法？
   因为Object类里的equals()比较的是地址值，没有意义。
我们需要的是比较内容，所以要重写。
3.==和equals（）的区别？
   ==比较的是基本数据类型的内容，引用数据类型则比较地址值，equals()比较的是对象的内容或者地址值。
4.String和StringBuilder的区别？
   StringBuilder运行效率更高，创建的对象长度和内容均可变，拼接时不用创建新的对象。
   String运行效率较慢，对象内容不可变，每次拼接时会创建一个新的对象。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
   包装类是指把基本数据类型包装成引用数据类型。包装类可以调用方法，基本数据类型不行。
基本数据类型自动包装成包装类叫自动装箱。
包装类自动转为基本数据类型叫自动拆箱。

作者: 迪亚波罗 时间: 2018-8-11 21:50
1。Object的默认toString是打印地址，有些类重写了toString方法，所以可以打印对象内容
在打印对象时会调用toString()方法
2。equals默认对比的是对象的地址值,我们需要的对比的是对象的值.
3.==在基础类型中比较的是类的值,引用对象比较的是地址值.equlas默认比较对象地址值.重写后比较对象的值.
4.String底层是final修饰的数组，所以长度不可改变，对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，而StringBuilder的长度是可变的，通过某些方法调用可以改变该序列的长度和内容，当添加的内容超出范围使会自动维护数组进行扩容。
5.包装类是指,把一些基本数据包装成对应的引用数据类型,使得普通的基本类型可以调用包装类的方法；
自动装箱是指在使用基本数据类型的数据时会自动转换为包装类，而不用特殊操作(JDK5.0以后)；
自动拆箱是指在使用包装类的数据时会自动转换为基本数据类型，而不用特殊操作(JDK5.0以后)。

作者: 赖良峰 时间: 2018-8-11 21:51
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？如果对象所对应的类对toString进行了重写,那么打印这个对象得到的就是对象内容,否则就得到对象的地址值,当对象被打印的时候;
2.我们为什么要重写equals（）方法？
equals方法在object中是用来比较两个对象的,直接比较对象其实是在比较对象的地址值,意义不大,通过重写equals方法可以在比较对象时直接比较对象的内容;
3.==和equals（）的区别？
==是比较运算符,如果是基本类型,则比较基本类型的值,如果是应用数据类型,则比较他们的地址值; 而equals只能比较应用数据类型,可以比较他们的地址值也可以比较他们的内容;
4.String和StringBuilder的区别？
stringbuilder可以提高程序的性能,原因是它底层的数组没有被final修饰,数组的长度可以改变,在进行数组拼接时,不用再平凡的在堆内存中创建新的对象;
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类就是将基本类型装在一个类中,在类中定义一些方法来操作这些基本类型;

作者: 冰是睡着的水 时间: 2018-8-11 21:52
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：程序中如果覆盖重写了toString，就会调用重写后的toString方法，此时打印的是对象内容。如果没有覆盖重写，那么会调用父类Object中的toString方法，打印出来的是内存地址值。
在打印输出类名对象的时候会自动调用（此时toString省略不写）。
2.我们为什么要重写equals（）方法？
答：如果不重写equals（）方法，那么我们在调用该方法是只能用父类Object中的equals（）方法，只能比较地址值。如果相比较内容就一定要对equals（）方法覆盖重写。
3.==和equals（）的区别？
答：==符号比较的是基本数据类型或者引用数据类型的地址值，重写的equals（）方法比较的内容。
4.String和StringBuilder的区别？
答：类名不同。StringBulider的效率比String高，StringBuilder的长度是可以改变的而String的长度一旦确定就不能让改变，String底层是final修饰的数组，所以长度不可改变，对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：由基本类型包装而成的类，称为包装类。和基本类型相比，包装类使用范围更为广泛，可以创建对象自动完成从基本类型转化成包装类的过程叫做自动装箱，自动完成从包装类转化成基本类型的过程叫做自动拆箱。
（黄嘉欣）

作者: MJ11 时间: 2018-8-11 21:53
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象输出地址值是因为toString对象没有被覆盖重写，打印的是对象内容的时候重写了toString方法。打印对象时会调用toString方法
2.我们为什么要重写equals（）方法？
因为Object类中的equals比较的是对象的地址值，没有意义，所以要重写equals方法,比较两对象的属性
3.==和equals（）的区别？
==是引用地址值的比较
equals是两个对象内容的比较
4.String和StringBuilder的区别？
String是字符串常量，它们的值在创建后不能被更改。
StringBuilder底层是一个数组，但是没有被final修饰,值的长度可以被改变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型所对应的引用数据类型，分为四类八种。基本数据类型不可以调用方法。自动装箱：从基本数据类型转换为对应的包装类的对象。自动拆箱：从包装类对象转换为基本的数据类型

田浪

作者: 陈锦祥 时间: 2018-8-11 21:54
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？打印出地址是的对象  所在类没有对toString 方法进行重写；
在System.out.println(对象名);  在输出语句的时候会自动隐式调用toString（）方法；

2.我们为什么要重写equals（）方法？
重写equals方法  比较对象的属性会更有意义

3.==和equals（）的区别？
  ==基本数据类型是比较值，引用类型是比较地址，
equals (  ) 比较的是对象地址或对象的内容

4.String和StringBuilder的区别？
String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，所以经常改变内容的字符串最好不要用String，因为每次生成对象都会对系统性能产生影响。

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

  基本数据类型，使用起来非常方便，但是没有对应的方法来操作这些基本类型数据
  可以使用一个类把数据类型的数据装起来，在类中定义了一些方法这个类叫包装类  我们可以使用类中的方法操作这些基本类型的数据
  包装类是引用数据类型
  初始化值不一样
  基本类型没有操作数据的方法包装类有
  基本类型数据和包装类之间可以自动互相转换

作者: 小鱼七 时间: 2018-8-11 22:01
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果对象所在的类没有重写toString，那么打印的就是地址值，重写了，打印的就是对象内容，在打印语句时会调用toString.
2.我们为什么要重写equals（）方法？
equals是抽象方法
3.==和equals（）的区别？
==两边是基本数据类型时，比较的是数值，是引用类型时比较的是地址值，equals比较的是地址值
4.String和StringBuilder的区别？
StringBuilder可以改变长度，String被final修饰，不可改变

作者: 陈张辉 时间: 2018-8-12 18:55

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
         看有没有重写toString方法                                     打印对象名或者直接调用
2.我们为什么要重写equals（）方法？
         要不然比较没有意义
3.==和equals（）的区别？
      ==比较地址    equals比较看重写的内容
4.String和StringBuilder的区别？
   长度可变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
   基本类型---变引用类型                引用类型自动变成基本类型  基本类型自动变成引用类型

作者: 苏华琛 时间: 2018-8-12 19:03
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为object的toString方法打印的是地址值，重写后的tostring方法打印出来的才是对象内容。
在打印对象的时候会调用toString内容。
2.我们为什么要重写equals（）方法？
在object中equals比较的是对象的地址值，没有意义，所以需要重写equals方法
3.==和equals（）的区别？
==等于比较的是比较对象的值，而equals比较的是比较对象的地址值
4.String和StringBuilder的区别？
String在进行多次数的运行时，效率比StringBuilder低很多
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本数据类型封装的类，
自动装箱：自动从数据类型转换为对应的包装类对象
自动拆箱：自动才包装类对象转换为数据类型

作者: 张子建 时间: 2018-8-12 19:06
1.打印对象时，输出为地址值时，是因为toString方法为Object类方法，没有覆盖重写，是对象内容即是重写了toString方法。直接打印对象名称时，会隐式调用toString方法。
2.Object类equals方法是比较对象的地址值，对对象类型没有限制，重写equals方法可以更完善代码，让两个对象在相比的时候类型一致且不为空。
3.==在基本数据类型中比较的是值，在引用数据类型比较的是地址值。
equals不能比较基本数据类型，如果要比较数据类型需要使用包装类。Object类中的equals方法不会报空指针异常。
4.String在底层被final修饰的长度不可变数组。String字符串不可变。StringBuider是长度可变的数组。StringBuider效率高。如果超出容量会自动扩容。
5.包装类是为了解决基本数据类型不能够被直接操作而将其包装成对象。与八个基本数据类型想对应。自动拆箱与自动装箱是基本数据类型可以直接互相转换。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2