Java进阶技巧-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaoxiaoyusheng2012/article/details/53379544

1、static

在java中，static可以修饰类，但不能用static来修饰顶级类（top level class），只有内部类可以为static。

2、接口中的default关键字

参看：https://blog.youkuaiyun.com/wf13265/article/details/79363522

在java8以后，接口中可以添加使用default或者static修饰的方法，在这里我们只讨论default方法，default修饰方法只能在接口中使用，在接口种被default标记的方法为普通方法，可以直接写方法体。

注意：

实现类会继承接口中的default方法
如果一个类同时实现接口A和B,接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法
如果子类继承父类，父类中有b方法，该子类同时实现的接口中也有b方法（被default修饰），那么子类会继承父类的b方法而不是继承接口的b方法
default不能修饰类中的方法和属性

3、关于匿名内部类

参看：https://www.2cto.com/kf/201712/706377.html

3.1 匿名内部类使用作用域以外的变量，要求该变量必域以外变量时须为final修饰

原因：首先，内部类编译成功后，会产生一个class文件，该文件不同于外部类的class文件，仅仅保留对外部类的引用；

其次，编译后的内部类并不是直接调用方法来传递外部类的参数进来，而是利用自身的构造器对传入参数进行备份，这种机制决定外部类参数和内部类自身的备份属性存在任意变化的可能性，但是从程序员的角度看，它们逻辑上是指的同一个变量，因此为了保持参数的一致性，java规定传递给内部类的外部定义参数必须为final修饰。

3.2 匿名内部类可以使用构造代码块来完成初始化工作

匿名内部类没有构造器，使用构造代码块能够达到为匿名内部类创建一个构造器的效果。

4、关于lambda表达式

参看：http://www.runoob.com/java/java8-lambda-expressions.html

参看：http://www.cnblogs.com/mahang/p/3247017.html

4.1 产生背景

在lambda之前，java中想写一个方法，必须把它放到一个类里面，然后new出来对象，对象调用这个方法。这种方式从函数式编程的角度看过于死板。（使用匿名内部类，是这种场景的基本方法）。

lambda表达式是对java实现函数式编程的一个取巧方式的补充。

再jdk8引入lambda表达式的同时也引入了一个概念：函数式接口。定义是：有且仅有一个方法的接口，称为函数式接口。任何函数式接口都可以使用lambda表达式替换。

4.2 语法特性

语法格式：

(parameters) -> expression
或
(parameters) ->{ statements; }

重要特征：

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回一个数值。

4.3 使用示例

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

5、Arrays.asList 返回的list执行add、remove方法时抛出异常：java.lang.UnsupportedOperationException

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(Unknown Source)
	at java.util.AbstractList.add(Unknown Source)

原因分析：Arrays.asList返回值类型为Arrays的内部类：Arrays.ArrayList

public class Arrays {
    ...
	
	@SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

    /**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        ...
    }
	
	...
}

Arrays.ArrayList与java.util.ArrayList都继承自java.util.AbstractList，remove、add等方法AbstractList中是默认throw UnsupportedOperationException而且不作任何操作。java.util.ArrayList重新了这些方法而Arrays的内部类ArrayList没有重新，所以会抛出异常

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    ...
	public void add(int index, E element) {
		throw new UnsupportedOperationException();
	}
		
	public E remove(int index) {
		throw new UnsupportedOperationException();
	}
	...
}

解决方法：使用new ArrayList()创建的对象