Java-引用类方法、对象的实例方法、类的实例方法、构造器的练习

ConverterDemo：
package com.fluffysponge;

/*
*   引用类方法练习：
*       1.定义一个接口(Converter)，里面定义一个抽象方法：
*           int convert(String s);
*       2.定义一个测试类(ConverterDemo)，在测试类中提供两个方法
*           一个方法是：userConverter(Converter c)
*           一个方法是主方法，在主方法中调用useConverter方法
* */
public class ConverterDemo {
    public static void main(String[] args) {
        //在主方法中调用useConverter方法
//        useConverter((String s) -> {
//            return Integer.parseInt(s);
//        });

        useConverter(s ->
            Integer.parseInt(s));

        //引用类方法
        useConverter(Integer::parseInt);

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

    private static void useConverter(Converter c){
        int number = c.convert("666");
        System.out.println(number);
    }
}

Converter：
package com.fluffysponge;

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

PrinterDemo：
package com.fluffysponge;
/*
 *   引用对象的实例方法练习：
 *       1.定义一个类(PrintString)，里面定义一个方法
 *          public void printUpper(String s):把字符串参数变成大写的数据，然后在控制台输出
 *       2.定义一个接口(Printer)，里面定义一个抽象方法：
 *           void printUpperCase(String s);
 *       3.定义一个测试类(PrinterDemo)，在测试类中提供两个方法
 *           一个方法是：userPrinter(Printer p)
 *           一个方法是主方法，在主方法中调用usePrinter方法
 * */
public class PrinterDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrinter方法
//        usePrinter((String s)->{
////            String result = s.toUpperCase();
////            System.out.println(result);
//            System.out.println(s.toUpperCase());
//        });
        usePrinter(s -> System.out.println(s.toUpperCase()));

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

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

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

PrintString：
package com.fluffysponge;

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

Printer：
package com.fluffysponge;

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

MyStringDemo：
package com.fluffysponge;
/*
 *   引用类的实例方法练习：
 *       1.定义一个接口(MyString)，里面定义一个抽象方法：
 *           String mySubString(String s,int x,int y);
 *       2.定义一个测试类(MyStringDemo)，在测试类中提供两个方法
 *           一个方法是：userMyString(MyString my)
 *           一个方法是主方法，在主方法中调用userMyString方法
 * */
public class MyStringDemo {
    public static void main(String[] args) {
        //在主方法中调用userMyString方法
//        userMyString((String s,int x,int y) ->{
//            return s.substring(x,y);
//        });

        userMyString((s,x,y) -> s.substring(x,y));

        //引用类的实例方法
        userMyString(String::substring);

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

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


MyString：
package com.fluffysponge;

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

StudentDemo：
package com.fluffysponge;

/*
 *   引用构造器练习：
 *       1.定义一个类(Student),里面有两个成员变量(name,age)
 *          并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
 *       1.定义一个接口(StudentBuilder)，里面定义一个抽象方法：
 *           Student build(String name,int age);
 *       2.定义一个测试类(StudentxDemo)，在测试类中提供两个方法
 *           一个方法是：userStudentBuilder(StudentBuilder s)
 *           一个方法是主方法，在主方法中调用userStudentBuilder方法
 * */
public class StudentDemo {
    public static void main(String[] args) {
        //一个方法是主方法，在主方法中调用userStudentBuilder方法
//        userStudentBuilder((String name,int age) -> {
////            Student s = new Student(name,age);
////            return s;
//              return new Student(name,age);
//        });

        userStudentBuilder((name,age) -> new Student(name,age));

        //引用构造器
        userStudentBuilder(Student::new);

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

    private static void userStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("张三", 30);
        System.out.println(s.getName() + "," + s.getAge());
    }
}


Student：
package com.fluffysponge;

public class Student {
    //有两个成员变量(name,age)
    //并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
    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 com.fluffysponge;

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