JavaSE - 练习面试题目 [3] 面向对象部分

1.哪个选项和show()方法重载
class Demo{
    void show(int a,int b,float c){}
}

A.void show(int a,float c,int b){}//yes
B,void show(int a,int b,float c){}//一模一样。不可以出现在同一个类中。
C.int show(int a,float c,int b){return a;}//yes。
D.int show(int a,float c){return a;}//yes

2.方法的重载

方法重载(overload)必须满足________
A. 在不同class中定义的方法 B.在同一类型中定义的方法
C. 方法名必须相同 D.返回类型必须相同
E. 参数一定不同 F.参数可以相同
答案：BCE

3.面向对象三大特征的说明

答：面向对象有三大特点：封装、继承、多态。(如果要回答四个，可加上 抽象性 这一特点)

3.1继承性：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.2 封装性：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

3.3 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
4.抽象性：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

4.作用域public,private,protected,以及默认不写时的区别
5.找错
public class Something {
   void doSomething () {
       private String s = "";
       int l = s.length();
   }
}

有错吗?
答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。

6.Java的内存管理之垃圾回收（了解）

分配：由JVM自动为其分配相应的内存空间
释放：由JVM提供垃圾回收机制自动的释放内存空间
垃圾回收机制（GC：Garbage Collection）：将垃圾对象所占用的堆内存进行回收。Java的垃圾回收机制是JVM提供的能力，由单独的系统级垃圾回收线程在空闲时间以不定时的方式动态回收。
垃圾对象：不再被任何引用指向的对象。

面试题：
问：在程序中是否可以通知垃圾回收机制过来回收垃圾？
能，通过调用System.gc();或Runtime.getRuntime().gc();

再问：调用了System.gc();或Runtime.getRuntime().gc();后是立刻执行垃圾回收吗？
不是，该调用并不会立刻启动垃圾回收机制开始回收，但会加快垃圾回收机制的运行。

7.构造器Constructor是否可被override

答：构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload

7.简答

当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的

8.java类是否可以多继承，怎么实现多继承？

答：java没有多继承，但可以通过接口的形式来达到多继承的目地。

9.重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

10.Overload的方法是否可以改变返回值的类型？

Overloaded的方法是可以改变返回值的类型

11.写出错误答案错误的原因
class Demo{
    int show(int a,int b){
        return 0;
    }
}

下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以，覆盖。
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。

12.写出程序结果
class Super {
    public int get() {
        return 4;
    }
}

class Demo15 extends Super {
    public long get() {
        return 5;
    }

    public static void main(String[] args) {
        Super s = new Demo15();
        System.out.println(s.get());
    }
}

编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。所以这样的函数不可以存在子父类中。

13.Object类的使用说明

我比较两个String总是false，但是它们明明都是"abc" ！
答：比较String一定要使用equals或equalsIgnoreCase方法，不要使用 ==
　　==比较的是两个引用（变量）是否指向了同一个对象，而不是比较其内容。

14.为什么要重写toString()方法？

方面打印对象,覆盖Object的toString方法,Object的toString方法打印的是引用地址

15.为什么要重写equals()方法？

如果不重写equals，那么比较的将是对象的引用是否指向同一块内存地址，重写之后目的是为了比较两个对象的value值是否相等。特别指出利用equals比较八大包装对象（如int，float等）和String类（因为该类已重写了equals和hashcode方法）对象时，默认比较的是值，在比较其它自定义对象时都是比较的引用地址。
而且重写equals方法必须重写 hashCode方法
object对象中的 public boolean equals(Object obj)，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true；
注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。如下：

(1)当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false

hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。
这样如果我们对一个对象重写了equals，意思是只要对象的成员变量值都相等那么equals就等于true，但不重写hashcode，那么我们再new一个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致，如在存储散列集合时（如Set类），将会存储了两个值一样的对象，导致混淆，因此，就也需要重写hashcode()。

16.写出“==”和equals的区别

== 是比较的对象 是地址的引用
equals 是比较的内容

17.包装类的使用

写出8中基本数据类型的包装类
int 和 Integer 有什么区别
答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。
int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类型及其对应的包装类：boolean Boolean,char Character,byte Byte,short Short,int Integer,long Long,float Float,doubl Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。
引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

18.请写出java基本数据类型及对应的封装类型，并说明封装类的作用。

boolean Boolean,
char Character,
byte Byte,
short Short,
int Integer,
long Long,
float Float,
double Double
包装之后,int 是基本类型,Integer是引用类型
对于a你只能用来做计算。。比如加减乘除。。

b你可以用来做很多事情，因为他是一个对象，他有很多方法，你可以像使用String对象那样使用它。 java.lang.Integer是一个类.对它的操作要通过类的方法，可以toString等，而int不行

另外，Integer对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了

总结一下几个点：
1.int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。
2.Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。
3.new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱。

19.写出程序结果
class Super {
    int i = 0;

    public Super(String s) {
        i = 1;
    }
}

class Demo extends Super {
    public Demo(String s) {

        i = 2;
    }

    public static void main(String[] args) {
        Demo d = new Demo("yes");
        System.out.println(d.i);
    }
}

//编译失败，因为父类中缺少空参数的构造器。
//或者子类应该通过super语句指定要调用的父类中的构造器。

20.main()方法

选择题

class Test {
    public static void main(String[] args) {
        String foo = args[1];
        String bar = args[2];
        String baz = args[3];
    }
}

d:>java Test Red Green Blue

what is the value of baz?
A. baz has value of ""
B. baz has value of null
C. baz has value of "Red"
D. baz has value of "Blue" //正确
E. baz has value of "Green"
F. the code does not compile
G. the program throw an exception

21.选择题:

1)下面关于接口的说法中不正确的是（C）。
A．接口中所有的方法都是抽象的
B．接口中所有的方法都是public访问权限
C．子接口继承父接口所用的关键字是implements
D．接口是Java中的特殊类，包含常量和抽象方法

public interface I extends Runner{

}

2)Java语言接口间的继承关系是（A）。
A．单继承 B．多重继承 C．不能继承 D．不一定
3)一个类实现接口的情况是（A）。
A．一次可以实现多个接口 B．一次只能实现一个接口
C．不能实现接口 D．不一定

22.填空题

1)____implements____是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的修饰符是public static final_，接口中的成员方法默认的修饰符是 public abstruct。
2)如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须该接口的所有抽象方法；如果实现某接口的类是abstract的抽象类，则它可以该接口所有的方法。但是对于这个抽象类任何一个非抽象的子类而言，它们父类所实现的接口中的所有抽象方法以及自身所实现接口中的抽象方法都必须有实在的。

23.abstract class 和interface 有什么区别?

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口

24.接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

答案是： 接口可以继承接口。抽象类可以实现(implements)接口，
抽象类可继承实体类，但实体类必须不能是如下两种情况之一：
1，final修饰符修饰的类是不能的
2，如果此实体类有且仅有私有的构造函数也是不能的。

25.是否能通过编译？
interface  A{
   int x = 0;
}
class B{
   int x =1;
}
class C extends B implements A {
   public void pX(){
      System.out.println(x);  //super.x   A.x
   }
   public static void main(String[] args) {
      new C().pX();
   }
}

答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，
两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，
而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

26.内部类

选择题

public class OuterClass { 
  private double d1 = 1.0; 
    //insert code here 
}

You need to insert an inner class declaration at line 3. Which two inner class declarations are valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
说明如下：
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。
故 D 错
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
四.答案为C、E

27.Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)

答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现

28.Static Nested Class 和 Inner Class的不同

答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。
Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。
注： 静态内部类（Inner Class）意味着
1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

29.写出程序结果
class TD {
    int y = 6;

    class Inner {
        static int y = 3;

        void show() {
            System.out.println(y);
        }
    }
}

class TC {
    public static void main(String[] args) {
        TD.Inner ti = new TD().new Inner();
        ti.show();
    }
}

编译失败，非静态内部类中不可以定义静态成员。
内部类中如果定义了静态成员，该内部类必须被静态修饰

30.判断题

1)内部类（可以/不可以）了解外部类
2)静态内部类用修饰。
3)外部类（可以/不可以）通过类名访问静态内部类里的静态成员（变量和方法）
4)外部类（可以/不可以）通过类名访问非静态内部类里的成员（变量和方法）
5)非静态内部类可以访问外部类的成员，也能访问外部类的成员
6)静态内部类可以访问外部类的成员，不能访问外部类的成员
7)非静态内部类（可以/不可以）用static修饰她的成员（变量和方法）

31.抽象类与抽象方法 abstract 的method 是否可同时是static，是否可同时是native，是否可同时是synchronized？

答：都不能

32.抽象类和抽象方法之间的关系

定义抽象类和抽象方法的关键字是（abstruct）。抽象类中（可以）（可以/不可以）有抽象方法，（可以）（可以/不可以）有普通方法（可以）（可以/不可以）有属性；一个类中定义了抽象方法，那这个类（必须）（必须/不必须）用abstract修饰，即抽象类。

33.判断题
abstract class Name {
   private String name;
   public abstract boolean isStupidName(String name) {}
}

这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。

34.是否可以通过编译？

abstract class Something {
private abstract String doSomething ();
}

答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

35.static的使用

是否可以从一个static方法内部发出对非static方法的调用？
答：不可以,如果其中包含对象的method()；不能保证对象初始化.

36.编译是否通过？
public class Something {
     public static void main(String[] args) {
        Something s = new Something();
        System.out.println("s.doSomething() returns " + doSomething());
    }
    public String doSomething() {
        return "Do something ...";
    }
}

看上去很完美。
答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。
但仔细看，main是static的。static method不能直接call non-static methods。
可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。
同理，static method不能访问non-static instant variable。

37.谈谈final, finally, finalize的区别(后面异常中讲finally)

答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载

finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

38.如下程序是否可通过编译？
public class Something {
   public int addOne(final int x) {
       return ++x;
   }
}

这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

如果修改为以下代码就没错了

public class Something {
   public int addOne(final int x) {
       return x+1;
   }
}
39.如下程序是否可通过编译？
public class Something {
   public static void main(String[] args) {
       Other o = new Other();
       new Something().addOne(o);
   }
   public void addOne(final Other o) {
       o.i++;
   }
}
class Other {
   public int i;
}

和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。

40.是否可以通过编译？
class Something {
    int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
}

答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。 int的default value是0。

41.是否可以通过编译？

接上题

class Something {
    final int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
}

和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?
答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,793评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,567评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,342评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,825评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,814评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,680评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,033评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,687评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,175评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,668评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,775评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,419评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,020评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,206评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,092评论 2赞 351
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,510评论 2赞 343