13.JavaSE_枚举的使用_注解中的准确覆写、过期声明、压制警告、_接口定义增强使用default和static_Lambda表达式的三种情况_方法引用的四种情景_内建函数式接口的常见四种接口

一、枚举

要求定义一个表示颜色（红、绿、蓝）基类的类
语法：

enum Color{
RED,GREEN,BLUE;
}

使用enum关键字定义的枚举结构实际上是默认继承了Enum类的枚举类。

Enum类中存在两大属性：
name：枚举对象名称
ordinal：枚举对象数字下标

protected Enum(String name,int ordinal);构造方法
public final int ordinal();	取得枚举对象下标
public final String name();	取得枚举对象名称

取得所有枚举类对象
枚举类.values()

enum Color{
    RED,GREEN,BLUE;
}
public class Test0125 {
    public static void main(String[] args) {
        for (Color tmp : Color.values()) {
            System.out.println(tmp);
        }
        System.out.println(Color.BLUE.ordinal()+"="+Color.BLUE.name());
    }
}

1.枚举中定义其他结构

• 枚举的构造方法必须私有化private(枚举类是多例类，枚举类外部无法产生对象）
• 枚举中若定义其他结构，枚举对象声明必须放在枚举类的首行。

enum Color{
    RED("红"),GREEN("绿"),BLUE("蓝");
    private String title;

    private Color(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return this.title;
    }
}
public class Test0125 {
    public static void main(String[] args) {
        for (Color tmp : Color.values()) {
            System.out.println(tmp);
        }
    }
}

2.枚举类实现接口

枚举中的对象自动变为接口对象

二、注解 @

1.@Override 准确覆写

当子类覆写父类方法时，此注解检查覆写的方法是否正确声明，只有满足覆写方法要求才会编译通过，否则编译出错。

2.@Deprecated 过期声明

建议用户不使用原有的类&方法时，可以在类或方法上的@Deprecated表示在当前版本不推荐使用。

3.@SuppressWarings 压制警告

调用某些操作可能产生问题的时候会出现警告信息，但是警告信息并不是异常。

class Person<T>{
    @Deprecated
    public Person(){}
    public Person(String name){}
    @Deprecated
    public void fun(){}
}
public class Test0125{
    @SuppressWarnings({"rawtypes","unused"})
    public static void main(String[] args) {
        Person person = new Person("");
    }
}

三、JDK1.8新特性

1、接口定义增强

JDK1.8之后接口中允许出现以下两类方法：

• 使用default定义的普通方法，需要通过接口对象来调用。
• 使用static定义的静态方法，直接使用接口名调用。

interface IMessage{
    public default void fun(){//=====default====
        System.out.println("hello IMessage");
    }
    public void print();
}
class MessageImpl implements IMessage{
    @Override
    public void print() {
        System.out.println("Hello MessageImpl");
    }
}
public class Test0125{
    public static void main(String[] args) {
        IMessage message = new MessageImpl();
        message.print();
        message.fun();
    }
}

运行结果：

Hello MessageImpl
hello IMessage

interface IMessage{
    public default void fun(){//=====default====
        System.out.println("hello IMessage");
    }

    public static IMessage getInstance(){//====static====
        return new MessageImpl();
    }
    public void print();
}
class MessageImpl implements IMessage{
    @Override
    public void print() {
        System.out.println("Hello MessageImpl");
    }
}
public class Test0125{
    public static void main(String[] args) {
        IMessage message = IMessage.getInstance();
        System.out.println(message);
        message.print();
        message.fun();
    }
}

运行结果：

枚举注解.MessageImpl@4554617c
Hello MessageImpl
hello IMessage

2、Lambda表达式

使用函数式编程的前提：接口必须只有一个方法。如果存在两个以上的方法，无法使用函数式编程。

如果现在某个接口就是为了函数式编程而生的，在定义时只能存在一个方法，因此有一个新的注解@FuntionInterface，此注解会检查该接口中是否只存在一个抽象方法。存在两个以上抽象方法，编译报错。

传统面向对象开发：

interface IMessage{
    public void print();//这是一个接口，接口中的抽象方法必须由子类覆写。
}
public class Test0125{
    public static void main(String[] args) {
        IMessage message = new IMessage() {//匿名内部类
            @Override
            public void print() {//完整语法
                System.out.println("hello my world!");
            }
        };
        message.print();
    }
}

语法：
（1）方法体只有一行代码时
（方法参数）->具体的方法体实现
函数式编程：

@FunctionalInterface//只允许有一个方法
interface IMessage{
    public void print();
}
public class Test0125{
    public static void main(String[] args) {
        IMessage message = () -> System.out.println("hello my world!");//函数式编程的使用
        message.print();
    }
}

（2）当方法有返回值时，单行代码的表达式可以省略return语句。

@FunctionalInterface//只允许有一个方法
interface IMath{
    public int add(int x,int y);
}
public class Test0125{
    public static void main(String[] args) {
        IMath msg = (p1, p2) -> p1 + p2;//只有一行返回
        System.out.println(msg.add(10,20));
    }
}

（3）当方法体有多行代码时：

（方法参数）->{
	...
	...
	...
	[return 语句];
};

@FunctionalInterface//只允许有一个方法
interface IMessage{
    public void print();
}
public class Test0125{
    public static void main(String[] args) {
        IMessage message = () -> {
            System.out.println("hello my world!");//函数式编程的使用
            System.out.println("hello roman");
            System.out.println("hello lm");
        };
        message.print();
    }
}

了解：已有公司做了一套自己的函数式编程语言：Scala语言

四、方法引用—与Lambda表达式搭配使用

方法引用只是给现有方法起了个别名

1、引用类中静态方法

类名称 :: 静态方法名称

@FunctionalInterface//是一个函数式编程接口，只允许有一个方法
interface IUtil<P,R>{
    public R switchPara(P p);
}
public class Test0125{
    public static void main(String[] args) {
        IUtil<Integer,String> iu = String :: valueOf;//进行方法引用
        String str = iu.switchPara(1000);//相当于调用了String.valueOf(1000):将基本数据形态转变成字符串
        System.out.println(str.length());
    }
}

运行结果：

4

2、引用某个对象的方法

实例化对象 :: 普通方法

@FunctionalInterface//只允许有一个方法
interface IUtil<R>{
    public R switchPara();
}
public class Test0125{
    public static void main(String[] args) {
        IUtil<String> iu = "hello" ::toUpperCase;//进行方法引用。将字符串转为大写
        System.out.println(iu.switchPara());
    }
}

运行结果：

HELLO

3、调用类中普通方法

类名称 :: 普通方法名

@FunctionalInterface//只允许有一个方法
interface IUtil<R,P>{
    public R compare(P p1,P p2);
}
public class Test0125{
    public static void main(String[] args) {
        IUtil<Integer,String> iu = String ::compareTo;//compareTo 返回这两个字符串长度的差
        System.out.println(iu.compare("罗","曼"));
    }
}

运行结果：

6235

4、引用类中构造方法

类名称 :: new

class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
@FunctionalInterface
interface IUtil<R,PN,PA>{
    public R createPerson(PN p1,PA p2);
}
public class Test0125{
    public static void main(String[] args) {
        IUtil<Person,String,Integer> iu = Person :: new;
        System.out.println(iu.createPerson("lm",21));//相当于调用Person类的构造方法
    }
}

运行结果：

Person{name=‘lm’, age=21}

五、内建函数式接口

Lambda的核心在于：函数式接口。
而函数式接口的核心：只有一个方法。
java.util.function

函数式编程分为以下四种接口：

1.功能型函数式接口：public interface Function<T,R> R apply(T t);

import java.util.function.Function;
import java.util.function.IntFunction;

public class Test0125{
    public static void main(String[] args) {
        Function<Integer,String> fun = String :: valueOf;
        IntFunction<String> fun1 = String :: valueOf;
        System.out.println(fun.apply(1000));
        System.out.println(fun1.apply(100));
    }
}

运行结果：

1000
100

2.供给型函数式接口：public interface Supplier T get();

import java.util.function.Supplier;

public class Test0125 {
    public static void main(String[] args) {
        Supplier<String> sup = "hello"::toUpperCase;
        System.out.println(sup.get());
    }
}

运行结果：

HELLO

3.消费型函数式接口：public interface Consumer void accept(T t);

import java.util.function.Consumer;

public class Test0125 {
    public static void main(String[] args) {
        Consumer<String> cons = System.out :: println;
        cons.accept("哈哈");
    }
}

运行结果：

哈哈

4.断言型接口：public interface Predicate boolean test(T t);

import java.util.function.Predicate;

public class Test0125 {
    public static void main(String[] args) {
        Predicate<String> pre = "##123shdbs" :: startsWith;
        System.out.println(pre.test("##"));
    }
}

运行结果：

true

如果要进行复杂的Lambda运算，就需要使用这类函数式接口运算。