Java lambda 查询条件isnull

转载

mob64ca14031c97 2024-10-29 18:37:05

文章标签 lambda 多态接口 java System 文章分类 Java 后端开发

文章目录

简介
易错练习题

练习题1 代码改错
练习题2

Lambda

Lambda表达式如果方法只有一个参数可以不写数据类型和( )
Lambda表达式可以不写数据类型，会自动寻找
Lambda表达式没有返回值的方法
成员匿名内部类用Lambda省略
函数类接口

::操作符绑定静态成员构造三种方法

静态
成员
构造

枚举

switch语句使用枚举
枚举类的常用方法

values()
valueOf和compareTo()
ordinal()

枚举的构造方法枚举实现接口枚举中声明抽象方法
枚举中重写父类方法，例如toString方法

简介

本文是2021/04/05整理的笔记
赘述可能有点多，还请各位朋友耐心阅读
本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进

易错练习题

练习题1 代码改错

interface IA{ 
void m1(); 
int a = 100; 
} 
class MyClass implements IA{ 
void m1(){} 
} 
public class TestInterface{ 
public static void main(String args[]){ 
IA ia = new MyClass(); 
ia.m1(); 
System.out.println(IA.a); 
}
}

答案:
将Myclass中的void m1()改为public void m1 (）
解析:
子类中的方法权限要大于等于父类的方法权限,返回值类型小于等于父类的返回值类型。
接口中方法默认为public static
实现类方法访问权限大于等于接口的，所以要public。

练习题2

interface IA{ 
void ma(); 
} 
interface IB extends IA{ 
void mb(); 
} 
interface IC{ 
void mc(); 
} 
interface ID extends IB, IC{ 
void md(); 
}

如果有一个类 ClassE 实现 ID 接口，如果不希望 ClassE 是抽象的，则需要
实现哪些方法？
答案:
需要重写所有的方法,即ma() mb() mc() md()
解析:
实现类实现接口，实现类如果不是抽象类，必须覆盖重写接口的所有抽象方法。
把下面的代码补充完整

public class TestClassE{ 
public static void main(String args[]){ 
IC ic = new ClassE(); 
//调用 ma 方法
______________ 
//调用 mb 方法
______________ 
//调用 mc 方法
______________ 
//调用 md 方法
______________ 
} 
}

答案:
//向下转型还原为ID类对象，即可调用所有方法
ID id = (ID) ic;
id.ma()
id.mb()
ic.mc()
id.md()
解析:
IC ic = new ClassE();
声明父类IC类引用，指向子类ClassE类对象。
IC类对象无法调用IA IB 和ID的方法。
需要向下转型还原为ID类或ClassE类，即可调用ma mb md方法

写出下面代码的输出结果

public class TestClassE{ 
public static void main(String args[]){ 
IC ic = new ClassE(); 
System.out.println(ic instanceof IA); 
System.out.println(ic instanceof IB); 
System.out.println(ic instanceof IC); 
System.out.println(ic instanceof ID); 
System.out.println(ic instanceof ClassE); 
} 
}

答案
true
true
true
true
true
解析:
instanceof 关键字看的是运行期类型，本题中为ClassE，ClassE是IA IB IC ID 的子类对象，是ClassE类的本类对象。

Lambda

Lambda表达式如果方法只有一个参数可以不写数据类型和( )

public class Test1 {
    public static void main(String[] args) {
     /*   原式
     A a = new A() {
            @Override
            public int m1(int x) {
                return 2 * x;
            }
        };*/

/*      第一次化简
 A a = (int x) -> 2*x; */
        A a = x -> 2*x;   //第二次化简
        int i = a.m1(5);
        System.out.println("i=" +i);
    }
}
interface A{
    int m1(int x);
}

Lambda表达式可以不写数据类型，会自动寻找

public class Test1 {
    public static void main(String[] args) {
          /*  匿名内部类写法
          A a = new A() {
               @Override
               public int m1(int x, int y) {
                   return  x - y;
               }
           };*/
      //Lambda表达式写法
        A a = (x,y) -> x+y;
        int i = a.m1(200, 100);
        System.out.println("i = " + i);
    }
}
interface  A{
    int m1(int x,int y);
}

Lambda表达式没有返回值的方法

public class Test1 {
    public static void main(String[] args) {
        /*A a = new A() {
            @Override
            public void m1(String s) {
                System.out.println("s = " + s);
            }
        };*/
        A a = s -> System.out.println("s = " + s);
        a.m1("Hello World");
    }
}
interface A{
    void m1(String s);
}

成员匿名内部类用Lambda省略

public class Test1 {
    private String name = "张三";
    private  int age = 20;
 /*  成员匿名内部类写法
  B b= new B() {
        @Override
        public void show() {
            System.out.println("name = " + name);
            System.out.println("age = " + age);
        }
    };*/
     //Lambda写法
    B b = () -> System.out.println("name = " + name + " age = "+age);

 public static void main(String[] args) {
     Test1 test1 = new Test1();
     test1.b.show();
 }
}
@FunctionalInterface
interface B{
   void show();

    default void method() {

    }
}

函数类接口

只有一个抽象方法的接口叫做函数类接口
@FunctionalInterface 检查是否是函数式接口
Lambda无法访问默认方法
Lambda表达式无法改变值

public class Test {
    private final int age = 0;

    public static void main(String[] args) {
        int age = 20;
        /*A a = new A() {
            @Override
            public void test() {
                System.out.println("age = " + age);
                m1();
            }
        };*/
        A a = () -> System.out.println("age = " + age);
            // m1();
        ;
        a.test();
    }
}
@FunctionalInterface
interface  A{
    void test();
    default  void m1(){
        System.out.println("A.m1([])方法");
    }
}

::操作符绑定静态成员构造三种方法

静态

public class Test1 {
    public static void main(String[] args) {
        //接口A绑定Integer里的静态方法valueOf
        A a = Integer::valueOf;
        Integer method = a.method("1234567");
        System.out.println("method = " + method);
    }
}
interface  A{
    Integer method(String s);
}

成员

public class Test1 {
    public void show(){
        System.out.println("Hello World");
    }
    public static void main(String[] args) {
        //绑定Test1的成员方法show
        Test1 test1 = new Test1();
        A a = test1::show;
        a.method1();
    }
}
interface  A{
void method1();
}

构造

public class Person {
    private String firstName;
    private String lastName;
    //无参构造
    public Person() {
    }
    //有参构造
    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                '}';
    }

    public static void main(String[] args) {
        //接口绑定构造方法
       A a = Person::new;
        Person abc = a.abc("彼得", "帕克");
        System.out.println(abc);
    }
}
interface  A{
        Person abc(String firstName, String lastName);
}

枚举

switch语句使用枚举

public class Test1 {
    Signal color = Signal.RED;
    public  void change(){
        switch (color){
            //如果是红灯，变绿灯
            case RED:color = Signal.GREEN;break;
            //如果是绿灯，变黄灯
            case GREEN: color = Signal.YELLO;break;
            //如果是黄灯，变红灯
            case YELLO: color = Signal.RED;break;
            default: break;
        }
    }
    public static void main(String[] args) {
        //创建测试类对象
        Test1 test1 = new Test1();
        test1.change();
        System.out.println("test1.color = " + test1.color);
    }
}
enum Signal{
    //绿灯 黄灯 红灯
    GREEN,YELLO,RED
}

枚举类的常用方法

values()

public class Test1 {
    public static void main(String[] args) {
        //调用values方法,返回值类型为数组，创建一个枚举类型的数组接收
        Signal[] values = Signal.values();
        //增强for循环遍历输出
        for (Signal value : values) {
            System.out.println("枚举变量:" + value);
        }
    }
}
enum Signal{
    //红灯 绿灯 黄灯
    RED,GREEN,YELLO
}

valueOf和compareTo()

public class Test1 {
    public static void main(String[] args) {
        Sex sex = Sex.valueOf("MALE");
        System.out.println("sex = " + sex);
        Sex[] values = Sex.values();
        for (Sex value : values) {
            //比较
            System.out.println("compare = "+ sex.compareTo(value));
        }
    }
}
enum Sex{
    //男生 女生
    MALE,FEMALE
        }

ordinal()

枚举的构造方法枚举实现接口枚举中声明抽象方法

public class Test1 {
    public static void main(String[] args) {
         Color color = Color.GREEN;
         Color color2 = Color.BLACK;
        System.out.println("color2.getColor = " + color2.getColor());
        System.out.println("color.getColor = " + color.getColor());
        color.m1();
    }
}
//声明枚举
enum Color implements A{
    //红绿蓝黑
     RED{
        @Override
        void m1() {
            System.out.println("RED.m1([])方法");
        }

        @Override
        public String getColor() {
            return "红色";
        }
    },GREEN{
        @Override
        void m1() {
            System.out.println("GREEN.m1([])方法");
        }

        @Override
        public String getColor() {
            return "绿色";
        }

    },BLUE{
        @Override
        void m1() {
            System.out.println("BLUE.m1([])方法");
        }

        @Override
        public String getColor() {
            return "蓝色";
        }

    },BLACK{
        @Override
        void m1() {
            System.out.println("BLACK.m1([])方法");
        }

        @Override
        public String getColor() {
            return "黑色";
        }

    };
       private String name;

    Color() {
        System.out.println("Color.Color([])方法");
    }

    Color(String name) {
        this.name = name;
        System.out.println("Color.Color([name])方法");
    }

    public String getName() {
        return name;
    }

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

}
interface  A{
    String getColor();
}

枚举中重写父类方法，例如toString方法

public class Test1 {
    public enum Color{
        //红色,黄色,绿色
        RED("红色",1),YELLOW("黄色",2),GREEN("绿色",3);
        private String name;
        private  int index;
        //无参构造方法
        Color() {
        }
        //有参构造方法
        Color(String name, int index) {
            this.name = name;
            this.index = index;
        }
        //重写toString方法
        @Override
        public String toString() {
            return this.index+":"+this.name;
        }

    }

    public static void main(String[] args) {
        System.out.println(Color.RED);
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。