黑马程序员技术交流社区

标题: 【厦门JavaEE就业5期-每日总结】Object类、常用API [打印本页]
作者: 厦门校区    时间: 2018-12-19 18:46
标题: 【厦门JavaEE就业5期-每日总结】Object类、常用API
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
2.我们为什么要重写equals（）方法？
3.==和equals（）的区别？
4.String和StringBuilder的区别？
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
作者: lj478360767    时间: 2018-12-19 20:11
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容

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

2.我们为什么要重写equals（）方法？
因为从父类Object中继承来的equals（）方法比较的是地址值，而比较地址值对我们而言没有太大意义，所以我们
需要重写equals（）方法，用来比较对象的每个属性是否相同。

3.==和equals（）的区别？
==比较的地址值，而equals方法如果没有被重写的话，默认的结果也是比较地址值，可以说，在默认的equals中，
就是使用的==比较。 而在重写后，equals（）就变成比较内容的方法。

4.String和StringBuilder的区别？
String是一个常量，由于底层是长度固定的数组，所以String对象的长度是不可变得，发生变化的都是创建出了新的
对象。而如果创建的对象过多的话，会占用过多的空间，导致执行效率低下。而StringBuilder就很好的解决了这个问题，StringBuilder是初始容量16的字符串，无论怎么拼接删减，他还是同一个数组，所以他占用空间小，执行效率高，他的底层是一个容量可以变化的数组，所以他的长度是可变化的

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱
包装类就是将基本类型数据进行包装，是的基本类型数据也能够被对象使用，而且功能相同。
名称与基本类型不同，包装类能够被对象使用，基本类型数据不行。
基本类型和包装类相互转化的过程被称为装箱和拆箱，在JDK1.5后，系统能够自动的帮我们完成这个转化的过程，
称为自动装箱和自动拆箱。











作者: 陈彬    时间: 2018-12-19 20:18
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？     所有类直接或间接继承Object类，在Object类中有toString()方法，默认是打印的是地址值，所以，有的类重写了toString()方法，那么就会答应重写的方法，有的类没有重写toString()方法所以会执行默认的方法就是打印地址值。
      对象在进行使用时，会调用toString()方法，尽管我们没有写，但是jvm默认会为我们添加上。
2.我们为什么要重写equals（）方法？
       equals（）的底层是比较两个对象的地址值，但是只比较地址值是没有意义的，所以我们要重写equals（）方法。用来比较对象的值是否相等。
3.==和equals（）的区别？
   ==比较的是地址值，比较两个对象的地址值。equals（）在没有重写前，也是比较的对象的地址值，在String中，重写了equals（）方法，所以会比较两个对象的值是否相等
4.String和StringBuilder的区别？
      String创建的字符串是常量，是不能修改的，而StringBuilder的常量是可以修改的。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
       包装类就是基本类型的包装起来，变成引用数据类型，以便给某些对象使用。基本类型不能再集合中使用。自动装箱就是JVM会自动转换基本数据类型为包装类型
        自动拆箱就是JVM会自动转换包装类型为基本数据类型。
作者: Chidori    时间: 2018-12-19 20:57
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？object类是所有类的父类，object中有一个toString方法，如果建立对象的类没有对这个方法进行重写，则会继承object类中的toString方法进行地址值的打印，如果进行了重写，则打印的内容为重写后方法中的内容。对象想转为字符串类型的时候就会调用toString方法
2.我们为什么要重写equals（）方法？
object类是所有类的父类，object中有一个equals方法，如果建立对象的类没有对这个方法进行重写，则会继承object类中的equals方法相当于==进行地址值的比较，如果进行了重写，则会进行属性的比较
3.==和equals（）的区别？
在基本数据类型中使用==和equals（）没有区别，都是进行数值内容的比较，但是在引用数据类型中==比较的是地址值，除非是对同一个对象进行比较，否则结果都为false
而equals()是进行内容的比较，与地址值无关
4.String和StringBuilder的区别？
String的字符串长度不可改变，一旦进行字符串连接都会创建一个新的字符串
Stringbuilder是字符串的缓冲区默认的长度就有16字符，超过了还可以自动扩容，所以可以进行长度的变更
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类就是对基本数据类型进行包装从而使得对象也可以直接使用，功能和基本数据类型相同
自动装箱和自动拆箱就是系统自动的帮我们进行转化，省去了我们包装类和基本类转化中的过程，提升了我们码代码效率


郑彤
作者: 杨鑫棋    时间: 2018-12-19 21:00
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

因为有的对象重写了toString方法，所以打印出来的是对象内容，而没有重写toString方法的对象，打印出来的就是地址值。
打印输出的时候，后面都会有一个toString方法。

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

因为如果是没用重写的equals（）方法，比较的是地址值，而我们想要比较的是对象中的内容，所以应该要重写equals（）方法。

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

==比较的是对象地址值，而equals（）方法没被重写比较的也是地址值，而重写后的equals（）方法比较的就是对象中的内容。

4.String和StringBuilder的区别？

String定义的字符串是常量，其长度不可改变，而StringBuilder定义的字符串长度可以发生改变。

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

包装类是对基本数据类型进行封装，包装类可以让我们像操作对象一样使用。而有的则无法使用直接的基本数据类型如ArrayList集合的泛型就不能直接使用基本数据类型，而需要使用基本类型的包装类。
从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。
作者: 续扬    时间: 2018-12-19 21:08
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为object类的toString（）返回的是对象的地址值，我们重写toString（）方法后得到的就是对象内容。在我们需要打印出内容的时候会调用toString（）方法。
2.我们为什么要重写equals（）方法？
不重写比较的是地址值是否相同，是一种严格意义的相同
重写比较的是内容，而不在是地址值。
3.==和equals（）的区别？
默认情况下也就是从父类Object继承而来的equals方法与‘==’是完全等价的，比较的都是对象的内存地址，但我们可以重写equals方法，使其按照我们的需求的方式进行比较，如String类重写了equals方法，使其比较的是内容，而不再是内存地址。
4.String和StringBuilder的区别？
String是固定的常量不可以改变，为了不创建过多对象有了StringBuilder。StringBuilder是一个字符串连接器，其中不包含任何字符，初始容量为16个字符，长度可以变化并且占的内存小
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
基本数据类型的数据使用起来非常的方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类。
包装类可以存null值。可以表示一个值。
基本类的计算效率高。不会由于常量池引起比较大小的错误。
基本类型的数据和包装类之间可以自动的相互转换。
作者: 刘荣城    时间: 2018-12-19 21:09
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在本类中不重写toString（）方法，打印对象就是地址值，重写后打印的就是对象的内容。
每次打印对象的时候对象名后面都会调用toString（）方法。
2.我们为什么要重写equals（）方法？
因为如果不重写equals（）方法，比较的是地址值，要比较对象的内容的时候就要重写equals（）方法。
3.==和equals（）的区别？
如果是字符串变量名：==就是比较两个字符串的地址值。
equals（）就是比较的是内容。
如果是对象名：==还是比较的是地址值，
不重写equals（）也是比较的是内容。

4.String和StringBuilder的区别？
String是常量，不可改变，只能拼接字符，每次拼接都会创建新对象。很浩内存。
StringBuilder是一个类，可以补充String的缺陷。不管怎么加减都行。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本类型数据进行包装，就是基本数据类型能被对象使用。
基本数据类型和包装类互相转换过程被称为装箱和拆箱，现在都是自动装箱和拆箱。
作者: zhuyiming    时间: 2018-12-19 21:10
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印出地址值的是没有重写toSring()方法,
打印出对象内容的是重写了toString()方法.
2.我们为什么要重写equals（）方法？
没有重写 equals()方法比较的是地址值
重写 equals()方法比较对象内容的属性
3.==和equals（）的区别？
== 直接比较地址值
equals()方法,在没有重写的时候是比较地址值,重写的时候比较对象的内容
4.String和StringBuilder的区别？
String 是一个常量  不可改变
StringBuilder 默认长度16个,如果不够还以增加长度.
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类的引用数据类型
在ArrayList集合中只能使用引用数据类型,不可以使用基本数据类型,
自动装箱拆箱在JDK1.5后添加的,系统会自动帮我们装箱 基本类型转换为包装类,
也会自动帮我们拆分  包装类转换为 基本类型
作者: Java中的莫Q哇啦    时间: 2018-12-19 21:12
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

答：因为所有的类都直接或者间接继承了Object类，Object类中的toString方法打印的是地址值，如果子类没有对toString方法进行重写，那么打印的就是地址值，如果子类对toString方法进行了重写，那么打印的就是重写的内容。对象在转化为String类型的时候就会调用toString方法。

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

答：因为没有重写equals（）方法的时候，比较的是两个对象的地址值，然而比较地址值没有意义，所以要进行重写。

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

答：==号比较的是两个对象的地址值， equals（）方法比较的是两个对象的属性值是否相等。

4.String和StringBuilder的区别？

答：String 字符串长度不可改变；StringBuilder又称为字符串缓冲区，长度可以发生改变，为系统节省内存空间，优化系统。

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

答：包装类是对基本类型转换为对象的一个过程，因为对象的使用比基本类型可以做更多的功能，基本类型的使用效率比较快，包装类使用可以实现更多的功能。包装类与基本类型之间的相互转换叫装箱与拆箱，装箱就是基本类型-->包装类，拆箱就是包装类-->基本类型，这些动作从JDK1.5开始是自动转换的过程，不需要我们再来操作。

------------------------------------------黄成成huangcc
作者: 周章强    时间: 2018-12-19 21:12
1.object类的toString方法是打印地址值，只要对象类没有重写toString方法，都是默认打印地址值。
对象在直接使用的时候会调用toString方法。

2.因为object类的equals方法是对比地址值是否相等，因为object类是所有类的父类，如果没有重写equals方法
默认equals方法都是对比地址值是否相等。重写了才能对比内容是否相等。

3.==是对比地址值；equals（）默认对比地址值，如果重写equals（）方法可以对比内容是否相等。

4.区别：String  无法改变长度，StringBuilder 可以改变长度。

5.包装类是能使基本类型数据能被对象使用的类。
区别：包装类能被对象使用，基本类型不行。
自动装（拆）箱：jdk1.5之后的版本，基本类型和包装类的装（拆）箱系统会自动进行，不需要我们手动进行。
作者: 吴少华    时间: 2018-12-19 21:15
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
基础类型打印的都是对象，引用类型打印出地址值是因为没有重写就调用Objectd的toString方法就打印地址，引用类型只有重写了才会打印出对象。toString方法可以输出成字符串，需要打印地址值。
2.我们为什么要重写equals（）方法？
没有重写的equals（）方法永远比较的是地址值，重写后就能比较属性和内容

3.==和equals（）的区别？
==和没重写的equals()比较的是地址值，重写后equals()比较的是属性
4.String和StringBuilder的区别？
String不能改变长度且没有缓冲区，拼接字符串就会不断地创建新对象浪费内存，StringBuilder有16个字节的缓冲区，不用不停的创建新对象长度可变，底部是由数组组成，
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是把同一种的基本类型包装成引用类型，包装类能被对象使用，打印只会出地址。基本类型不能被对象使用，打印出内容。在JDK1.5之后系统会帮我们自动帮我们进行包装盒解析的过程
作者: 赵烈刚    时间: 2018-12-19 21:16
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果没有重写equals()方法的话打印的是对象的地址值,重写后打印的是对象的内容;如果需要按照对象的属性得到相应字符串的表示形式的话需要重写toString()方法。
2.我们为什么要重写equals（）方法？
如果要进行对象内容比较的话必须重写equals()方法;
3.==和equals（）的区别？
==比较的是地址值,equals()比较的是对象内容
4.String和StringBuilder的区别？
String字符串一旦创建长度不可变,，StringBuilder是可变字符序列;
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是可以将基本数据类型当成对象一样便于操作,基本类型对应的包装类开头字母大写;自动装箱和自动拆箱就是基本类型和包装类之间的来回转换
作者: ab8846254    时间: 2018-12-19 21:18
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？答：1.我们在直接打印对象名的时候如果没有重写toString方法的话或默认调用父类Object的toString方法，而Object类的toString方法是直接返回的一串地址值在底层源码是
return getClass().getName() + "@" + Integer.toHexString(hashCode()); 其中getClass() 用到了反射的技术.getName获取到了这个类的类名，然后加上一个哈希码值2.但是假如我们重写了父类Object的toString方法，则将会打印我们重写的内容2.我们为什么要重写equals（）方法？
答：假设我们不重写equals方法，比较的是地址值，这个对我们没有意义。
3.==和equals（）的区别？
答：==比较基本数据类型的时候比较的是内容比较引用数据类型的时候比较的是地址值，equals（）在没被重写之前比较的是地址值，在重写了之后比较的是内容
4.String和StringBuilder的区别？
答：String是长度不可变的一种数据类型，因为底层是被final修饰的数组，而StringBuilder类型，是长度可变的一个字符串缓冲区，他的底层也是数组实现的，但是没有被final修饰，所以长度可变
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

答：包装类是对应我们基本数据类型的一种类型，每种基本数据类型都有相对应的包装类，其中只有int 类型和char类型的包装类较为特殊，其余的包装类都是首字母大写，
2.他们的区别是 包装类是引用数据类型，基本类型是基本数据类型，
3.自动装箱，意思是我们可以直接把一个基本数据类型int可以直接赋值给一个包装类型Intrger，从而变成一个引用数据类型，这个过程就叫做自动装箱，而我们可以把一个integer类型的对象直接赋值给一个基本数据类型的int这个时候就是自动拆箱。程序会自动把引用数据类型的integer转换成int类型然后赋值给int类型。
作者: 陈益源    时间: 2018-12-19 21:20

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
Object类是所有类的父类，如果没有没有特别指定的父类，那么默认继承Object类，打印的是地址值是因为Object类中toString()方法没有重写，默认返还的是地址值；打印的是对象内容的是因为toString()方法被重写，按照重写的内容打印；输出打印对象名其实就是调用toString()方法。

2.我们为什么要重写equals（）方法？
equals()方法默认的是地址值比较，没有意义，需要进行重写，来比较对象的属性内容。

3.==和equals（）的区别？
==：基本类型数据比较的数据值；引用类型比较的是地址值
equals（）：默认进行==地址值的比较，重写后可以进行对象属性内容的比较

4.String和StringBuilder的区别？
String是常量，长度不可变；每次拼接都需要new一个String对象，耗时又浪费内存，但是少量的字符串拼接可以考虑；
StringBuilder是字符串的缓冲区，字符串长度可以改变，默认16个字符空间，不够会自动扩充；

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
基本数据类型的数据，使用起来非常的方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来，这个类叫包装类，在包装类中可以定义一些方法，用来操作基本类型的数据；
自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的互相转换，JDK1.5只有主线的新特性
作者: 陈辉阳    时间: 2018-12-19 21:22
本帖最后由 陈辉阳 于 2018-12-31 13:33 编辑

一 ：能够说出Object类的特点
1> 它是所有类的根类，父类，它的所有方法子类都可以使用。

二：说出object的toString方法
打印的是地址值，所以需要重写toString

三：能够重写Object类的equals方法
要重写 如果没有重写默认进行==的地址值比较，只要不是同一个对象，内容相同也返回false

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

四：objects类
这个类是容忍空指针，空指针安全的。
，用于计算对象的hashcode、返回对象的字符串表 示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问 题。方法如下：
public?static?boolean?equals(Object?a,?Object?b) :判断两个对象是否相等。


五：能够使用日期类输出当前日期
Date date =new Date ;
Date date =new Date(long time ) longtime是时间，从1970年1月1日8时0分0秒开始，经历了longtime时间后，返回这个日期
public?long?getTime() 把日期对象转换成对应的时间毫秒值。

六：DateFormate 抽象类
创建对象 给它一个时间的格式  ?DateFormat?format?=?new?SimpleDateFormat("yyyy‐MM‐dd?HH:mm:ss");
调用format方法 将时间日期格式转为 字符串格式
public?String?format(Date?date) ：将Date对象格式化为字符串。
?Date?date?=?new?Date(); ???获取当前时间Date格式????
?//?创建日期格式化对象,在获取格式化对象时可以指定风格 ??DateFormat?df?=?new?SimpleDateFormat("yyyy年MM月dd日"); ??

?调用方法 将时间日期格式转为 字符串格式    String?str?=?df.format(date);

解析 parse 将String格式的日子转为Date
?Date?date?=?df.parse(str);


七：Calendar 日历类

重点 创建对象时特殊候比较
?Calendar?cal?=?Calendar.getInstance();  通过调用getInstance方法返回Calendar的对象

常用的方法
获取当前时间的详细信息  cal.get(  ) 里面参数很多 比如月的第几个星期  星期的第几天
获取Date格式的 方法  cal.getTime  //Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。



八 System 系统类
?long?currentTimeMillis() ：返回以毫秒为单位的当前时间。 放在程序前后就可以用来统计程序运行了多少时间

九  StringBuilder类  很重要
因为String这个类创建之后 长度不可变 内容也不可变  但是StringBuilder类可以，它的底层是一个可变的字符缓冲区
//它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。



十 包装类

基本类型 对应的包装类（位于java.lang包中）
byte   Byte
short  Short
int      Integer
long   Long
?oat   Float
double  Double
char   Character
boolean   Boolean
其中主要记住char Charcter  和int Integer
其他的都是首字母大写
作者: 苏阿合    时间: 2018-12-19 21:24
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果打印的是对象是地址值，说明调用的是Object类中的toString方法；如果打印的是对象的内容说明该类重写Object类中的toString方法。对象在直接输出打印对象名时默认调用toString方法和对象名.toString方法都会调用toString方法。

2.我们为什么要重写equals（）方法？
当没有重写equals（）方法时，调用的是Obect类中equals（）方法，比较的是两个对象的地址值判断是否是同个对象，不是所我们想要，我们想要的是比较对象的属性内容判断是否相同，所以对equals（）方法进行重写。

3.==和equals（）的区别？
若是对象==比较得是对象地址值，判断是否是同个对象；equals（）没有重写时比较的是地址值，判断是否是同个对象，若重写后则是比较对象的属性内容，判断内容是否相同。

4.String和StringBuilder的区别？
String中的字符串长度是不可变的，若要进行字符串拼接会产生多个字符串常量。StringBuilder相当于可变字符序列可以对字符串的内容进行拼接追加字符串，不会创建多个字符串对象节省内存占用空间，且效率高。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
将基本类型的数据进行包装成类，内部定义了一些可操作基本类型数据的方法。包装类不能直接进行运算。自动装箱：从基本类型转换为对应的包装类对象；自动拆箱：从包装类对象转换为对应的基本类型。
作者: 黄毅    时间: 2018-12-19 21:26
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？因为object类返回的是地址值，重写方法后打印的是对象内容。当想要打印内容的时候调用toString（）方法。
2.我们为什么要重写equals（）方法？
因为不重写的话比较的是地址值，重写后比较的是内容
3.==和equals（）的区别？
==无法重写，只有不是在同一对象，结果必然为false；而equals（）可以通过重写比较对象的内容。
4.String和StringBuilder的区别？
String类的对象内容不可改变，所以在字符串拼接时，总会创建新的对象；StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲
区，通过某些方法调用可以改变该序列的长度和内容 。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类可以使基本数据类型像对象一样操作
自动装箱：从基本类型自动转换为对应的包装类对象
自动拆箱：从包装类对象自动转换为对应的数据类型
作者: 赖熙蒙    时间: 2018-12-19 21:27
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？答：在直接使用输出语句输出字符串对象的时候，系统会默认调用该字符串对象的toString（）方法，所以输出的是字符串对象的地址值，而使用覆盖重写所输出的就是字符串对象的内容。

2.我们为什么要重写equals（）方法？
答：重写equals（）方法能够将两个对象的内容进行比较。

3.==和equals（）的区别？
答：使用==等于是默认调用了equals（）方法进行比较，比较的是两个对象的地址值，使用equals（）方法分为默认和自定义两种情况，如果没有覆盖重写就是默认使用==对两个对象的地址值进行比较，覆盖重写的话就是对两个对象的内容进行比较。

4.String和StringBuilder的区别？
答：String字符串是常量，底层是一个byte数组，所以它的值在创建后不能改变，StringBuilder是字符串的缓冲区，能够改变长度和内容。

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

答：包装类就是将基本类型转换为引用类型，使得基本类型能够像对象一样操作。自动装箱和自动拆箱指的是在进行基本类型和包装类之间转换时系统能够自动完成装箱和拆箱的动作。
作者: 许晓明    时间: 2018-12-19 21:30
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编译器自行把包装类转换为相对应的基本数据类型。


作者: 董志超Eric    时间: 2018-12-19 21:31
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：打印对象时如果对应的类重写了toString()方法，打印对象显示的就是对象的内容；如果没有重写toString（）方法，打印的就是地址值。
直接打印对象时，就会调用toString（）方法，如果本类中没有重写toString方法，那么就会找到父类（Object）,打印地址值。

2.我们为什么要重写equals（）方法？
答：因为不重写的话，equals比较的是引用类型的地址值，这样比较没有意义。重写equals()方法是为了比较两者的属性。

3.==和equals（）的区别？
答：==和对应基本数据类型来说是比较的具体内容。 ==对于引用类型来说是比较的地址值，equals（）没有覆盖重写时比较的的是地址值，重写后比较的是两者的属性。

4.String和StringBuilder的区别？
答：String是字符串是常量，在常量池里面     StringBuilder是类字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容 。他们的底层都是字节数组。
在进行拼接时，string需要新建一个数组，而StringBulider是直接在数组中加入新内容，会自动维护数组的扩容，默认16字符空间。


5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：基本类型的数据不能作为对象调用方法，使用包装类就可以把基本数据类型转换为引用数据类型。区别是基本数据类型可以进行运算，而引用数据类型不能。引用数据类型能够进行方法的调用，基本数据类型不能。基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“，自动装箱和自动拆箱是在程序运行过程中不用进行转换，虚拟机自动完成。

作者: 李灵杰    时间: 2018-12-19 21:31
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
所有对象默认继承Object类,所有如果没有重写toString()方法,打印的就是地址值;对象在转换为string 默认调用toString 方法

2.我们为什么要重写equals（）方法？
equals 方法默认比较对象的地址值,无法比较对象的内容,所以要重写equels

3. == 和equals（）的区别？
== 直接比较地址值              equals()方法,在没有重写的时候是比较地址值,重写的时候比较对象的内容

4.String和StringBuilder的区别？
String 是固定的常量类型,
StringBuilder 是一个字符串数组,字符串的缓冲区,可以进行字符串的操作.

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是对基本数据类型进行包装从而使得对象也可以直接使用，功能和基本数据类型相同
自动装箱和自动拆箱就是系统自动的帮我们进行转化，省去了我们包装类和基本类转化中的过程，提升了我们码代码效率


作者: 黄海兵    时间: 2018-12-19 21:32
1.重写了toString方法的类打印的是对象的内容，没有重写的打印的是对象的地址值。
2.因为不重写的话比较的就是两个对象地址值是否相同，这样没有意义。所以我们要重写 比较的就是对象的属性。
3.==比较地址值 equals（）方法在没有重写的时候是比较地址值，重写的时候比较对象的内容
4.String的长度不可变，StringBuilder初始容量为16的字符串
5.包装类就是将基本类型数据进行包装，让基本数据类型也能被对象使用。名称不同
基本类型和包装类相互转化。
作者: 陈佳鹏    时间: 2018-12-19 21:38
1.Object是所有类直接或间接父类，如果没有重写Object中的toString方法，则继承的是Object的toString方法，则打印的是地址值，如果对toString方法进行重写，就能实现打印对象内容，在进行打印和拼接字符串操作时对象会调用toString方法。
2.Object类中的equals方法是对对象地址值的比较，不是同一个对象地址值必然不相同，没有什么意义。重写equals方法能够实现对对象属性的比较。
3.==为比较运算符，能进行基本数据类型和引用数据类型的比较，equals（）只能进行引用数据类型的比较，当equals（）没有重写时，和==一样都是进行地址值的比较，当重写了equals（），比较的是内容。
4.String创建的字符串是常量，不可改变，进行拼接时生成的是新的String对象，StringBuilder可以进行字符串的拼接操作,底层是初始长度为16的数组，当多个字符串拼接可自动扩容，进行大量字符串拼接时更省资源。
5.包装类就是对基本数据类型进行包装，使得基本类型也能被对象使用，包装类能够被对象使用，基本类型数据不行。基本类型和包装类相互转化的过程被称为装箱和拆箱，在JDK1.5后，系统能够自动的帮我们完成这个转化的过程，称为自动装箱和自动拆箱。
作者: 陈基林    时间: 2018-12-19 21:45
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？在打印的时候调用的是toString方法，如果这个对象所在的类没有重写toString方法的话，默认继承的是超类object的toString方法，打印出来的就是地址值。如果有重写toString方法的话就会按照重写的方式输出内容。在使用对象的时候都会调用toString方法。
2.我们为什么要重写equals（）方法？
Object类的equals方法比较的是两个对象的地址值，如果想要比较两个对象的具体属性内容的话就必须要重写equals方法。
3.==和equals（）的区别？
==比较的是两个对象的地址值，equals方法在object类里面也是比较两个对象的地址值，如果有重写equals方法的话可以比较两个对象的属性内容。
4.String和StringBuilder的区别？
String类型的字符串底层是被final修饰的字节数组，是不可以改变长度的；而StringBuilder的底层是没有被final修饰的字节数组，它的长度是可变的。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

把基本数据类型的数据包装起来的类叫做包装类。包装类是引用数据类型，集合中只能存储引用数据类型，不能存储基本数据类型。如果想要存储基本数据类型的话就要使用与之对应的包装类。 自动装箱是指基本数据类型可以直接赋值给对应的包装类，程序默认自动装箱，将该基本数据类型包装成引用数据类型。自动拆箱是指在包装类转换为基本数据类型的过程中系统免去这个操作中间的过程自动完成强转。
作者: 李柏刚    时间: 2018-12-19 21:47
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？  打印对象默认打印的是地址值，只有当重写了toString方法，才是打印的对象内容。
对象在被调用参与运算是，会调用toString方法。
2.我们为什么要重写equals（）方法？
默认情况下是对比的地址值是否为同一个，如果需要比较两个不同对象的内容属性是否一致的时候，就需要重写equal（）方法，也避免当其中一方为null的时候，对比导致出现的空指针异常。
3.==和equals（）的区别？
==是根据地址值来进行比较看是否相同；equals没被重写的情况下比较的地址值，看是否来自同一对象，equals重写的情况下，比较的是对象的成员变量属性是否一致。
4.String和StringBuilder的区别？
  String的底层是由char类型的数组拼接而成的字符串常量，是不可变的，如果使用拼接，会生成多个字符串常量，再拼接成新的字符串。
   StringBuilder是个字符串的缓冲区，是由一个会自动扩容的数组组成，当需要使用拼接的时候，会自动添加到这个数组中，而无需创建新的字符串。
  5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
    包装类就是把基本类型转换成对象类型，从而实现更多的功能操作。
    自动装箱：将基本类型转换为对应的包装类对象。
    自动拆箱：从包装类对象转换为对应的基本类型。
作者: 李嘉福    时间: 2018-12-19 21:48
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？Object类的toString方法是打印地址值，只要对象类没有重写toString方法，都是默认打印地址值;
直接使用对象的时候就会调用toString方法
2.我们为什么要重写equals（）方法？
equals()方法默认的是地址值比较，没有意义，需要进行重写，来比较对象的属性内容
3.==和equals（）的区别？
==：基本类型数据比较的数据值；引用类型比较的是地址值
equals（）：默认进行==地址值的比较，重写后可以进行对象属性内容的比较
4.String和StringBuilder的区别？
String中的字符串长度是常量,它们的值在创建之后不可变的，若要进行字符串拼接会产生多个字符串常量。
StringBuilder是字符串缓冲区,可变字符序列可以对字符串的内容进行拼接追加字符串，不会创建多个字符串对象节省内存占用空间，效率高
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类可以使基本数据类型像对象一样操作
自动装箱：从基本类型自动转换为对应的包装类对象
自动拆箱：从包装类对象自动转换为对应的数据类型
作者: Wujainwei    时间: 2018-12-19 21:48
1.toString()方法
可以重写toString()方法，来按照自己需要的格式直接可以打印对象的属性而不是地址值。可以快捷生成

2.equals（）方法
因为从父类Object中继承来的equals（）方法比较的是地址值，而比较地址值对我们而言没有太大意义，所以我们
需要重写equals（）方法，用来比较对象的每个属性是否相同。可以快捷生成

3.==和equals（）的区别？
==比较的地址值。 而在重写后，equals（）就可以比较属性。

4.String和StringBuilder的区别
StringBuilder是初始容量16的长度可变化的字符串，无论怎么拼接删减，他还是同一个数组，所以他占用空间小，执行效率高，
创建对象后可以使用.append()和.toString()方法

5.了解自动装箱和自动拆箱
包装类就是将基本类型数据进行包装，是的基本类型数据也能够被对象使用，而且功能相同。
在JDK1.5后，系统能够自动的帮我们完成这个转化的过程，称为自动装箱和自动拆箱。

6.new Date()获取当前时间
创建SimpleDateFormat对象后可用String a = sdf.format(Date date)    ,Date b = sdf.parse(String str);

7. Calendar ca = Calendar.getInstance();   可以调用 .get();   .set()   ;    .add()   ;.getTime()
作者: 黄嘉宏    时间: 2018-12-19 21:49
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？地址值是引用的内容，对象内容是常量值。toString()方法返回的结果是内存地址，在开发中，经常要按照对象的属性得到相应的字符串。
2.我们为什么要重写equals（）方法？
如果想进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同。
3.==和equals（）的区别？
没有覆盖重写的equals（）与==相同，比较的是对象地址。覆盖重新的equals（）比较是对象的内容。
4.String和StringBuilder的区别？
String类的的对象内容不可改变，StringBuider是可变的字符序列，可以改变长度和内容。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
使基本类型像对象一样做更多的操作。包装类首字母大写，int类型和cha类型英文不同。包装类能完成对象的操作。基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“，基本类型与包装类型自动完成称为自动装箱和自动拆箱。


作者: 林文悦    时间: 2018-12-19 21:50
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？

object类是所有子类的最高父类，它的类中有toString()方法，所有子类默认继承了toString()方法，如果没有重写toString()方法，name默认打印的是地址值，如果重写了toString()方法，那么打印的是重写后方法的内容。对象转为字符串类型的时候就会调用toString方法

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

不重写equals（）方法的话，默认比较的是两个对象的地址值，没有什么意义。重写equals（）方法则比较的是两个方法的内容属性。

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

对基本数据类型来说==比较的是两个数据的值，对于引用数据类型来说比较的是两个对象的地址值；equals比较的是两个对象的内容属性是否相同。

4.String和StringBuilder的区别？

String类长度是不可变的，StringBuilder类长度是可以改变的；

如果要操作少量的数据，用String ；操作大量数据，用StringBuilder ；

String是不可变的对象，因此每次在对String类进行改变的时候都会生成一个新的string对象 。

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

1、包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址，基本类型不是；

2、包装类型是引用的传递，基本类型是值的传递；

3、声明方式不同，基本数据类型不需要new关键字，而包装类型需要new在堆内存中进行new来分配内存空间；

4、存储位置不同，基本数据类型直接将值保存在值栈中，而包装类型是把对象放在堆中，然后通过对象的引用来调用他们；

5、初始值不同，int初始值是0，boolean的初始值是false，而包装类初始值是null。

  自动装箱和自动拆箱就是基本类型与包装类的装箱、拆箱动作可以自动完成 。
作者: 吴洪标    时间: 2018-12-19 21:51
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果对象所在的类没有覆盖重写Object类中的toString方法，则打印对象时会调用Object类中的toString方法，此时打印输出的是地址值；
如果覆盖重写了toString方法，那么打印时，调用toSting方法，执行方法体，一般此时打印输出对象内容；
当直接调用对象时会调用对象的toString方法。

2.我们为什么要重写equals（）方法？
当我们自己定义一个类时，希望equals方法比较类中的属性，若这些属性相等则认为对应的类是一样的，此时需要重写equals方法，否则将比较两个对象的地址值。

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

4.String和StringBuilder的区别？
a.String对象是常量，内容不可变，而StringBuilder可以根据需要改变或增加对象的内容；
b.进行字符串拼接时，String总是会在内存中创建一个新的对象，而StringBuilder直接在内部数组中加入新内容。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是各种基本数据类型对应的类，内部定义了方法来操作基本数据，而基本数据类型只是一个数值，不可以调用方法；
自动装箱是指将基本数据类型包装成对应的包装类，自动拆箱是指将包装类转换成对应的基本数据类型。

作者: 王宏    时间: 2018-12-19 21:54
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：所有类的父类都是object，所以所有的类中如果有重写toString的话，就会比较内容，如果没有重写的话就会比较地址，对象在创建的时候就会调用toString（）方法

2.我们为什么要重写equals（）方法？
答：因为equals是默认比较两个引用类型的地址值，比较地址值没意义，所以要重写，比较两个引用类型的属性。

3.==和equals（）的区别？
答：==对于基本数据类型是比较内用的，而对于引用数据类型是比较地址值的，而equals在没有重写时，是比较地址值的，在重写后是比较属性值是否相同

4.String和StringBuilder的区别？
答：String的底层是字符串数组，他的长度是不可改变的，而StringBuilder底层是字符串缓冲区，在创建后长度可以改变。

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：将基本类型的数据进行包装成类，内部定义了一些可操作基本类型数据的方法。包装类不能直接进行运算。
自动装箱：从基本类型转换为对应的包装类对象。
自动拆箱：从包装类对象转换为对应的基本类型。
作者: 杨馥榕    时间: 2018-12-19 21:58
今天我们进入到了就业班，来看看就业班第一天我们都需要掌握哪些内容

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为to string的方法没有被重写，需要重写to string的方法这样出来的就不是地址值而是我们需要的对象内容
对象在知道对象内容的时候会调用tostring（）方法。
2.我们为什么要重写equals（）方法？
答:没有重新equals的话，比较的是地址值，而地址值对于现在的我们来说是无意义的所以需要重新equals的方法去比较类的属性
3.==和equals（）的区别？
答：==：是比较的是地址值；
     equals：是比较的是属性
4.String和StringBuilder的区别？
答：string：是字符串，字符串一但创建长度就不能更改，Stringbuilder相当于string的升级版它可以对字符串进行拼接追加字符串，创建多个字符对象也不会占用空间

5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：在基本类型中数据进行包装成为类；
包装类首字母都是大写，（int和char不仅首字母要大写还有变化）其他都是首字母大写，而且包装类不能直接运算；
跟我们之前基础班学的自动转化一样，系统自动装把基本类型包装为包装类，这就是自动装箱，
包装类不能直接运算，所以需要自动拆箱，把包装类转换为基本类型

作者: 苏志祥    时间: 2018-12-19 21:58
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果在定义类的时候,没有重写toString方法,直接创建对象打印将得到地址值,如果类中有重写toString方法,打印对象的时候会自动调用toString方法,将会得到的是对象内容。打印或者直接使用的时候会调用toString()方法。
2.我们为什么要重写equals（）方法？
equals:指示其他某个对象是否与此对象“相等”。
重写equals 的方法可以帮我们判断两个对象的属性是否一致。
3.==和equals（）的区别？
“==”在基本数据类型中比较的是内容，在引用数据类型比较的是地址值，
“equals”在没有重写的啥时候比较的也是地址值，被重写后，比较的是对象的属性。
4.String和StringBuilder的区别？
String的底层是数组所以长度不可改变，StringBuilder是一个可变的字符系类。StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进
行各种操作
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本类型进行包装转换成引用数据类型来使用，基本类型与引用数据类型间发生自动转换的工程叫自动装箱和自动拆箱。
作者: 骆颖权    时间: 2018-12-19 21:58
1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？因为object类是所有类的超类，object类的toString（）方法默认调用的是对象的地址值，
如果没有重写toString()方法，打印对象的时候就是地址值，如果重写toString()方法，打印对象的时候就是对象内容。
打印对象的时候就会调用toString（）方法。
2.我们为什么要重写equals（）方法？
如果不重写equals（）方法，比较的是地址值，
如果要比较对象的内容的时候就要重写equals（）方法。
3.==和equals（）的区别？
==操作比较的是两个变量的地址值是否相等。
equals （）方法（是超类Object中继承的）被用来检测两个对象的内容是否相等。
4.String和StringBuilder的区别？
String 字符串长度不可改变；
StringBuilder又称为字符串缓冲区，长度可以发生改变。
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类可以把基本数据类型转换为引用数据类型，是基本类型像对象一样使用。
包装类是引用数据类型。基本类型是基本数据类型，可以进行运算。
.自动装箱：直接把一个基本数据类型可以直接赋值给一个包装类型，从而变成一个引用数据类型。
自动拆箱：把一个包装类类型的对象直接赋值给一个基本数据类型的过程。

作者: 王宇鹏    时间: 2018-12-23 20:58

1.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果在定义类的时候,没有重写toString方法,直接创建对象打印将得到地址值,如果类中有重写toString方法,打印对象的时候会自动调用toString方法,将会得到的是对象内容。打印或者直接使用的时候会调用toString()方法。
2.我们为什么要重写equals（）方法？
equals:指示其他某个对象是否与此对象“相等”。
重写equals 的方法可以帮我们判断两个对象的属性是否一致。
3.==和equals（）的区别？
“==”在基本数据类型中比较的是内容，在引用数据类型比较的是地址值，
“equals”在没有重写的啥时候比较的也是地址值，被重写后，比较的是对象的属性。
4.String和StringBuilder的区别？
String的底层是数组所以长度不可改变，StringBuilder是一个可变的字符系类。StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进
行各种操作
5.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本类型进行包装转换成引用数据类型来使用，基本类型与引用数据类型间发生自动转换的工程叫自动装箱和自动拆箱。
作者: 艾卡西亚的惊喜    时间: 2018-12-29 21:57
林少伟



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