黑马程序员技术交流社区

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

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

作者: 汪一飞 时间: 2019-4-20 21:23
1.什么是内部类，使用匿名内部类的前提是什么？

内部类是类中之类，分为成员内部类和局部内部类。
前提是有一个接口或者一个抽象类。

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

匿名内部类减少了程序资源的浪费，提高了开发人员在编程中的效率。有了匿名内部类以后，不用像之前有抽象类或者接口的时候需要单独创建一个子类或者实现类。直接在方法中创建一个匿名内部类即可调用方法。

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

因为所有的类都直接或间接的继承了Object类，要是继承的子类没有重写toString方法则默认继承了Object类的toString方法，即是地址值，要是有重写方法则打印的是对象内容。
打印对象名的时候会调用toString方法。

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

重写equals（）是为了比较两个对象的内容是否相同，而不重写比较的是地址值是否相同。
5.==和equals（）的区别?

==应用在基本数据类型比较的是数据值
==应用在引用数据类型比较的是地址值
重写的equals（）方法比较的是对象内容

作者: 吴星辉 时间: 2019-4-20 21:23

1.什么是内部类，使用匿名内部类的前提是什么？
一个类中包含一个类，被包含的类叫做内部类，内部类不能定义静态成员。使用匿名内部类的前提是需要有一个父类/抽象类/接口。
2.请从你的理解谈谈，匿名内部类的作用？
匿名内部类适合创建那种只需要一次使用的类。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
默认是打印地址值，有的类重写了说以打印的是内容。在需要返回对象的内容的时候会调用toString()方法。
4.我们为什么要重写equals（）方法？
默认的是对象地址值的比较，在开发中经常需要比较传进来的值是否相等。
5.==和equals（）的区别?
==对于基本类型来说比较的是值，对于引用类型来说比较的是引用。equals默认是引用比较，只是很多类重写了equals方法，比如String等把它变成了值比较，所以一般情况下比较的是值是否相等。

作者: 陈青超 时间: 2019-4-20 21:23
1.什么是内部类，使用匿名内部类的前提是什么？
内部类是指在一个类中包含有另外一个类。使用匿名内部类的前提是：1.有继承关系；2.方法重写；
2.请从你的理解谈谈，匿名内部类的作用？
如果在主方法中，创建一个子类的对象，当此对象在使用次数上很少时，为了节省创建子类，可以直接在主方法中创建匿名内部类来代替创建子类和调用子类的方法俩个步骤，达到同样的效果。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString(）
输出是地址值是因为所有类都间接继承了Object类，而Object类中的toString()方法输出默认的就是对象的地址值，而输出不是地址值是因为子类重写toString()方法。
4.我们为什么要重写equals（）方法？
因为我们需要比较的是对象的内容而不是对象的地址值。
5.==和equals（）的区别?
==俩边若是基本数据类型比较的是数据值，若是引用数据类型比较的地址值。
equals比较的是引用数据类型的地址值，也可以重写equals来比较引用数据类型的内容。

作者: 阮必文 时间: 2019-4-20 21:24

1.什么是内部类，使用匿名内部类的前提是什么？
内部类是在一个类中的一个类
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
2.请从你的理解谈谈，匿名内部类的作用？
发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
当直接调用Object的toString方法的时候打印的是地址值，当重写toString方法的时候打印的是对象内容
在打印输出对象的时候回默认调用toString();

4.我们为什么要重写equals（）方法？
不希望比较对象的地址值，想要结合对象属性进行比较的时候

5.==和equals（）的区别?
equals()用于对象之间的内容比较，返回true和false的结果
== 用于比较两个具体的值

作者: 宋加福 时间: 2019-4-20 21:25
1.什么是内部类，使用匿名内部类的前提是什么？
内部类：在一个类中定义一个类
匿名内部类的前提，存在一个抽象类或接口
2.请从你的理解谈谈，匿名内部类的作用？
当实现类只使用一次时还要继续编写，使用匿名内部类可以简化代码
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
所有的类都间接或直接继承于object类，object类中提供的方法打印的是地址值。而有的打印的是对象内容是因为在对象中重写了打印方法。
直接打印的时候会显示对象的地址值，当我们不想看到地址值想看到类的内容的时候，回去调用toString（）方法
4.我们为什么要重写equals（）方法？
在object中equals（）的源码是== 比较的是对象的地址值而我们要比较的是对象字符串的内容所以要重写equals()；
5.==和equals（）的区别?
==在基本类型中比较的是值，引用类型中比较的是对象的地址值而equals（）在objec中比较的是地址值而重写后要比较的是对象的字符串内容

作者: 林聪全 时间: 2019-4-20 21:25
1.什么是内部类，使用匿名内部类的前提是什么？
答:内部类:在一个类中定义一个类.
前提:存在一个类或者接口,这里的类可以是具体类也可以是抽象类

2.请从你的理解谈谈，匿名内部类的作用？
答:将编写实现类和创建实现类对象合并成一步.

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答:当直接打印Object类中的tostring ()方法,显示的是对象的地址值
我们直接打印对象,对象会默认调用tostring()方法
一般情况下object的子类(所有类,)都需要重写从object类中的tostring()的方法,显示该对象的地址值

4.我们为什么要重写equals（）方法？
答:当我们不想要比较对象的地址值,想要结合对象属性进行比较的时候,我们就要重写equals;

5.==和equals（）的区别?
答:== 比较的是两个对象的地址值
eqals 比较的是内容

--------林聪全

作者: 林美娇 时间: 2019-4-20 21:25

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

答：被一个类包含的类叫做内部类。前提是有一个接口/抽象类/具体类。

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

答：从匿名内部类的本质出发，它是一个继承了某类或实现了某接口的匿名子类对象，是个对象，就可以直接使用，简洁方便。
   当有些子类或实现类只需要使用很少次数时，我们还去创建，程序就显得太冗余了。

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

答：因为超类Object提供的toString()方法返回的是对象的地址值，而
   JDK提供的类有些有重写toString()方法（打印出来的是内容），有些没有（打印出来的是地址值）。
   当直接打印对象的时候默认会调用toString()方法。

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

答：因为大多时候我们想比较的还是对象的内容，而不是地址值，所以要重写。

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

答：对于引用类型而言，==只能比较地址值；equals（）重写后可以比较对象的内容。

作者: 郑方灼 时间: 2019-4-20 21:26
1.什么是内部类，使用匿名内部类的前提是什么？
答：①在一个类A中定义另一个类B，类B就被称为内部类。
②存在一个父类或者接口。

2.请从你的理解谈谈，匿名内部类的作用？
答：当某个方法需要重写父类或实现一个接口，但是使用的次数较少时，可以使用匿名内部类简化代码，不用创建一个子类或实现类。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：①因为所有类都直接或间接继承Object类，在不进行toString方法重写的情况下，当进行打印输出时，基本数据类型会直接输出对象内容，而引用数据类型会默认调用Object类的toString（）方法，输出地址值。
②当引用数据类型进行输出时，会调用toString方法。

4.我们为什么要重写equals（）方法？
答：因为继承自Object类的equals（）方法默认与“==”作用相同，在对引用数据类型进行判断时，只能判断其地址值而无法对具体内容进行判断，所有需要对其进行重现加上具体内容判断功能。

5.==和equals（）的区别?
答：在equal（）方法没重写的情况下，两者是没有区别的。

作者: 刘鸿 时间: 2019-4-20 21:27

1.什么是内部类，使用匿名内部类的前提是什么？
  在一个类的内部创建的类叫内部类；
  使用匿名内部类前提：存在一个类或接口。

2.请从你的理解谈谈，匿名内部类的作用？
  使用匿名内部类直接调用那些只会使用一次的类，而不用为了这次调用特地创建一个类，从而达到简化代码的作用。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
  所有类都继承Oject类的toString（）方法，Oject类的toString（）方法默认是打印对象地址值，而有的打印出对象内容是因为该类重写了toString（）方法。
  直接打印对象会调用toString（）方法。

4.我们为什么要重写equals（）方法？
  让我们更方便比较两个对象的参数内容是否一致。
5.==和equals（）的区别?
  ==是对地址值的比较；equals（）是对数值的比较。

作者: 黄戚君 时间: 2019-4-20 21:28
1.什么是内部类，使用匿名内部类的前提是什么？

内部类是类中之类，分为成员内部类和局部内部类。
前提是有一个接口或者一个抽象类。

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

匿名内部类减少了程序资源的浪费，提高了开发人员在编程中的效率。有了匿名内部类以后，不用像之前有抽象类或者接口的时候需要单独创建一个子类或者实现类。直接在方法中创建一个匿名内部类即可调用方法。

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

因为所有的类都直接或间接的继承了Object类，要是继承的子类没有重写toString方法则默认继承了Object类的toString方法，即是地址值，要是有重写方法则打印的是对象内容。
打印对象名的时候会调用toString方法。

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

重写equals（）是为了比较两个对象的内容是否相同，而不重写比较的是地址值是否相同。
5.==和equals（）的区别?

==应用在基本数据类型比较的是数据值
==应用在引用数据类型比较的是地址值
重写的equals（）方法比较的是对象内容

作者: 维度猎人 时间: 2019-4-20 21:28
郑峰

1.什么是内部类，使用匿名内部类的前提是什么？
答：
内部类的概念：在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
匿名内部类的前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

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

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：答应对象自动调用Object的toString（）方法，答应的结果默认为地址值，当toString方法被重写后，打印的则是对象内容

对象执行打印输出操作的时候回调用toString（）方法

4.我们为什么要重写equals（）方法？
答：不希望比较对象的地址值，想要结合对象属性进行比较时重写equals（）方法。

5.==和equals（）的区别?
答：
==
基本数据类型比较内容；引用类型比较地址值

equals（）
默认方法执行==操作，字符串调用的equals（）方法比较的是内容；重写后引用类型比较的也是内容

作者: 郭建（07期） 时间: 2019-4-20 21:29

1.什么是内部类，使用匿名内部类的前提是什么？
答：在一个类中定义一个新的类，这个新的类就是内部类。
使用匿名内部类的前提是存在一个父类（可以是具体类，也可以是抽象类）或者接口，存在这样的上下关系。

2.请从你的理解谈谈，匿名内部类的作用？
答：匿名内部类的本质是一个父类的子类对象或者是一个接口的实现类对象，这个对象可以直接调用方法。
这样我们就不需要创建子类或者实现类，在现实操作中比较节约时间和资源。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：所有的类都会继承Object类的toString()方法，当自己打印对象的时候，实际上调用的是Object类中的toString()方法，得到的是对象的地址值。
一般情况下，所有类都需要重写这个继承过来的方法，在重写该方法之后进行打印对象时，得到的就会是类的内容。
我们直接打印对象时，对象会默认调用toString()方法。

4.我们为什么要重写equals（）方法？
答：因为Object类的equals()方法实现对象上差别可能性最大的相等关系，而在操作过程中，我们不满足仅进行对象地址值的比较，我们还想对内容上进行比较，所以需要重写该方法。

5.==和equals（）的区别?
答：==比较的是对象的地址值
equals()比较的是对象的内容

作者: 宋涵耀 时间: 2019-4-20 21:29
1.什么是内部类，使用匿名内部类的前提是什么？
在一个类中定义一个类。存在一个类或者接口，这里的类可以是具体类也可以是抽象类
2.请从你的理解谈谈，匿名内部类的作用？
在不编写实现类的情况下，创建对象
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
(1)如果类中没有重写tostring方法那么就会使用默认的tostring方法，使用默认的tostring方法返回的就是地址值
，如果重写了tostring方法那么返回的就是自定义的值。
(2)想要查看或展示对象属性（地址值）时
4.我们为什么要重写equals（）方法？
不希望比较对象的地址值，想要结合对象属性进行比较
5.==和equals（）的区别?
==是比较地址值 equals重写可以比较对象内字符串内容

作者: 高建有 时间: 2019-4-20 21:31

1.什么是内部类，使用匿名内部类的前提是什么？
定义在类中的类就是内部类;
前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类;

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

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

有些类重写的toString()方法所以打印的是对象内容,有些没有重写,所以使用的是Object的toString()方法打印的是地址值;
在打印对象时默认会调用toString()方法;

4.我们为什么要重写equals（）方法？
因为Object提供的equals()方法默认比较的是对象的地址值,不能满足我们的比较需求;

5.==和equals（）的区别?
==比较的是两侧变量的地址值(基本数据类型比较的是数据值)
equals()未重写时效果与==相同;重写后按重写后方法比较

作者: 黄孝贵 时间: 2019-4-20 21:34
1.什么是内部类，使用匿名内部类的前提是什么？
内部类：在一个类中定义一个类，被包含的类叫内部类，包含它的类叫外部类。
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

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

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为obje是所有类的超类，有的类是直接使用了objiect的toString()的方法打印出来的对象就是地址值，
有的类自己重写了toString()或者是父类和向上有重写toString的方法，打印出来的就是对象的内容，
对象会在打印输出的时候调用toString()方法

4.我们为什么要重写equals（）方法？
因为没有重写equals()方法的话，有些类直接继承了object的equals()方法，判断的条件不是看其内容是否相同，
而是看其地址值是否相等。

5.==和equals（）的区别?
==是指两边的值或者地址值是否相等，equals()是指两边的内容是否相同。

作者: LPY 时间: 2019-4-20 21:34

1.什么是内部类，使用匿名内部类的前提是什么？
内部类是指在一个类中包含有另外一个类。使用匿名内部类的前提是：1.有继承关系；2.方法重写；
2.请从你的理解谈谈，匿名内部类的作用？
如果在主方法中，创建一个子类的对象，当此对象在使用次数上很少时，为了节省创建子类，可以直接在主方法中创建匿名内部类来代替创建子类和调用子类的方法俩个步骤，达到同样的效果。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString(）
输出是地址值是因为所有类都间接继承了Object类，而Object类中的toString()方法输出默认的就是对象的地址值，而输出不是地址值是因为子类重写toString()方法。
4.我们为什么要重写equals（）方法？
因为我们需要比较的是对象的内容而不是对象的地址值。
5.==和equals（）的区别?
==俩边若是基本数据类型比较的是数据值，若是引用数据类型比较的地址值。
equals比较的是引用数据类型的地址值，也可以重写equals来比较引用数据类型的内容。

作者: 刘炯榕 时间: 2019-4-20 21:34

1.什么是内部类，使用匿名内部类的前提是什么？
内部类是在一个类中的一个类
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
2.请从你的理解谈谈，匿名内部类的作用？
发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
当直接调用Object的toString方法的时候打印的是地址值，当重写toString方法的时候打印的是对象内容
在打印输出对象的时候回默认调用toString();
4.我们为什么要重写equals（）方法？
不希望比较对象的地址值，想要结合对象属性进行比较的时候
5.==和equals（）的区别?
equals()用于对象之间的内容比较，返回true和false的结果
== 用于比较两个具体的值

作者: 王卓立 时间: 2019-4-20 21:34
1.什么是内部类，使用匿名内部类的前提是什么？

定义在类中的类叫做内部类.

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

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

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

有些对象只继承object类的方法,因此只打印地址值.

有些对象会继承重写过的tostring方法,因此能打印对象内容.

打印时会调用tostring方法.

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

创建对象时会默认equals()方法是比较地址值.

不希望比较对象的地址值，想要结合对象属性进行比较的时候需要重写equals()方法。

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

==在比较基本数据类型时比较的是值,在比较引用数据类型时比较的是内存中指向的存储地址,并返回boolean类型结果.

equals方法不能作用于基本数据类型的变量,如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；诸如String、Double、Date、Integer 等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

作者: 覃坤基 时间: 2019-4-20 21:35
1.什么是内部类，使用匿名内部类的前提是什么？
答：在一个类中定义一个类。
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

2.请从你的理解谈谈，匿名内部类的作用？
答：方便单个只用一次的方法调用；

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为对象有地址值和对象内容；
对象在结果需要排序的时候使用toString()方法来排序；

4.我们为什么要重写equals（）方法？
答：因为我们需要比较的是对象的内容而不是对象的地址值。

5.==和equals（）的区别?
==俩边若是基本数据类型比较的是数据值，若是引用数据类型比较的地址值。
equals比较的是引用数据类型的地址值，也可以重写equals来比较引用数据类型的内容。

作者: Dream梦 时间: 2019-4-20 21:35
潘绍平：
1.什么是内部类，使用匿名内部类的前提是什么？
答：1、内部类：定义在类中的类叫做内部类。
2、使用前提：存在一个类或者接口，类可以是具体类也可以是抽象类
2.请从你的理解谈谈，匿名内部类的作用？
作用：现实类只是用一次的情况下，可以不编写现实类，创建对象。简单理解，就是将编写实现类和创建实现类对象合并成一步。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
toString()
1、所有的引用数据类型都直接或间接继承Object
2、直接打印对象，对象会默认调用toString()方法
3、所有的类都会继承Object类的toString（）方法，当直接打印对象的时候，实际上调用Object类中的toString()方法，显示该对象地址值
4、一般情况下，Object的子类（所有类），都需要重写Object类中继承过来toString（）。因为我们不想看到地址值，想看到具体值
结论：所有定义的类建议重写toString（）方法
4.我们为什么要重写equals（）方法？
equals()
1、equals()是Object类中的方法，所用类都继承这个方法
2、Object类中的equals()源码是==，比较的是对象的地址值是否相等。
结论：建议，所有的类都重写equals()，因为我们希望比较的是两个对象的内容。
5.==和equals（）的区别?
==：比较引用数据类型比较的是对象的地址值。
equals()：未重写时效果与==相同;重写后按重写后方法比较

作者: 徐雯雯 时间: 2019-4-20 21:35

1.什么是内部类，使用匿名内部类的前提是什么？
答: 存在一个类或者接口, 类指的是具体的类也可以是抽象类

2.请从你的理解谈谈，匿名内部类的作用？
答:       只需要一个接口或者抽象类或者普通父类, 就可以直接在测试类中
   创建实现类或者子类对象

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答:    当直接调用Object的toString方法的时候打印的是地址值，当重写toString方法的时候打印的是对象内容
在打印输出对象的时候回默认调用toString();

4.我们为什么要重写equals（）方法？
答: 因为我们需要进行对象内容的比较,所以需要重写equals（）方法;

5.==和equals（）的区别?
答:  equals（）是对对象地址值进行比较 ,  需要重写后才能对对象内容进行比较
   ==  是比较运算符,比较具体值

作者: 唐仲泽 时间: 2019-4-20 21:35

1.什么是内部类，使用匿名内部类的前提是什么？
答：一个类包含一个类，被包含的类叫做内部类，包含他的类叫做外部类

2.请从你的理解谈谈，匿名内部类的作用？
答：在方法的参数是抽象类或者接口类型的时候，只能使用一次，也无法实例化，需要子类在创建对象，很繁琐，
而使用匿名内部类很简单的解决了这个问题，可以直接在测试类里创建。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为在作比较或这需要拿出对象的地址值、内容去作其他操作需要打印对象，一般来说没有
哪个程序员要打印地址值去做什么理解，当然我不会，对象在需要返回对象的内容时会调用toString（）方法

4.我们为什么要重写equals（）方法？
因为每个类默认object为父类，所以会继承它的属性和特性，在没有重写时，进行的是对象地址值的比较，重写后
进行的则是对象内容的比较

5.==和equals（）的区别?
==是在相同数据类型的前提下，进行内容比较，而equals若无重写后，比较的是对象的地址值，
重写后比较的才是对象的内容

作者: 余鹏程 时间: 2019-4-20 21:37

1.什么是内部类，使用匿名内部类的前提是什么？
答：
内部类就是创建在类的类，分为局部内部类、成员内部类
使用匿名内部类的前提是：
有一个接口或者抽象类、具体类

2.请从你的理解谈谈，匿名内部类的作用？
答：
当方法需要的形参是接口或者是抽象类时，就可以直接使用匿名内部类来代替传统的方法，不用再创建类来继承（实现），简化了使用方法

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：
(1)如果类中没有重写tostring方法那么就会使用默认的tostring方法，使用默认的tostring方法返回的就是地址值
，如果重写了tostring方法那么返回的就是自定义的值。
(2)想要查看或展示对象属性（地址值）时

4.我们为什么要重写equals（）方法？
答：
不重写equals方法的话比较的是两个对象的地址值
重写equals方法比较的是自定义的属性

5.==和equals（）的区别?
答：
==比较的是两个对象的地址值或者是两个数据的数据值
equals 比较的是你定义的对象属性

作者: 王嘉俊 时间: 2019-4-20 21:37
1.什么是内部类，使用匿名内部类的前提是什么？
答：一个类中包含一个类，被包含的类叫做内部类，包含他的类叫做外部类。使用内部类的前提是当两个类描述的事物是包含关系的时候
2.请从你的理解谈谈，匿名内部类的作用？
答：是一个继承了该类或者实现了该接口的子类匿名对象。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：因为toString将对象中的数据以字符串的形式返回。当String转为StringBuilder的时候会用toString。
4.我们为什么要重写equals（）方法？
答：进行对象内容的比较
5.==和equals（）的区别?
答：==是比较对象的地址值，equals （）比较的是对象内容的比较

作者: 林勇华 时间: 2019-4-20 21:37
1.什么是内部类，使用匿名内部类的前提是什么？
①内部类：在类的内部定义了一个类，是包含关系
②使用内部类的前提：有一个接口或者抽象类
2.请从你的理解谈谈，匿名内部类的作用？
匿名内部类作用：可以将它看作一个接口或者实现类对象，凡是可以用到实现类或者子类对象的地方都可以替换。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
①打印默认使用了toString方法，同样打印对象，当输出的对象的父类重写了toString方法就会打印出自定义内容。
②在打印输出对象的时候回默认调用toString();
4.我们为什么要重写equals（）方法？
我们定义的类直接或间接继承了Object类，equals（）方法在Object类中比较的是地址值是否相同，不能满足我们的需要
5.==和equals（）的区别?
比较引用类型数据的时候：==默认比较引用类型地址值是否相同，而重写了equals（）方法后比较的是具体值。

作者: 连惠腾 时间: 2019-4-20 21:37

1.什么是内部类，使用匿名内部类的前提是什么？
在一个类中定义的另一个类就是内部类，就是类a包含类b，其中类a是外部类，
类b是内部类。
前提：当两个类描述的事物是包含关系的时候。

2.请从你的理解谈谈，匿名内部类的作用？
匿名内部类作用：当在定义一个接口或抽象类/父类时，如果只需要用一次实现类或实现接口的的时候可以用
匿名内部类来简化代码。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
因为每个类都默认继承Object基类，而Object类中带有toString方法，对象在使用的时候会继承过来，而Object类中的toString（）方法打印的是地址值，一些对象的类会对
从Object类中继承的toString方法重写成简明而通俗易懂的表达形式。

4.我们为什么要重写equals（）方法？
equals（）的重写作用是不希望比较对象的地址值，想要结合对象属性进行比较的时候。

5.==和equals（）的区别?
==基本数据类型中比较两个值是否相等，在引用类型中比较两个类型地址值是否相等。
equals是指示其他某个对象是否与此对象“相等”。一般自己在定义基本类的时候要重写equals（）方法,
进行内容的比较。

作者: 谢龙炜 时间: 2019-4-20 21:39
1.什么是内部类，使用匿名内部类的前提是什么？
答：一个类中包含一个类，被包含的类叫做内部类，包含他的类叫做外部类。
例：计算机中的CPU，CUP只是计算机的一部分，而CUP自然是计算机的内部类，计算机是CPU的外部类
使用匿名内部类的前提是：需要有一个父类/抽象类/接口

2.请从你的理解谈谈，匿名内部类的作用？
答：使用匿名内部类可以简化代码，无需新增类，减少性能开销。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：
打印对象有时打印的是地址值是因为该对象的类或者父类都没有重写toString方法，
那么该对象就会执行超类Object类中的toString方法进行打印，而Object类中的toString方法打印的就是地址值
打印对象有时打印的是内容是因为该对象的类或者父类中有人重写了toString方法，那么该对象打印输出时就会打印出对象内容。
对象在类创建对象的时候就会自动调用toString方法。

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

5.==和equals（）的区别?
答：
==：基本类型数据比较的是数据值；引用类型比较的是地址值
equals():当子类的equals方法在没有重写之前比较的是两个对象之间的地址值，
当子类重写equals方法后，比较的是子类对象的属性是否相同。

作者: 郑少峰 时间: 2019-4-20 21:39

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

1.内部类是在一个类中定义一个类。有在成员内定义内部类，也有在局部定义内部类。使用匿名内部类的前提是要有接口或者抽象类或者具体类。
2.请从你的理解谈谈，匿名内部类的作用？
2.为了解决防止实现类或者子类只使用了一次，却需要占用内存的问题。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
3.如果该对象没有进行toString方法的重写，那么打印地址值；如果进行重写，则打印对象内容。打印输出的时候会调用toString方法。
4.我们为什么要重写equals（）方法？
4.重写equals方法可以具体比较到对象内容。
5.==和equals（）的区别?
5.==比较的是值，equals比较两边的内容。

作者: 吴晓斌 时间: 2019-4-20 21:39
1：一个类中包含一个类，被包含的类叫做内部类。前提是需要有一个父类/抽象类/接口。

2：使编程更方便，不需要编写类,可以直接创建该类/抽象类/接口的子类/实现类对象。

3：

4：一般自己写的equals类中需要重写该方法，进行对象内容的比较

5：equals：用于对象之间的比较，返回true和false的结果
== ：

作者: 伍志晟 时间: 2019-4-20 21:41

1.什么是内部类，使用匿名内部类的前提是什么？
答：
在类中重新定义的类叫内部类。
前提：存在一个类（可以是具体类也可以是抽象类）或者接口。
2.请从你的理解谈谈，匿名内部类的作用？
答：
节省了编写创建子类或者实现类。
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：
打印地址值是直接使用了Object的toString()方法，打印的是内容是因为重写了Object的toString()方法
在打印输出对象的时候默认会调用toString()方法
4.我们为什么要重写equals（）方法？
答：
如果不重写equals()方法对比对象时比较的是地址值，地址值是不会相同的。所以要重写此方法。
5.==和equals（）的区别?
答：
==比较的是具体值
equals()比较的是内容

作者: 余聪望 时间: 2019-4-20 21:41
1.什么是内部类，使用匿名内部类的前提是什么？

内部类是类中之类，分为成员内部类和局部内部类。
前提是有一个接口或者一个抽象类。

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

匿名内部类减少了程序资源的浪费，提高了开发人员在编程中的效率。有了匿名内部类以后，不用像之前有抽象类或者接口的时候需要单独创建一个子类或者实现类。直接在方法中创建一个匿名内部类即可调用方法。

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

因为所有的类都直接或间接的继承了Object类，要是继承的子类没有重写toString方法则默认继承了Object类的toString方法，即是地址值，要是有重写方法则打印的是对象内容。
打印对象名的时候会调用toString方法。

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

重写equals（）是为了比较两个对象的内容是否相同，而不重写比较的是地址值是否相同。
5.==和equals（）的区别?

==应用在基本数据类型比较的是数据值
==应用在引用数据类型比较的是地址值
重写的equals（）方法比较的是对象内容

作者: 方文彪 时间: 2019-4-20 21:42

1.什么是内部类，使用匿名内部类的前提是什么？
在一个类中类叫内部类；匿名内部类的前提是必须有一个父类对象或抽象方法或者接口，
2.请从你的理解谈谈，匿名内部类的作用？
可以直接创建该类或者接口的子类，不需要通过实现类
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？因为所有类都间接继承了Object类,而Object中的toString方法默认的就是打印地址值，有的重写了方法打印的就是内容；我们需要打印输出对象就会调用toString方法，为了让人容易看明白我们一般都会重写方法。
4.我们为什么要重写equals（）方法？
Object 中的equals方法默认是比较地址值，如果我们需要比较里面的内容就要重写。
5.==和equals（）的区别?
==在基本数据类型比较的是值，在引用数据类型比较的是地址值；equals（）默认的是比较地址值，重写之后可以比较对象的内容

作者: 庄天顺 时间: 2019-4-20 21:43

1.什么是内部类，使用匿名内部类的前提是什么？
存在父类（可以是实体类也可以是抽象类）或者接口这样的上下关系
2.请从你的理解谈谈，匿名内部类的作用？
解决问题：当前实现类或者子类只使用一次，还必须编写的问题
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
我们直接打印对象，对象会默认调用toString()方法想看到类的内容
4.我们为什么要重写equals（）方法？
才能对比内容
5.==和equals（）的区别?
一个对比地址值一个对比内容

作者: 李侄旭 时间: 2019-4-20 21:45
1.什么是内部类，使用匿名内部类的前提是什么？
答:内部类:在一个类中定义一个类.
前提:存在一个类或者接口,这里的类可以是具体类也可以是抽象类

2.请从你的理解谈谈，匿名内部类的作用？
答:将编写实现类和创建实现类对象合并成一步.

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答:当直接打印Object类中的tostring ()方法,显示的是对象的地址值
我们直接打印对象,对象会默认调用tostring()方法
一般情况下object的子类(所有类,)都需要重写从object类中的tostring()的方法,显示该对象的地址值

4.我们为什么要重写equals（）方法？
答:当我们不想要比较对象的地址值,想要结合对象属性进行比较的时候,我们就要重写equals;

5.==和equals（）的区别?
答:== 比较的是两个对象的地址值
eqals 比较的是内容

作者: 刘洪霖 时间: 2019-4-20 21:45
1.什么是内部类，使用匿名内部类的前提是什么？
答：内部类是类中指类中有类，类嵌套；前提需要有接口/抽象类/父类；
2.请从你的理解谈谈，匿名内部类的作用？
答：个自己感觉可以省略去创建一个类，也不用去写具体类的类名，可以让自己更清楚地处理接口/抽象类做参数或是返回值是的方法调用；
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：是因为有的数据类型有自带重写toString（）方法；输出地址值的没有自带重写toString（）方法需要自己去重写；需要去看对象具体有什么内容是可以去调用toString方法
4.我们为什么要重写equals（）方法？
答：重写equals是为了让我们更清楚地去比较两个引用数据类型的具体内容；
5.==和equals（）的区别?
答：基础数据类型中==比较的是具体值；
引用数据类型中==比较的是地址值；
重写后的equals（）比较的是具体内容；

作者: 陈明捷 时间: 2019-4-20 21:46

1.什么是内部类，使用匿名内部类的前提是什么？
包含于类中的类,存在一个类或者接口，这里的类可以是具体类也可以是抽象类

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

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
有些对象只继承object类的方法,因此只打印地址值.
有些对象会继承重写过的tostring方法,因此能打印对象内容.
打印时会调用tostring方法.

4.我们为什么要重写equals（）方法？
需要比较的是对象的内容而不是对象的地址值。

5.==和equals（）的区别?
==俩边若是基本数据类型比较的是数据值，若是引用数据类型比较的地址值。
equals比较的是引用数据类型的地址值，也可以重写equals来比较引用数据类型的内容。

作者: 严显辉 时间: 2019-4-20 21:48
.什么是内部类，使用匿名内部类的前提是什么？
内部类：在一个类中定义一个类
匿名内部类的前提，存在一个抽象类或接口
2.请从你的理解谈谈，匿名内部类的作用？
当实现类只使用一次时还要继续编写，使用匿名内部类可以简化代码
3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
所有的类都间接或直接继承于object类，object类中提供的方法打印的是地址值。而有的打印的是对象内容是因为在对象中重写了打印方法。
直接打印的时候会显示对象的地址值，当我们不想看到地址值想看到类的内容的时候，回去调用toString（）方法
4.我们为什么要重写equals（）方法？
在object中equals（）的源码是== 比较的是对象的地址值而我们要比较的是对象字符串的内容所以要重写equals()；
5.==和equals（）的区别?
==在基本类型中比较的是值，引用类型中比较的是对象的地址值而equals（）在objec中比较的是地址值而重写后要比较的是对象的字符串内容

作者: 许泽伟 时间: 2019-4-20 21:54
1.什么是内部类，使用匿名内部类的前提是什么？
答：
1、在一个类A中定义另一个类B，类B就被称为内部类。
2、前提是具有接口/抽象类/具体类

2.请从你的理解谈谈，匿名内部类的作用？
答：
当某个方法需要重写父类或实现一个接口，但是使用的次数较少时，可以使用匿名内部类简化代码，不用创建一个子类或实现类。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
答：
1、因为所有类都直接或间接继承Object类，在不进行toString方法重写的情况下，当进行打印输出时，基本数据类型会直接输出对象内容，而引用数据类型会默认调用Object类的toString（）方法，输出地址值。
2、当引用数据类型进行输出时，会调用toString方法。

4.我们为什么要重写equals（）方法？
答：
因为继承自Object类的equals（）方法默认与“==”作用相同，在对引用数据类型进行判断时，只能判断其地址值而无法对具体内容进行判断，所有需要对其进行重现加上具体内容判断功能。

5.==和equals（）的区别?
答：
在equal（）方法没重写的情况下，两者是没有区别的。

作者: 林晓诗 时间: 2019-4-21 21:43
1.什么是内部类，使用匿名内部类的前提是什么？
写在一个类中的类；
存在一个父类或接口。

2.请从你的理解谈谈，匿名内部类的作用？
某个方法中需要使用接口或抽象类的实现类或子类，使用匿名内部类可以不用在创建一个java文件去写实现类或子类，直接创建一个只能在这个方法中使用的实现类或子类。

3.思考一下为什么打印对象，有的是地址值，有的是对象内容?对象在什么时候会调用toString()方法？
打印对象会默认调用toString方法，如果对象没有重写，会调用父类（Object类）的方法，打印地址值，重写后就是对象内容。

4.我们为什么要重写equals（）方法？
不希望比较对象的地址值，想要结合对象属性进行比较

5.==和equals（）的区别?
==用于比较对象时只是简单的比较两个对象的地址值；
equals()方法重写后，可以进行更灵活的比较，没有重写则调用父类Object的equals方法，最后也是使用==进行比较。

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

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