Java基础二十一：JDK新特性之接口中的默认方法、静态方法、私有方法，方法的引用之方法引用符、引用类方法、引用对象与类的实例方法、引用构造器

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;
   }
}