接口默认方法 && 接口静态方法 && 函数式接口

目录

接口默认方法

接口静态方法 

 函数式接口

---

 

接口默认方法

package com.tmooc.interfacedefaultandstaticmethod;

import jdk.internal.instrumentation.Logger;
import lombok.extern.slf4j.Slf4j;


/**
 * @author cuitao
 * @ className:IntefaceDefaultMethod
 * @ description:
 * 接口默认方法，可以有0个，多个，而默认方法的使用，使得接口的方法增加，不用考虑到接口实现类的大面积适配，或者不用在写钩子方法
 * 接口实现类，只需要去选择性的重写接口中的默认方法，包括新增的默认方法即可
 *
 * @ create 2021-02-27 10:45
 **/


public class IntefaceDefaultMethod {

//
//    public static void main(String[] args) {
//
//
//        IAimpl iAimpl = new IAimpl();
//        //调用接口实现类中重写接口后的方法
//        iAimpl.defaultmethod1();
//    }
}

/**
 * 接口中定义默认方法，子类可选择性的重写
 */
interface IA {
    default void defaultmethod1() {
        System.out.println("接口中有了默认方法，子类可选择性重写");
    }

    default void defaultMethod2() {
    }

    //抽象方法
    void abstractMethod();
}

/**
 * 接口实现类，可以不重写，接口默认方法，可以重写一部分接口默认方法，但是必须实现口的抽象方法
 */
class IAimpl implements IA {
    //实现接口的抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("实现接口中的抽象方法");
    }

    //选择性的重写接口的默认方法
    @Override
    public void defaultMethod2() {
        System.out.println("选择性的从写接口默认方法");
    }

    //重写的接口方法，可以选择是调用接口的默认方法，还是重写该方法
    public void defaultmethod1() {
        //调用接口的原方法
        IA.super.defaultmethod1();
        //重写接口的该方法
        System.out.println("重写接口的默认方法");
    }
}

package com.tmooc.interfacedefaultandstaticmethod;

import jdk.internal.instrumentation.Logger;
import lombok.extern.slf4j.Slf4j;


/**
 * @author cuitao
 * @ className:IntefaceDefaultMethod
 * @ description:
 * 接口默认方法，可以有0个，多个，而默认方法的使用，使得接口的方法增加，不用考虑到接口实现类的大面积适配，或者不用在写钩子方法
 * 接口实现类，只需要去选择性的重写接口中的默认方法，包括新增的默认方法即可
 *
 * @ create 2021-02-27 10:45
 **/


public class IntefaceDefaultMethod {

//
//    public static void main(String[] args) {
//
//
//        IAimpl iAimpl = new IAimpl();
//        //调用接口实现类中重写接口后的方法
//        iAimpl.defaultmethod1();
//    }
}

/**
 * 接口中定义默认方法，子类可选择性的重写
 */
interface IA {
    default void defaultmethod1() {
        System.out.println("接口中有了默认方法，子类可选择性重写");
    }

    default void defaultMethod2() {
    }

    //抽象方法
    void abstractMethod();
}

/**
 * 接口实现类，可以不重写，接口默认方法，可以重写一部分接口默认方法，但是必须实现口的抽象方法
 */
class IAimpl implements IA {
    //实现接口的抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("实现接口中的抽象方法");
    }

    //选择性的重写接口的默认方法
    @Override
    public void defaultMethod2() {
        System.out.println("选择性的从写接口默认方法");
    }

    //重写的接口方法，可以选择是调用接口的默认方法，还是重写该方法
    public void defaultmethod1() {
        //调用接口的原方法
        IA.super.defaultmethod1();
        //重写接口的该方法
        System.out.println("重写接口的默认方法");
    }
}

 

package com.tmooc.interfacedefaultandstaticmethod;

/**
 * @author cuitao
 * @ className:IntefaceDefaultMethod
 * @ description:
 * 接口默认方法，可以有0个，多个，而默认方法的使用，使得接口的方法增加，不用考虑到接口实现类的大面积适配，或者不用在写钩子方法
 * 接口实现类，只需要去选择性的重写接口中的默认方法，包括新增的默认方法即可
 *
 * @ create 2021-02-27 10:45
 **/


public class IntefaceDefaultMethod {

//
//    public static void main(String[] args) {
//
//
//        IAimpl iAimpl = new IAimpl();
//        //调用接口实现类中重写接口后的方法
//        iAimpl.defaultmethod1();
//    }
}

/**
 * 接口中定义默认方法，子类可选择性的重写
 */
interface IA {
    default void defaultmethod1() {
        System.out.println("接口中有了默认方法，子类可选择性重写");
    }

    default void defaultMethod2() {
    }

    //抽象方法
    void abstractMethod();
}

/**
 * 接口实现类，可以不重写，接口默认方法，可以重写一部分接口默认方法，但是必须实现口的抽象方法
 */
class IAimpl implements IA {
    //实现接口的抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("实现接口中的抽象方法");
    }

    //选择性的重写接口的默认方法
    @Override
    public void defaultMethod2() {
        System.out.println("选择性的从写接口默认方法");
    }

    //重写的接口方法，可以选择是调用接口的默认方法，还是重写该方法
    public void defaultmethod1() {
        //调用接口的原方法
        IA.super.defaultmethod1();
        //重写接口的该方法
        System.out.println("重写接口的默认方法");
    }
}

 

接口静态方法 

package com.tmooc.interfacedefaultandstaticmethod;

/**
 * @author cuitao
 * @ className:IntefaceStaticMethod
 * @ description:接口静态方法
 * 1.方法的重写标志就是@overWrite ，如果没有这个注解，表明是相同方法名的两个独立的方法
 * 2.静态方法不能被重写
 * 3.静态方法只能用接口名||类名直接调用
 * 4.方法调用时，看的是 =左边，左边是接口，就是用接口调用，左边是接口实现类就是用接口实现类来调用
 * @ create 2021-02-27 11:22
 **/
public class IntefaceStaticMethod {
    public static void main(String[] args) {
        //调用接口静态方法
        IStatic.doPrint();
        //调用接口实现类中的方法
        IStaticImpl.doPrint();
    }
}

interface IStatic {
    //定义一个接口静态方法
    public static void doPrint() {
        System.out.println("接口静态方法");
    }
}

class IStaticImpl implements IStatic {
    //因为没有@overWrite--> 单独的一个和原先的接口方法doPrint 无关，只是恰好名字相同的方法
    //当然，该方法也不能写 @overWrite,因为凡是静态方法都不能被重写
    static void doPrint() {
        System.out.println("单独的方法");
    }
}

package com.tmooc.interfacedefaultandstaticmethod;

/**
 * @author cuitao
 * @ className:IntefaceStaticMethod
 * @ description:接口静态方法
 * 1.方法的重写标志就是@overWrite ，如果没有这个注解，表明是相同方法名的两个独立的方法
 * 2.静态方法不能被重写
 * 3.静态方法只能用接口名||类名直接调用
 * 4.方法调用时，看的是 =左边，左边是接口，就是用接口调用，左边是接口实现类就是用接口实现类来调用
 * @ create 2021-02-27 11:22
 **/
public class IntefaceStaticMethod {
    public static void main(String[] args) {
        //调用接口静态方法
        IStatic.doPrint();
        //调用接口实现类中的方法
        IStaticImpl.doPrint();
    }
}

interface IStatic {
    //定义一个接口静态方法
    public static void doPrint() {
        System.out.println("接口静态方法");
    }
}

class IStaticImpl implements IStatic {
    //因为没有@overWrite--> 单独的一个和原先的接口方法doPrint 无关，只是恰好名字相同的方法
    //当然，该方法也不能写 @overWrite,因为凡是静态方法都不能被重写
    static void doPrint() {
        System.out.println("单独的方法");
    }
}

package com.tmooc.interfacedefaultandstaticmethod;

/**
 * @author cuitao
 * @ className:IntefaceStaticMethod
 * @ description:接口静态方法
 * 1.方法的重写标志就是@overWrite ，如果没有这个注解，表明是相同方法名的两个独立的方法
 * 2.静态方法不能被重写
 * 3.静态方法只能用接口名||类名直接调用
 * 4.方法调用时，看的是 =左边，左边是接口，就是用接口调用，左边是接口实现类就是用接口实现类来调用
 * @ create 2021-02-27 11:22
 **/
public class IntefaceStaticMethod {
    public static void main(String[] args) {
        //调用接口静态方法
        IStatic.doPrint();
        //调用接口实现类中的方法
        IStaticImpl.doPrint();
    }
}

interface IStatic {
    //定义一个接口静态方法
    public static void doPrint() {
        System.out.println("接口静态方法");
    }
}

class IStaticImpl implements IStatic {
    //因为没有@overWrite--> 单独的一个和原先的接口方法doPrint 无关，只是恰好名字相同的方法
    //当然，该方法也不能写 @overWrite,因为凡是静态方法都不能被重写
    static void doPrint() {
        System.out.println("单独的方法");
    }
}

 

 函数式接口

package com.tmooc.interfacedefaultandstaticmethod;

import java.sql.SQLOutput;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author cuitao
 * @ className:FunctionIntefaceDemo
 * @ description: 函数式接口
 * 1定义：
 * 当且仅当，一个接口被@FunctionInterface注解，且接口中有且只有一个抽象方法的接口
 * 2注意：一旦被@FunctionInteface注解后，接口中有多个抽象方法就会报错
 * 3其他方法：
 * 函数时接口就中的静态方法，默认方法，
 * 4可看成函数式接口的接口：
 * 接口没有被@FunctionInterface注解，但是接口中只有一个抽象方法，这种接口也可以堪称函数式接口
 * 5存在意义：
 * 配和 lambda表达式 操作
 * 6 常见的几种函数是接口的分类
 * 6.1 消费性接口： 有入参没有返回值，如 Consumer<T>
 * 6.2 函数式接口： 有入参，入参在接口方法中计算后返回接口，如 Function<T,R>
 * 6.3 判定式样接口: 有入参，返回值是boolean 类型 如 Predicate
 * 6.4 供给式接口：  无参数，有返回值
 * @ create 2021-02-27 11:35
 **/
public class FunctionIntefaceDemo {
    public static void main(String[] args) {
        //创建函数式接口实例
        Fun fun = new Fun() {
            @Override
            public void domethod01() {
                System.out.println("函数式接口被成功调用");
            }
        };
        //调用函数式接口中唯一的抽象方法
        fun.domethod01();
        System.out.println("=======================================");
        //================================常见的集中函数式接口类型举例================================
        //消费型接口
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("消费型接口成功被调用");
        System.out.println("=======================================");
        //函数式接口举例
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        Integer result = function.apply("100");
        System.out.println(result);
        consumer.accept("函数型接口成功被调用");
        System.out.println("=======================================");
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return false;
            }
        };
        boolean res = predicate.test("测试");
        System.out.println(res);
        System.out.println("判定型接口被成功调用");
        System.out.println("=======================================");
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 0;
            }
        };
        Integer ress = supplier.get();
        System.out.println(ress);
        System.out.println("供给型接口被成功调用");
    }
}

@FunctionalInterface
interface Fun {
    //函数式接口中的唯一抽象方法
    void domethod01();

    //其他的都是一个或多个静态方法或则默认方法
    static int domethod2() {
        return 1;
    }

    default void domethod03() {
    }
}

package com.tmooc.interfacedefaultandstaticmethod;

import java.sql.SQLOutput;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author cuitao
 * @ className:FunctionIntefaceDemo
 * @ description: 函数式接口
 * 1定义：
 * 当且仅当，一个接口被@FunctionInterface注解，且接口中有且只有一个抽象方法的接口
 * 2注意：一旦被@FunctionInteface注解后，接口中有多个抽象方法就会报错
 * 3其他方法：
 * 函数时接口就中的静态方法，默认方法，
 * 4可看成函数式接口的接口：
 * 接口没有被@FunctionInterface注解，但是接口中只有一个抽象方法，这种接口也可以堪称函数式接口
 * 5存在意义：
 * 配和 lambda表达式 操作
 * 6 常见的几种函数是接口的分类
 * 6.1 消费性接口： 有入参没有返回值，如 Consumer<T>
 * 6.2 函数式接口： 有入参，入参在接口方法中计算后返回接口，如 Function<T,R>
 * 6.3 判定式样接口: 有入参，返回值是boolean 类型 如 Predicate
 * 6.4 供给式接口：  无参数，有返回值
 * @ create 2021-02-27 11:35
 **/
public class FunctionIntefaceDemo {
    public static void main(String[] args) {
        //创建函数式接口实例
        Fun fun = new Fun() {
            @Override
            public void domethod01() {
                System.out.println("函数式接口被成功调用");
            }
        };
        //调用函数式接口中唯一的抽象方法
        fun.domethod01();
        System.out.println("=======================================");
        //================================常见的集中函数式接口类型举例================================
        //消费型接口
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("消费型接口成功被调用");
        System.out.println("=======================================");
        //函数式接口举例
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        Integer result = function.apply("100");
        System.out.println(result);
        consumer.accept("函数型接口成功被调用");
        System.out.println("=======================================");
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return false;
            }
        };
        boolean res = predicate.test("测试");
        System.out.println(res);
        System.out.println("判定型接口被成功调用");
        System.out.println("=======================================");
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 0;
            }
        };
        Integer ress = supplier.get();
        System.out.println(ress);
        System.out.println("供给型接口被成功调用");
    }
}

@FunctionalInterface
interface Fun {
    //函数式接口中的唯一抽象方法
    void domethod01();

    //其他的都是一个或多个静态方法或则默认方法
    static int domethod2() {
        return 1;
    }

    default void domethod03() {
    }
}