黑马程序员技术交流社区

标题: 【厦门校区JavaEE就业8期-每日总结】内部类&API [打印本页]

作者: 厦门校区 时间: 2019-6-17 17:42
标题: 【厦门校区JavaEE就业8期-每日总结】内部类&API
1.什么是内部类，使用匿名内部类的前提是什么？
2.请从你的理解谈谈，匿名内部类的作用？
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
4.我们为什么要重写equals（）方法？
5.==和equals（）的区别?

作者: 许雅丽 时间: 2019-6-17 21:24
1.什么是内部类，使用匿名内部类的前提是什么？

1.1类中有类叫做内部类，当两个类是包含关系（一个类依附于另一个类存在，前者为内部类，后者为外部类）

1.2当实现类对象只创建一次，调用多次

2.请从你的理解谈谈，匿名内部类的作用？

好处：省略变量名，使代码更加简洁

弊端：只能使用一次方法，方法不能被多次调用

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

3.1对象打印的是地址值是因为在默认的父类Object中会自动执行toString（），所以打印的是地址值。

3.2对象打印的是对象是因为创建对象然后用get和set方法得到的对象，或者重写toString（），也可以打印对象。

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

因为equals（）在没有重写的情况下比较的是地址值

5.==和equals（）的区别?

==

在基础数据类型的情况下比较的是值

在引用数据类型的情况下比较的是地址值

equals

在应用数据情况的下比较的是值，比较的是内容

在没有重写的情况下比较的是地址值

作者: 陈少勇 时间: 2019-6-17 21:25
1.什么是内部类，使用匿名内部类的前提是什么？
解：定义在类中的类。
前提：存在一个类或者接口。

2.请从你的理解谈谈，匿名内部类的作用？
解：简化代码，不用再写实现类。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
解：因为我们要了解对象中的内容，而有的对象继承Object类的toString()方法，打印出来的是地址值。有的对象在类中重写了Object类的toString(),显示了对象内容。打印对象就是调用对象的toString()方法。

4.我们为什么要重写equals（）方法？
解：不重写的话继承根类Object的equals（）方法，格式为包路径+@+系统给的哈希码，不利于我们对对象内容的解读。

5.==和equals（）的区别?
解：==在基本数据类型用来比较数值，在引用数据类型比较地址值。
equals（）只能引用数据类型比较，不重写的话比较的是引用数据类型的地址值，重写后比较引用数据类型的内容。

作者: 辛全旺 时间: 2019-6-17 21:25

1.什么是内部类，使用匿名内部类的前提是什么？
答：在另一个类中的类就是内部类。需要存在一个类或者接口。

2.请从你的理解谈谈，匿名内部类的作用？
答：在只需要创建一个接口或抽象类的子类对象的时候，可以直接用匿名内部类创建，不用再另外写一个子类，简洁代码。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：所有的类都直接或间接继承Object类，直接输出对象会调用Object类的toString方法得到输出内容，Object默认的toString方法返回的内容是地址，所以所有的类没有重写toString方法时输出对象都是地址，重写toString方法的类输出对象是自己重写toString方法设置的内容。

4.我们为什么要重写equals（）方法？
答：所有的类都直接或间接继承Object类，Object类默认的equals()方法是比较地址，当我们想用equals()方法比较对象内容时就需要重写。

5.==和equals（）的区别?
答：==基本数据类型是比较内容是否相同，引用数据类型时比较地址是是否相同。Object类默认的equals()方法是比较对象的地址，所有的类都可以重写这个方法，改成能够比较内容。

作者: 王猛虎 时间: 2019-6-17 21:25
1.定义于类内部的类叫内部类，两个类有包含关系，且内部类依附于外部类。
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

2.当只需要创建一次实现类对象，或者只调用一次实现类方法时，匿名内部类可以减少实现类的编写，减少代码量

3.每个类都直接或者间接的继承至Object类，而直接打印对象时，实际上是打印该对象的toString()方法的返回结果，
如果这个类没有重写父类的toString()方法，那么将直接调用父类Object的方法，而Object的toString()方法底层
返回的是：类全路径名@内存地址值，即：getClass().getName() + "@" + Integer.toHexString(hashCode());
而重写了父类的toString()方法的就返回对象内容，eg：String类就重写父类的toString()方法。

4.equals()方法是父类Object的方法，而每个类都直接或者间接的继承至Object类，若我们没有重写该方法，那么
调用的将是父类中的方法，而Object中该方法的底层实现是return this == object;即比较的是地址值，一般情况下
这并不是我们所需要的结果，我们需要的是比较内容，所以需要重写equals()方法。

5.==和equals()区别：
a.==可以用于对象及基本数据类型的比较，在基础数据类型中==比较的是值是否相等，在对象中比较的是两个对象的地址值是否相等，
而equals()只能用于比较对象不能用于基本数据类型的比较
b.在不考虑重写equals()方法的前提下，在对象的比较中，==和equals()方法比较的都是对象的地址值所以没区别
c.在考虑重写equals()方法的情况下，==比较的是地址值，equals()比较的是对象的内容。例如：在String类中==比较的是字符串的地址值，equals()比较的是字符串的内容

作者: 郭付民 时间: 2019-6-17 21:26

1.什么是内部类，使用匿名内部类的前提是什么？
答：在类中又定义一个类，这个类就是内部类，内部类分为成员内部类和局部内部类，成员内部类在类中方法外，内部内部类在类中方法内，局部内部类包括匿名内部类。
匿名内部类的前提是有接口或者类，这个类可以是具体类也可以是抽象类。

2.请从你的理解谈谈，匿名内部类的作用？
答：当我们需要调用子类对象的方法时，我们就可以传递一个匿名内部类过去，省去了编写子类的麻烦，简化传统代码。匿名内部类本质上是一个继承了该类或者实现了该接口的子类匿名对象。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答;所有类都直接或者间接继承Object,都有Object的方法，当使用输出语句打印对象，默认调用toString()方法，此时打印的是地址值，如果重写toString()方法，打印的是内容。
当直接打印对象时，会调用toString()方法，只不过对象名后省略了.toString()。

4.我们为什么要重写equals（）方法？
答：重写equals方法是为了比较两个对象的内容是否相同，不重写比较的两者的地址值。

5.==和equals（）的区别?
答：如果是基本数据类型==比较的是两者的数值，如果是引用数据类型，==比较的是地址值。
对于equals方法不重写比较的两者的地址值，重写比较的是内容。

作者: 朱铭恺 时间: 2019-6-17 21:26
1.什么是内部类，使用匿名内部类的前提是什么？

内部类：：在一个类中定义一个类,内部类依附于外部类
使用匿名类前提：存在一个类或者接口，类可以是具体类也可以是抽象类

2.请从你的理解谈谈，匿名内部类的作用？

在需要调用接口或者抽象类时，直接使用匿名内部类可以简化代码编写，将创建子类或实现类与编写类合二为一

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

因为new出来的对象本质就是地址值，需要将toString()方法重写才会显示对象内容。
在打印对象时就会默认调用toString()方法。

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

为了直接比较对象内容而不是地址值

5.==和equals（）的区别?

==是运算符，可以比较基本数据类型和对象地址值，不能比较对象内容
equals()是方法，只能对象调用，可以比较对象地址值，也可以比较对象内容

作者: 黎先帆 时间: 2019-6-17 21:27

1.什么是内部类，使用匿名内部类的前提是什么？
定义在类中的类就是内部类
在方法调用的时候，方法的参数列表是抽象类/接口类型，这个时候，可以在调用方法的时候传递一个匿名内部类，作为该抽象类/接口的子类对象/实现类对象

2.请从你的理解谈谈，匿名内部类的作用？
解决在只创建一次对象的时候，不得不编写子类/实现类的问题
省略了实现类的编写

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为打印对象默认的是使用Object类中的toString方法，这个打印的是地址值
而如果希望打印子类对象的时候，显示的是对象的内容，在子类中就需要重写toString方法，届时打印的就是内容

4.我们为什么要重写equals（）方法？
希望在调用equals方法的时候，对象比较的是内容，需要重写equals方法，因为Object类中，equals方法的底层源码就是==

5.==和equals（）的区别?
==
比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是内存地址值
equals()
因为Object类中，equals方法底层源码就是 ==，默认是使用Object类中的equals方法，这个打印的是地址值
如果希望调用equals方法的时候，对象比较的是内容，需要重写equals方法
比较String、StringBuilder类型时，比较的是内容是否相同

作者: 林雅彬 时间: 2019-6-17 21:27
1.什么是内部类，使用匿名内部类的前提是什么？
  当两个类是包含关系，其中一个类是依附于另一个类存在，这个类叫做内部类，包含他的类叫做外部类
  使用匿名内部类的前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

2.请从你的理解谈谈，匿名内部类的作用？
  当实现类对象只需要调用一次时，可将编写实现类和创建对象二合一，因此使用匿名内部类可省略实现类的编写

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
  打印对象实际上是调用toString()方法，如果该对象所在的类没有重写Object类的toString()方法，则默认
  使用Object继承过来的toString()方法，Object类的toString()方法就是对象的地址值
  对象在打印和字符串拼接的时候会调用toString()方法

4.我们为什么要重写equals（）方法？
  如果不重写equals()方法，比较的是对象的地址值，不同对象的地址值都是不一样的，如果需要比较对象的属性值
  就必须重写equals()方法，否则默认使用继承自Object类的equals()方法

5.==和equals（）的区别?
  ==比较基本数据类型时，比较的是数据值是否相等；比较引用数据类型时，比较的是地址值
  equals()比较的是引用类型，如果不重写Object类的equals()方法比较的是地址值，如果重写了该方法，可以比较
  引用类型的内容

作者: 郭伟杰- 时间: 2019-6-17 21:29

1.什么是内部类，使用匿名内部类的前提是什么？
答：在一个类中再定义一个类，
在方法调用的时候，方法的参数列表是抽象类/接口类型，可以在调用方法是传递一个匿名内部类，作为该类的对象。

2.请从你的理解谈谈，匿名内部类的作用？
答：在只创建一次对象的时候，可以将创建子类/实现类和创建对象合并，简化传统代码。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为调用的类型都是继承自Object类，而根据调用的类型是否对toString进行重写来决定打印的内容。
当需要对对象进行打印时都会调用toString()方法

4.我们为什么要重写equals（）方法？
答：希望调用equals方法的时候，对象比较的是内容，需要重写equals方法。

5.==和equals（）的区别?
答：equal方法的底层源码就是==，而当需要比较对象内容时，可以通过重写equals的方法实现。

作者: 陈杰1 时间: 2019-6-17 21:30
1.什么是内部类，使用匿名内部类的前提是什么？
它是一个继承了该类或者实现了该接口的子类对象。
存在一个类或者接口，可以是具体类也可以是抽象类。

2.请从你的理解谈谈，匿名内部类的作用？
方便我们编写程序而设计的一个机制。就是有时候只需要创建一个对象就可以了，
以后也不会用到这个类了。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
（1）对象打印的是地址值是因为在默认的父类Object中会自动执行toString（），所以打印的是地址值。
（2）对象打印的是对象是因为创建对象然后用get和set方法得到的对象，或者重写toString（），也可以打印对象。
如果对象不为空，就取toString（）方法

4.我们为什么要重写equals（）方法？
因为如果要判断两个对象逻辑上是否相等，如果根据成员变量来判断两个类的实例
是否相等，而继承Object中的equals方法只能判断两个引用变量是否是同一个对象，这时候就要重写equals方法

5.==和equals（）的区别?
==是比较的是他们的值和存放的地址
equals比较的是地址值

作者: 郭付民 时间: 2019-6-17 21:30

1.什么是内部类，使用匿名内部类的前提是什么？
答：在类中又定义一个类，这个类就是内部类，内部类分为成员内部类和局部内部类，成员内部类在类中方法外，内部内部类在类中方法内，局部内部类包括匿名内部类。
匿名内部类的前提是有接口或者类，这个类可以是具体类也可以是抽象类。

2.请从你的理解谈谈，匿名内部类的作用？
答：当我们需要调用子类对象的方法时，我们就可以传递一个匿名内部类过去，省去了编写子类的麻烦，简化传统代码。
匿名内部类本质上是一个继承了该类或者实现了该接口的子类匿名对象。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答;所有类都直接或者间接继承Object,都有Object的方法，当使用输出语句打印对象，默认调用toString()方法，此时
打印的是地址值，如果重写toString()方法，打印的是内容。
当直接打印对象时，会调用toString()方法，只不过对象名后省略了.toString()。

4.我们为什么要重写equals（）方法？
答：重写equals方法是为了比较两个对象的内容是否相同，不重写比较的两者的地址值。

5.==和equals（）的区别?
答：如果是基本数据类型==比较的是两者的数值，如果是引用数据类型，==比较的是地址值。对于equals方法不
重写比较的两者的地制值，重写比较的是内容。

作者: 邹楷能 时间: 2019-6-17 21:32
1.什么是内部类，使用匿名内部类的前提是什么？
答：内部类就是在类中又定义了一个类，该类称为内部类。
匿名内部类的前提是需要存在一个类或者接口。

2.请从你的理解谈谈，匿名内部类的作用？
答：作用是不需要创建接口或者抽象类的子类对象，可以简化代码。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为object类中toString()方法定义的就是返回地址值，能够打印内容是因为其他类中重写了toString()方法。
对象在想要打印该对象内容的时候，会调用该方法。

4.我们为什么要重写equals（）方法？
因为object类中的equals()方法只能比较地址值，要想比较内容只能重写该方法。

5.==和equals（）的区别?
答：
一个是比较运算符，一个是方法。==在比较基本数据类型时比较的是具体的值，而在比较引用类型时比较的是地址值。
equals()方法在未重写时等同于==，但有的类中如果对其重写则就会与其产生区别。

作者: 张遵荣 时间: 2019-6-17 21:34

1.什么是内部类，使用匿名内部类的前提是什么？
答：内部类即在类的内部定义（作为类的成员）或者在类的成员方法的内部定义（作为类的局部元素）的类。
前提是，必须存在父类或者接口，且若有抽象方法，必须重写实现。

2.请从你的理解谈谈，匿名内部类的作用？
答：跨过了实现子类的文件编写与创建过程，省略了程序的一个类文件的资源占用（匿名内部类编译时是否会
自动创建一个类文件？），同样需要实现父类或者接口的抽象方法。
匿名内部类的使用，使代码可读性变差，在对接口传参给方法时用得多，避免了间接构造实现子类的过。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：输出对象内容的类，是因为该类已经重写了Object类的toString方法，实现了对内容的输出，基类中
原始的功能是关于地址的。
对象在进行拼接时或者打印时，会自动调用toString方法。

4.我们为什么要重写equals（）方法？
答：没有重写equals方法时，该方法的内里本质就是==,调用该方法达不到判定内容是否相等的功能需求。

5.==和equals（）的区别?
答：在基类中，两个方法本质都是==，在子类调用了该方法时，没有重写则都是对指地址值，而重写之后，
打印对象名，对指的都是内容。在内涵上，前者是数值上的对比，后者是引用类型的对比。

作者: 许俊杰 时间: 2019-6-17 21:34

1.什么是内部类，使用匿名内部类的前提是什么？
定义在类中的类是内部类
在只创建一次对象，不得不编写子类/实现类的时候使用匿名内部类

2.请从你的理解谈谈，匿名内部类的作用？
可以省建一个类。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
如果打印对象是地址值的，使用的是object里的toString（）方法。如果打印的是对象内容的，则引用的对象有重写toString（）方法。
对象在sout输出时会默认调用toString（）方法。

4.我们为什么要重写equals（）方法？
使用Object里的equals对比的是对象的地址值，如果我们需要对比对象的内容则需要重写equals（）方法。

5.==和equals（）的区别?
==对比的是地址值。
equals对比的也是地址值，要看引用类型是否有重写equals方法。

作者: 邱昊翔 时间: 2019-6-17 21:38

1.什么是内部类，使用匿名内部类的前提是什么？
答：定义在类中的类就是内部类，使用匿名内部类的前提是在方法调用的时候，方法的参数列表是抽象类/接口类型，
这个时候，可以在调用方法的时候传递一个匿名内部类，作为该抽象类/接口的子类对象/实现类对象

2.请从你的理解谈谈，匿名内部类的作用？
答：作用是简化代码，不用再写实现类。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：对象继承Object类的toString()方法，打印出来的是地址值。重写了Object类的toString(),显示了对象内容。对象在打印时候会调用toString()方法

4.我们为什么要重写equals（）方法？
答：应为希望调用equals方法的时候，对象比较的是内容

5.==和equals（）的区别?
答：==比较是地址值；equals（）重写前比较的是地址值，重写后比较的是内容

作者: 吴汕汕 时间: 2019-6-17 21:40
1.什么是内部类，使用匿名内部类的前提是什么？

在类中定义的类，这个类就叫做内部类；

在方法内部创建对象并使用；

2.请从你的理解谈谈，匿名内部类的作用？

对象只创建一次，将编写类和对象合二为一，省略了实现类的编写；

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?

没有默认重写equals方法时打印的是地址值；

对象在什么时候会调用toString()方法？

打印子类的对象需要显示内容；

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

equals（）方法底层源码是==，比较的是地址值，当对象比较内容时需要重写；

5.==和equals（）的区别?

== 可以是运算符，也可以是比较值；equals（）用来比较地址值或者内容；

作者: 李保佳 时间: 2019-6-17 21:40
1.什么是内部类，使用匿名内部类的前提是什么？
定义在类中的类就是内部类，在只创建一次对象的时候，不得不编写子类/实现类
2.请从你的理解谈谈，匿名内部类的作用？
用于一些只创建一次的的实现类对象，作用是省略了现实类的编写，省略了变量名使代码跟加简洁

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
在
所有的类都直接或间接继承Object类，直接输出对象会调用Object类的toString方法得到输出内容，
Object默认的toString方法返回的内容是地址，
所以所有的类没有重写toString方法对象输出都是地址值
，重写toString方法的类输出对象是自己重写toString方法的内容。

4.我们为什么要重写equals（）方法？
因为equals的底层源码是==，比较的是内存地址值，
有些时候对象需要比较的是内容，所以我们要重写toString来比较引用数据类型

5.==和equals（）的区别?
==是在比较基本数据类型，比较的是数据值
比较引用数据类型，比较的是内存地址值，
equals()比较的是引用类型，如果不重写Object类的equals()方法比较的是地址值
，如果重写了该方法，可以比较

作者: wangdebin 时间: 2019-6-17 21:43

1.什么是内部类，使用匿名内部类的前提是什么？

类A在类B的内部，类A就称为类B的内部类
使用匿名内部类的前提是：存在一个类或者接口并且该子类匿名对象仅仅使用一次
  匿名内部类的本质就是一个继承了该类或者实现了该接口的子类匿名对象

2.请从你的理解谈谈，匿名内部类的作用？

1. 将编写实现类与创建对象的步骤二合一，简化了代码。
2. 在平时的开发中，会看到抽象类，或者接口作为参数。
而这个时候，我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

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

所有类默认都继承object类，object类的toString()方法默认是打印类名全路径@地址值。
如果子类有重写toString()方法，则会打印对象内容。
直接输出一个对象名称，其实是默认调用了该对象的toString()方法。

4.我们为什么要重写equals（）方法？
  因为Object类的equals()方法默认是比较地址值，而比较地址值通常是没有意义的，所以我们需要重写equals（）方法，一般可由软件自动生成

5.==和equals（）的区别?
== 如果是基本类型比较的是数据值
   如果是引用类型比较的是地址值
  equals()  只能比较引用类型，默认情况下是比较地址值
         但我们可以重写该方法，用来比较对象的属性值

作者: 何凯 时间: 2019-6-17 21:45

1.什么是内部类，使用匿名内部类的前提是什么？

内部类是在一个类中定义的类分为成员内部类和局部内部类，匿名内部类
使用匿名内部类的前提是我只需要继承或者实现一次抽象类子类对象/接口实现就使用匿名内部类，这样可以省略一个实现类的定义节省空间

2.请从你的理解谈谈，匿名内部类的作用？

比如一个接口我现在只需要实现一次，如果不用匿名内部类则需要定义一个实现类再创建对象调用该方法，用了匿名内部类则定义实现类和对象在一行代码，省略的定义实现类的操作，节省了空间

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

打印的是地址值的是因为子类没有重写Object中的ToString方法默认返回的是地址值
有些类则重写了ToString方法，就可以打印对象中的内容
我们想打印对象内容也可以在定义类时重写ToString方法打印自己想要的内容

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

我们自己定义的类不重写equals它底层代码是== 如果对比的是两个对象时则会对比它们的地址值，重写了equals则对比的时对象中的内容

5.==和equals（）的区别?
==对比的是两个值是否相等， equals重写后则可以对比对象中的内容

作者: 林锦长 时间: 2019-6-17 21:47
1.什么是内部类，使用匿名内部类的前提是什么？
内部类：在一个类中定义一个类，可以在类中方法外~成员内部类，也可以在类中方法内~局部内部类。
前提：必须存在一个类或者是接口，类的话可以是普通类，也可以是抽象类。

2.请从你的理解谈谈，匿名内部类的作用？
作用：当方法中需要一个抽象类的子类或者是接口的实现类时，我们可传递一个匿名内部类，这样就可以简化代码。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
当我们直接打印对象的时候，打印的是地址值（Object类中toString打印默认为地址值）
当我们对Object中的toString方法进行重写时，就会打印对象的内容，
当我们需要打印对象以字符串形式表示的时候就会调用toString（）方法

4.我们为什么要重写equals（）方法？
当我们将两个对象进行比较的时候，比较的是他们的地址值（Object中equals方法默认比较的是地址值）
当我们不希望比较对象的地址值，而是比较他们的内容的时候，就需要将equals（）方法重写，

5.==和equals（）的区别?
==：是将两个对象的地址值和内容属性进行比较
equals（）：是将两个对象的地址值进行比较，只有重写equals（）方法时，才会比较他们的内容属性。

作者: 江健 时间: 2019-6-17 21:48
1.在一个类中又定义另一个类。使用匿名内部类的前提是存在一个类或者接口，这里的类可以是具体也可以是抽象类。
2.匿名内部类的本质是一个继承了该类或者实现该接口的子类匿名对象。如果这个子类只用到1次的话，有匿名内部类的话，就可以不需要再写这个子类了，省略了实现类的编写，可以简化代码。
3.打印对象和sout(对象.toString())效果是一样的，会默认加上.toString()方法。如果toString()方法没有重写，使用的是Object类的，返回的是一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。重写toString()方法可以改变返回字符串内容。打印对象的时候会默认调用同String（）.
4.因为默认继承的是Object类，而Object类的equals方法返回的是(this == obj)的比较地址的结果，有时候我们要比较的是内容，而不是地址，所以需要重写equals方法。
5.==对基本数据类型来说比较的是值，对引用数据类型来说比较的是对象的地址值。Object类中的equals比较的也是地址值，有些类重写了equals方法，变成比较内容。

作者: 孙健健 时间: 2019-6-17 21:59

1.什么是内部类，使用匿名内部类的前提是什么？

当俩个类是包含关系，其中一个类依附于另一个类存在，类叫做内部类，包含他的类叫做外部类

当实现类对象只创建一次的时候，可以将编写实现类和创建对象二合一，使用匿名内部类

2.请从你的理解谈谈，匿名内部类的作用？

简化了代码，省略了实现类的编写

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

使用输出语句打印对象的时候，默认调用toString（）方法。
4.我们为什么要重写equals（）方法？

因为底层默认使用的是== 比较的是俩个地址值相同，重写equal（）方法是为了比较俩个对象内容相同
5.==和equals（）的区别?
引用数据类型==比较的是地址值
重写后equal比较的是内容

作者: 饶小保 时间: 2019-6-18 00:47
1.什么是内部类，使用匿名内部类的前提是什么?
定义在类中的类就是内部类,出现在一个类依附于另一个类的时候
存在一个类或者接口，这里的类可以是具体类也可以是抽象类

2.请从你的理解谈谈，匿名内部类的作用？
当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象出现地址值是该类中没有重写Object类中的toString方法，打印出现对象内容时则是重写了toString方法。
希望打印子类对象的时候，显示的是对象的内容

4.我们为什么要重写equals（）方法？
希望调用equals方法的时候，对象比较的是内容

5.==和equals（）的区别?
==是一个比较运算符，在基本数据类型中是比较值是否相等，在引用数据类型中比较的是地址值（对象的指引）是否相等。
equals()是一个方法，只能比较引用数据类型；
重写前比较的是地址值，比如在String，Integer，Date类中，重写了equals()方法，比较的是对象的具体内容。

作者: 刘鸿昌 时间: 2019-6-18 00:54
1.什么是内部类，使用匿名内部类的前提是什么？
在类中创建的类，是内部类
前提：在只创建一次对象的时候，不得不编写子类/实现类

2.请从你的理解谈谈，匿名内部类的作用？
外界不能直接访问匿名内部类中的方法
省略了实现类的编写，减少内存占用。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
所有的类都直接或间接继承Object，当打印对象时，默认调用toString()方法，不重写toString()方法，则打印的是地址值，
重写toString()方法，则打印的是对象内容。
子类重写Object类中toString()方法，子类对象会调用toString()方法
4.我们为什么要重写equals（）方法？
在Object类中，默认equals比较的是地址值
调用equals方法的时候，需要对象比较的是内容，则需要重写
5.==和equals（）的区别?
==比较的是对象的地址值
equals()在Object类中，默认比较是地址值，当equals()被重写，则比较的是对象的内容

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

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