JavaSEDemo11Lambda表达式与枚举

刺骨的言语ヽ痛彻心扉 2021-09-25 06:40 290阅读 0赞

### 文章目录 ###

*  简介
 *  易错练习题
 *   *  练习题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(); 
    }

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

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方法

1.  写出下面代码的输出结果

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);
        }
    }