JDK新特性
1. 接口组成：常量 public static final
抽象方法 public abstract
2. 默认方法：Java8
3. 静态方法：Java8
4. 私有方法：Java9
1、接口中的默认方法
1. 格式：public default 返回值类型 方法名(参数列表){ }
2. 范例：public default void Show3(){ }
注意事项：
1. 默认方法不是抽象方法，所以不能强制被重写，但是可以被重写，重写时去掉default关键字
2. public可以省略，default不能省略
/*需求：
1.定义一个接口MyInterface，里面有2个抽象方法
void show1();
void show2();
2.定义接口的2个实现类
MyInterfaceOne
MyInterfaceTwo
3。定义测试类
MyinterfaceDemo
在主方法中，按照多态的方式创建对象并使用
* */
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterface my = new MyInterfaceOne();
my.show1();
my.show2();
my.show3();
}
}
//接口
public interface MyInterface {
void show1();
void show2();
//Java8以上的新特性，默认方法
public default void show3(){
}
}
//接口的第一个实现类
public class MyInterfaceOne 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");
}
}
//接口的第二个实现类
public class MyInterfaceTwo implements MyInterface{
@Override
public void show1() {
System.out.println("Two Show1");
}
@Override
public void show2() {
System.out.println("Two Show2");
}
}
2、接口中的静态方法
注：接口中的静态方法，只能通过接口名来调用
格式：public static void show(){ }
3、接口中的私有方法
格式1：private void show(){ }
格式12：private static void method(){ }
注：默认方法中可以调用私有的默认方法、私有方法
静态方法中只能调用私有的静态方法
方法引用
1.方法引用符
/*需求：
1.定义一个接口，里面有一个抽象方法
2.定义一个测试类，测试类中有2个方法
一个主方法，另外一个方法中，以接口作为参数进行对象传递
* */
public class PrintDemo {
public static void main(String[] args) {
//usePrinttable((String s) ->System.out.println(s));
//方法引用符：::
usePrinttable(System.out::println); //替代了上面的Lambda表达式输入方式
}
public static void usePrinttable(Print p){
p.printString("爱学习，爱java");
}
}
//接口
public interface Print {
void printString(String s);
}
2、方法引用：引用类方法
引用类方法格式：类名::静态方法 例如：Integer::parseInt
Integer类的方法：public static int parseInt(String s)将此String类型转换成int类型数据
/*需求：
* 1.定义一个接口Converter，里面定义一个抽象方法
* 2.定义一个测试类ConverterDemo: 在测试类中定义2个方法
* 一个方法是：useConverter(Converter c)
* 一个方法是主方法：在主方法中调用useConverter()方法
* */
public class ConverterDemo {
public static void main(String[] args) {
//第一种：Lambda表达式的方式
useConverter((String s) ->{
return Integer.parseInt(s);
});
//第二种：引用类方法
useConverter(Integer::parseInt);
//注：Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法做为参数
}
public static void useConverter(Converter c){
int number = c.convert("888");
System.out.println(number);
}
}
//接口
public interface Converter {
int convert(String s);
}
3、方法引用：引用对象的实例方法
1. 引用对象的方法，其实就是引用类中的成员方法
2. 格式：对象::成员方法
3. 例如：”HelloWorld”::toUpperCase
4. String类的方法：public String toUpperCase()将此方法中的String所有字符转换为大写
//测试类
/*需求：
1.定义一个类PrintStrin，里面定义一个方法
public void printUpper(String s){ }把字符串参数变成大写的数据，然后在控制台输出
2.定义一个接口Printer，里面定义一个抽象方法void printUpperCase(String s);
3.定义一个测试类，在测试类中簿2个方法
一个方法是：usePrinter(Printer p)
一个方法是主方法，在主方法中调用usePrinter(Printer p)方法
*
* */
public class PrintDemo {
public static void main(String[] args) {
//第一种：Lambda表达式的方式
usePrinter((String s)->{
String result = s.toUpperCase();
System.out.println(result);
});
//第二种：引用对象的实例方法
PrintString ps = new PrintString();
usePrinter(ps::printUpper);
//注：Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法做为参数
}
public static void usePrinter(Printer p){
p.printUpperCase("HelloWorld");
}
}
//普通类
public class PrintString {
public void printUpper(String s){
String result = s.toUpperCase();
System.out.println(result);
}
}
//接口
public interface Printer {
//抽象方法
void printUpperCase(String s);
}
4、方法引用：引用类的实例方法
1、引用类的实例方法，其实就是引用类中的成中方法
2、格式：类名::成员方法
3、例如：String::substring
4、String类中的方法：public String substring(int beginIndex,int endIndex)
5、从beginIndex开始到endIndex结束，截取字符串，返回一个子串，子串的长度为endIndex - beginIndex
/*需求：
* 1、定义一个接口MyString，里面定义一个方法mySubString(String s,int x,int y)
* 2、定义一个测试类MyStringDemo，在测试类中提供2个方法
* 一个方法是useMyString(MyString ms)：
* 一个方法是主方法，在主方法中调用方法useMyString()
* */
public class MyStringDemo {
public static void main(String[] args) {
//第一种：Lambda表达式的方式
useMyString((String s,int x,int y)->{
return s.substring(x,y); // 从2索引开始截取3个到5索引
});
//第二种：引用类的实例方法
useMyString(String::substring);
//注：Lmabda表达式被类的实例方法替代的时候，
// 它的第一个参数作为调用者，
// 后面的参数全部传递给方法作为参数
}
public static void useMyString(MyString ms){
String s = ms.mySubString("HelloWorld",2,5);
System.out.println(s);
}
}
//接口
public interface MyString {
//抽象方法
String mySubString(String s,int x,int y);
}
5、 方法引用：引用构造器
1、 引用构造器其实就是引用构造方法
2、 格式：类名::new 例如：Student::new
需求：
1、 定义一个类，里面有2个成员变量(name,age)
并提供一个无参构造方法和带参构造方法，以及成员变量对应的get和set方法
2、 定义一个接口，里面定义一个抽象方法
3、 定义一个测试类，在测试类中提供两个方法
一个方法是
一个方法是主方法，在主方法中调用方法
/*需求：
1、定义一个类Student，里面有2个成员变量(name,age)
并提供一个无参构造方法和带参构造方法，以及成员变量对应的get和set方法
2、定义一个接口StudentBuilder，里面定义一个抽象方法Student build(String name,int age)
3、定义一个测试类，在测试类中提供两个方法
一个方法是:useStudentBuilder(StringBuilder sb)
一个方法是主方法，在主方法中调用useStudentBuilder()方法
* */
public class StudentDemo {
public static void main(String[] args) {
//第一种：lambda表达式的方式
useStudentBuilder((String name , int age) ->{
/*Student s = new Student(name,age);
return s;*/
return new Student(name,age);//对上面的2句简化
});
//第二种：引用构造器
useStudentBuilder(Student::new);
//注Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
}
public static void useStudentBuilder(StudentBuilder sb){
Student s = sb.build("北京",30);
System.out.println(s.getName()+","+s.getAge());
}
}
//接口
public interface StudentBuilder {
Student build(String name,int age);
}
//Student类
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;
}
}