20201023：算法+错题

错题一

• 下列说法正确的是（）
  答案及解析：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;
      }
  }