乐趣区

关于java:ApacheCN-Java-译文集-20211012-更新

  • Effective Java 中文第三版

    • 1. 思考应用动态工厂办法代替构造方法
    • 2. 当构造方法参数过多时应用 builder 模式
    • 3. 应用公有构造方法或枚类实现 Singleton 属性
    • 4. 应用公有结构器执行非实例化
    • 5. 依赖注入优于硬连贯资源(hardwiring resources)
    • 6. 防止创立不必要的对象
    • 7. 打消过期的对象援用
    • 8. 防止应用 Finalizer 和 Cleaner 机制
    • 9. 应用 try-with-resources 语句代替 try-finally 语句
    • 10. 重写 equals 办法时恪守通用约定
    • 11. 重写 equals 办法时同时也要重写 hashcode 办法
    • 12. 始终重写 toString 办法
    • 13. 审慎地重写 clone 办法
    • 14. 思考实现 Comparable 接口
    • 15. 使类和成员的可拜访性最小化
    • 16. 在公共类中应用拜访办法而不是公共属性
    • 17. 最小化可变性
    • 18. 组合优于继承
    • 19. 要么设计继承并提供文档阐明,要么禁用继承
    • 20. 接口优于抽象类
    • 21. 为后辈设计接口
    • 22. 接口仅用来定义类型
    • 23. 类层次结构优于标签类
    • 24. 反对应用动态成员类而不是非动态类
    • 25. 将源文件限度为单个顶级类
    • 26. 不要应用原始类型
    • 27. 打消非查看正告
    • 28. 列表优于数组
    • 29. 优先思考泛型
    • 30. 优先应用泛型办法
    • 31. 应用限定通配符来减少 API 的灵活性
    • 32. 正当地联合泛型和可变参数
    • 33. 优先思考类型平安的异构容器
    • 34. 应用枚举类型代替整型常量
    • 35. 应用实例属性代替序数
    • 36. 应用 EnumSet 代替位属性
    • 37. 应用 EnumMap 代替序数索引
    • 38. 应用接口模仿可扩大的枚举
    • 39. 注解优于命名模式
    • 40. 始终应用 Override 注解
    • 41. 应用标记接口定义类型
    • 42. lambda 表达式优于匿名类
    • 43. 办法援用优于 lambda 表达式
    • 44. 优先应用规范的函数式接口
    • 45. 理智审慎地应用 Stream
    • 46. 优先思考流中无副作用的函数
    • 47. 优先应用 Collection 而不是 Stream 来作为办法的返回类型
    • 48. 审慎应用流并行
    • 49. 查看参数有效性
    • 50. 必要时进行防御性拷贝
    • 51. 认真设计办法签名
    • 52. 理智审慎地应用重载
    • 53. 理智审慎地应用可变参数
    • 54. 返回空的数组或汇合,不要返回 null
    • 55. 理智审慎地返回 Optional
    • 56. 为所有已公开的 API 元素编写文档正文
    • 57. 最小化局部变量的作用域
    • 58. for-each 循环优于传统 for 循环
    • 59. 理解并应用库
    • 60. 若须要准确答案就应防止应用 float 和 double 类型
    • 61. 根本数据类型优于包装类
    • 62. 当应用其余类型更适合时应防止应用字符串
    • 63. 当心字符串连贯引起的性能问题
    • 64. 通过接口援用对象
    • 65. 接口优于反射
    • 66. 理智审慎地本地办法
    • 67. 理智审慎地进行优化
    • 68. 恪守被宽泛认可的命名约定
    • 69. 只针对异样的状况下才应用异样
    • 70. 对可复原的状况应用受检异样,对编程谬误应用运行时异样
    • 71. 防止不必要的应用受检异样
    • 72. 优先应用规范的异样
    • 73. 抛出与形象对应的异样
    • 74. 每个办法抛出的异样都须要创立文档
    • 75. 在细节音讯中蕴含失败一捕捉信息
    • 76. 放弃失败原子性
    • 77. 不要疏忽异样
    • 78. 同步访问共享的可变数据
    • 79. 防止适度同步
    • 80. executor、task 和 stream 优先于线程
    • 81. 并发工具优于 wait 和 notify
    • 82. 文档应蕴含线程平安属性
    • 83. 理智审慎的应用提早初始化
    • 84. 不要依赖线程调度器
    • 85. 优先选择 Java 序列化的代替计划
    • 86. 十分审慎地实现 Serializable
    • 87. 思考应用自定义的序列化模式
    • 88. 保护性的编写 readObject 办法
    • 89. 对于实例管制,枚举类型优于 readResolve
    • 90. 思考用序列化代理代替序列化实例
  • Thinking in Java (Java 编程思维)

    • 写在后面的话
    • 引言
    • 第 1 章 对象入门

      • 1.1 形象的提高
      • 1.2 对象的接口
      • 1.3 实现计划的暗藏
      • 1.4 计划的重复使用
      • 1.5 继承:从新应用接口
      • 1.6 多态对象的调换应用
      • 1.7 对象的创立和存在工夫
      • 1.8 异样管制:解决谬误
      • 1.9 多线程
      • 1.10 永久性
      • 1.11 Java 和因特网
      • 1.12 剖析和设计
      • 1.13 Java 还是 C ++
    • 第 2 章 一切都是对象

      • 2.1 用援用操纵对象
      • 2.2 所有对象都必须创立
      • 2.3 相对不要革除对象
      • 2.4 新建数据类型:类
      • 2.5 办法、参数和返回值
      • 2.6 构建 Java 程序
      • 2.7 咱们的第一个 Java 程序
      • 2.8 正文和嵌入文档
      • 2.9 编码款式
      • 2.10 总结
      • 2.11 练习
    • 第 3 章 管制程序流程

      • 3.1 应用 Java 运算符
      • 3.2 执行管制
      • 3.3 总结
      • 3.4 练习
    • 第 4 章 初始化和革除

      • 4.1 用结构器主动初始化
      • 4.2 办法重载
      • 4.3 革除:收尾和垃圾收集
      • 4.4 成员初始化
      • 4.5 数组初始化
      • 4.6 总结
      • 4.7 练习
    • 第 5 章 暗藏实现过程

      • 5.1 包:库单元
      • 5.2 Java 拜访批示符
      • 5.3 接口与实现
      • 5.4 类拜访
      • 5.5 总结
      • 5.6 练习
    • 第 6 章 类复用

      • 6.1 組合的语法
      • 6.2 继承的语法
      • 6.3 组合与继承的联合
      • 6.4 到底抉择组合还是继承
      • 6.5 protected
      • 6.6 累积开发
      • 6.7 向上转换
      • 6.8 final关键字
      • 6.9 初始化和类装载
      • 6.10 总结
      • 6.11 练习
    • 第 7 章 多态性

      • 7.1 向上转换
      • 7.2 深刻了解
      • 7.3 笼罩与重载
      • 7.4 抽象类和办法
      • 7.5 接口
      • 7.6 外部类
      • 7.7 结构器和多态性
      • 7.8 通过继承进行设计
      • 7.9 总结
      • 7.10 练习
    • 第 8 章 对象的包容

      • 8.1 数组
      • 8.2 汇合
      • 8.3 枚举器(迭代器)
      • 8.4 汇合的类型
      • 8.5 排序
      • 8.6 通用汇合库
      • 8.7 新汇合
      • 8.8 总结
      • 8.9 练习
    • 第 9 章 异样差错控制

      • 9.1 根本异样
      • 9.2 异样的捕捉
      • 9.3 规范 Java 异样
      • 9.4 创立本人的异样
      • 9.5 异样的限度
      • 9.6 用 finally 革除
      • 9.7 结构器
      • 9.8 异样匹配
      • 9.9 总结
      • 9.10 练习
    • 第 10 章 Java IO 零碎

      • 10.1 输出和输入
      • 10.2 削减属性和有用的接口
      • 10.3 自身的缺点:RandomAccessFile
      • 10.4 File 类
      • 10.5 IO 流的典型利用
      • 10.6 StreamTokenizer
      • 10.7 Java 1.1 的 IO 流
      • 10.8 压缩
      • 10.9 对象序列化
      • 10.10 总结
      • 10.11 练习
    • 第 11 章 运行期类型辨认

      • 11.1 对 RTTI 的须要
      • 11.2 RTTI 语法
      • 11.3 反射:运行期类信息
      • 11.4 总结
      • 11.5 练习
    • 第 12 章 传递和返回对象

      • 12.1 传递援用
      • 12.2 制作本地正本
      • 12.3 克隆的管制
      • 12.4 只读类
      • 12.5 总结
      • 12.6 练习
    • 第 13 章 创立窗口和程序片

      • 13.1 为何要用 AWT?
      • 13.2 根本程序片
      • 13.3 制作按钮
      • 13.4 捕捉事件
      • 13.5 文本字段
      • 13.6 文本区域
      • 13.7 标签
      • 13.8 复选框
      • 13.9 单选钮
      • 13.10 下拉列表
      • 13.11 列表框
      • 13.12 布局的管制
      • 13.13 action的替代品
      • 13.14 程序片的局限
      • 13.15 视窗化利用
      • 13.16 新型 AWT
      • 13.17 Java 1.1 用户接口 API
      • 13.18 可视编程和 Beans
      • 13.19 Swing 入门(正文⑦)
      • 13.20 总结
      • 13.21 练习
    • 第 14 章 多线程

      • 14.1 反馈灵活的用户界面
      • 14.2 共享无限的资源
      • 14.3 梗塞
      • 14.4 优先级
      • 14.5 回顾 runnable
      • 14.6 总结
      • 14.7 练习
    • 第 15 章 网络编程

      • 15.1 机器的标识
      • 15.10 练习
      • 15.2 套接字
      • 15.3 服务多个客户
      • 15.4 数据报
      • 15.5 一个 Web 利用
      • 15.6 Java 与 CGI 的沟通
      • 15.7 用 JDBC 连贯数据库
      • 15.8 近程办法
      • 15.9 总结
    • 第 16 章 设计模式

      • 16.1 模式的概念
      • 16.2 观察器模式
      • 16.3 模仿垃圾回收站
      • 16.4 改良设计
      • 16.5 形象的利用
      • 16.6 多重散发
      • 16.7 拜访器模式
      • 16.8 RTTI 真的无害吗
      • 16.9 总结
      • 16.10 练习
    • 第 17 章 我的项目

      • 17.1 文字处理
      • 17.2 办法查找工具
      • 17.3 复杂性实践
      • 17.4 总结
      • 17.5 练习
    • 附录 A 应用非 JAVA 代码
    • 附录 B 比照 C ++ 和 Java
    • 附录 C Java 编程规定
    • 附录 D 性能
    • 附录 E 对于垃圾收集的一些话
    • 附录 F 举荐读物
  • Java 8 扼要教程

    • Java 8 扼要教程
    • Java 8 数据流教程
    • Java 8 Nashorn 教程
    • Java 8 并发教程:线程和执行器
    • Java 8 并发教程:同步和锁
    • Java 8 并发教程:原子变量和 ConcurrentMap
    • Java 8 API 示例:字符串、数值、算术和文件
    • 在 Java 8 中防止 Null 查看
    • 应用 Intellij IDEA 解决 Java 8 的数据流问题
    • 在 Nashron 中应用 Backbone.js
  • Java 设计模式最佳实际

    • 零、前言
    • 一、从面向对象到函数式编程
    • 二、创立型模式
    • 三、行为模式
    • 四、构造模式
    • 五、函数式模式
    • 六、让咱们开始反应式吧
    • 七、反应式设计模式
    • 八、利用架构的发展趋势
    • 九、Java 最佳实际
  • Java 编程问题

    • 零、前言
    • 一、字符串、数字和数学
    • 二、对象、不变性和 switch 表达式
    • 三、应用日期和工夫
    • 四、类型推断
    • 五、数组、汇合和数据结构
    • 六、Java I/O 门路、文件、缓冲区、扫描和格式化
    • 七、Java 反射类、接口、结构器、办法和字段
    • 八、函数式编程 - 根底和设计模式
    • 九、函数式编程——深入研究
    • 十、并发 - 线程池、可调用对象和同步器
    • 十一、并发 - 深刻摸索
    • 十二、Optional
    • 十三、HTTP 客户端和 WebSocket API
  • Java 我的项目大全

    • 零、前言
    • 一、Java11 入门
    • 二、第一个真正的 Java 程序 - 排序名称
    • 三、优化排序代码
    • 四、Mastermind- 发明游戏
    • 五、扩大游戏 - 跑得并行,跑得更快
    • 六、使咱们的游戏专业化 - 将其作为 Web 利用
    • 七、应用 REST 构建商业 Web 利用
    • 八、扩大咱们的电子商务利用
    • 九、应用反应式编程构建会计利用
  • Java 12 编程学习手册

    • 零、前言
    • 第 1 节:Java 编程概述

      • 一、Java12 入门
      • 二、Java 面向对象编程(OOP)
      • 三、Java 根底
    • 第 2 节:Java 的构建块

      • 四、异样解决
      • 五、字符串、输出 / 输入和文件
      • 六、数据结构、泛型和风行工具
      • 七、Java 规范和内部库
      • 八、多线程和并发解决
      • 九、JVM 构造与垃圾收集
      • 十、治理数据库中的数据
      • 十一、网络编程
      • 十二、Java GUI 编程
    • 第 3 节:高级 Java

      • 十三、函数式程序设计
      • 十四、Java 规范流
      • 十五、反应式程序设计
      • 十六、微服务
      • 十七、Java 微基准线束
      • 十八、编写高质量代码的最佳实际
      • 十九、Java 新个性
    • 二十、答案
  • 精通 Java 11

    • 零、前言
    • 一、Java11 环境
    • 二、摸索 Java11
    • 三、Java11 根底
    • 四、用 Java11 构建模块化利用
    • 五、将利用迁徙到 Java11
    • 六、试用 Java Shell
    • 七、利用默认的 G1 垃圾收集器
    • 八、JMH 的微基准利用
    • 九、利用过程 API
    • 十、细粒度栈跟踪
    • 十一、新工具和工具加强性能
    • 十二、并发性加强
    • 十三、平安加强性能
    • 十四、命令行标记
    • 十五、Java 平台的其余加强性能
    • 十六、将来倒退方向
    • 十七、为 Java 平台做奉献
    • 十八、答案
  • Java 自动化测试初学者实用指南

    • 零、前言
    • 一、Java 中的第一个编程步骤
    • 二、理解 Java 中的类、对象及其用法
    • 三、在 Java 中解决字符串及其函数
    • 四、Java 程序–循环和条件的构建块
    • 五、您须要理解的对于接口和继承的所有信息
    • 六、理解无关数组的所有信息
    • 七、理解 Java11 中的日期类和结构器
    • 八、superthis 关键字和异样在 Java 中的重要性
    • 九、了解汇合框架
    • 十、final关键字、包和修饰符的重要性
  • Java9 高性能利用

    • 零、序言
    • 一、学习 Java 9 底层性能改良
    • 二、进步生产率和减速利用的工具
    • 三、多线程和反应式编程
    • 四、微服务
    • 五、利用新 API 改良代码
    • 六、测验答案
  • Java11 秘籍

    • 零、序言
    • 一、装置和对 Java11 的窥探
    • 二、面向对象编程的快速通道 - 类和接口
    • 三、模块化编程
    • 四、走向函数式
    • 五、流和管道
    • 六、数据库编程
    • 七、并发和多线程编程
    • 八、更好地治理操作系统过程
    • 九、应用 springboot 的 restfulWeb 服务
    • 十、网络
    • 十一、内存治理和调试
    • 十二、应用 JShell 的读取求值打印循环(REPL)
    • 十三、应用新的日期和工夫 API
    • 十四、测试
    • 十五、Java10 和 Java11 的编程新办法
    • 十六、将 JavaFX 用于 GUI 编程
  • 精通 JUnit5 软件测试

    • 零、序言
    • 一、软件品质与 Java 测试回顾
    • 二、JUnit5 有什么新性能
    • 三、JUnit5 规范测试
    • 四、应用高级 JUnit 个性简化测试
    • 五、JUnit5 与内部框架的集成
    • 六、从需要到测试用例
    • 七、测试治理
  • Java 测试驱动开发

    • 零、前言
    • 一、为什么我应该关怀测试驱动的开发?
    • 二、工具、框架和环境
    • 三、红绿重构——从失败到胜利,直到完满
    • 四、单元测试——关注你做了什么,而不是曾经做了什么
    • 五、设计——如果它不可测试,那么它就设计得不好
    • 六、模仿——删除内部依赖项
    • 七、TDD 和函数式编程——完满匹配
    • 八、BDD——与整个团队单干
    • 九、重构遗留代码——使其再次年老
    • 十、性能切换——将局部实现的性能部署到生产环境
    • 十一、把它们放在一起
    • 十二、通过实现间断交付利用 TDD
  • Java 云原生利用

    • 零、前言
    • 一、云原生简介
    • 二、编写第一个云原生利用
    • 三、设计您的云原生利用
    • 四、扩大云原生利用
    • 五、测试云原生利用
    • 六、云原生利用部署
    • 七、云原生利用运行时
    • 八、平台部署——AWS
    • 九、平台部署——Azure
    • 十、集成为服务
    • 十一、API 设计最佳实际
    • 十二、数字转型
  • Java 代码面试齐全指南

    • 零、序言
    • 第一节:面试的非技术局部

      • 一、从何处开始以及如何筹备面试
      • 二、大公司的面试是什么样的
      • 三、常见非技术性问题及解答
      • 四、如何解决失败
      • 五、如何应答编码挑战
    • 第二节:概念

      • 六、面向对象编程
      • 七、算法的大 O 剖析
      • 八、递归与动静布局
      • 九、位操作
    • 第三节:算法和数据结构

      • 十、数组和字符串
      • 十一、链表和地图
      • 十二、栈和队列
      • 十三、树与图
      • 十四、排序
      • 十五、数学与谜题
    • 第四节:处分——并发和函数式编程

      • 十六、并发
      • 十七、函数式编程
      • 十八、单元测试
      • 十九、零碎可扩展性
  • Java 基础知识

    • 零、序言
    • 一、Java 简介
    • 二、变量、数据类型和运算符
    • 三、管制流程
    • 四、面向对象编程
    • 五、深刻 OOP
    • 六、数据结构、数组和字符串
    • 七、Java 汇合框架和泛型
    • 八、Java 高级数据结构
    • 九、异样解决
    • 十、附录
  • JavaFX 基础知识

    • 零、序言
    • 一、JavaFX 8 入门
    • 二、JavaFX 8 根底和创立自定义 UI
    • 三、开发 JavaFX 桌面和 Web 利用
    • 四、为 Android 开发 JavaFX 利用
    • 五、为 iOS 开发 JavaFX 利用
    • 六、在 Raspberry Pi 上运行 JavaFX 利用
    • 七、应用 JavaFX 监控 Arduino
    • 八、应用 JavaFX 的交互式 Leap Motion 利用
    • 九、成为 JavaFX 巨匠
  • Java 编程入门

    • 零、前言
    • 一、计算机上的 Java 虚拟机(JVM)
    • 二、Java 语言根底
    • 三、您的开发环境设置
    • 四、您的第一个 Java 我的项目
    • 五、Java 语言元素和类型
    • 六、接口、类和对象结构
    • 七、包和可拜访性(可见性)
    • 八、面向对象设计(OOD)准则
    • 九、运算符、表达式和语句
    • 十、控制流语句
    • 十一、JVM 过程和垃圾收集
    • 十二、Java 规范和内部库
    • 十三、Java 汇合
    • 十四、治理汇合和数组
    • 十五、治理对象、字符串、工夫和随机数
    • 十六、数据库编程
    • 十七、Lambda 表达式与函数式编程
    • 十八、流和管道
    • 十六、反应式零碎
  • Java7 并发秘籍

    • 零、序言
    • 一、线程治理
    • 二、线程根本同步
    • 三、线程同步工具
    • 四、线程执行器
    • 五、Fork/Join 框架
    • 六、并发
    • 七、自定义并发类
    • 八、测试并发利用
  • Java9 和 JShell

    • 零、序言
    • 一、JShell——Java 9 的读取 - 求值 - 打印循环
    • 二、通过 Java 9 JShell 将事实世界的对象转换为 UML 图
    • 三、类与实例
    • 四、数据封装
    • 五、可变类和不可变类
    • 六、继承、形象、扩大和特化
    • 七、成员继承与多态性
    • 八、应用接口的契约式编程
    • 九、应用接口的高级契约式编程
    • 十、应用泛型实现代码重用的最大化
    • 十一、高级多态
    • 十二、面向对象、函数式编程和 Lambda 表达式
    • 十三、Java 9 中的模块化
    • 十四、练习答案
  • 面向初学者的 Java 编程

    • 零、前言
    • 一、Java 入门
    • 二、了解类型化变量
    • 三、分支
    • 四、数据结构
    • 五、函数
    • 六、Java 面向对象建模
    • 七、更加面向对象的 Java
    • 八、有用的 Java 类
    • 九、文件输出和输入
    • 十、根本图形用户界面开发
    • 十一、XML
  • 精通 Java8 并发编程

    • 零、序言
    • 一、第一步——并发设计准则
    • 二、治理大量线程——执行器
    • 三、最大水平利用执行器
    • 四、从工作获取数据——Runnable接口和 Future 接口
    • 四、分阶段运行工作——相位器类
    • 六、优化分治的解决方案——Fork/Join 框架
    • 七、用并行流解决海量数据集——映射和归约模型
    • 八、用并行流解决海量数据集——映射和收集模型
    • 九、深入研究并发数据结构和同步工具
    • 十、片段整合和备选计划实现
    • 十一、测试和监控并发利用
  • Java7 新个性秘籍

    • 零、序言
    • 一、Java 语言的改良
    • 二、应用门路定位文件和目录
    • 三、获取文件和目录信息
    • 四、管理文件和目录
    • 五、治理文件系统
    • 六、Java 7 中的流式 IO
    • 七、图形用户界面改良
    • 八、事件处理
    • 九、数据库、平安和零碎加强
    • 十、并发解决
    • 十一、杂项
  • Java9 编程蓝图

    • 零、前言
    • 一、引言
    • 二、用 Java 治理过程
    • 三、清理反复的文件
    • 四、日期计算器
    • 五、Sunago——社交媒体聚合器
    • 六、Sunago——安卓端
    • 七、应用邮件过滤器治理电子邮件和垃圾邮件
    • 八、应用 PhotoBeans 进行照片治理
    • 九、应用 Monumentum 记笔记
    • 十、无服务器 Java
    • 十一、DeskDroid——Android 手机的桌面客户端
    • 十二、下一步是什么?
  • Java SE7 编程学习指南

    • 零、序言
    • 一、Java 入门
    • 二、Java 数据类型及其应用
    • 三、决策构造
    • 四、应用数组和汇合
    • 五、循环构造
    • 六、类、结构器和办法
    • 七、继承与多态性
    • 八、解决利用中的异样
    • 九、Java 利用
    • 十、测试你的常识——答案
  • Java Lambda 学习指南

    • 零、序言
    • 一、引言
    • 二、Lambda 简介
    • 三、深刻 Lambda
    • 四、字节码
  • Java 网络编程学习指南

    • 零、序言
    • 一、网络编程入门
    • 二、网络寻址
    • 三、NIO 对网络的反对
    • 四、客户端 / 服务器开发
    • 五、对等网络
    • 六、UDP 和多播
    • 七、网络可扩展性
    • 八、网络安全
    • 九、网络互操作性
  • Java8 反应式编程学习指南

    • 零、序言
    • 一、反应式编程简介
    • 二、应用 Java 8 的函数构造
    • 三、创立和连贯可察看对象、观察者和主体
    • 四、转换、过滤和积攒您的数据
    • 五、组合器、条件和错误处理
    • 六、应用调度器取得并发性和并行性
    • 七、测试 RxJava 利用
    • 八、资源管理与 RxJava 扩大

下载

Docker

docker pull apachecn0/apachecn-java-zh
docker run -tid -p <port>:80 apachecn0/apachecn-java-zh
# 拜访 http://localhost:{port} 

PYPI

pip install apachecn-java-zh
apachecn-java-zh <port>
# 拜访 http://localhost:{port} 

NPM

npm install -g apachecn-java-zh
apachecn-java-zh <port>
# 拜访 http://localhost:{port} 

奉献指南

本我的项目须要校对,欢送大家提交 Pull Request。

请您怯懦地去翻译和改良翻译。尽管咱们谋求卓越,但咱们并不要求您做到美中不足,因而请不要放心因为翻译上犯错——在大部分状况下,咱们的服务器曾经记录所有的翻译,因而您不用放心会因为您的失误受到无法挽回的毁坏。(改编自维基百科)

组织介绍

拜访咱们的主页。

资助咱们

通过平台自带的打赏性能,或点击这里。

退出移动版