学Java的第15天

 

 

public interface Eatable {
    void eat();
}

public class EatableImpl implements Eatable{
    @Override
    public void eat(){
        System.out.println("一天一苹果，医生远离我");
    }
}

public class demo {
    public static void main(String[] args) {
        //在主方法中调用useEatable
        Eatable e = new EatableImpl();
        useEatable(e);
        //lambda表达式
        useEatable(()->{
            System.out.println("一天一苹果，医生远离我");
        });
    }
    private static void useEatable(Eatable e){
        e.eat();

    }
}

public interface Flyable {
    void fly(String s);
}

public class demo {
    public static void main(String[] args) {
        //lambda
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }
    private static void useFlyable(Flyable f){
        f.fly("风和日丽，晴空万里");
    }
}

public interface Addable {
    int add(int x,int y);
}

public class demo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y)->{
            return x+y;
        });

    }
    private static void useAddable(Addable a){
        int sum = a.add(10, 20);
        System.out.println(sum);

    }
}

public class demo {
    public static void main(String[] args) {
        useAddable((int x,int y)->{
            return x+y;
        });
        //参数的类型可以省略
        useAddable((x,y)->{
            return x+y;//有多个参数时不能只省略一个
        });
        useFlyable((String s)->{
            System.out.println(s);
        });
        useFlyable(s->{
            System.out.println(s);//如果参数有且仅有一个，小括号可以省略
        });
        //如果代码块语句只有一条，可以省略大括号和分号
        useFlyable(s-> System.out.println(s));
        //如果有return，return也要省略
        useAddable((x,y)-> x+y);


    }
    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
        private static void useAddable(Addable a){
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

public class demo {
    public static void main(String[] args) {
        //使用lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
        useInter(()-> System.out.println("好好学习，天天向上"));
        //必须有上下文环境，才能推导出lambda对应的接口
        //根据构造方法的参数推断
        new Thread(()-> System.out.println("lambda表达式")).start();

    }
    private static void useInter(Inter i){
        i.show();
    }
}

 

 

public interface MyInterface {
    void show1();
    void show2();
    //用于不破坏现有代码的基础上进行接口升级
    default void show3(){
        System.out.println("show3");
    }
}

完整代码在heima71

public interface Inter {
    void show();
    default void method(){
        System.out.println("Inter中的默认方法执行了");
    }
    public static void test(){//public可以省略
        System.out.println("Inter中的静态方法执行了");

    }
}

完整代码在heima72

public class demo {
    public static void main(String[] args) {
        usePrintable(i-> System.out.println(i));
        //方法引用
        usePrintable(System.out::println);//方法引用会将参数i传递给方法
    }
    private static void usePrintable(Printable p){
        p.printInt(666);
    }
}

public class demo {
    public static void main(String[] args) {
        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);
    }
}

heima75

public class demo {
    public static void main(String[] args) {
        usePrinter((String s)->{
            System.out.println(s.toUpperCase());
        });
        //lambda表达式
        usePrinter(s-> System.out.println(s.toUpperCase()));
        //引用对象实例方法
        PrintString ps = new PrintString();
        usePrinter(ps:: printUpper);
        //lambda表达式被对象的实例方法代替的时候，他的形式参数全部传递给该方法作为参数

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

 

public class demo {
    public static void main(String[] args) {
        //lambda表达式
        useStudentBuilder((String name,int age)->{
            return new Student(name,age);
        });
        //优化的lambda表达式
        useStudentBuilder((name,age)->new Student(name,age));
        //引用构造器
        useStudentBuilder(Student::new);
        //lambda表达式被构造器替代的时候，他的形式参数全部传递给构造器作为参数


    }
    private static void useStudentBuilder(StudentBuilder sb){
        Student s = sb.build("林青霞",30);
        System.out.println(s.getName()+s.getAge());
    }
}