錯題一

• 下列說法正確的是（）
  答案及解析：C

  sychronized關鍵字和volatile關鍵字比較：
  (1)volatile關鍵字是線程同步的輕量級實現，所以volatile性能肯定比synchronized關鍵字要好。但是volatile關鍵字
  只能用于變量而synchronized關鍵字可以修飾方法以及代碼塊。
  (2)多線程訪問volatile關鍵字不會發生阻塞，而synchronized關鍵字可能會發生阻塞
  (3)volatile關鍵字能保證數據的可見性，但不能保證數據的原子性。synchronized關鍵字兩者都能保證。
  (4)volatile關鍵字主要用于解決變量在多個線程之間的可見性，而 synchronized關鍵字解決的是多個線程之間訪問資源
  的同步性。 
  

錯題二

• 如下的Java程序：若采用命令行“java Test one two three”調用，則程序輸出的結果為：

  public class Test { 
       public static void main(String[] args) { 
       System.out.println(args[0]); 
       } 
  } 
  ```![](https://img-blog.csdnimg.cn/img_convert/b46a40d7f77087b1b3b37794223b533a.png)
  

答案及解析：B

采用命令行“ java Test one two three ”調用
其中Test為調用的方法，而one two three則為Test方法里面main函數的參數；
  System.out.println(args[0]);表示輸出第一個元素，故為one；

錯題三

• 關于依賴注入，下列選項中說法錯誤的是（）
  答案及解析：B

依賴控制和控制反轉是同一概念：
依賴注入和控制反轉是對同一件事情的不同描述，從某個方面講，就是它們描述的角度不同。
依賴注入是從應用程序的角度在描述，可以把依賴注入描述完整點：應用程序依賴容器創建并注入它所需要的外部資源；而控制
反轉是從容器的角度在描述，描述完整點：容器控制應用程序，由容器反向的向應用程序注入應用程序所需要的外部資源。

錯題四

• 以下代碼執行的結果是多少（）？

  public class Demo {
  	public static void main(String[] args) {
  		Collection<?>[] collections = 
  {new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
  				Super subToSuper = new Sub();
  				for(Collection<?> collection: collections) {
  	System.out.println(subToSuper.getType(collection));
  	}
  }
  	abstract static class Super {
  		public static String getType(Collection<?> collection) {
  			return “Super:collection”;
  		}
  		public static String getType(List<?> list) {
  			return “Super:list”;
  		}
  		public String getType(ArrayList<?> list) {
  			return “Super:arrayList”;
  		}
  		public static String getType(Set<?> set) {
  			return “Super:set”;
  		}
  			public String getType(HashSet<?> set) {
  				return “Super:hashSet”;
  			}
  		}
  		static class Sub extends Super {
  			public static String getType(Collection<?> collection) {
              	return "Sub"; 
          	}
  		}
  }
  ```![](https://img-blog.csdnimg.cn/img_convert/3fb7861e829db23e53fddafc8628304f.png)
  

答案及解析：C

重載靜態多分派——根據傳入重載方法的參數類型，選擇更加合適的一個重載方法
static方法不能被子類覆寫，在子類中定義了和父類完全相同的static方法，則父類的static方法被隱藏，Son.staticmethod()
或new Son().staticmethod()都是調用的子類的static方法，如果是Father.staticmethod()或者Father f = new Son(); 
f.staticmethod()調用的都是父類的static方法。
此題如果都不是static方法，則最終的結果是A. 調用子類的getType，輸出collection

錯題五

• 下列代碼的運行結果為：（）

  import java.io.*;
  import java.util.*;
  public class foo{
  	public static void main (String[] args){
  		String s;
  		System.out.println("s=" + s);
  	}
  }
  ```![](https://img-blog.csdnimg.cn/img_convert/14e6821f1fda57541458bdb30d7e929c.png)
  

答案及解析：C

局部變量可以先申明不用必須初始化，但使用到了一定要先初始化

錯題六

• 以下代碼可以使用的修飾符是：（）

  public interface Status {
   /*INSERT CODE HERE*/  int MY_VALUE=10;
   }
  ```![](https://img-blog.csdnimg.cn/img_convert/8b9d253a46df7279ade72adac6ba3c18.png)
  

答案及解析：A B D

接口中字段的修飾符：public static final（默認不寫）
接口中方法的修飾符：public abstract（默認不寫）
abstract只能修飾類和方法 不能修飾字段

錯題七

• class A {}
  class B extends A {}
  class C extends A {}
  class D extends B {}
  Which four statements are true ?
  答案及解析：A C D G

1. 只看尖括號里邊的！！明確點和范圍兩個概念
2. 如果尖括號里的是一個類，那么尖括號里的就是一個點，比如List<A>,List<B>,List<Object>
3. 如果尖括號里面帶有問號，那么代表一個范圍，<? extends A> 代表小于等于A的范圍，<? super A>代表大于等于A的范圍，
4. <?>代表全部范圍
5. 尖括號里的所有點之間互相賦值都是錯，除非是倆相同的點
6. 尖括號小范圍賦值給大范圍，對，大范圍賦值給小范圍，錯。如果某點包含在某個范圍里，那么可以賦值，否則，不能賦值
7. List<?>和List 是相等的，都代表最大范圍
----------------------------------------------------------------------------------
7.補充：List既是點也是范圍，當表示范圍時，表示最大范圍

public static void main(String[] args) {
		List<A> a;
		List list;
		list = a;   //A對，因為List就是List<?>，代表最大的范圍，A只是其中的一個點，肯定被包含在內
		List<B> b;
		a = b;      //B錯，點之間不能相互賦值
		List<?> qm;
		List<Object> o;
		qm = o;     //C對，List<?>代表最大的范圍，List<Object>只是一個點，肯定被包含在內
		List<D> d;
		List<? extends B> downB;
		downB = d;  //D對，List<? extends B>代表小于等于B的范圍，List<D>是一個點，在其中
		List<?extends A> downA;
		a = downA;  //E錯，范圍不能賦值給點
		a = o;      //F錯，List<Object>只是一個點
		downA = downB;  //G對，小于等于A的范圍包含小于等于B的范圍，因為B本來就比A小，B時A的子類嘛
}

算法一

• 請判斷一個鏈表是否為回文鏈表

  示例1：

  輸入: 1->2
  輸出: false
  

  示例2：

  輸入: 1->2->2->1
  輸出: true
  

  class Solution {
      public boolean isPalindrome(ListNode head) {
          ListNode slow = head;
          ListNode fast = head;
          if(fast==null||fast.next==null){//0個節點或者1個節點
              return true;
          }
          while(fast.next!=null&&fast.next.next!=null){
              fast = fast.next.next;
              slow = slow.next;
          }
          //對鏈表后半段進行反轉
          ListNode midNode = slow;
          //后半段鏈表的第一個節點
          ListNode firNode = slow.next;
          //插入節點從第一個節點后面一個開始
          ListNode cur = firNode.next;
          //第一個節點最后會變最后一個節點
          firNode.next = null;
  
          while(cur!=null){
              //保存下次遍歷的節點
              ListNode nextNode =  cur.next;
              cur.next = midNode.next;
              midNode.next = cur;
              cur = nextNode;
          }
  
          //反轉之后對前后半段進行比較
          slow = head;
          fast = midNode.next;
          while(fast!=null){
              if(fast.val!=slow.val){
                  return false;
              }
              slow = slow.next;
              fast = fast.next; 
          }
          return true;
      }
  }