JAVA网络爬虫
HttpClient

导航

 
方法引用

方法引用

  1. 方法引用

    • 接口Printable

      package cn.xiaoge.day21.demo04;

/*
    定义一个打印的函数是接口
 */

public interface Printable {

    // 定义打印字符串的抽象方法
    public abstract void print(String s);

}

    • Demo01Printable

      package cn.xiaoge.day21.demo04;

public class Demo01Printable {

    // 定义一个方法, 参数传递Printable接口和一个字符串, 对字符串就行打印
    public static void printString(Printable p){
        p.print("哈哈");
    }


    public static void main(String[] args) {
        String name = "哈哈";
        // 调用printString方法的参数Printable是一个函数式接口, 所以传递lambda
        printString((str)->{
            System.out.println(str);
        });



        /*
            分析:
                Lambda表达式的目的, 打印参数传递的字符串
                把参数: 传递给了System.out对象, 调用out对象中的方法println对字符串进行输出
                注意:
                    1. System.out独享是已经存在的
                    2. println方法也是已经存在的
                所以我们可以使用方法引用来优化Lambda表达式
                可以使用System.out方法直接引用(调用)println方法
         */

        printString(System.out::println);



    }

}


// 运行结果
哈哈
哈哈

  2. 方法引用_通过对象名引用成员方法

    • 接口Printable

      package cn.xiaoge.day21.demo05;

/*
    定义一个打印的函数是接口
 */

public interface Printable {

    // 定义打印字符串的抽象方法
    public abstract void print(String s);

}

    • 类MethodRerObject

      package cn.xiaoge.day21.demo05;

public class MethodRerObject {

    // 定义一个成员方法, 传递字符串, 把字符串按照大写输出
    public void printUpperCase(String s) {
        System.out.println(s.toUpperCase());
    }

}

    • Demo01ObjectMethodReference

      package cn.xiaoge.day21.demo05;

/*
    通过对象名引用成员方法
    使用前提是对象名已经存在的, 成员方法也是已经存在
    就可以使用对象名来引用成员方法
 */

public class Demo01ObjectMethodReference {

    // 定义一个方法, 方法的参数传递Printable接口
    public static void printString(Printable p) {
        // 调用重写的print方法处
        p.print("hello");  // 调用抽象方法  传递"hello" 因为抽象方法需要传递参数
    }

    public static void main(String[] args) {
        // 调用printString方法, 方法的参数Printable是一个函数式接口, 所以可以传递Lambda表达式
        // 记住Lambda才是参数, (s)是看你的函数式接口定义的抽象方法有没有参数, 有参数就必须传.
        // Lambda就是重写接口里的抽象方法
        printString((s)->{
            // 创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();

            // 调用MethodRerObject对象中的成员方法printUpperCaseString, 把字符串按照大写输出
            obj.printUpperCase(s);
        });


        /*
            使用方法引用优化Lambda
            对象已经存在的MethodRerObject
            成员方法已经存在printUpperCaseString
            所以我们可以使用对象名引用成员方法
         */
        MethodRerObject obj = new MethodRerObject();
        printString(obj :: printUpperCase); // 只关注你要用什么对象  执行什么方法 并且都已存在

    }

}


// 运行结果
HELLO
HELLO

  3. 方法引用_通过类名引用静态成员

    • 接口Calcable

      package cn.xiaoge.day21.demo06;

@FunctionalInterface
public interface Calcable {

    // 定义一个抽象方法, 传递一个整数, 对整数进行绝对值计算并返回
    public abstract int calsAbs(int num);

}

    • Demo01StaticMethodReference

      package cn.xiaoge.day21.demo06;

/*
    通过类名引用静态成员方法
    类已经存在, 静态成员方法也已经存在
    就可以通过类名直接引用静态成员方法
 */

public class Demo01StaticMethodReference {

    // 定义一个方法, 方法的参数传递要计算绝对值的整数, 和函数式接口Calcable
    public static int method(int num, Calcable c) {
        return c.calsAbs(num);
    }

    public static void main(String[] args) {
        // 调用method方法, 传递计算绝对值得整数, 和Lambda表达式
        int number = method(-4, (num)->{
            // 对象进行绝对值的计算并返回结果
            return Math.abs(num);
        });

        System.out.println(number);



        /*
            使用方法引用优化Lambda
            Math类是存在的
            abs计算绝对值的静态方法也是已经存在的
            所以我们可以直接通过类名引用静态方法
        */
        System.out.println(method(-10, Math :: abs));


    }


}


// 运行结果
4
10

  4. 方法引用_通过super引用父类的成员方法

    • 接口Greetable

      package cn.xiaoge.day21.demo07;

/*
    定义见面的函数式接口
 */


/*
加上注解
接口有且仅有一个抽象方法
    允许定义静态方法
    允许定义默认方法
    允许java.lang.Object中的public方法
    该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。
         加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，
         但是加上了@FunctionInterface，那么编译器会报错
 */
@FunctionalInterface
public interface Greetable {
    // 定义一个见面的方法
    public abstract void greet();
}

    • 父类Human

      package cn.xiaoge.day21.demo07;

/*
    定义父类
 */
public class Human {

    // 定义一个sayHello的方法
    public void sayHello(){
        System.out.println("Hello 我是Human!");
    }

}

    • Man

      package cn.xiaoge.day21.demo07;

/*
    定义子类
 */

public class Man extends Human {

    // 子类重写父类sayHello方法
    @Override
    public void sayHello(){
        System.out.println("Hello 我是Man!");
    }

    // 定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        // 调用method方法, 方法的参数Greetable是一个函数式接口, 所以可以传递Lambda
        /*method(()->{
            // 创建父类Human对象
            Human h = new Human();
            // 调用父类的sayHello方法
            h.sayHello();
        });
        */
        // 因为有子父类关系, 所以存在的一个关键字super, 代表父类, 所以我们可以直接是用super调用父类的成员方法
        method(()->{
            super.sayHello();  // Hello 我是Human!
        });

        /*
            使用super引用父类的成员方法
            super是已经存在的
            父类的成员方法sayHello也是已经存在的
            所以我们可以直接使用super引用父类的成员方法
         */
        method(super :: sayHello);
    }

    public static void main(String[] args) {
        Man m = new Man();
        m.show();
    }

}


// 运行结果
Hello 我是Human!
Hello 我是Human!

  5. 方法引用_通过this引用本类的成员方法

    • 接口Richable

      package cn.xiaoge.day21.demo08;

/*
    定义一个函数是接口
 */
@FunctionalInterface
public interface Richable {
    // 定义一个想买什么就买什么的方法
    public abstract void buy();

}

    • Husband

      package cn.xiaoge.day21.demo08;

/*
    通过this引用本类的成员方法
 */

public class Husband {

    // 定义一个买房子的方法
    public void buyHouse(){
        System.out.println("北京二环内买一套四合院!");
    }

    // 定义一个结婚的方法, 参数传递Richable接口
    public void marry(Richable r) {
        r.buy();
    }

    // 定义一个非常高兴的方法
    public void soHappy(){
        // 调用结婚的方法, 方法的参数Richable是一个函数式接口, 传递Lambda表达式
        marry(()->{
            // 使用this.成员方法, 调用本类买房子的方法
            this.buyHouse();
        });

        /*
            使用方法引用优化Lambda
            this已经存在的
            本类的成员方法buyHouse也是已经存在的
            所以我们可以直接使用this引用本类的成员方法buyHouse
         */
        marry(this :: buyHouse);
    }

    public static void main(String[] args) {
        new Husband().soHappy();
    }

}


// 运行结果
北京二环内买一套四合院!
北京二环内买一套四合院!

  6. 方法引用_类构造器(构造方法)引用

    • 接口PersonBuilder

      package cn.xiaoge.day21.demo09;

/*
    定义一个创建Person对象的函数式接口
 */

@FunctionalInterface
public interface PersonBuilder {

    // 定义一个方法, 根据传递的姓名, 创建Person度夏宁返回
    public abstract Person builderPerson(String name);
}

    • 类Person

      package cn.xiaoge.day21.demo09;

public class Person {

    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

    • Demo

      package cn.xiaoge.day21.demo09;

/*
    类的构造器(构造方法)引用
 */

public class Demo {

    // 定义一个方法, 参数传递姓名和PersonBuilder接口, 方法中通过姓名创建Person对象
    public static void printName(String name, PersonBuilder pb) {
        Person p = pb.builderPerson(name);
        System.out.println(p.getName());
    }


    public static void main(String[] args) {
        // 调用printName方法, 方法的参数PersonBuilder接口是一个函数式接口, 可以传递Lambda
        printName("张三", (name)->{
            return new Person(name);
        });

        /*
            使用方法引用优化Lambda表达式
            构造方法new Person(String name) 已知
            创建对象已知 new
            就可以使用Person引用new对象
         */
        printName("李四", Person :: new);  // 使用Person类的带参构造方法, 通过传递的姓名创建对象
        
    }

}


// 运行结果
张三
李四

  7. 方法引用_数组的构造器引用

    • ArrayBuilder

      package cn.xiaoge.day21.demo10;

/*
    定义一个创建数组的函数式接口
 */
@FunctionalInterface
public interface ArrayBuilder {
    // 定义一个创建int类型数组的方法, 参数传递数组的长度, 返回创建好的int类型数组
    public abstract int[] buliderArray(int length);

}

    • Demo

      package cn.xiaoge.day21.demo10;

/*
    数组的构造器引用
 */

public class Demo {

    /*
        定义一个方法
        方法的参数传递创建数组的长度和ArrayBuilder接口
        方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
     */
    public static int[] createArray(int length, ArrayBuilder ab) {
        return ab.buliderArray(length);
    }

    public static void main(String[] args) {
        // 调用createArray方法吗传递数组的长度和Lambda表达式
        int[] array = createArray(8, (length)->{
            // 根据数组的长度, 创建数组并返回
            return new int[length];
        });
        System.out.println(array.length);

        /*
            使用方法引用优化Lambda表达式
            已知创建的就是int[]数组
            数组的长度也是已知的
            就可以使用方法引用
            int[]引用new, 根据参数穿度的长度来创建数组
         */
        int[] array2 = createArray(10, int[] :: new);
        System.out.println(array2.length);
    }

}


// 运行结果
8
10
posted on 2020-01-18 14:33  gmlgxx  阅读(27)  评论(0)    收藏  举报
 
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3