Java高级特性

最新推荐文章于 2024-07-18 20:13:39 发布
最新推荐文章于 2024-07-18 20:13:39 发布
阅读量795 收藏 15
点赞数 22
分类专栏： java 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weidl001/article/details/139693950
版权

引言

Java不仅提供了基础的编程功能，还包括了一系列强大的高级特性，这些特性能够显著提高代码的灵活性、可扩展性和性能。本文将详细介绍Java的几个高级特性，包括反射机制、注解与注释、泛型编程、以及Lambda表达式与Stream API，并通过表格进行总结和示范。

反射机制

什么是反射？

反射是Java动态语言特性的一个重要体现，它允许在运行时获取类的详细信息、操作类的属性和方法。利用反射，可以在运行时动态地创建对象、调用方法和访问字段，从而提高代码的灵活性。

反射的基本操作

获取类信息

使用Class对象获取类的详细信息。

java

Copy

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");

            // 获取类名
            System.out.println("Class Name: " + clazz.getName());

            // 获取类的所有方法
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println("Method: " + method.getName());
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

动态创建对象

使用Constructor对象动态创建实例。

java

Copy

import java.lang.reflect.Constructor;

public class DynamicInstanceExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");
            Constructor<?> constructor = clazz.getConstructor(String.class);
            
            // 创建对象实例
            Object instance = constructor.newInstance("Hello, Reflection!");
            System.out.println("Instance: " + instance);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

调用方法

使用Method对象动态调用类的方法。

java

Copy

import java.lang.reflect.Method;

public class MethodInvocationExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.lang.String");
            Method method = clazz.getMethod("substring", int.class, int.class);

            // 调用方法
            String result = (String) method.invoke("Hello, Reflection!", 7, 17);
            System.out.println("Result: " + result);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

反射常用类与方法表

类/接口方法描述
ClassforName(String)获取指定类的Class对象
getName()获取类名
getDeclaredMethods()获取所有声明的方法
ConstructornewInstance(Object...)创建实例
Methodinvoke(Object, Object...)调用方法

注解与注释

什么是注解？

注解（Annotation）是Java提供的一种元数据，用于在代码中提供额外信息，它并不直接影响程序行为，但可以通过工具或框架解析和处理注解。注解常用于代码生成、编译时检查、文档生成等。

定义与使用注解

定义自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

使用自定义注解

public class AnnotationUsageExample {
    
    @MyAnnotation(value = "Test Method")
    public void testMethod() {
        System.out.println("Testing method with annotation");
    }

    public static void main(String[] args) {
        try {
            Method method = AnnotationUsageExample.class.getMethod("testMethod");

            if (method.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
                System.out.println("Annotation Value: " + annotation.value());
            }

            method.invoke(new AnnotationUsageExample());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注解与注释的常见类型表

注解描述
@Override表示方法覆盖了父类方法
@Deprecated表示方法或类已过时，不建议使用
@SuppressWarnings抑制编译器警告

泛型编程

什么是泛型？

泛型（Generic）是Java中的一种代码复用机制，允许在类、接口和方法定义中引入类型参数，从而使代码可以处理多种数据类型而不需要类型转换。泛型提高了代码的安全性和可读性。

泛型类与方法

定义泛型类

public class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

使用泛型类

public class GenericUsageExample {
    public static void main(String[] args) {
        GenericClass<String> stringInstance = new GenericClass<>("Hello, Generic!");
        System.out.println("String Value: " + stringInstance.getValue());

        GenericClass<Integer> integerInstance = new GenericClass<>(123);
        System.out.println("Integer Value: " + integerInstance.getValue());
    }
}

定义泛型方法

public class GenericMethodExample {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        String[] stringArray = {"A", "B", "C"};
        Integer[] intArray = {1, 2, 3};

        printArray(stringArray);
        printArray(intArray);
    }
}

常用泛型集合表

集合类描述示例代码
ArrayList<T>动态数组，允许重复元素ArrayList<String> list = new ArrayList<>();
HashSet<T>无序集合，不允许重复元素HashSet<Integer> set = new HashSet<>();
HashMap<K, V>键值对映射，不允许重复键HashMap<String, Integer> map = new HashMap<>();

Lambda表达式与Stream API

什么是Lambda表达式？

Lambda表达式是一种简洁的函数表示方法，可替代匿名内部类，使得代码更加简洁和易读。Lambda表达式主要用于简化对集合的操作，特别是在使用Stream API时。

Lambda表达式的基本语法

(parameters) -> expression
或
(parameters) -> { statements; }

示例：使用Lambda表达式

import java.util.Arrays;
import java.util.List;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Jane", "Jack");
        
        names.forEach(name -> System.out.println("Hello, " + name));
    }
}

什么是Stream API？

Stream API是Java 8引入的一套用于处理集合（如List、Set、Map）的强大工具。它支持函数式编程风格，通过一系列中间操作（如filter、map）和终端操作（如forEach、collect）实现高效的数据处理。

示例：使用Stream API

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 筛选偶数，计算平方，并收集结果
        List<Integer> result = numbers.stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

Lambda表达式与Stream API常用方法表

方法描述示例代码
forEach对集合中的每个元素执行操作list.forEach(element -> { ... });
filter筛选符合条件的元素stream.filter(element -> element > 0);
map对集合中的每个元素进行转换stream.map(element -> element * 2);
collect将流中的元素收集成另一集合stream.collect(Collectors.toList());
reduce将流中的元素根据某个策略合并成一个值stream.reduce(0, (a, b) -> a + b);
sorted对流中的元素进行排序stream.sorted();
distinct去除流中的重复元素stream.distinct();
limit截取流中的前n个元素stream.limit(5);

表格总结

反射常用类与方法表

类/接口方法描述
ClassforName(String)获取指定类的Class对象
getName()获取类名
getDeclaredMethods()获取所有声明的方法
ConstructornewInstance(Object...)创建实例
Methodinvoke(Object, Object...)调用方法

注解与注释的常见类型表

注解描述
@Override表示方法覆盖了父类方法
@Deprecated表示方法或类已过时，不建议使用
@SuppressWarnings抑制编译器警告

常用泛型集合表

集合类描述示例代码
ArrayList<T>动态数组，允许重复元素ArrayList<String> list = new ArrayList<>();
HashSet<T>无序集合，不允许重复元素HashSet<Integer> set = new HashSet<>();
HashMap<K, V>键值对映射，不允许重复键HashMap<String, Integer> map = new HashMap<>();

Lambda表达式与Stream API常用方法表

方法描述示例代码
forEach对集合中的每个元素执行操作list.forEach(element -> { ... });
filter筛选符合条件的元素stream.filter(element -> element > 0);
map对集合中的每个元素进行转换stream.map(element -> element * 2);
collect将流中的元素收集成另一集合stream.collect(Collectors.toList());
reduce将流中的元素根据某个策略合并成一个值stream.reduce(0, (a, b) -> a + b);
sorted对流中的元素进行排序stream.sorted();
distinct去除流中的重复元素stream.distinct();
limit截取流中的前n个元素stream.limit(5);

应用场景与实践

反射机制的应用场景

反射常用于框架和库的开发，如Spring和Hibernate，这些框架通过反射动态创建对象和调用方法。同时，反射还可以用于工具和调试，动态分析和处理类。

示例：使用反射实现简单的依赖注入

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class DependencyInjection {

    public static void main(String[] args) {
        Container container = new Container();
        Service service = container.getService(Service.class);
        service.execute();
    }
}

class Container {
    public <T> T getService(Class<T> clazz) {
        try {
            Constructor<T> constructor = clazz.getConstructor();
            T instance = constructor.newInstance();

            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Inject.class)) {
                    field.setAccessible(true);
                    field.set(instance, new ServiceImpl());
                }
            }

            return instance;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

class ServiceImpl implements Service {
    public void execute() {
        System.out.println("Service executed!");
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Inject {}

interface Service {
    void execute();
}

class AppService implements Service {
    @Inject
    private Service service;

    public void execute() {
        service.execute();
    }
}

泛型编程应用场景

泛型编程常用于提高代码的复用性和类型安全性。例如，集合框架中广泛使用泛型，以确保存储在集合中的元素类型一致。

示例：创建泛型栈（Stack）

import java.util.ArrayList;
import java.util.List;

public class GenericStack<T> {
    private List<T> stack = new ArrayList<>();

    public void push(T item) {
        stack.add(item);
    }

    public T pop() {
        if (!stack.isEmpty()) {
            return stack.remove(stack.size() - 1);
        }
        return null;
    }

    public static void main(String[] args) {
        GenericStack<String> stack = new GenericStack<>();
        stack.push("Hello");
        stack.push("World");
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

Stream API应用场景

Stream API用于处理数据流，如集合和数组，可以简洁而高效地对数据进行过滤、转换、排序和收集操作。

示例：使用Stream API处理数据流

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamApiExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Jane", "Jack", "Jill", "James");

        // 过滤以J开头的名字，并转换为大写
        List<String> result = names.stream()
                .filter(name -> name.startsWith("J"))
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

总结

本文详细介绍了Java的高级特性，包括反射机制、注解与注释、泛型编程、以及Lambda表达式与Stream API。通过示例代码和表格总结，帮助您更好地理解和应用Java的这些高级特性，提高代码的灵活性、可扩展性和性能。

小魏冬琅
关注
  • 22
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java高级特性总结（复习自用）
qq_41995845的博客
08-20 694
一、
头歌——Java高级特性 - Java反射
weixin_62440328的博客
12-27 2034
【代码】头歌——Java高级特性 - Java反射。
java高级特性有哪些_Java高级特性总结（一）
weixin_33914679的博客
02-16 1505
Java高级特性总结(I/O&&Thread篇)1.File类可以完成对文件、目录的操作，新建、删除、重命名文件、目录等，但不能访问文件本身的内容，访问文件本身内容需要使用输入输出流，对于Java来说文件和目录都是一个概念。2.Window的路径分隔符使用反斜线(\)，而Java的程序中反斜线表示转义字符，所以如果要使用反斜线应该用两条线(\\),或者只是用正斜线(/)。3.字节流...
JAVA高级特性总结
我爱大海V5的专栏
11-28 4955
1.File类可以完成对文件、目录的操作，新建、删除、重命名文件、目录等，但不能访问文件本身的内容，访问文件本身内容需要使用输入输出流，对于Java来说文件和目录都是一个概念。 2.Window的路径分隔符使用反斜线（\），而Java的程序中反斜线表示转义字符，所以如果要使用反斜线应该用两条线（\\）,或者只是用正斜线（/）。 3.字节流一InputStream和OutStream作为
Java高级特性 - 集合框架（1）
xu_tingfang的博客
05-20 1625
什么是泛型呢？类型参数，那什么又是类型参数呢？我们知道一个方法如果指定了一个字符串类型的参数，那方法的调用者就只能传递String类型的参数才能正确的使用这个方法了，否则就报错，其实泛型也是一样，只不过在这里泛型用在集合上，即指定集合中只能放某一种类型的元素你要往ATM机中存钱，就只能放毛爷爷，而不能放冥币，这就是泛型，指定只能用一种类型。
详解Java高级特性之反射
08-19
"详解Java高级特性之反射" Java反射机制是Java语言中一个非常重要的概念，它允许程序在运行时检查和修改其他类的行为。Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意...
JAVA高级特性.docx
07-07
Java的高级特性涵盖了许多主题，但在讨论中，我们主要聚焦于Java集合框架，这是一个非常重要的概念，它使得在处理对象的存储和管理时更加高效和灵活。Java集合框架包括List、Set和Map三大核心接口，以及相关的实现类...
java高级特性增强
03-27
java多线程、反射、代理等基础知识详细介绍，通过此文档可快速进阶为中级工程师
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 821
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 893
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1020
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
接口防刷！利用redisson快速实现自定义限流注解
最新发布
架构师小吴的博客
07-18 823
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 825
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 686
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 154
【JAVA】相关程序组件
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 703
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 511
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java高级特性面试题
09-22
Java高级特性面试题涉及到Java的一些高级概念和特性，其中包括反射、代理、类加载器和系统类加载器等。 反射是Java中的一项重要特性，它允许程序在运行时动态地获取和操作类的信息。java.lang.reflect.Proxy接口和InvocationHandler接口是反射机制的核心接口。 代理是面向对象编程中的一种设计模式，通过代理对象来间接访问目标对象，可以在不改变目标对象的情况下增加额外的逻辑。反射与代理结合使用，可以实现动态代理。 类加载器是Java中用于加载类的重要组件，它负责将类的字节码文件加载到内存中，并转换为可执行的Java类。java.lang.Object、java.lang.ClassLoader、java.security.SecureClassLoader和java.net.URLClassLoader是Java中常用的类加载器。 系统类加载器是Java运行时环境的一部分，它负责加载应用程序所需的类。在Java中，系统类加载器可以通过设置-classpath选项或通过java.class.path属性来指定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值