基础知识巩固三（问题部分）

 

问题一：关于Comparable与Comparator接口：

  • Comparable & Comparator 都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。
  • Comparator位于包java.util下，而Comparable位于包java.lang下
  • Comparable 是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作，已经实现了Comparable接口）
  • 自定义的类要在加入list容器中后能够排序，可以实现Comparable接口，在用Collections类的sort方法排序时，如果不指定Comparator，那么就以自然顺序排序，如API所说：Sorts the specified list into ascending order, according to the natural ordering of its elements. All elements in the list must implement the Comparable interface
  • 这里的自然顺序就是实现Comparable接口设定的排序方式。
  • 而 Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。
  • 可以说一个是自已完成比较，一个是外部程序实现比较的差别而已。
 1 public interface Comparable{
 2 
 3        public int compareTo(Object o);
 4 
 5 }
 6 
 7 public interface Comparator{
 8 
 9       public int compare(T t1,T t2);
10 
11       public boolean equals(Object o); 
12 
13 }

问题二：关于没有抽象方法的抽象类的意义

没有抽象方法的抽象类的意义就在于不让你去实例化这个类。

 1 interface Inter
 2 {  void show1();
 3    void show2();
 4    void show3();
 5     void show4();
 6     
 7 }
 8 //没有抽象方法的抽象类，可以方便的创建接口对象，去覆盖指定的功能
 9 abstract class A implements Inter
10 {   public void show1() {
11 }
12     public void show2() {
13     }
14     public void show3() {
15     }
16     public void show4() {
17     }
18    
19 }
20  class B extends A
21 {
22   public void show1()
23   {
24       System.out.println("111111111111");
25       
26   }
27 }    
28 public class Test5
29 {
30   public static void main(String[] args) {
31       B b = new B();
32       b.show1();
33     
34 }    
35 }

 

问题三：static/final写的前后顺序无影响

问题四：接口中能有静态方法么？

Java8引入了一种新特性，为了使接口具有更大的灵活性，将接口静态方法来一个默认实现，当然子类可以重写，也可以不重写。如下：

public interface Service{
     public static int testMethod(int i){
         return i;
    }
}

则这种情况是允许的，在实现类中可以进行覆盖testMethod(int i),也可以不进行覆盖

问题五：valueOf与parseInt区别

  1. valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。 
  2. parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析，返回int类型。
 1 //先调用parseInt获得int值，然后封装成Integer对象，注意封装的逻辑，有缓存
 2  public static Integer valueOf(String s) throws NumberFormatException {
 3         return Integer.valueOf(parseInt(s, 10));
 4  }
 5     
 6  public static Integer valueOf(int i) {
 7     assert IntegerCache.high >= 127;
 8  if (i >= IntegerCache.low && i <= IntegerCache.high)
 9         return IntegerCache.cache[i + (-IntegerCache.low)];
10     return new Integer(i);
11  }
12  //直接转换，获得int值
13  public static int parseInt(String s) throws NumberFormatException {
14     return parseInt(s,10);
15  }

valueOf内部就用了parseInt，区别在于parseInt直接返回原始int类型数据；而valueOf又装了下箱，返回Integer类型。

还有一个区别，parseInt期待输入是String，而valueOf不是。

注意：一般用Integer.parseInt(str)，除非你要返回Integer类型，不然还有封装拆箱，性能多少会耗费些。

 

posted @ 2018-03-08 22:09  PottyHarry  阅读(124)  评论(0)  编辑  收藏  举报