时间：   |   分类：     |   阅读： 1538 字 ~4分钟

1. 接口

  • 常量:public static final int x=5;
  • 抽象方法:public abstract void add();

1.1. 新的默认方法

场景:

接口1,有很多类实现了接口1,这时需要给接口1添加一个方法,所有的类都需要修改

普通解决方案:

接口2继承接口1,在接口2中添加这个方法,需要这个方法的继承接口2,不需要的还是接口1.

真正解决方案:

public interface Inter1 {
  void show1();
  default void show2(){//直接贼接口中添加这个防范
    System.out.println("德玛西亚");
  }
}
public class Real implements Inter1{
  public void show1(){
    //...
  }
  //也可以重写show2,需要去掉default关键字
}

注意事项

  1. 默认方法不是抽象方法,所以不强制被重写.但是可以被重写,重写的时候去掉default关键字
  2. public可以省略,default不能省略

1.2. 新的静态方法

接口中的静态方法只能被接口调用

public interface I{
  public static void func(){
    System.out.println("静态方法");
  }
  void show();
}

public class implements I{
  void show(){
    //...
  }
}

public class Main{
  public static void main(String[] args){
    I.func();
  }
}

注意事项:

  1. 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用
  2. public可以省略,static不能省略

1.3. 新的私有方法

场景:

由于接口中可以有静态方法和默认方法.它们是可以包含一段同样的代码的.这个代码是可以被提出出来复用的.并且不需要暴露给其他其它.

public interface Inter1 {
  private static void common2(String x){
  System.out.println("this");
  }
  private void common(String x){
    System.out.println(x);
  }
  default void func1(){
    common("this is private");
  }
  default void func2(){
    common2("this is private static");
  }
}

注意事项:

  1. 默认方法可以调用私有的静态方法和非静态方法
  2. 静态方法只能调用私有的静态方法

2. 方法引用

场景:

使用Lambda时,其它地方已经写了对应的代码了,想用Lambda复用这段代码

public interface InterPrint {
  void MyPrint(String s);
}

public class Test {
  public static void main(String[] args) {
    useMyPrint(s -> System.out.println(s));

    useMyPrint(System.out::println);//方法引用
    //System.out 对象
    //println方法 参数是隐性传的.
  }
  public static void useMyPrint(InterPrint i) {
    i.MyPrint("this is sparta");
  }
}

注意事项:

  • :::该符号为引用运算符,而它所在的表达式被称为方法引用
  • 推导与省略
    • 如果使用Lambda,那么根据"可推导就是可省略"的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导
    • 如果使用方法引用,也是同样可以根据上下文进行推导
    • 方法引用是Lambda的孪生兄弟

2.1. 引用类方法

引用类方法,其实就是引用类的静态方法,如Integer::parseInt

public interface Converter {
  int convert(String s);
}

public class Test {
  public static void main(String[] args) {
    useMyPrint(s -> Integer.parseInt(s));
    useMyPrint(Integer::parseInt);//方法引用
  }

  public static void useMyPrint(Converter i) {
    int num = i.convert("100");
    System.out.println(num);
  }
}

Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数

2.2. 引用对象的实例方法

引用类中的成员方法

public interface Printer {
  void printUpperCase(String s);
}

public class PrintString {
  //把字符串参数变成大写的数据,然后在控制台输出
  public void myPrintUpper(String s) {
    String result = s.toUpperCase();
    System.out.println(result);
  }
}

public class Test {
  public static void main(String[] args) {
    usePrinter(s -> System.out.println(s.toUpperCase()));

    //引用对象的实例方法
    PrintString ps = new PrintString();
    usePrinter(ps::myPrintUpper);
  }

  private static void usePrinter(Printer p) {
    p.printUpperCase("HelloWorld");
  }
}

Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数

2.3. 引用类的实例方法

public interface MyString {
  String mySubString(String s,int x,int y);
}

public class MyStringDemo {
  public static void main(String[] args) {
  //Lambda简化写法
  useMyString((s,x,y) -> s.substring(x,y));
  //引用类的实例方法
  useMyString(String::substring);
}

private static void useMyString(MyString my) {
  String s = my.mySubString("HelloWorld", 2, 5);
  System.out.println(s);
  }
}

Lambda表达式被类的实例方法替代的时候 第一个参数作为调用者 后面的参数全部传递给该方法作为参数

2.4. 引用构造器

public class Student {
  public String name;
  public int age;

  Student(String n, int i) {
    this.name = n;
    this.age = i;
  }
}

public interface StudentBuilder {
  Student build(String name, int age);
}

public class Test {
  public static void main(String[] args) {
    useStudentBuilder((name, age) -> new Student(name, age));
    useStudentBuilder(Student::new);//引用构造器
  }

  private static void useStudentBuilder(StudentBuilder sb) {
    Student s = sb.build("马前卒", 40);
    System.out.println(s.name + s.age);
  }
}

Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数

0%