接口组成更新
接口组成更新概述
接口的组成
-
常量: public static final
-
抽象方法: public abstract
-
默认方法(java8中新增)
-
静态方法(java8中新增)
-
私有方法(java9中新增)
接口的默认方法
定义格式: default void 方法名() {};
MyInterface
package interfaceJava.interfaceUpdate.defaultMethod;
public interface MyInterface {
void show1();
void show2();
// void show3();
/*
public default void show3() {
System.out.println("show3");
}
*/
default void show3() {
System.out.println("show3");
}
}
MyInterfaceImplOne
package interfaceJava.interfaceUpdate.defaultMethod;
public class MyInterfaceImplOne implements MyInterface {
@Override
public void show1() {
System.out.println("One show1");
}
@Override
public void show2() {
System.out.println("One show2");
}
@Override
public void show3() {
System.out.println("One show3");
}
}
MyInterfaceImplTwo
package interfaceJava.interfaceUpdate.defaultMethod;
public class MyInterfaceImplTwo implements MyInterface {
@Override
public void show1() {
System.out.println("Two show1");
}
@Override
public void show2() {
System.out.println("Two show2");
}
}
MyInterfaceDemo
package interfaceJava.interfaceUpdate.defaultMethod;
public class MyInterfaceDemo {
public static void main(String[] args) {
//使用多台方式创建对象并使用
MyInterface my = new MyInterfaceImplOne();
my.show1();
my.show2();
my.show3();
}
}
接口中静态方法
接口中静态方法定义格式
-
格式: public static 返回值类型方法名(参数列表) {};
-
范例: public static void show() {};
Inter
package interfaceJava.interfaceUpdate.staticMethod;
public interface Inter {
void show();
default void method(){
System.out.println("Inter 中默认方法");
}
// public可以省略掉
static void test() {
System.out.println("Inter 中静态方法执行了");
}
}
InterImpl
package interfaceJava.interfaceUpdate.staticMethod;
public class InterImpl implements Inter, Flyable {
@Override
public void show() {
System.out.println("show 方法执行");
}
}
Flyable
package interfaceJava.interfaceUpdate.staticMethod;
public interface Flyable {
public static void test() {
System.out.println("Flyable 静态方法test执行");
}
}
InterDemo
package interfaceJava.interfaceUpdate.staticMethod;
public class InterDemo {
public static void main(String[] args) {
Inter i = new InterImpl();
i.show();
i.method();
// i.test(); // 静态方法只能被接口调用
Inter.test();
// InterImpl.test(); // 实现类也不能
Flyable.test();
// 如果能够通过实现类调用,当实现两个接口中有重复的方法名时, 不知道该调用哪一个, 所以不能用实现类调用
}
}
接口中私有方法
java9中新增了带方法体的私有方法. 当两个默认方法或者静态方法包含一段相同的代码实现时, 程序必然考虑将这段实现代码抽取成一个共性方法, 而这个共性方法是不需要让别人使用的, 因此用私有隐藏起来.
格式一:
- private 返回值类型 方法名(参数列表) {}
- private void show() {}
格式二:
- private static 返回值类型 方法名(参数列表) {}
- private static void method() {}
Inter
package interfaceJava.interfaceUpdate.privateMethod;
public interface Inter {
default void show1() {
System.out.println("show1 开始");
// System.out.println("1");
// System.out.println("2");
// System.out.println("3");
// show();
method();
System.out.println("show1 结束");
}
default void show2() {
System.out.println("show2 开始");
// System.out.println("1");
// System.out.println("2");
// System.out.println("3");
// show();
method();
System.out.println("show2 结束");
}
static void method1(){
System.out.println("method1 开始");
// System.out.println("1");
// System.out.println("2");
// System.out.println("3");
method();
System.out.println("method1 结束");
}
static void method2() {
System.out.println("method2 开始");
// System.out.println("1");
// System.out.println("2");
// System.out.println("3");
method();
System.out.println("method2 结束");
}
private void show() {
System.out.println("1");
System.out.println("2");
System.out.println("3");
}
private static void method() {
System.out.println("1");
System.out.println("2");
System.out.println("3");
}
}
InterImpl
package interfaceJava.interfaceUpdate.privateMethod;
public class InterImpl implements Inter {
}
InterDemo
package interfaceJava.interfaceUpdate.privateMethod;
public class InterDemo {
public static void main(String[] args) {
// 按照多态的方式创建类
Inter i = new InterImpl();
i.show1();
System.out.println("--------");
i.show2();
System.out.println("--------");
Inter.method1();
System.out.println("--------");
Inter.method2();
}
}
注意:
- 默认方法可以调用私有的静态方法和非静态方法
- 静态方法只能调用私有的静态方法
方法引用
如果lambda中指定的操作方案, 已经有地方存在相同方案, 就没有必要重写逻辑, 这就是方法引用, 用来使用已经存在的方案
方法引用符
"::"该符号为引用运算符, 而它所在的表达式被称为方法引用
回顾一下我们在体验方法引用中的代码
- lambda表达式: usePrintable(s -> System.out.println(s));
- 拿到参数s后, 通过lambda表达式, 传递给System.out.println方法
- 方法引用: usePrintable(System.out::println);
推导和省略
-
如果使用lambda, 根据"可推导就是可省略"原则, 无需指定参数类型, 也无需指定重载形式, 他们都将被自动推导
-
如果使用方法引用, 也是同样可以根据上下文进行推导
-
方法引用是lambda的孪生兄弟
Printable
package methodQuote;
public interface Printable {
void printString(String s);
}
PrintableDemo
package methodQuote;
public class PrintableDemo {
public static void main(String[] args) {
// 调用usePrintable
/*
usePrintable((String s) -> {
System.out.println(s);
});
*/
usePrintable(s -> System.out.println(s));
// System.out.println("热爱生活");
// 方法引用符: ::
usePrintable(System.out::println); // 没有参数, 直接引用前面的参数
// 可推导的就可以省略
}
private static void usePrintable(Printable p) {
p.printString("热爱生活");
}
}
lambda表达式支持的方法引用
常见的引用方式
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器
引用类方法
就是引用类的静态方法
- 格式: 类名::静态方法
- 范例: Integer::parseInt
Convert
package methodQuote.staticQuote;
public interface Converter {
int convert(String s);
}
ConverterDemo
package methodQuote.staticQuote;
public class ConverterDemo {
public static void main(String[] args) {
// 调用convert方法
useConverter(s -> Integer.parseInt(s));
// 引用类方法
useConverter(Integer::parseInt);
// 注意: lambda表达式被类方法代替的时候, 它的形式参数全部传递给静态方法做为参数
}
private static void useConverter(Converter c) {
int number = c.convert("666");
System.out.println(number);
}
}
引用对象的实例方法
引用类中的成员方法
-
格式: 对象::成员方法
-
范例: "HelloWrold"::toUpperCase
Printer
package methodQuote.methodQuote;
public interface Printer {
void printUpperCase(String s);
}
PrintString
package methodQuote.methodQuote;
public class PrintString {
public void printUpper(String s) {
String result = s.toUpperCase();
System.out.println(result);
}
}
PrinterDemo
package methodQuote.methodQuote;
public class PrinterDemo {
public static void main(String[] args) {
// 调用usePrinter方法
usePrinter((String s) -> {
System.out.println(s.toUpperCase());
});
// 引用对象的实例方法
PrintString ps = new PrintString();
usePrinter(ps::printUpper);
// lambda表达式被对象的实例方法替代的时候, 它的形式参数全部传递给该方法作为参数
}
private static void usePrinter(Printer p) {
p.printUpperCase("HelloWorld");
}
}
引用类的实例方法
引用类中的成员方法
- 格式: 类名::成员方法
- 范例: String::substring
MyString
package methodQuote.classQuote;
public interface MyString {
String mySubString(String s, int x, int y);
}
MyStringDemo
package methodQuote.classQuote;
public class MyStringDemo {
public static void main(String[] args) {
// 调用useMyString方法
/*
useMyString((String s, int x, int y) -> {
return s.substring(x,y);
});
*/
useMyString((s, x, y) -> s.substring(x, y));
// 引用类中的实例方法
useMyString(String::substring);
// lambda表达式被类的实例方法替代的时候, 它的第一个参数作为调用者, 后面的参数全部传递给该方法作为参数
}
private static void useMyString(MyString my) {
String s = my.mySubString("HelloWorld", 2, 5);
System.out.println(s);
}
}
引用构造器
引用构造方法
- 格式: 类名::new
- 范例: Student::new
Student
package methodQuote.constructQuote;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
StudentBuilder
package methodQuote.constructQuote;
public interface StudentBuilder {
Student build(String name, int age);
}
StudentDemo
package methodQuote.constructQuote;
public class StudentDemo {
public static void main(String[] args) {
// 调用useStudentBuilder
/*
useStudentBuilder((String name, int age) -> {
return new Student(name, age);
});
*/
useStudentBuilder((name, age) -> new Student(name, age));
// 方法引用
useStudentBuilder(Student::new);
// lambda表达式被构造器替代的时候, 它的形式参数全部传递给构造器作为参数
}
private static void useStudentBuilder(StudentBuilder sb) {
Student s = sb.build("林青霞", 30);
System.out.println(s.getName() + "," + s.getAge());
}
}