Hire the Top 3% of 自由Java开发人员

The Challenge

今天，在它最初发布近20年后，据报道Java是世界上最伟大的语言 最受欢迎的语言技能，并且遥遥领先(受欢迎程度是亚军PHP的两倍)。.

Java应用程序的使用如此普遍, 简历上不乏会Java的开发人员. 但就像任何技术一样，首先要了解Java，然后 really knowing Java. 那么，如何才能确定谁是真正的Java开发专家呢?

Java mastery, 就像生活中的许多技能一样, 要充分利用它的力量需要时间和健康的好奇心. 因此，如我们的帖子所述 寻找少数精英, an effective recruiting process needs to evaluate many dimensions of a candidate beyond just technical knowledge; attributes such as drive, integrity, 创造力同样是一个软件开发大师的基本属性. 评估候选人的这些方面，然后可以用问题(例如本文中提出的问题)来扩充，以帮助确定哪些人是真正的高质量Java专家.

评估基金会

我们从一些问题开始，这些问题可以帮助评估候选人对一些基本Java范例和概念的理解深度.

问:什么是匿名类? 何时、为何以及如何使用它们? 提供一个示例.

匿名类是内联表达式, 为了方便，通常是一次性使用的类, 这有助于使您的代码更简洁. 下面的示例实例化了一个new ActionListener 处理与按钮相关的事件:

button.addActionListener(new ActionListener()) {
    公共无效actionPerformed(ActionEvent e) {
        /*响应按钮动作事件*/
    }
});

这是有意义的，因为类不在其他地方使用，也不需要名称. However, 如果将匿名类传递给注册方法, for instance, 您可能需要跟踪它的引用, 以便以后能够注销它. 让我们扩展上面的例子来演示这一点:

ActionListener = new ActionListener() {
    公共无效actionPerformed(ActionEvent e) {
        /*响应按钮动作事件*/
    };
button.addActionListener(听众);

/* some time later... */

button.removeActionListener(听众);

问:什么是抽象类? 何时、为何以及如何使用它们? 提供一个示例.

Abstract classes 是有用的定义抽象模板方法，具体子类必须实现. 因此，所有具体的子类都保证遵循由它们继承的抽象类中的抽象方法指定的API. 这在某种程度上类似于Java interface 为实现它的所有类指定一个API.

公共用例是指有一类对象具有共同的行为(例如.g., 所有形状都有一个面积), 但是计算或执行这些功能的细节因对象而异. For example:

 公共抽象类Shape {
     公共抽象双区();
 }
 
 公共类Circle extends Shape {
     专用双半径;
     
     公共圆(双半径){
         this.radius = radius;
     }
     public double area(){返回数学.PI * Math.pow(this.radius,2); }
 }
 
 公共类矩形扩展形状{
     私人双宽、高;
     
     公共矩形(双宽，双高){
         this.width = width;
         this.height = height;
     }
     Public double area(){返回这个.width * this.height; }
 }

以下几点值得注意:

• Abstract classes may not be instantiated directly; only their concrete subclasses are instantiable.
• 一个类可以被声明为抽象的，即使它没有抽象方法. 这将阻止该类被实例化. 这很有用, for example, 如果类层次结构中的基类没有抽象方法，但本身不打算被实例化.

问:比较和对比已检查和未检查的异常. Provide examples.

未经检查的异常 例外是 not 被认为是可恢复的. Java不会因为它们表示异常而强制您捕获或处理它们, 代码中的意外问题，例如 NullPointerException, ArithmeticException and IndexOutOfBoundsException. 也就是说，这些都是你需要修复或预防的问题. 未检查异常都派生自 RuntimeException.

Checked exceptions 例外情况是 are 被认为是可恢复的. Checked exceptions must explicitly be specified as part of a method’s API; that is, 可能抛出一个或多个受控异常的方法必须将这些潜在异常列为其方法声明的一部分(Java编译器实际上会强制执行这一点)。.

当调用引发异常的方法时，调用者必须处理(i.e.(捕获)这些异常，或者必须自己抛出它们. For example, 如果方法抛出检查异常, 调用者可能决定忽略错误并继续(吞下它), 向用户显示一个对话框, 或者重新抛出异常，让调用链更上层的方法处理它(在这种情况下，它还必须声明它抛出检查异常)。.

For example:

readFile(文件文件)抛出IOException, MyReadFileException {
    try {
        FileInputStream fis = new FileInputStream(file);
    } catch(FileNotFoundException e) {
        //捕获FileNotFoundException并抛出IOException;
        //所以我们没有在上面的"throws"子句中包含FileNotFoundException. 
        抛出新的IOException();
    }
    
    if (somethingBadHappened) {
        //我们在这里显式抛出自己的MyReadFileException，
        //所以我们把它包含在上面的"throws"子句中.
        抛出新的MyReadFileException();
    }
}

检查异常清楚地传达并强制处理错误条件. 然而，对于开发人员来说，不断地需要包含它也是一种痛苦 try/catch 块来处理来自它们调用的方法的所有已知异常. 尽管在Java中确实允许大量的检查异常, 事情可能会变得有点笨拙. For example:

抛出DataFormatException, InterruptedException， 
	IOException, SQLException, TimeoutException, ParseException {
...
}

因此，有 raging debate 例如，在编写库时是使用已检查异常还是未检查异常，多年来一直存在争议. 很多这样的辩论都是如此, 事实上，没有放之四海而皆准的方法, 全部正确答案. 检查异常和未检查异常各有优缺点, 因此，决定使用哪一种主要取决于情况和背景.

问:描述泛型，并提供Java中泛型方法和类的例子.

Java generics 使程序员能够指定, 使用单个方法或类声明, 可以应用于多种不同数据类型的功能. 泛型还提供编译时类型安全性，允许Java编程专家在编译时捕获无效类型.

例如，这里是a generic method that uses 作为泛型类型的占位符:

public  void printArray( E[] inputArray ) {
    //显示数组元素              
    for (E element: inputArray) {        
        System.out.Printf(“%s”，元素);
    }
    System.out.println();
}

The above method could then be invoked with various types of arrays and would handle them all appropriately; e.g.:

//使用Double数组调用printArray方法
Double[] doubleArray = {1.1, 2.2, 3.3, 4.4 };
printArray (doubleArray);

//使用字符数组调用通用printArray方法
字符[]charArray ={‘H’,‘E’,‘L’,‘L’,”O '};
printArray (charArray);

There may be times, though, 当您想要限制允许传递给泛型类型参数的类型类型时. For example, 对数字进行操作的方法可能只想接受Number或其子类的实例. 这是在一般情况下使用 有界型参数，其中列出了类型参数的名称，后面跟着 extends keyword. For example:

//确定三个可比对象中最大的
public static > T maximum(T x, T y, T z) {                      
  T max = x; // assume x is initially the largest       
  if ( y.compareTo( max ) > 0 ) {
     max = y; // y is the largest so far
  }
  if ( z.compareTo( max ) > 0 ) {
     max = z; // z is the largest now                 
  }
  return max; // returns the largest object   
}

与泛型方法一样，类的类型参数部分 generic class 可以使用逗号分隔一个或多个类型参数吗. For example:

public class Cell {
  private T val;

  public void set(T val){这个.val = val; }

  public T get() { return val; }

  public static void main(String[] args) {
     Cell integerCell = new Box();
     Cell stringCell = new Box();
    
     integerCell.(新添加整数(10));
     stringCell.add(new String("Hello World"));

     System.out.printf("整数值:%d\n\n"， integerCell.get());
     System.out.printf("字符串值:%s\n"， stringCell.get());
  }
}

问:什么是多重继承? 它有哪些潜在的问题?为什么Java传统上不支持它? 随着Java 8的发布，这种情况发生了什么变化?

多重继承 是一些面向对象的计算机编程语言的一个特征，其中一个对象或类可以从多个父对象或父类继承特征和功能. 它不同于单继承, 对象或类只能从一个特定的对象或类继承.

在Java 8之前，Java只支持单继承. 稍后我们将讨论Java 8对多重继承的准支持, 但是首先让我们了解多重继承会导致什么问题，以及为什么Java中极力避免多重继承.

反对多重继承的主要理由是复杂性, 潜在的模糊性, 它可以引入. 最典型的例子就是人们常说的“钻石问题”。, B类和C类继承于A类, 类D同时继承类B和类C. 如果a中的方法被B和C都重写了，就会产生歧义. If D does not override it, then which version of the method does it inherit; that of B, or that of C?

让我们考虑一个简单的例子. 一所大学有附属于它的人. 有些是学生，有些是教员，有些是管理人员，等等. 因此，一个简单的继承方案可能有不同类型的人担任不同的角色, 所有这些都继承自一个共同的“Person”类. Person类可以定义一个抽象 getRole() 方法，然后由其子类重写该方法以返回正确的角色类型.e.:

但是如果我们想要模拟助教的角色会发生什么呢?? Typically, a TA is both a grad student and a faculty member. 这就产生了多重继承的经典菱形问题，以及由此产生的关于TA的歧义 getRole() method:

(Incidentally, 注意上面继承图的菱形, 这就是为什么这被称为“钻石问题”.)

Which getRole() 实现应该继承TA? 教员或研究生的证言? 简单的答案可能是让TA类覆盖 getRole() 方法并返回名为“TA”的新定义角色。. 但这个答案也是不完美的，因为它会掩盖一个事实，即助教是, in fact, 既是教员也是研究生. 有多种设计方法和模式可以在没有多重继承的情况下处理这种类型的情况, 这就是为什么一些语言(Java就是其中之一)决定简单地避开多重继承的原因.

Java 8, however, 通过允许在接口上指定默认方法(在Java 8之前)，引入了对多重继承的准支持形式, 只有方法签名, 不是方法定义, 允许在接口上使用). Since Java does 允许单个类实现多个接口(而单个类只能扩展单个父类), Java 8中允许在接口中定义方法，这首次在Java中引入了菱形问题的可能性.

For example, if A, B, 和C是接口, B和C可以各自为a的抽象方法提供不同的实现, 导致任何实现B和C的类D出现菱形问题. 类D必须重新实现该方法(其主体可以简单地将调用转发给其中一个超级实现), 否则歧义将作为编译错误而被拒绝.

Gourmet Java

在这里，我们将介绍一些更高级的概念和问题，Java编程大师可能会熟悉这些概念和问题.

问:如何使用外部条件变量可靠地退出线程?

有时，开发人员希望在外部条件为真时终止线程. 考虑下面的例子 bus 继续无限驱动的线程，直到 pleaseStop 变量变为真.

boolean pleaseStop = false; // The bus pull cord.

公共void pleaseStopTheBus() {
    pleaseStop = true;
}

公共无效startTheBus() {
    new Thread("bus") {
        公共无效运行(){
            //无限驱动总线.
            while (!pleaseStop) {
                //花点时间开车到下一站.
            }
            pleaseStop = false; // Reset pull cord.
        }
    }.start();
}

看起来简单. However, Java不保证线程边界之间隐式的变量同步, 所以这个线程不能保证可靠地退出, 这让缺乏经验的Java开发人员感到头疼.

要使上述代码正常工作，需要按以下方式同步线程:

volatile boolean pleaseStop = false; // The bus pull cord.
Object driver = new Object(); // We can synchronize on any Java object.

公共void pleaseStopTheBus() {
	//在"线程1"中，同步驱动程序对象
    Synchronized (driver) {
        pleaseStop = true;
    }
}

公共无效startTheBus() {
    new Thread("bus") {
        公共无效运行(){
            //无限驱动总线.
            while (true) {
				//在这里的“线程2”，也同步驱动程序对象
                Synchronized (driver) {
                    if (pleaseStop) {
                        pleaseStop = false; // Reset pull cord.
                        return; // Bus stopped.
                    }
                }
                //花点时间开车到下一站.
            }
        }
    }.start();
}

Q: How can null 问题重重，怎样才能避免陷阱?

For one thing, null is often ambiguous. 它可以用来表示成功或失败. 或者它可以用来表示值的缺失. 或者在某些上下文中它可能是一个有效值.

即使一个人知道 null 在特定的环境中, 如果不幸的开发人员在取消引用它之前忘记检查它，它仍然会造成麻烦, 从而触发 NullPointerException.

避免这些问题的最常见和最有效的技术之一是 使用有意义的非空默认值. 换句话说，就是避免使用 null 尽你所能. 避免将变量设置为 null 避免返回 null 从任何可能的方法(例如.g.，返回空列表，而不是 null).

In addition, as of JDK 8， Java已经引入了对 Optional 类(或者如果您使用的是较早版本的Java，则可以使用 Optional class in the Guava libraries. Optional 用一个值表示和包装缺席和存在. 而Optional则添加了更多内容 ceremony 到您的代码中，通过强制您展开 Optional to obtain the non-null 值，它避免了可能导致的 NullPointerException.

问:什么是“拳击”?要注意的问题有哪些?

Java的基本类型是 long, int, short, float, double, char, byte and boolean. 通常需要将原始值作为对象存储在各种数据结构中，这些数据结构只接受诸如 ArrayList, HashMap, etc. 因此，Java引入了“装箱”的概念，将原语打包成对象类的等效物, e.g., Integer for int, Float for float, and Boolean for boolean. Of course, as objects, 它们会导致对象分配的开销, 内存膨胀和方法调用, 但他们确实付出了一些代价来达到目的.

“自动装箱”是编译器自动将原语转换为装箱对象，反之亦然. 这只是为了方便，e.g.:

ArrayList ints = new ArrayList();

// Autoboxing.  编译器会自动将"35"转换成一个带框的整数.
ints.add(35); 

//上面的表达式等价于:int.(新添加整数(35));

尽管它们很方便, though, 盒装对象因引入粗糙的bug而臭名昭著, 特别是对于经验不足的Java开发人员.

首先，想想这个:

System.out.println(new Integer(5) == new Integer(5));   // false

在上面的代码行中，我们比较了 identity 两个整数对象. Since each new Integer(5) 创建一个新对象 new Integer(5) 不等于另一个 new Integer(5).

但更令人不安的是下面这个看似莫名其妙的区别:

System.out.println(Integer.valueOf(127) == Integer.valueOf(127));   // true
System.out.println(Integer.valueOf(128) == Integer.valueOf(128));   // false

Huh? 这怎么可能呢 true and the other be false? 这似乎说不通啊. 事实上，答案非常微妙.

正如在一个容易被忽视的 note 在Javadoc中 Integer class, the valueOf() method method缓存取值范围为-128到127的整数对象, inclusive, 也可能缓存这个范围之外的其他值. 因此，调用一次返回的Integer对象 Integer.valueOf(127) will 方法返回的Integer对象 Integer.valueOf(127)，因为它是缓存的. 但在-128到127的范围之外， Integer.valueOf() calls, 即使是相同的值, 不一定会返回相同的Integer对象(因为它们不一定被缓存).

同样重要的是要注意，使用盒装对象的计算时间可能是使用原语的6倍左右, 以下基准测试代码可以证明这一点:

void sum() {
	Long sum = 0L; // Swap "Long" for "long" and speed dramatically improves.
	for (long i = 0; i <= Integer.MAX_VALUE; i++) {
		sum += i;
	}
}

执行上面的代码 sum declared as Long 花费6547ms，而相同的代码使用 sum declared as long (i.e.(原始类型)只花了1138ms.

问:什么是类型擦除?

向语言中添加泛型并非没有问题. Java泛型的一个特别棘手的问题是 type erasure.

作为一个例子，考虑以下代码片段:

List a = new ArrayList();
List b = new ArrayList();
return a.getClass() == b.getClass();  // returns true??!!

这应该会返回 false since a and b 不同的类类型(i.e., ArrayList vs. ArrayList), yet it returns true. Why?

这里的罪魁祸首是类型擦除. 一旦上面的代码通过了所有的Java编译器验证，编译器 erases the String and Integer 类型，以保持与旧jdk的向后兼容性. 因此，上面的代码被Java编译器转换为以下代码:

列表a = new ArrayList();
List b = new ArrayList();
return a.getClass() == b.getClass();  // returns true (understandably)

因此，在编译后的代码中， a and b 都是没有类型的吗 ArrayList 对象，而其中一个是 ArrayList 另一个是 ArrayList is lost. 尽管在实践中，与类型擦除相关的问题很少给开发人员带来问题, 这是一个需要注意的重要问题，在某些情况下可能会导致非常严重的bug.

问:请描述一下观察者模式以及如何在Java中使用它. 提供一个示例.

The Observer pattern 让对象注册，以便在观察对象发生变化时接收其发出的通知. 的内置支持 Observable class and Observer interface.

下面是一个实现Observable的简单例子:

公开类展览主义者{
	MyObservable = new MyObservable();

	公开展示者(){}

	public java.util.getObservable() {
		返回myObservable;
	}

	private void触发器(字符串条件){
		myObservable.invalidate();
		myObservable.notifyObservers(条件);
	}

	私有类MyObservable扩展java.util.Observable {
		Private void invalidate() {
			setChanged();
		}
	}
}

下面是一个相应的Observer示例:

public类Voyeur实现Observer {

	公众偷窥狂(暴露狂){
		//注册为对“暴露狂”感兴趣.
		exhibitionist.getObservable().addObserver(this);
	}
	
	@Override
	public void update(Observable o, Object arg) {
		//当observable通知它的观察者时调用.
		System.out.println(arg.toString());
	}
}

使用这种方法也有一些缺点:

1. 观察到的类必须扩展 Observable 从而阻止它扩展一个更理想的类(请参阅我们前面关于 多重继承)
2. 被观察类和观察类是紧密耦合的，可能导致 NullPointerException如果你不小心的话.

为了避免第一个问题，高级开发人员可以使用代理(委托) Observable 对象，而不是扩展它. 要解决第二个问题，可以使用松耦合的发布-订阅模式. 例如，您可以使用Google的Guava Library EventBus 对象连接到中间人的系统.

问:描述一下Java中的强引用、软引用和弱引用. 何时、为何以及如何使用它们?

在Java中，当分配一个新对象并将其引用(简单的指针)赋值给一个变量时，a strong reference is created by default; e.g.:

String name = new String(); // Strong reference

然而，Java中还有两个额外的引用优势可以显式指定: SoftReference and WeakReference. (实际上在Java中还有一种额外的引用强度，称为 PhantomReference. 这是很少使用的, though, 即使是经验丰富的Java开发人员也很可能不熟悉它, 所以我们从这里的讨论中省略了它.)

为什么需要软引用和弱引用，它们什么时候有用?

Java的垃圾收集器(GC)是一个后台进程，它定期运行以从应用程序的内存堆中释放“死”对象(没有强引用的对象). 尽管GC有时给人的印象是一个神奇的黑盒, 它其实并没有那么神奇. 有时你必须帮助它，以防止内存被填满.

More specifically, GC不会从强引用对象链中释放可强访问的对象. 这句话的意思就是, 如果GC仍然认为需要某个对象, it leaves it alone, 这通常是你想要的(i.e.(你不希望一个你需要的对象在GC启动时突然消失).

但有时强引用太过强大，这时软引用和弱引用就派上了用场. Specifically:

• SoftReference 对象根据内存需求由垃圾收集器自行清除. 软引用最常用于实现对内存敏感的缓存.
• WeakReference 对象不会阻止它们的引用对象被设置为可终结的、被终结的，然后被回收. 弱引用最常用于实现规范化映射.

Wrap up

Java作为一种占主导地位的流行语言继续生存和发展. 但是正如在软件开发中的任何语言所期望的那样, Web和移动应用开发经历了多次迭代, 它有许多并非所有开发人员都熟悉的细微差别. Moreover, Java功能不断增长的广度需要大量的经验才能完全理解. 因此，那些掌握了该语言的人可以对开发团队的生产力和系统的性能产生重大的积极影响, scalability, and stability.

本文提出的问题和技巧对于识别真正的Java大师可能是有价值的辅助工具. 我们希望您发现它们是在寻找高级Java开发人员中的少数精英时“去粗取精”的有用基础. 然而，重要的是要记住，当您寻求雇用Java程序员时，这些工具仅仅是作为将其纳入整体招聘工具箱和策略的更大上下文中的工具.

(最后一点:如果你对Java感兴趣的是android手机应用, 我们建议您阅读我们的 Android面试内幕指南 as well.)