第八章接口与Lambda表达式（甘琳凤）

一：课前学习与自测
（1）定义一个接口使用的关键字是 interface 。
（2）接口中抽象方法的默认修饰符为 public 和 abstract 。
（3）接口中常用的默认修饰符为 public 、 static 和 final 。
（4）接口中可以包含常量和抽象方法的定义，还可以包含 静态方法和 default修饰的成员方法 。
（5）一个类实现一个接口使用的关键字是 implements 。类可同时实现多个接口吗？ 可以，一个类可以实现多个接口，一个接口可以有多个实现 。
（6）一个接口继承另一个接口使用的关键字是 extends 。接口可以多继承吗？ 可以，一个接口可以extends多个接口 。

（7）接口中定义的静态方法能被子接口或实现类继承吗？ 不能 。默认方法能被子接口或实现类继承吗？能
（8）若要使一个类的两个实例能够比较大小,这个类应该实现 Comparable 接口。
（9）如果一个接口仅包含一个抽象方法，该接口称为 函数式接口(单抽象方法接口） 。
（10）有一个Lambda表达式，(a,b)->a.compareTo(b)，它是实现哪个接口的匿名内部类的实例？ Comparable接口 。
（11）给出函数式接口Predicate所定义的抽象方法的格式

@FunctionalInterface
public interface Predicate<T>{
boolean test(T t);

（12）方法引用使用的运算符是 双冒号（：：） 。

编程题：
1、编写程序证明接口的静态方法不能被子接口继承，也不能被实现类继承。接口的默认方法可以被子接口和子类继承。
代码如下:

package ggllff;
public class TTest {
	    public static void main(String[] args) {
	        A_TestClass my_a_test = new A_TestClass();
	        my_a_test.A_method_a();
	        my_a_test.A_method_b();
//	        my_a_test.A_method_c();

	        B_TestClass my_b_test = new B_TestClass();
	        my_b_test.A_method_a();
	        my_b_test.A_method_b();
	        my_b_test.B_method_a();
	        my_b_test.B_method_b();
	    }
	    // A接口
	    public interface A {
	        // 空方法
	        void A_method_a();
	        // 默认方法
	        default void A_method_b() {
	            System.out.println("这是A接口的默认方法A_method_b");
	        }
	        // 静态方法
	        static void A_method_c() {
	            System.out.println("这是A接口的静态方法A_method_c");
	        }
	    }
	    // B接口，继承A接口
	    public interface B extends A {
	        // 空方法
	        void B_method_a();
	        // 默认方法
	        default void B_method_b() {
	            System.out.println("这是B接口的默认方法B_method_b");
	        }
	        // 静态方法
	        static void B_method_c() {
	            System.out.println("这是A接口的静态方法B_method_c");
	        }

	    }
	    // 实现A接口
	    public static class A_TestClass implements A {
	        @Override
	        public void A_method_a() {
	            System.out.println("这是继承A接口类的方法");
	        }
	    }
	    // 继承B接口类
	    public static class B_TestClass implements B {
	        @Override
	        public void A_method_a() {
	            System.out.println("这是继承B接口类的A_method_a方法");
	        }

	        @Override
	        public void B_method_a() {
	            System.out.println("这是继承B接口类的B_method_a方法");
	        }

//	        @Override
//	        public void B_method_c() {
	
//	        }
	    }
}

会出错
接口的静态方法不能被子接口继承，也不能被实现类继承。接口的默认方法可以被子接口和子类继承。

2、(1)定义一个函数式接口Calculator，它包含单一的calculate()抽象方法，另外还包含两个默认方法，定义如下：

@FunctionalInterface
public interface Calculator{
 public abstract double calculate(int a,int b);
 public default int subtract(int a, int b){
          return a –b ;
}
public default int add(int a,int b){
  return a + b;
}
}

编写程序，使用Lambda表达式实现calculate()方法，使该方法可以计算a^ 2+b^2
代码如下：

package ggllff;
@FunctionalInterface
public interface Calculator{
	    public abstract double calculate(int a,int b);
	    public default int subtract(int a, int b){
	          return a-b ;
	    }
	    public default int add(int a,int b){
	        return a + b;
	    }
	    public static int app(int a,int b) {
	    	return a*a+b*b;
	    }
	}

package ggllff;

public abstract class Lio implements Calculator {
	public static void main(String[] args) {
		 getProduct(7,5,(a,b)->a*a+b*b);
	}
	public static void getProduct(int a,int b,Calculator calculator){
		int product = Calculator.app(a,b);
        System.out.println(product);
   }
}

运行结果如下：

我个人觉得这一题的上面的方法比较好。下面是另外一种，只是有些代码不同。

package ggllff;

@FunctionalInterface
public interface Calculator{
      public abstract double calculate(int a,int b);
       public static int subtract(int a, int b){
          return a-b ;
}
public static int add(int a,int b){
  return a + b;
}
}

package ggllff;
public abstract class Animal implements Calculator{
	public static void main(String[] args) {
		getProduct(7,5);
	}
	public static void getProduct(int a,int b){
        int product = Calculator.subtract(a,b);
        int product2 = Calculator.add(a,b);
        int c=product+product2;
        int d=product2-product;
        System.out.println((c*product+d*product2)/2);}
}

运行结果还是一样的。

补充一些在Lambda表达式中的点：
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda表达式还增强了集合库。
Lambda表达式的语法
基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }

下面是Java Lambda表达式的简单例子:

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

使用 Lambda 表达式需要注意以下两点：
1:Lambda 表达式主要用来定义行内执行的方法类型接口。
2:Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。