Java中的枚举、注解、接口定义加强、Lambda表达式、方法引用

最新推荐文章于 2024-05-11 20:53:57 发布
最新推荐文章于 2024-05-11 20:53:57 发布
阅读量512 收藏
点赞数 2
分类专栏： Java Java学习 文章标签： 枚举 注解 接口定义加强 Lambda表达式 方法引用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao_miao/article/details/89040021
版权

文章目录

1.枚举

假设我们定义一个颜色类:

//三原色 典型的多例模式
class Color{
    private String title;
    private Color(String title){
        this.title = title;
    }
    public static final int RED_FLAG = 1;
    public static final int GREEN_FLAG = 5;
    public static final int BLUE_FLAG = 10;

    private static final Color RED = new Color("红");
    private static final Color GREEN = new Color("绿");
    private static final Color BLUE = new Color("蓝");
    public static  Color getInstance(int flag){
        switch (flag){
            case RED_FLAG:return RED;
            case GREEN_FLAG:return GREEN;
            case BLUE_FLAG:return BLUE;
            default:return null;
        }
    }

    @Override
    public String toString() {
        return this.title;
    }
}
public class Test{
    public static void main(String[] args) {
        Color color = Color.getInstance(Color.RED_FLAG);
        System.out.println(color);
    }
}

使用多例模式这种方法，扩展会非常的麻烦，JDK1.5之后产生了枚举类，使用枚举类修改以上代码：

enum Color{
    RED,BLUE,GREEN
}
public class Test{
    public static void main(String[] args) {
        Color color = Color.RED;
        System.out.println(color);
    }
}

1.1 语法

enum 类名{ 
    //属性通常大写
    属性1,属性2,属性3
}
  1. 使用enum关键字定义的枚举结构实际上是默认继承了Enum枚举类(java.long.Enum)
  2. Enum中存在两大属性
    name:枚举对象名称
    ordinal:枚举对象的数字下标
//枚举类.name() 取得枚举对象名称
public final String name() {return name; }
//取得枚举对象下标
public final int ordinal() {return ordinal;}

//枚举类.value()取得所有枚举类的对象
enum Color{
    RED,BLUE,GREEN
}
public class Test{
    public static void main(String[] args) {
        for(Color color : Color.values()){
            System.out.println(color);
        }
    }
}

在这里插入图片描述

1.2 enum和Enum的区别

enum是一个关键字，使用enum定义的枚举类本质上就相当于一个类继承了Enum这个抽象类而已。

1.3 枚举中定义其他结构

枚举类和普通类有很多相似的地方、可以定义成员、静态属性、方法

  1. 枚举中若定义构造方法，构造方法必须使用private封装（枚举类是多例类，枚举类外部不可以产生对象）
  2. 枚举类中若定义其他结构，枚举对象声明必须放在枚举类的首行
  3. 枚举可以实现接口
interface IColor{
    String color();
}
enum Color implements IColor{
    RED("红"),BLUE("蓝"),GREEN("绿");
    private String title;

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

    @Override
    public String color() {
        return this.name();
    }
}
public class Test{
    public static void main(String[] args) {
        for(Color color : Color.values()){
            System.out.println(color);
        }
        //枚举类向上转型成接口
        IColor color = Color.RED;
        System.out.println(color.color());
    }
}

1.4 枚举类的应用与总结

/**
 4. 枚举类
 5. 1.枚举类型不能被用户实例化(用户不能new)
 6. 2.定义枚举对象(通常名字是大写)
 7. 3.使用枚举对象通过  枚举类.属性
 8. 4.枚举类是典型的多例设计、每个枚举对象有且只有一个
 9. 5.列举所有枚举对象 枚举类.values()
 10. 6.枚举对象名称 枚举对象.name()
 11. 7.通过枚举类的valueOf方法获取枚举对象(枚举常量)，name必须要存在否则会有非法参数异常
 12. 8.枚举类和普通类有很多相似的地方、可以定义成员-静态属性-方法
 13. 9.枚举对象有一个方法ordinal可以表示一个下标，从0开始依次加1 在开发中避免使用，它的值基于枚举对象定义的顺序
 14. 10.枚举类继承自java.lang.Enum,不能继承其他类
 15. 11.枚举类的构造方法是私有的,外部不可以new
 16. 12.枚举类可以实现接口
 */
enum Color{
    RED("#dd0000"),GREEN("#00dd00"),BLUE("#0000dd");
    private String rgb;
    Color(String rgb) {
        this.rgb = rgb;
    }
    //为什么不提供set方法 枚举对象全局唯一 有且只有一个
    //要是有set方法，意味着我们可以改枚举对象，那么所有使用到它的地方都被改了
    public String getRgb() {
        return rgb;
    }

    public void print(){
        System.out.println(this+" 颜色的rgb为:"+this.rgb);
    }
}
public class Test {
    public static void main(String[] args) {
        Color color = Color.RED;
        Color color1 = Color.RED;
        System.out.println(color == color1);
        //列举所有枚举对象
        Color[] colors = Color.values();
        for(Color c:colors){
            //枚举对象名称
            System.out.println(c.name());
        }
        //通过枚举类的valueOf方法获取枚举对象(枚举常量)，name必须要存在否则会有非法参数异常
        System.out.println(Color.valueOf("RED"));
        Color.RED.print();
        //ordinal:枚举对象的数字下标
        System.out.println(Color.RED.ordinal());
        System.out.println(Color.GREEN.ordinal());
        System.out.println(Color.BLUE.ordinal());
        System.out.println(Color.class.getSuperclass());
    }
}

在这里插入图片描述

2.注解

2.1 @Override 准确覆写

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

2.2 @Deprecated 过期声明

建议用户不使用原有类或者方法时，可以在类或者方法上加@Deprecated表示在当前版本中不推荐使用
在这里插入图片描述

2.3 @SuppressWarnings 压制警告

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

3. JDK1.8新特性

3.1 接口定义加强

JDK1.8之前，接口中只允许有抽象方法和常量，如果此时某一个接口想增加一个方法，就必须去父接口增加这个方法，但是父接口增加了这个方法，其他的子接口和子类又必须全部覆写这个方法，有些工具接口有成百上千个子接口，为了一个接口中有某一个方法，其他的接口和该都必须跟着改变，十分麻烦。
JDK1.8之后接口中允许出现以下两类构造方法

  1. 用default定义的普通方法，需要通过接口对象来调用
  2. 用static定义的静态方法，直接使用接口名调用
interface IInterface{
    void test();
    //用default定义的普通方法，需要通过接口对象来调用
    //default不可以省略
    default void fun(){
        System.out.println("JDK1.8新增的普通方法，通过接口对象调用");
    }
    //用static定义的静态方法，直接使用接口名调用
    static void method(){
        System.out.println("JDK1.8新增的静态方法，通过接口名称调用");
    }
}
class InterfaceImpl implements IInterface{
    @Override
    public void test() {
        System.out.println("子类覆写抽象方法");
    }
}
public class Test {
    public static void main(String[] args) {
        IInterface iInterface =
                new InterfaceImpl();
        iInterface.fun();
        iInterface.test();
        IInterface.method();
    }
}

在这里插入图片描述

3.2 Lambda表达式

interface Add{
    void add(int x,int y);
}
class AddImpl implements Add{
    @Override
    public void add(int x, int y) {
        System.out.println(x+y);
    }
}
public class Test {
    public static void main(String[] args) {
        Add add = new AddImpl();
        add.add(10,20);
    }
}

此程序用于计算两个数的加法，如果此时想要计算两个数的和再加10，为了不影响其他数据求和，就必须重新写一个专门的类来计算x+y+10，当然也可以使用匿名内部类来实现

interface Add{
    void add(int x,int y);
}
public class Test {
    public static void main(String[] args) {
        Add add = new Add() {
            @Override
            public void add(int x, int y) {
                System.out.println(x+y);
            }
        };
        add.add(10,20);
    }
}

在JDK1.8之后有了一种新的方法：函数式编程

interface Add{
    void add(int x,int y);
}

public class Test {
    public static void main(String[] args) {
        //(x,y)--掉膘参数  System.out.println(x+y)函数实现
       Add add = (x,y)-> System.out.println(x+y);
       Add add1 = (x,y)-> System.out.println(x+10+y);
       add.add(10,20);
       add1.add(10,20);
    }
}

在这里插入图片描述
要想使用函数式编程有一个前提，接口必须只有一个抽象方法，如果存在两个以上的抽象方法就无法使用函数式编程，如果某个接口就是为函数编程而生的，在定义时只能存在一个抽象方法，因此有一个新的注解**@FunctionalInterface**，此注解会检查该接口是否只存在一个抽象方法，存在两个抽象方法以上编译出错。

3.2.1 语法

当方法体中只有一行代码时:（方法参数）->具体的方法体实现
当方法有返回值时，单行代码的lambda表达式可以省略return语句

@FunctionalInterface
interface Add{
    void add(int x,int y);
}
@FunctionalInterface
interface AddTest{
    int add(int x,int y);
}
public class Test {
    public static void main(String[] args) {
        //(x,y)--参数  System.out.println(x+y)函数实现
       Add add = (x,y)-> System.out.println(x+y);
       add.add(10,20);

       AddTest add1 = (x,y)-> x+y+10;
        System.out.println(add1.add(10,20));
    }
}

在这里插入图片描述
当方法体中有多行代码时:

(方法参数) ->{
.......
.......
[return 语句];
};

@FunctionalInterface
interface Add{
    int add(int x,int y);
}
public class Test {
    public static void main(String[] args) {
        Add add = (p1,p2) ->{
            int result = p1+p2;
            result+=20;
            return result;
        };
        System.out.println(add.add(20,20));
    }
}

在这里插入图片描述

4.方法引用

方法引用只是给现有方法起别名
方法引用一共有四大形式：

4.1 引用类中的静态方法

类名称::静态方法名称

interface IUnit<P,R>{
    R switchPara(P p);
}
public class Test {
    public static void main(String[] args) {
        //相当于给String类的valueOf方法起了一个别名switchPara
        IUnit<Integer,String> util
                = String::valueOf;
        //相当于调用String.valueOf()   将Integer类型的值变成String类
        String str = util.switchPara(123);
        System.out.println(str);
    }
}

在这里插入图片描述

4.2 引用类中的普通方法

类名称::普通方法名

//调用类中普通方法
interface IUnit<R,P>{
    R compare(P p1,P p2);
}
public class Test {
    public static void main(String[] args) {
        IUnit<Integer,String> util
                = String::compareTo;
        //相当于调用String.comparTo
        System.out.println(util.compare("a","v"));
    }
}

在这里插入图片描述

4.3 引用类中的构造方法

类名称::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 +
                '}';
    }
}
interface IUtil<R,PN,PR>{
    R createPer(PN p1,PR p2);
}
public class Test {
    public static void main(String[] args) {
        IUtil<Person,String,Integer> util =
                Person::new;
        System.out.println(util.createPer("张三",12));
    }
}

在这里插入图片描述

4.4 引用某个对象的方法

实例化对象::普通方法

// 引用某个对象的方法
interface IUnit<R>{
    R switchPara();
}
public class Test {
    public static void main(String[] args) {
        IUnit<String> util
                = "hello"::toUpperCase;
        //相当于调用"hello".toUpperCase(10)
        System.out.println(util.switchPara());
    }
}

在这里插入图片描述

zhao_miao
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
一个接口中定义多个枚举
zwjCSDNer的博客
11-03 697
一个接口中定义多个枚举一个接口中定义多个枚举 一个接口中定义多个枚举 去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片. // An highlighted block public interface DictEnum { enum SendStatus{ /** * 发送成功 */ SEND_STATUS_1("1", "发送成功"), SEND_STATUS_2("2", "发送失败
Java-lambda表达式、函数式接口、方法引用
KeepStruggling的博客
08-15 1015
1. Lambda表达式 1.1 Lambda概念 1.8的新特性 用来简化接口匿名内部类 1.2 使用前提（重点） 必须有接口且接口中有且只有一个抽象方法！！ 1.3 标准格式 - (参数类型 参数名称) -&amp;amp;amp;amp;amp;gt; {执行代码语句} 说明： ()里面放接口中抽象方法的参数列表； -&amp;amp;amp;amp;amp;gt;新语法格式，代表指
枚举实现接口——模拟可扩展的枚举
qq_43842093的博客
02-18 746
枚举类和普通类实现接口一样吗？
看看人家在接口中使用枚举类型的方式，那叫一个优雅！
芋艿V
02-23 1089
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...
JAVA中的枚举类：如何定义枚举类+枚举类的使用+枚举类中常用方法的介绍+一个枚举类的示例
最新发布
a289246的博客
05-11 1576
Java中的枚举类，什么是枚举类、如何定义枚举类、枚举类型在switch中的作用、枚举类中的方法、枚举类的构造器、枚举类可以有哪些成员、如何在枚举类中定义抽象方法、枚举类中的两个特殊的方法：values()和valueOf()，最后写了一个枚举类的小例子，进一步理解枚举类
类，接口，枚举，注解
weixin_45059879的博客
04-29 413
四种类型编译之后都是class文件。 一、类 2、修饰符：final(最终，不可修改)，static（静态），权限修饰符（public，protected，友好，protected），abstract（抽象类） 1、变量 分类：实例变量，局部变量，静态变量，常量（引用数据类型可以修改其属性）， 2、方法 定义：[修饰符列表] 返回值 方法名 形参列表 分类：根据修饰符的不同可以分为：静态，实例，抽象， 特殊：静态代码块，
java(Day25)----注解,lambda,方法引用,新实践API
m0_53441015的博客
10-30 292
在Lambda表达式前提下一些特殊情况可以继续简化常见形式对象:实例方法类:静态方法类:实例方法类:new `Stream:工作流类似于集合,区别是集合中存储数据,流中存储过程以前时间相关API时线程不安全的,而且在设计时就是混乱的所以在jdk1.8时提供新的时间的API的类。
Java Lambda表达式及方法引用
一个博客
07-10 3606
LambdaLambda表达式是Java SE 8中一个重要的新特性。允许你通过表达式来代替功能接口，其几乎解决了匿名内部类带来的所有问题。 其实Lambda表达式的本质是一个”语法糖”,由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。
最全Java注解图文超详解(建议收藏)
03-19
- `@FunctionalInterface`：表示接口仅包含一个抽象方法，通常用于Lambda表达式。 3. **自定义注解**： 自定义注解以`@`开头，后跟注解名称。注解可以有元素，元素是带有值的属性。例如： ```java @interface ...
Java 中文API 谷歌翻译
03-28
3. **方法与构造器引用**：除了lambda表达式，Java 8还引入了方法引用和构造器引用，可以直接引用已有方法或构造器，进一步简化代码。 4. **日期与时间API**：Java 8对日期和时间的处理进行了全面改进，`java.time`...
java8 中文文档
06-26
- Java 8 允许在接口中定义私有方法和静态方法，使得接口可以封装一些辅助逻辑，提高代码复用。 7. **并行流**： - Stream API 支持并行流，可以在多核处理器上实现数据的并行处理，提高性能。通过调用 `parallel...
Java枚举类的使用与注解
01-20
一、枚举类的使用： 1.枚举类的理解：类的对象只有有限个，确定的。我们称此为枚举类 2.当需要定义一组常量时，强烈建议使用枚举类。 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。 二、如何定义枚举类 方式一：Jdk5.0之前，自定义枚举类 方式二：jdk5.0之后，可以使用enum关键字定义枚举类 三、Enum类的主要方法： 四、使用enum关键字定义的枚举类实现接口的情况 栗子一：实现接口,在enum类中实现抽象方法。 栗子二：让枚举类的 对象分别实现接口中的抽象方法。 五、注解(Annotation)概述 二、常见的Annotation 示例： 六、JDK中的元
java10中文api帮助文档chm！
08-31
这个CHM（Compiled Help Manual）文件包含了Java 10的所有核心类库、接口、枚举、注解以及方法的详细描述，是程序员日常开发、调试和解决问题不可或缺的工具。 在Java 10中，引入了一些关键的新特性，这些特性极大...
JAVA_API_1.7中文.zip_API_java api 1.7 中文
09-23
- 虽然Java 8才正式引入，但Java 7是其过渡阶段，为Lambda表达式打下了基础，如引入了`FunctionalInterface`标记接口。 10. **类型推断**： - **`<>`泛型钻石操作符**：简化了创建泛型实例的语法，编译器可以根据...
java学习笔记——抽象类、接口、内部类、枚举 和 注解
qq_25106373的博客
06-25 1008
抽象类1. 为什么使用抽象类？类用于描述现实生活中的一类事物，类中属性、方法，方法都有方法体。某种情况下，父类只能知道子类应该具备一个怎样的方法，但是不能明确知道子类如何实现该方法。例如：几何图形（多态练习）。所有几何图形都应该具备一个计算面积的方法，但是不同几何图形计算面积的方式不同Java 为上述问题提供了相应的解决办法：Java 允许父类只是提供一个方法的声明，不提供具体的实现具体的实现交给...
java 接口中定义枚举_Java：包含内部枚举的接口;在实现类中扩展功能
weixin_35034088的博客
02-13 717
我有一个如下界面：package example;import java.awt.Point;public interface Thing {public enum MovingState {MOVING_LEFT,MOVING_UP,MOVING_RIGHT,MOVING_DOWN}public void setNewPosition(MovingState state);public Poin...
Java 的枚举(Enums) 可以实现接口(Interfaces)
热门推荐
机遇与挑战
01-17 1万+
Java 中一个典型的枚举类型，看似字符串值，但包含一些附加的信息，包括排序以及附加的方法可以获取枚举值的信息。 下面是一个基本的枚举类型： ? 1 public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES } 可增加附加信息，例如私有构造器、私有
Effective Java 3版：实战Lambda与Stream新特性
此外，书中还探讨了泛型、枚举类型、注解和并发容器等主题，这些都是现代Java开发中不可或缺的部分。 值得注意的是，虽然本书提供了丰富的技术知识，但它也明确声明不承担任何形式的明示或暗示保证，且不对因使用书...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值