30JDK5新特性

合集下载

8-jav_1.5新特新

1、jdk1.5出现的新特性---->增强for循环
增强for循环的作用：简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历。)
增强for循环的适用范围：如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。
增强for循环的格式：
for(数据类型变量名 :遍历的目标){
//集合：集合是可以存储任意对象类型数据的容器。
ArrayList list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
//自动装箱：自动把java的基本数据类型数据转换成对象类型数据。
3. 普通for循环与增强for循环的区别：普通for循环可以没有变量的目标，而增强for循环一定要有变量的目标。
//注意： Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环，如果需要使用增强for循环需要借助于Collection的集合。
2、dk1.5新特性之------->可变参数
int temp = 10; //基本数据类型
Integer b =temp; //a存储的值赋予给b变量。 //自动拆箱：把引用类型的数据转换成基本类型的数据
4、jdk1.5新特性之-----枚举
问题：某些方法所接收的数据必须是在固定范围之内的，
解决方案：这时候我们的解决方案就是自定义一个类,然后是私有化构造函数，在自定义类中创建本类的对象对外使用。
System.out.println("把整数转换成对应的字符串："+Integer.toString(i));

第6章集合类(黑马程序员版)

案例代码
接下来通过一个案例来学习这些方法的使用，请查看教材文件6-2。
✎ 6.3 List接口
Iterator接口
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口Iterator。Iterator接口也是Java集合中的一员，但它与Collection、 Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
பைடு நூலகம்
✎ 6.3 List接口
图中，通过两张图描述了LinkedList集合新增元素和删除元素的过程。其中，左图为新增一个元素，图中的元素1和元素2在集合中彼此为前后关系，在它们之间新增一个元素时，只需要让元素1记住它后面的元素是新元素，让元素2记住它前面的元素为新元素就可以了。右图为删除元素，要想删除元素1与元素2之间的元素3，只需要让元素1与元素2变成前后关系就可以了。由此可见 LinkedList集合具有增删元素效率高的特点。
图中，在调用Iterator的next()方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next()方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next()方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext()方法返回false，表示到达了集合的末尾，终止对元素的遍历。
☞点击查看本小节知识架构
模拟KTV点歌系统
Set接口
☞点击查看本小节知识架构
模拟新浪微博用户注册
Map接口
☞点击查看本小节知识架构

JDK(Java Development Kit,Java开发包,Java开发工具)是一个写Java的

JDK(Java Development Kit，Java开发包，Java开发工具)是一个写Java的applet 和应用程序的程序开发环境。

它由一个处于操作系统层之上的运行环境还有开发者编译，调试和运行用Java语言写的applet和应用程序所需的工具组成。

JDK(Java Development Kit)是Sun Microsystems针对Java开发员的产品。

自从Java 推出以来，JDK已经成为使用最广泛的Java SDK（Software development kit）。

JDK包含的基本组件包括：·javac –编译器，将源程序转成字节码·jar –打包工具，将相关的类文件打包成一个文件·javadoc –文档生成器，从源码注释中提取文档·jdb – debugger，查错工具JDK中还包括完整的JRE（Java Runtime Environment，Java运行环境），也被称为private runtime。

包括了用于产品环境的各种库类，以及给开发员使用的补充库，如国际化的库、IDL库。

JDK中还包括各种例子程序，用以展示Java API中的各部分。

从初学者角度来看，采用JDK开发Java程序能够很快理解程序中各部分代码之间的关系，有利于理解Java面向对象的设计思想。

JDK的另一个显著特点是随着Java （J2EE、J2SE 以及J2ME）版本的升级而升级。

但它的缺点也是非常明显的就是从事大规模企业级Java应用开发非常困难，不能进行复杂的Java软件开发，也不利于团体协同开发。

JDK一般有三种版本：SE(J2SE),standard edition,标准版，是我们通常用的一个版本EE(J2EE),enterpsise edtion,企业版，使用这种JDK开发J2EE应用程序，ME(J2ME),micro edtion,主要用于移动设备、嵌入式设备上的java应用程序Java开发工具（JDK）是许多Java专家最初使用的开发环境。

Java7新特性和用法简介

Java7新特性和用法简介Java是目前使用最广泛的编程语言之一，它的稳定性以及广泛的应用领域使得Java在软件开发中占据了重要地位。

在Java的发展历程中，伴随着各种技术和新特性的推出，Java在不断地优化，让编程变得更加简单和高效。

Java7作为Java语言的重要版本，引入了许多新特性和用法，让我们一起来了解一下Java7的新特性和用法吧！1.自动关闭资源（Try with Resources）在Java7中，引入了一种新的资源自动关闭方式，可以避免程序员在每一个资源处理完之后都要手动关闭资源。

实现该功能主要是通过使用try-with-resources语句，该语句允许使用一个或多个资源，这些资源都将在try语句结束后自动关闭。

例如，如果在程序中使用文件流IO等资源，我们可以这样写：```try (FileInputStream fis = new FileInputStream("test.txt")){//Do Something...} catch (IOException e) {e.printStackTrace();}```这样当try语句结束时，无论是否有异常抛出，文件流都会自动关闭，代码变得更加简洁和安全。

2.多异常捕获（Multi-Catch）以前，Java代码中只能在一个catch语句中处理一个异常，但在Java7中，可以在一个catch块中处理一个或多个异常。

这样有利于简化代码，提高代码可读性和维护性。

例如：```try {//Do Something...} catch (IOException | NullPointerException e){e.printStackTrace();}```可以看到，使用“|”片断连接多个异常，捕获多种异常类型，让代码更加高效。

3.字符串在switch中使用在Java6之前，我们在使用switch语句时，只能使用整数类型或枚举类型。

Spring5核心原理与30个类手写实战pdf下载

Spring5核心原理与30个类手写实战pdf下载基于编程开发实践，不仅深度解析Spring 5的原理与新特性，更从环境准备、顶层结构设计、数据访问等方面一步步地推导出Spring的设计原理。

在每个知识点上，均以大量的经典代码案例辅助讲解，使理论紧密联系实际。

最后手写30个类，以体会Spring的创作过程，让每一位读者学以致用。

Spring5核心原理与30个类手写实战资料目录第1篇 Spring内功心法第1章软件架构设计原则 21.1 开闭原则 21.2 依赖倒置原则 41.3 单一职责原则 71.4 接口隔离原则 101.5 迪米特原则 121.6 里氏替换原则 141.7 合成复用原则 191.8 设计原则总结 20第2章 Spring中常用的设计模式 212.1 为什么要从设计模式开始 212.1.1 写出优雅的代码 222.1.2 更好地重构项目 242.1.3 经典框架都在用设计模式解决问题 36 2.2 工厂模式详解 362.2.1 工厂模式的由来 362.2.2 简单工厂模式 372.2.3 工厂方法模式 412.2.4 抽象工厂模式 432.2.5 利用工厂模式重构的实践案例 472.3 单例模式详解 532.3.1 单例模式的应用场景 532.3.2 饿汉式单例模式 532.3.3 懒汉式单例模式 542.3.4 反射破坏单例 602.3.5 序列化破坏单例 612.3.6 注册式单例模式 682.3.7 线程单例实现ThreadLocal 742.3.8 单例模式小结 752.4 原型模式详解 752.4.1 原型模式的应用场景 752.4.2 浅克隆 772.4.3 深克隆 792.4.4 克隆破坏单例模式 812.4.5 clone()方法的源码 822.5 代理模式详解 822.5.1 代理模式的应用场景 822.5.2 静态代理 832.5.3 动态代理 882.5.4 代理模式与Spring 1072.5.5 静态代理和动态代理的本质区别 1082.5.6 代理模式的优缺点 1092.6 委派模式详解 1092.6.1 委派模式的定义及应用场景 1092.6.2 委派模式在源码中的体现 1112.7 策略模式详解 .1142.7.1 策略模式的应用场景 1142.7.2 用策略模式实现选择支付方式的业务场景 .114 2.7.3 策略模式在JDK源码中的体现 1222.7.4 策略模式的优缺点 1252.7.5 委派模式与策略模式综合应用 1252.8 模板模式详解 1292.8.1 模板模式的应用场景 1292.8.2 利用模板模式重构JDBC操作业务场景 132 2.8.3 模板模式在源码中的体现 1362.8.4 模板模式的优缺点 1382.9 适配器模式详解1392.9.1 适配器模式的应用场景 1392.9.2 重构第三方登录自由适配的业务场景141 2.9.3 适配器模式在源码中的体现 1492.9.4 适配器模式的优缺点 1532.10 装饰者模式详解 1532.10.1 装饰者模式的应用场景 1532.10.2 装饰者模式和适配器模式对比 1632.10.3 装饰者模式在源码中的应用 1632.10.4 装饰者模式的优缺点 1652.11 观察者模式详解 1652.11.1 观察者模式的应用场景 1652.11.2 观察者模式在源码中的应用 1752.11.3 基于Guava API轻松落地观察者模式 176 2.11.4 观察者模式的优缺点 1772.12 各设计模式的总结与对比 177 2.12.1 GoF 23种设计模式简介 177 2.12.2 设计模式之间的关联关系 178 2.12.3 Spring中常用的设计模式 182 2.13 Spring中的编程思想总结 183 第2篇 Spring环境预热第3章 Spring的前世今生 1863.1 一切从Bean开始 1873.2 Spring的设计初衷 1883.3 BOP编程伊始 1883.4 理解BeanFactory 1893.5 AOP编程理念 189第4章 Spring 5系统架构 1914.1 核心容器 1924.2 AOP和设备支持1924.3 数据访问与集成1934.4 Web组件 1944.5 通信报文 1944.6 集成测试 1944.7 集成兼容 1944.8 各模块之间的依赖关系 194第5章 Spring版本命名规则 1965.1 常见软件的版本命名 1965.2 语义化版本命名通行规则 1975.3 商业软件中常见的修饰词 1975.4 软件版本号使用限定 1985.5 Spring版本命名规则 199第6章 Spring源码下载及构建技巧 2006.1 Spring 5源码下载 2006.2 基于Gradle的源码构建技巧 2016.3 Gradle构建过程中的坑 207第3篇 Spring核心原理第7章用300行代码手写提炼Spring核心原理 210 7.1 自定义配置 2107.1.1 配置application.properties文件 2107.1.2 配置web.xml文件 2107.1.3 自定义注解 2117.1.4 配置注解 2127.2 容器初始化 2137.2.1 实现1.0版本 2137.2.2 实现2.0版本 2167.2.3 实现3.0版本 2237.3 运行效果演示 227第8章一步一步手绘Spring IoC运行时序图 228 8.1 Spring核心之IoC容器初体验 2288.1.1 再谈IoC与DI 2288.1.2 Spring核心容器类图 2298.1.3 Web IoC容器初体验 2328.2 基于XML的IoC容器的初始化 2378.2.1 寻找入口 2388.2.2 获得配置路径 2388.2.3 开始启动 2408.2.4 创建容器 2428.2.5 载入配置路径 2438.2.6 分配路径处理策略 2448.2.7 解析配置文件路径 2478.2.8 开始读取配置内容 2498.2.9 准备文档对象 2508.2.10 分配解析策略 2518.2.11 将配置载入内存 2528.2.12 载入＜bean＞元素 2578.2.13 载入＜property＞元素 2618.2.14 载入＜property＞子元素 2648.2.15 载入＜list＞子元素 2668.2.16 分配注册策略 2678.2.17 向容器注册 2678.3 基于注解的IoC初始化 2708.3.1 注解的前世今生 2708.3.2 定位Bean扫描路径 2718.3.3 读取注解的元数据 2738.3.4 扫描指定包并解析为BeanDefinition 277 8.3.5 注册注解BeanDefinition 2838.4 IoC容器初始化小结 285第9章一步一步手绘Spring DI运行时序图 287 9.1 Spring自动装配之依赖注入 2879.1.1 依赖注入发生的时间 2879.1.2 寻找获取Bean的入口 2889.1.3 开始实例化 2939.1.4 选择Bean实例化策略 2979.1.5 执行Bean实例化 2999.1.6 准备依赖注入 3019.1.7 解析属性依赖注入规则 3069.1.8 注入赋值 3109.2 Spring IoC容器中那些鲜为人知的细节 314 9.2.1 关于延时加载 3149.2.2 关于FactoryBean和BeanFactory 3179.2.3 再述autowiring 322第10章一步一步手绘Spring AOP运行时序图 326 10.1 Spring AOP初体验 32610.1.1 再述Spring AOP应用场景 32610.1.2 AOP中必须明白的几个概念 32710.1.3 使用Spring AOP的两种方式 32910.1.4 切入点表达式的配置规则 33310.2 Spring AOP源码分析 33410.2.1 寻找入口 33410.2.2 选择代理策略 33810.2.3 调用代理方法 34110.2.4 触发通知 347第11章一步一步手绘Spring MVC运行时序图 352 11.1 初探Spring MVC请求处理流程 35211.2 Spring MVC九大组件 35311.2.1 HandlerMapping 35311.2.2 HandlerAdapter 35311.2.3 HandlerExceptionResolver 354 11.2.4 ViewResolver 35411.2.5 RequestToViewNameTranslator 354 11.2.6 LocaleResolver 35411.2.7 ThemeResolver 35511.2.8 MultipartResolver 35511.2.9 FlashMapManager 35511.3 Spring MVC源码分析 35511.3.1 初始化阶段 35611.3.2 运行调用阶段 35911.4 Spring MVC优化建议 367第4篇 Spring手写实战第12章环境准备 37012.1 IDEA集成Lombok插件 37012.1.1 安装插件 37012.1.2 配置注解处理器 37312.1.3 使用插件 37412.2 从Servlet到ApplicationContext 375 12.3 准备基础配置37612.3.1 application.properties配置.377 12.3.2 pom.xml配置 37712.3.3 web.xml配置 37812.3.4 GPDispatcherServlet 378第13章 IoC顶层结构设计 38013.1 Annotation（自定义配置）模块 380 13.1.1 @GPService 38013.1.2 @GPAutowired 38113.1.3 @GPController 38113.1.4 @GPRequestMapping 38213.1.5 @GPRequestParam 38213.2 core（顶层接口）模块 38213.2.1 GPFactoryBean 38213.2.2 GPBeanFactory 38313.3 beans（配置封装）模块 38313.3.1 GPBeanDefinition 38313.3.2 GPBeanWrapper 38413.4 context（IoC容器）模块 38513.4.1 GPAbstractApplicationContext 385 13.4.2 GPDefaultListableBeanFactory 385 13.4.3 GPApplicationContext38513.4.4 GPBeanDefinitionReader 38813.4.5 GPApplicationContextAware 391第14章完成DI模块的功能 39214.1 从getBean()方法开始 39314.2 GPBeanPostProcessor 395第15章完成MVC模块的功能 39615.1 MVC顶层设计 39615.1.1 GPDispatcherServlet 39615.1.2 GPHandlerMapping 40215.1.3 GPHandlerAdapter 40315.1.4 GPModelAndView 40615.1.5 GPViewResolver 40615.1.6 GPView 40715.2 业务代码实现40915.2.1 IQueryService 40915.2.2 QueryService 41015.2.3 IModifyService 41015.2.4 ModifyService 41115.2.5 MyAction 41215.2.6 PageAction 41315.3 定制模板页面41415.3.1 first.html 41415.3.2 404.html 41415.3.3 500.html 41515.4 运行效果演示415第16章完成AOP代码织入 417 16.1 基础配置 .41716.2 完成AOP顶层设计 41816.2.1 GPJoinPoint 41816.2.2 GPMethodInterceptor .419 16.2.3 GPAopConfig 41916.2.4 GPAdvisedSupport 420 16.2.5 GPAopProxy 42216.2.6 GPCglibAopProxy 42316.2.7 GPJdkDynamicAopProxy 423 16.2.8 GPMethodInvocation425 16.3 设计AOP基础实现 42716.3.1 GPAdvice 42716.3.2 GPAbstractAspectJAdvice 427 16.3.3 GPMethodBeforeAdvice 428 16.3.4 GPAfterReturningAdvice 429 16.3.5 GPAfterThrowingAdvice 430 16.3.6 接入getBean()方法 43016.4 织入业务代码43216.4.1 LogAspect 43216.4.2 IModifyService 43316.4.3 ModifyService 43416.5 运行效果演示435第5篇 Spring数据访问第17章数据库事务原理详解 438 17.1 从Spring事务配置说起 438 17.2 事务的基本概念 43917.3 事务的基本原理 43917.4 Spring事务的传播属性 440 17.5 数据库事务隔离级别 44117.6 Spring中的事务隔离级别 441 17.7 事务的嵌套 44217.8 Spring事务API架构图 44417.9 浅谈分布式事务 444第18章 Spring JDBC源码初探 44618.1 异常处理 44718.2 config模块 44818.3 core模块45018.4 DataSource 45618.5 object模块 45718.6 JdbcTemplate 45818.7 NamedParameterJdbcTemplate 458第19章基于Spring JDBC手写ORM框架 459 19.1 实现思路概述45919.1.1 从ResultSet说起 45919.1.2 为什么需要ORM框架 46419.2 搭建基础架构46719.2.1 Page 46719.2.2 ResultMsg 47019.2.3 BaseDao 47119.2.4 QueryRule 47319.2.5 Order.47919.3 基于Spring JDBC实现关键功能 480 19.3.1 ClassMappings 48019.3.2 EntityOperation 48319.3.3 QueryRuleSqlBuilder 48819.3.4 BaseDaoSupport 49819.4 动态数据源切换的底层原理 50719.4.1 DynamicDataSource 50819.4.2 DynamicDataSourceEntry 50919.5 运行效果演示51019.5.1 创建Member实体类 51019.5.2 创建Order实体类 51119.5.3 创建MemberDao 51219.5.4 创建OrderDao 51219.5.5 修改db.properties文件 51419.5.6 修改application-db.xml文件 515 19.5.7 编写测试用例 516第6篇 Spring经验分享第20章 Spring 5新特性总结 52020.1 升级到Java SE 8和Java EE 7 520 20.2 反应式编程模型 52120.3 使用注解进行编程 52120.4 函数式编程 52220.5 使用 REST 端点执行反应式编程 52320.6 支持HTTP/2 52320.7 Kotlin和Spring WebFlux 52320.8 使用Lambda表达式注册Bean 52420.9 Spring Web MVC 支持最新的 API 52420.10 使用JUnit 5执行条件和并发测试 52520.11 包清理和弃用 52620.12 Spring核心和容器的一般更新 52620.13 我如何看Spring 5 527第21章关于Spring的经典高频面试题 52821.1 什么是Spring框架，Spring框架有哪些主要模块52821.2 使用Spring框架能带来哪些好处 52821.3 什么是控制反转（IoC），什么是依赖注入 52921.4 在Java中依赖注入有哪些方式 52921.5 BeanFactory和ApplicationContext有什么区别 530 21.6 Spring提供几种配置方式来设置元数据 53021.7 如何使用XML配置方式配置Spring .53121.8 Spring提供哪些配置形式 53221.9 怎样用注解的方式配置Spring 53321.10 请解释Spring Bean的生命周期 53421.11 Spring Bean作用域的区别是什么 53521.12 什么是Spring Inner Bean 53521.13 Spring中的单例Bean是线程安全的吗 53621.14 请举例说明如何在Spring中注入一个Java集合 53621.15 如何向Spring Bean中注入java.util.Properties 53721.16 请解释Spring Bean的自动装配 53821.17 自动装配有哪些局限性 53821.18 请解释各种自动装配模式的区别 53921.19 请举例解释@Required注解 53921.20 请举例说明@Qualifier注解 54021.21 构造方法注入和设值注入有什么区别 54021.22 Spring中有哪些不同类型的事件 54121.23 和ClassPathResource有什么区别 54221.24 Spring中用到了哪些设计模式 54221.25 在Spring中如何更有效地使用JDBC 54321.26 请解释Spring中的IoC容器 54321.27 在Spring中可以注入null或空字符串吗 543Spring5核心原理与30个类手写实战介绍1996年，Java还只是一个新兴的、初出茅庐的编程语言。

注解annotation的详细介绍

JDK5内置的基本注释JDK5内置了一些常用的注释，可以在编译时帮我们捕获部分编译错误，及提示信息，下面介绍下这些注释的用法：1、@Override定义在ng.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。

如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。

例如我们为某类重写toString()方法却写成了tostring()，并且我们为该方法添加了@Override注释；代码如下：Java代码1.public class OverrideDemo {2.@Override3.public String tostring() {4. return super.toString();5. }6.}在编译时，会提示以下错误信息：引用OverrideTest.java:4: 方法未覆盖其父类的方法@Override^1 错误2、@Deprecated定义在ng.Deprecated中，此注释可用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。

在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。

使用@Deprecated的示例代码如下：Java代码1.public class DeprecatedDemo {2. public static void main(String[] args) {3. DeprecatedClass.DeprecatedMethod();4. }5.}6.7.class DeprecatedClass {8.@Deprecated9. public static void DeprecatedMethod() {10. // TODO11. }12.}在编译时，会得到以下提示信息：引用注意：DeprecatedDemo.java 使用或覆盖了已过时的 API。

JDK发展历史以及版本特性

JDK发展历史以及版本特性JDK（Java Development Kit）是Java语言的开发工具包，包含了Java编译器、调试器、自动构建工具和其他一些实用工具。

JDK的发展历史可以追溯到上世纪90年代，从最早的JDK 1.0到最新的JDK 17，每个版本都带来了许多新的功能和改进。

下面将详细介绍JDK的发展历史以及每个版本的主要特性。

1. JDK 1.0（1996年）：JDK 1.0是Java开发工具包的首个正式发布版本。

它包含了Java编译器、调试器、类库和开发工具。

JDK 1.0的特性包括基本的Java语言特性、图形界面和网络编程支持。

2. JDK 1.1（1997年）：JDK 1.1引入了许多重要的新功能，包括内部类、JavaBeans、RMI（远程方法调用）和反射。

此外，JDK 1.1还带来了对AWT（图形用户界面工具包）和JDBC（Java数据库连接）等的改进。

3. JDK 1.2（1998年）：JDK 1.2是一个重要的里程碑，它引入了许多基本的Java特性，包括协同多线程、集合框架、Java虚拟机内存管理和Java 2D API。

此外，JDK 1.2还提供了对Java Servlet和JavaServer Pages（JSP）的支持。

4. JDK 1.3（2000年）：JDK 1.3主要集中在性能改进和稳定性方面。

它引入了HotSpot虚拟机，其中包含了即时编译器，可以显著提高Java程序的执行速度。

此外，JDK 1.3还带来了对JNDI（Java命名和目录接口）和Java Sound API的支持。

5. JDK 1.4（2002年）：JDK 1.4引入了许多新功能，包括正则表达式库、XML处理工具、Java Web Start和JMX（Java管理扩展）。

此外，JDK 1.4还改进了性能、内存管理和安全性能。

6. JDK 5（2004年）：JDK 5（也称为J2SE 5.0）是一个重要的版本，引入了许多新的语言特性，如泛型、枚举、自动装箱和拆箱以及注解。

java判断题博学谷

第一章一、判断题1.Java核心源码包存放在JDK安装目录的bin目录下A. 对B. 错答案：false解析：src.zip文件是Java的核心源码包，它在JDK安装的根目录下。

考察点：第一章 Java开发入门题目难度：★☆☆☆容易2.JDK安装成功后，可以将bin目录的路径配置在环境变量path中。

A. 对B. 错答案：true解析：为了方便java程序开发，最好将bin目录的路径配置到环境变量中。

考察点：第一章 Java开发入门题目难度：★☆☆☆容易3.安装JDK时可以选择不安装公共JREA. 对B. 错答案：true解析：由于开发工具中已经包含了一个JRE，因此没有必要再安装公共的JRE环境，此项可以不作选择。

考察点：第一章 Java开发入门题目难度：★★☆☆一般4.lib是library的缩写，用于存放Java类库或库文件A. 对B. 错答案：true解析：lib是library的缩写，意为Java类库或库文件，是开发工具使用的归档包文件考察点：第一章 Java开发入门题目难度：★☆☆☆容易5.如果classpath环境变量没有进行设置，Java虚拟机会自动将其设置为“.”，也就是当前目录。

A. 对B. 错答案：true解析：如果classpath环境变量没有进行设置，Java虚拟机会自动将其设置为“.”，也就是当前目录。

考察点：第一章 Java开发入门题目难度：★☆☆☆容易6.JDK安装的时候不可以修改安装目录A. 对B. 错答案：false解析：JDK在安装的过程中，可以通过点击按钮进行选择或直接输入路径的方式修改JDK的安装目录。

考察点：第一章 Java开发入门题目难度：★☆☆☆容易7.Java是一门高级计算机语言。

A. 对B. 错答案：true解析：Java是一种高级计算机语言，它是由Sun公司（已被Oracle公司收购）于1995年5月推出的一种可以编写跨平台应用软件、完全面向对象的程序设计语言。

java 8 产品说明使用手册

Java 8 产品说明使用手册一、产品简介1. Java 8 是由美国甲骨文公司开发的一种计算机编程语言，最初由Sun Microsystems推出，后被甲骨文公司收购。

Java 8 是Java语言的一个重大版本更新，于2014年3月发布。

Java 8 引入了许多新特性和改进，包括Lambda 表达式、函数式接口、默认方法、流式 API 等，极大地提高了Java语言的表达能力和编程效率。

2. 本使用手册旨在介绍Java 8 的相关特性和使用方法，帮助用户充分了解Java 8 的优势和使用技巧。

二、新特性介绍3. Lambda 表达式：Lambda 表达式是Java 8 最重要的特性之一，它使得匿名函数的创建和使用变得简单和高效。

通过Lambda 表达式，可以更加优雅地编写代码，实现函数式编程的特性。

4. 函数式接口：Java 8 引入了函数式接口的概念，即只有一个抽象方法的接口。

函数式接口可以被Lambda 表达式直接赋值，使得代码变得更加简洁清晰。

5. 默认方法：在接口中可以定义默认方法，这使得接口的演化变得更加灵活。

接口的默认方法可以在不破坏现有的实现的情况下，为接口添加新的方法。

6. 流式 API：Java 8 引入了流式 API，它提供了一种新的数据处理方式，能够更加方便地进行集合操作。

流式 API 可以大大简化循环、过滤和映射等操作，提高代码的可读性和性能。

三、使用方法7. 在本节中，我们将介绍如何使用Java 8 的新特性，以及一些常见的使用技巧。

8. Lambda 表达式的使用：- Lambda 表达式的语法格式为：(parameters) -> expression 或(parameters) -> { statements; }。

- Lambda 表达式可以替代匿名内部类的使用，使得代码更加简洁清晰。

- 可以使用Lambda 表达式对集合进行排序：list.sort((a, b) -> apareTo(b))。

J2SE(TM) 5.0 语言特性

J2SE(TM) 5.0专题之语言特性回复Posted on 2005-01-12 22:49 大胃阅读(4275) 评论(7)编辑收藏引用收藏至365Key所属分类: On Java[准备工作]首先，为了了解J2SE(TM) 5.0的新的语言特性，你需要下载新版的JDK，在这里可以找到下载链接：/j2se/1.5.0/download.jsp。

当然，如果你已经有过手动配置Java环境的经历，我也建议你使用一个支持J2SE(TM) 5.0的IDE，推荐Eclipse SDK 3.1 M4，或者NetBeans IDE 4.0。

两个都是开源免费的，且很容易找到（Eclipse不用说了，NetBeans IDE 4.0有与JDK 5.0 Update 1的捆绑版）。

说点题外话，Java的版本号自从1.2开始，似乎就多少显得有点蹩脚。

从1.2版本开始，Java (J2SE)被称作Java 2，而不是Java 1.2，现在则显得更加离奇：Java(TM) 2 Platform Standard Edition 5.0或者J2SE(TM) 5.0，而内部的版本号还是1.5.0。

那么到底是1、2、还是5呢？来看看Sun官方网站是怎么说的：从Java诞生至今已有9年时间，而从第二代Java平台J2SE算起也有5个年头了。

在这样的背景下，将下一个版本的版本号从1.5改为5.0可以更好的反映出新版J2SE的成熟度、稳定性、可伸缩性和安全性。

好吧，现在我们将面对如下一些名称，而它们指的基本上是同一个东西：TigerJava(TM) 2 Platform Standard Edition 5.0J2SE(TM) 5.0Java version 1.5.0…在本文中，为了方便起见，我将统一使用J2SE(TM) 5.0这个名称。

如果你对Java各个版本的代号感兴趣，就像这里的"Tiger"，可以参考如下网址：/j2se/codenames.html。

JDK1.5 JDK1.6 各自的新特性

JDK1.5(JDK5.0)Java2标准版(Java 2 Platform, Standard Edition, J2SE)1.5版本更新不同于以往，它带来了很多里程碑式的革新，SUN将其绰号取名为“虎”。

这一次的变革将是Java诞生以来从未有过的，它给我们带来了耳目一新的感觉。

下面我们就来欣赏一下其中的部分典型变化：比较JDK版本，JDK 1.5中新增的语言特性：1．枚举（增加了一个关键字enum）；2．变参（方法参数数量可以不固定多少）；3．泛型；4．自动拆装箱（基本类型与包装类型可以混用）；5．foreach循环（方法地用于遍历数组和集合）；6．静态导入（可以在使用静方法前不加类名）；7．注释（采用@前缀，这个基本上是为了简化J2EE而准备的，在JavaEE5中的EJB3、JPA 等中随处可以看到它的身影）。

在JVM、基本类库、SDK工具和硬件平台支持上都有很多的提高，这个JDK版本的出现可以说是Java中的一次飞越。

具体的解释下：1.自动包装和解包(Autoboxing and unboxing)代码示例往一个ArrayList中加入一个整数，1.5版本以前的版本写法是：List list = new ArrayList();list.add( new Integer( 10 ) );而在1.5版本中可以写为：list.add( 10 );因为，在1.5版本中，对一个整数进行包装，使之成为一个Integer对象(即包装，boxing)，然后加入到一个ArrayList中的做法被认为是没有必要的，反之，解包(unboxing)的做法也是没有必要的，这样的代码只是增加了程序的文本长度而已，所以1.5版本支持了自动包装和解包操作，对于bool/Boolean，byte/Byte，double/Double，short/Short，int/Integer，long/Long，float/Float的相应包装/解包操作都进行了支持，从而使代码变得简单。

JDk以及各个版本的区别

JDK的含义：java development kit是程序员编写java程序需要的软件，JDK是整个java 的核心，包括了java运行环境、java工具和java基础的类库。

JDK包含的基本组件包括：.javac—编译器，将源程序转成字节码.jar—打包工具，将相关的类文件打包成一个文件.javadoc—文档生成器，从源码注释中提取文档.jdb—debugger，查错工具.java—运行编译后的java程序appletviewer:小程序浏览器，一种执行HTML文件上的java小程序的java浏览器。

javah:产生可以调用java过程的C过程，或建立能被java程序调用的C过程的头文件。

javap：java反汇编器，显示编译类文件中的可访问功能和数据，同时显示字节代码含义。

jconsole:java进行系统调试和监控的工具。

ng：这个是系统的基础类，比如String等都是这里面的，这个package是唯一一个可以不用import就可以使用的package;java.io:这里面有所有输入输出有关的类，比如文件操作等；:这是与网络有关的类，比如URL,URLConnection等；java.util:这个是系统辅助类，特别是集合类Collection,List,Map等；java.sql:这个是数据库操作的类，Connection,Statement,ResultSet等；javax.servlet这个是JSP，Servlet等使用到的类；JDK各个版本的新特性：jdk1.5的新特性（代号：猛虎）：1.静态导入（import static）import语句可以导入一个类或是某个包中的所有类。

import static 语句可以导入一个类中的某个静态方法或是所有静态方法。

例如：Math类提供了很多于数学运算的静态方法，通常情况下我们是以Math.abs();这样的方式来进行调用函数的。

但是我们可不可以只写出adb();在JDK1.5之后，可以使用import static 语句导入一个类中的某个静态方法或是所有静态方法。

张孝祥java高新特性个人整理(上)

Java高新技术 (2)课程内容 (2)Eclipse的使用技巧 (4)1名词翻译面试题 (4)2Java开发阶段和运行阶段使用的jdk可分别设置 (5)3workspace工作间概念 (5)调试，查看变量的值（面试） (5)透视图与视图的关系 (6)配置单个工程的javac和java (6)Eclipse里的各种模版，可以新建 (7)StaticImport静态导入 (7)方法的可变参数VariableParameter (7)自动裝箱和自动拆箱AutoBox (7)自动裝箱细节-基本数据类型缓存（享元模式） (8)枚举Enum (8)普通类模拟枚举 (8)Enum的基本使用 (9)实现带有构造方法的枚举 (9)实现带有抽象方法的枚举 (10)反射的基石-Class类 (10)如何得到各个字节码对应的实例对象（Class类） (10)理解反射的概念 (11)反射里的Construct类 (11)反射是比较耗时的，大量使用会降低程序性能 (11)成员变量Field类 (11)暴力反射 (11)将任意对象的String属性的值里的b字符替换成a (12)数组与Object的关系 (12)不用循环语句打印数组的值 (12)Hashset的内部原理 (13)重写HashSet的equals方法时自变量参数必须是Object (14)Hashcode方法与equals方法的关系 (14)Hashset存后又修改元素导致的内存泄漏 (14)框架要解决的核心问题 (15)最小框架实现 (15)什么是JavaBean (16)内省（xing）->InterSpector 内窥 (16)简单的内省操作 (16)使用BeanUtils工具包设置和读取JavaBean属性 (17)BeanUtils使用详解 (17)JDK里的注解 (18)什么是注解（Annotation）？ (18)自定义注解及其应用 (20)为注解增加基本属性 (20)为注解增加高级属性 (21)泛型 (21)使用反射可以跳过编译期向泛型集合中添加别的类型数据 (21)你了解泛型（术语）吗？ (22)泛型中的？通配符 (22)泛型中的？通配符的扩展 (23)泛型应用：遍历参数化HashMap (23)由c++的模版函数引入自定义泛型<T>方法（重点） (25)交换任意数组中的两个元素位置泛型语法实现 (25)编译器不会对int[]数组里面的int进行自动裝箱和自动拆箱 (26)泛型方法练习题 (26)类型参数的类型推断(难点） (27)定义泛型类型 (27)通过反射获得泛型的参数化类型 (28)类加载器（参考虚拟机详解笔记） (28)Java高新技术课程内容===================第1单元：概述======================01.课程价值与目标介绍===============第2单元：eclipse开发工具================02.eclipse及IDE开发工具介绍03.eclipse工程管理与快捷键配置04.eclipse视图管理与程序调试05.配置eclispe的编译与运行环境06.在eclispe中配置java模板代码07.在eclipse中导入已有的工程==========第3单元：java5的一些简单新特性===============08.java5的静态导入与编译器语法设置09.可变参数与OverLoad相关面试题分析10.java5的增加for循环11.基本数据的自动拆装箱及享元设计模式=================第4单元：java5的枚举==================12.枚举的作用介绍13.用普通类模拟枚举的实现原理14.java5的枚举的基本应用15.实现带有构造方法的枚举16.实现带有抽象方法的枚举=================第5单元：反射的深入讲解===============17.透彻分析反射的基础_Class类18.理解反射的概念19.构造方法的反射应用20.成员变量的反射21.成员变量反射的综合案例22.成员方法的反射23.对接收数组参数的成员方法进行反射24.数组与Object的关系及其反射类型25.数组的反射应用26.ArrayList_HashSet的比较及Hashcode分析27.框架的概念及用反射技术开发框架的原理28.用类加载器的方式管理资源和配置文件29.由内省引出JavaBean的讲解30.对JavaBean的简单内省操作31.对JavaBean的复杂内省操作32.使用BeanUtils工具包操作JavaBean================第6单元：java5的注解===================33.了解和入门注解的应用34.注解的定义与反射调用35.为注解增加各种属性================第7单元：java5的泛型===================36.入门泛型的基本应用37.泛型的内部原理及更深应用38.泛型的通配符扩展应用39.泛型集合的综合应用案例40.自定义泛型方法及其应用41.自定义泛型方法的练习与类型推断总结42.自定义泛型类的应用43.通过反射获得泛型的实际类型参数=========第8单元：类加载器的深入讲解与应用=============44.类加载器及其委托机制的深入分析45.自定义类加载器的编写原理分析46.编写对class文件进行加密的工具类47.编写和测试自己编写的解密类加载器48.类加载器的一个高级问题的实验分析==========第9单元：动态代理技术的深入讲解==============49.分析代理类的作用与原理及AOP概念50.创建动态类及查看其方法列表信息51.创建动态类的实例对象及调用其方法52.完成InvocationHandler对象的内部功能53.分析InvocationHandler对象的运行原理54.总结分析动态代理类的设计原理与结构55.编写可生成代理和插入通告的通用方法56.实现类似spring的可配置的AOP框架=======第10单元（待补充整理）：多线程及java5的线程并发库========57.创建和启动线程的两种传统方式58.传统的定时器实现方式59.传统的线程同步互斥60.传统的线程间通讯61.多线程访问共享数据的经典总结62.ThreadLocal与线程级变量共享63.Java5中的线程池64.Java5中的定时器65.java5提供的可返回结果的线程模式66.java5中的锁与读写锁67.Semaphore同步工具68.CyclicBarrier同步工具69.CountDownLatch同步工具70.Exchanger同步与数据交换工具71.Java5中的可阻塞队列72.传统与java5中的同步集合Eclipse的使用技巧1名词翻译面试题面试的时候包名写公司的倒转域名，面试interviewJDK就是Java Development Kit它包含开发工具包和JRE(运行时环境包)JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。

java 21 使用笔记

java 21 使用笔记Java 21 是一个较新的 Java 版本，带来了许多新特性和改进。

以下是一些使用 Java 21 的笔记：1. 新的 JDK 版本Java 21 是 Oracle JDK 的一个版本，它提供了最新的 Java 标准和库。

与之前的版本相比，Java 21 引入了许多新功能和改进，包括对 ZGC 和 Shenandoah 垃圾收集器的改进、对 JIT 编译器的改进以及对 JavaFX 的更新。

2. ZGC 和 Shenandoah 垃圾收集器Java 21 引入了对 ZGC 和 Shenandoah 垃圾收集器的改进。

ZGC 和 Shenandoah 是两种可选的垃圾收集器，它们可以提供更好的性能和更低的延迟。

在 Java 21 中，ZGC 和 Shenandoah 的性能得到了进一步改进，可以更好地处理大型应用程序和工作负载。

3. JIT 编译器改进Java 21 对JIT（即时）编译器进行了改进，以提高应用程序的性能。

JIT 编译器是将字节码转换为本地代码的组件，它在运行时将 Java 代码编译成本地代码，以提高性能。

在 Java 21 中，JIT 编译器进行了优化，可以更好地处理热点代码和循环，从而提高应用程序的性能。

4. JavaFX 更新JavaFX 是用于构建桌面应用程序的库，它包含了许多用于创建图形用户界面、处理多媒体和网络通信等的类和接口。

在 Java 21 中，JavaFX 得到了更新，包括对 UI、布局和动画的改进以及对一些新功能的支持。

使用 JavaFX，可以轻松地创建具有吸引力和功能强大的桌面应用程序。

5. 其他新特性Java 21 还包含了许多其他新特性和改进，例如对 Unicode 14 的支持、对 HTTP/2 的改进以及对 Java API for WebSocket 的更新。

使用这些新特性和改进，可以更好地构建和扩展应用程序，并提高应用程序的性能和安全性。

Java8，java9和java11的特性和区别！

Java8，java9和java11的特性和区别！Java8，java9和java11的特性总结！Java 8 的主要新特性1. Lambda 表达式Lambda 允许把函数作为⼀个⽅法的参数传递进⽅法中。

作⽤：解决 Java 被诟病的匿名内部类的问题。

2. 接⼝中可增加了默认⽅法作⽤：在接⼝中也可以有实现⽅法了。

3. HashMap 底层数据结构的变化java 8 之前，HashMap 底层的数据结构是数组+链表实现的， Java 8 之后是数组+链表+红⿊树实现的，当链表的长度超过 8 之后，会转换成红⿊树。

作⽤：解决因哈希冲突导致的链表过长，查询效率低的问题。

4. Stream API新添加 Stream API (java.util.stream)，把真正函数式编程的风格引⼊ Java。

5. 提供⼀个新的 JavaScript 引擎Java 8 提供了⼀个新的 Nashorn JavaScript 引擎，它允许在 JVM 上运⾏特定的 JavaScript 应⽤。

作⽤：解决⽇益增长的 Java 跟 JS 交互混合的需求。

Java 9 新特性1. 模块系统模块是⼀个包的容器，Java 9 最⼤的变化之⼀是引⼊模块系统。

（Jigsaw 项⽬）作⽤：解决⼤型项⽬模块化开发的需求。

2. ⽀持 HTTP/2 标准HTTP/2 标准是 HTTP 协议的最新版本，新的 HTTPClient API ⽀持 Websocket 和 HTTP2 流以及服务器推送特性。

3. 提供创建不可变集合的静态⼯⼚⽅法List、Set、Map 接⼝中，提供新的静态⼯⼚⽅法直接创建不可变的集合实例。

作⽤：创建不可变集合更⽅便，⼀⾏代码就搞定，节省了开销。

4. 私有接⼝⽅法在接⼝中也允许编写 private 修饰的私有⽅法了。

作⽤：增强了接⼝的功能，提⾼了可扩展性。

5. 轻量级的 JSON API内置了⼀个轻量级的 JSON API。

jsr 305标准

jsr 305标准在软件开发领域，规范和标准的制定对确保代码的质量和可维护性至关重要。

JSR 305标准（Java Specification Request 305）就是软件开发过程中的一个重要标准，本文将对其进行详细介绍和讨论。

一、JSR 305标准概述JSR 305标准是由Sun Microsystems（现在是Oracle Corporation）提出的一个规范，其目的是提供一套注解（Annotation）以帮助开发人员识别和修复代码中的缺陷、错误和潜在的风险。

这些注解可以用于方法、类和字段上，以提供对代码的额外信息和限制。

二、常用注解1. @Nullable和@Nonnull：这两个注解用于标识变量或方法的返回值是否可以为null。

@Nullable表示允许为null，@Nonnull表示不允许为null。

使用这些注解可以减少空指针异常的风险。

2. @CheckReturnValue：该注解用于标识方法的返回值应该被检查，以确保调用方对返回值进行合理处理。

这可以帮助开发人员避免忽略方法的返回值，从而提高代码的健壮性。

3. @ReadOnly和@Mutable：这两个注解用于标识字段或方法参数的可变性。

@ReadOnly表示只读，不可修改；@Mutable表示可变，可以被修改。

使用这些注解可以提醒开发人员遵循正确的访问权限和修改规则，从而减少潜在的错误和问题。

4. @VisibleForTesting：该注解用于标识方法或字段是为了测试而暴露的，不建议在正式的代码中使用。

这可以帮助开发人员区分测试代码和生产代码，避免将不应该暴露的方法或字段暴露给外部。

三、使用示例下面是一个简单的示例，展示了如何使用JSR 305标准中的注解：```javapublic class ExampleClass {@Nullableprivate String nullableField;@Nonnullprivate String nonnullField;public ExampleClass(@Nonnull String nonnullField) {this.nonnullField = nonnullField;}@CheckReturnValuepublic String processString(@Nullable String input) {if (input == null) {return "";}return input.trim();}@ReadOnlypublic void printField() {System.out.println(nonnullField);}@VisibleForTestingpublic String getNonnullField() {return nonnullField;}}```在上面的示例中，我们使用了@Nullable和@Nonnull注解来明确标识了两个字段的属性。

JDK1.8新特性Lambda表达式简化if-else里都有for循环的优化方式

JDK1.8新特性Lambda表达式简化if-else⾥都有for循环的优化⽅式在⽇常开发过程当中，能把代码写出来，不⼀定就意味着能把代码写好，说不准，所写的代码在他⼈看来，其实就是⼀坨乱七⼋糟的翔，因此，代码简化尤其重要，我曾经遇到过这样⼀个类型的代码，即if-else⾥都有相同的for循环，这时，我就思考了，如何简化它可以既提⾼代码性能⼜减少代码量。

1public static void main(String[] args) {2 String status = "is";3 String[] arrayStr = {"1", "3", "4", "6"};4if ("is".equals(status)) {5for (int i = 0; i < arrayStr.length; ++i) {6 System.out.println("执⾏了正确的⽅法");7 }8 } else {9for (int i = 0; i < arrayStr.length; ++i) {10 System.out.println("执⾏了错误的⽅法");11 }1213 }14 }研究了⼀番后，发现jdk1.8有⼀个Lambda新特性，其实，这玩意很有⽤，若能熟悉它，可以减少很多的代码量，也能⼀定提⾼代码的性能，例如，我通过Lambda表达式将上⾯的代码简化这了这样，看起来是不是就没那么冗余了：1public static void main(String[] args) {2 String status = "is";3 String[] arrayStr = {"1", "3", "4", "6"};45 Arrays.asList(arrayStr).stream().forEach(6 (e) -> {7if ("is".equals(status)) {8 System.out.println("执⾏了正确的⽅法");9 } else {10 System.out.println("执⾏了错误的⽅法");11 }12 }13 );14 }。

【计算机专业文献翻译】在 JDK 早期版本中使用 Java 5 的语言特性

Using Java 5 language features in earlier JDK Java 5 added a number of powerful language features: generics, enumerations, annotations, autoboxing, and the enhanced for loop. However, many shops are still tied to JDK 1.4 or earlier and may be for some time to come. But it's still be possible for those developers to take advantage of these powerful language features while continuing to deploy on earlier JVMs. Brian Goetz returns from his hiatus in this installment of Java theory and practice to demonstrate how.With Java 6.0 being newly released, you might think the Java 5 language features are "old news." But even now, when I ask developers which version of the Java platform they are using in development, typically only half are using Java 5 -- and the other half are jealous. They are eager to use the language features added in Java 5 such as generics and annotations, but a number of factors still prevent many from doing so.One category of developers unable to take advantage of Java 5 features are those who develop components, libraries, or application frameworks. Because their customers may still be using JDK 1.4 or earlier and classes compiled with Java 5 cannot be loaded by JDK 1.4 or previous JVMs, using Java 5 language features would limit their customer base to companies that have already transitioned to Java 5.Another group of developers often held back from using Java 5 are those working with Java EE. Many shops will not use Java 5 with Java EE 1.4 or earlier for fear that it will not be supported by their application server vendor. But it may be a while before those shops transition to Java EE 5. In addition to the lag time between the Java EE 5 and Java SE 5 specifications, commercial Java EE 5 containers are not necessarily available as soon as the ink is dry on the specification, businesses do not necessarily upgrade theirapplications servers as soon as the next version is available, and even after upgrading their application server, it may take some time to certify their applications on the new platform.Java 5 language feature implementationThe language features added in Java 5 -- generics, enumerations, annotations, autoboxing, and the enhanced for loop -- required no change to the JVM instruction set, and are almost entirely implemented in the static compiler (javac) and class libraries. When the compiler encounters the use of generics, it attempts to verify that type safety is preserved (emitting an "unchecked cast" warning if it cannot) and then emits bytecode that is identical to what would be produced from equivalent nongeneric code, casts and all. Similarly, autoboxing and the enhanced for loop are simply "syntactic sugar" for equivalent, but more verbose, idioms, and enumerations are compiled into ordinary classes.In theory, you could take the class files produced by javac and load them in earlier JVMs, which was, in fact, the intention when JSR 14 (the Java Community Process working group responsible for generics) was convened. However, other issues (such as retention of annotations) forced the class file version to be changed between Java 1.4 and Java 5, which prevents code compiled for Java 5 to be loaded by earlier JVMs. Further, some of the language features added in Java 5 have dependencies on the Java 5 libraries. If you compile a class with javac -target 1.5 and try to load it on an earlier JVM, you'll get an UnsupportedClassVersionError because the -target 1.5 option generates classes with a class file version of 49, and JDK 1.4 only supports class file versions through 48.The for-each loopThe enhanced for loop, sometimes called the for-each loop, is translated by the compiler as if the programmer had supplied the equivalent old-stylefor loop. The for-each loop can iterate over the elements of an array or of a collection. Listing 1 shows the syntax of iterating over a collection with the for-each loop:Listing 1. The for-each loopCollection<Foo> fooCollection = ...for (Foo f : fooCollection) {doSomething(f);}The compiler translates this code into the equivalent iterator-based loop, as shown in Listing 2:Listing 2. Iterator-based equivalent for Listing 1for (Iterator<Foo> iter=f.iterator(); f.hasNext();) {Foo f = (Foo)iter.next();doSomething(f);}How does the compiler know that the supplied argument has an iterator() method? The architects of the javac compiler could have built in understanding of the collections framework, but this approach would have been unnecessarily restrictive. Instead, a new interface was created, ng.Iterable (see Listing 3), and the collection classes were retrofitted to implement Iterable. This way, container classes that do not build on the core collections framework can still take advantage of the new for-each loop. But doing so creates a dependency on the Java 5 class library because Iterable is not present in the JDK 1.4 library.Listing 3. The Iterable interfacepublic interface Iterable<T> {Iterator<T> iterator();}Enumerations and autoboxingJust like the for-each loop, enumerations require support from the class library. When the compiler encounters an enumerated type, it generates a class that extends the library class ng.Enum. But, just like Iterable, the Enum class is not present in the JDK 1.4 class library.Similarly, autoboxing relies on the valueOf() methods being added to the primitive wrapper classes (such as Integer). When boxing requires conversion from int to Integer, rather than calling new Integer(int), the compiler generates a call to Integer.valueOf(int). The implementation of the valueOf() methods employs the flyweight pattern to cache the Integer objects for commonly used integer values (the Java 6 implementation caches integers from -128 to 127), which may improve performance by eliminating redundant instantiations. And, just like Iterable and Enum, the valueOf() methods are not present in the JDK 1.4 class library.VarargsWhen the compiler encounters a method defined with a variable-length argument list, it converts it into a method that takes an array of the appropriate component type; when the compiler encounters a call to a method with a variable-length argument list, it boxes the arguments into an array.AnnotationsWhen an annotation is defined, it can be annotated with @Retention, which determines what the compiler will do with classes, methods, or fields that possess that annotation. The defined retention policies are SOURCE (discard annotation data at compilation), CLASS (record annotations in the class file),or RUNTIME (record annotations in the class file and retain them at runtime so they can be accessed reflectively).Other library dependenciesPrior to Java 5, when the compiler encountered an attempt to concatenate two strings, it used the helper class StringBuffer to perform the concatenation. In Java 5 and later, it instead generates calls to the new StringBuilder class, which is not present in the JDK 1.4 and earlier class libraries.Accessing Java 5 featuresBecause of dependencies of language features on library support, even if the class files produced by the Java 5 compiler could be loaded by earlier JVM versions, execution would still fail because of class loading errors. However, it should be possible to solve these problems by suitably transforming the bytecode because these missing classes do not contain substantial new functionality.JSR 14During the development of the Java generics specification (and other language features added in Java 5), experimental support was added to the javac compiler to allow it to consume Java 5 language features and generate bytecode that could be run on a Java 1.4 JVM. While these features are not supported (or even documented), they are used by a number of open source projects to allow developers to code using Java 5 language features and produce JAR files that can be used on earlier JVMs. And, now that javac is open source, it is possible the features might be supported by a third party. To activate these features, you can invoke javac with the -source 1.5 and -target jsr14 options.The JSR 14 target mode of javac causes the compiler to emit JDK 1.4-compatible bytecode corresponding to Java 5 language features:∙Generics and varargs: The casts inserted by the compiler in the presence of generics have no dependency on the class library, and so they can execute equally well on a pre-5 JVM. Similarly, the code generated by the compiler in the presence of variable-length argument lists has no dependency on the class library.∙for-each loop: When iterating over an array, the compiler generates an induction variable and the standard array iteration idiom. When iterating over a Collection, the compiler generates the standard iterator-based idiom. When iterating over a non-Collection Iterable, the compiler produces an error.∙Autoboxing: Rather than generating calls to the valueOf() method in the wrapper class, the compiler generates calls to the constructor instead.∙String concatenation: The JSR 14 target mode of javac causes the compiler to generate calls to StringBuffer instead of StringBuilder.∙Enumerations: The JSR 14 target mode of javac has no special support for enumerations. Code that attempts to use enumerations will fail with a NoClassDefFoundError looking for the ng.Enum base class.Using the JSR 14 target mode allows you to write code that uses generics, autoboxing, and the for-each loop in the "easy" cases, which may suffice for many projects. It is convenient, if unsupported, and the compiler generates mostly compatible bytecode in a single pass.RetroweaverThere are certain Java 5 language features not supported by the JSR 14 target mode (such as Iterable and enumerations). An alternate approach, taken by open-source projects such as Retroweaver and Retrotranslator, is to generate bytecode using -target 1.5 and then mechanically transform the bytecode into something compatible with JDK 1.4.Retroweaver came first, and it handled all the cases handled by javac -target JSR 14, and a few more:∙The for-each loop: Retroweaver provides an implementation of the Iterable interface and rewrites classes that implement Iterable to implement its own version instead.∙Autoboxing: Retroweaver rewrites calls to the valueOf() methods to the corresponding constructors.∙String concatenation: Retroweaver replaces use of StringBuilder with StringBuffer.∙Enumerations: Retroweaver provides an implementation of the Enum base class and rewrites classes that implement Enum or invoke its methods to use its own version instead.RetrotranslatorAs often happens in the open source world, if a project stops moving forward, it is declared dead and a new project takes its place -- even if it is just resting. Such was the fate of Retroweaver; the primary maintainer took a break from the project and another similar project, Retrotranslator, took its place. Retrotranslator offers the same features as Retroweaver, plus many additional features aimed at supporting important class library additions in Java 5:∙Replaces calls to java.util.concurrent classes to corresponding classes in the open-source JDK 1.4 backport.∙Provides implementations for features added to the collections framework in Java 5, such as the new methods in Arrays and Collections. Similarly, provides implementations of other new methods and classes added to the class library in Java 5.∙Supports runtime reflection for annotations.Both Retroweaver and Retrotranslator can perform their bytecode transformation statically (at compile time) or dynamically (at class-load time).在 JDK 早期版本中使用 Java 5 的语言特性Java 5 添加了许多强大的语言特性：泛型、枚举、注释、自动装箱和增强的 for 循环。

JDK各个版本发布时间和版本名称

JDK各个版本发布时间和版本名称版本名称发⾏⽇期JDK 1.0Oak(橡树)1996-01-23JDK 1.11997-02-19JDK 1.1.4Sparkler（宝⽯）1997-09-12JDK 1.1.5Pumpkin（南⽠）1997-12-13JDK 1.1.6Abigail（阿⽐盖尔–⼥⼦名）1998-04-24JDK 1.1.7Brutus（布鲁图–古罗马政治家和将军）1998-09-28JDK 1.1.8Chelsea（切尔西–城市名）1999-04-08J2SE 1.2Playground（运动场）1998-12-04J2SE 1.2.1none（⽆）1999-03-30J2SE 1.2.2Cricket（蟋蟀）1999-07-08J2SE 1.3Kestrel（美洲红隼）2000-05-08J2SE 1.3.1Ladybird（瓢⾍）2001-05-17J2SE 1.4.0Merlin（灰背隼）2002-02-13J2SE 1.4.1grasshopper（蚱蜢）2002-09-16J2SE 1.4.2Mantis（螳螂）2003-06-26Java SE 5.0 (1.5.0)Tiger（⽼虎）2004-09-30Java SE 6.0 (1.6.0)Mustang（野马）2006-04Java SE 7.0 (1.7.0)Dolphin（海豚）2011-07-28Java SE 8.0 (1.8.0)Spider（蜘蛛）2014-03-18Java SE 9.02017-09-21Java SE 10.02018-03-21Java SE 11.02018-09-25从这个表中我们可以看出⼀个⾮常有意思的现象，就是JDK的每⼀个版本号都使⽤⼀个开发代号表⽰（就是表中的中⽂名）。

⽽且从JDK1.2.2 开始,主要版本(如1.3,1.4,5.0)都是以鸟类或哺乳动物来命名的. ⽽它们的bug修正版本(如1.2.2,1.3.1,1.4.2)都是以昆⾍命名的。

CMPP30接口使用手册(JAVA版本)

3
通信协议................................................................................................................................... 6 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 阅读说明........................................................................................................................... 6 LOGIN 消息体................................................................................................................... 6 LOGIN RESPONSE 消息体 .................................................................................................. 7 LOGOUT 消息体 ............................................................................................................... 7 LOGOUT RESPONSE 消息体 ............................................................................................... 7 SUBMIT 消息体 ................................................................................................................ 7 SUBMIT RESPONSE 消息体 ................................................................................................ 8 DELIVER 消息体 ............................................................................................................... 9 DELIVER RESPONSE 消息体 ............................................................................................ 11 CANCEL 消息体 .............................................................................................................. 12 CANCEL RESPONSE 消息体 ............................................................................................. 12 ACTIVE 消息体 ............................................................................................................... 12 ACTIVE RESPONSE 消息体 .............................................................................................. 12