潘绍平：
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()：未重写时效果与==相同;重写后按重写后方法比较

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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方法后，比较的是子类对象的属性是否相同。

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

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

1：一个类中包含一个类，被包含的类叫做内部类。前提是需要有一个父类/抽象类/接口。

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

3：

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1.什么是内部类，使用匿名内部类的前提是什么？
答：
1、在一个类A中定义另一个类B，类B就被称为内部类。
2、前提是具有接口/抽象类/具体类

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

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

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

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

1.什么是内部类，使用匿名内部类的前提是什么？
写在一个类中的类；
存在一个父类或接口。

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

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

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

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