java笔记--多敲代码四

Lambda表达式体验
格式：（形式参数）->{代码块}

package test08;

public class MyRunnable implements Runnable {
    @Override
    public void run(){
        System.out.println("多线程启动了");
    }
}

package test08;

/*
需求：启动一个线程，在控制台输出多线程启动了
 */
public class LambdaDemo {
    public static void main(String[] args) {
//        //实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

//        //匿名内部类的方式改进
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("多线程启动了");
//            }
//        }).start();

        //Lambda表达时方式改进
        new Thread(() -> {
            System.out.println("多线程启动了");
        }).start();
    }
}

Lambda使用前提，有一个接口，接口中有且仅有一个方法
lambda表达式，抽象方法无参无返回值

//package test08;
//
//public class EatableImp implements Eatable{
//    @Override
//    public void eat(){
//        System.out.println("one day");
//    }
//
//}

package test08;

public interface Eatable {
    void eat();
}

package test08;

public class EatableDemo {
    public static void main(String[] args) {
//        //在主方法中调用useEatable方法
//        EatableImp e = new EatableImp();
//        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("匿名内部类");
            }
        });

        //Lambda表达式（前提：定义一个接口，有且仅有一个方法；定义一个方法使用接口）
        useEatable(() -> {
            System.out.println("lambda表达式");
        });

    }

    //定义一个方法使用接口
    public static void useEatable(Eatable e) {
        e.eat();
    }
}

lambda表达式，抽象方法带参无返回值

package test08;

public interface Flyable {
    //定义一个接口，定义一抽象方法
    void fly(String s);
}

package test08;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("匿名内部类的方法");
            }
        });

//        //Lambda表达式
//        useFlyable((String s) -> {
//            System.out.println(s);
//            System.out.println("lambda");
//        });
        
//        //可以省略括号
//        useFlyable(s -> {
//            System.out.println(s);
//            System.out.println("lambda");
//        });
        //如果代码块只有一条，可以省略大括号和分号
        useFlyable(s ->
                System.out.println("lambda")
        );


    }

    public static void useFlyable(Flyable f) {
        f.fly("Flyable接口");
    }
}

lambda表达式，抽象方法带参带返回值

package test08;

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

package test08;

public class AddableDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y)->{
//            return x+y;
            return x-y;
//        });
        //参数的类型可以省略，需要一起省略
        useAddable(( x, y)->{
            return x+y;
        });

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

接口中的默认方法
格式：public default 返回值类型 方法名（参数列表）{}
范例：public default void show(){}
接口中默认方法的注意事项：
1、默认方法不是抽象方法，所以不强制被重写，但是可以被重写，重写的时候需要去掉default关键字
2、public可以省略，default不能省略

package test09;

public interface MyInterface {
    void show1();
    void show2();
    default void show3(){
        System.out.println("show3");
    };
}

package test09;

/**
 * 需求：定义一个接口MyInterface 里面有两个方法void show1()，void show2()
 * 定义接口的两个实现类 MyInterfaceImplOne， MyInterfaceImplTwo
 * 定义测试类，MyInterfaceDemo,在主方法中按照多态的方式创建对象
 */

public class MyInterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象
        MyInterfaceImplOne myInterfaceImplOne = new MyInterfaceImplOne();
        myInterfaceImplOne.show1();
        myInterfaceImplOne.show2();
        myInterfaceImplOne.show3();
        MyInterfaceImplTwo myInterfaceImplTwo = new MyInterfaceImplTwo();
        myInterfaceImplTwo.show1();
        myInterfaceImplTwo.show2();
    }
}

package test09;

public class MyInterfaceImplTwo implements MyInterface{
    @Override
    public void show1() {
        System.out.println("two show1");
    }

    @Override
    public void show2() {
        System.out.println("two show2");
    }
}

package test09;

public class MyInterfaceImplOne implements MyInterface{
    //重写方法，直接输方法名
    @Override
    public void show1() {
        System.out.println("one show1");
    }

    @Override
    public void show2() {
        System.out.println("one show2");
    }

}

接口中的静态方法
格式：public static 返回值类型 方法名（参数列表）{}
范例：public static void show(){}
接口中静态方法的注意事项：
静态方法只能通过接口名调用；不能通过实现类名或对象调用
public可以省略，static不能省略

package test09;

public interface Inter {
    void show();
    default void method(){
        System.out.println("Inter中的默认方法");
    };
    public static void test(){
        System.out.println("Inter中的静态方法");
    };

}

package test09;

public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show 方法");
    }
}

package test09;

/**
 * 需求：定义一个接口Inter，里面有三个方法，一个抽象方法，一个默认方法，一个静态方法，void show();default void method(){};public static void test(){}
 * 定义接口的一个实现类，InterImpl
 * 定义测试类InterDemo在主方法中，按照多态的方式创建对象并使用
 */
public class InterDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show();
        i.method();
        Inter.test();

    }
}

接口中的私有方法
范例1：public void show(){}
范例2：public static void show(){}
接口中私有方法注意事项：
1、1默认方法可以调用私有的静态方法和非静态方法
2、静态方法之能调用私有的静态方法

引用类方法

package test09;

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

package test09;

public class ConverterDemo {
    public static void main(String[] args) {
//        useConverter((String s)->{return Integer.parseInt(s)});
        useConverter(s -> Integer.parseInt(s));
        //引用类方法
        useConverter(Integer::parseInt);
    }
    private static void useConverter(Converter c){
        int i = c.convert("666");
        System.out.println(i);
    }
}

370