Java编程专业术语

王奋

Angle bracket
尖括号

Universal type
通用类型

Constant-time
固定时间


Maps（also known as associative arrays, to associate objects with other objects)
Maps(也称为关联数组，用来建立对象之间的关联）

Sets（ to hold one of each type of object)
Sets（每种对象类型只持有1个）

Queue、 tree、stack
队列、树、堆栈

Hold sequence
存储序列

Generic containers
通用容器

A set of containers
容器集

Visual Component Library VCL
可视化构件库

Standard Template Library （STL）
标准模板库

Starting from scratch
从头开始

A backward-compatibility standpoint
一个向后兼容的角度

Multiple inheritance
多重继承


Have an interface in common
共用接口



It turns out
事实证明

Existing type
已有类型

Decoupled
分离的

Uniform interface
一致接口

the family of classes
类族

The method body
方法体


In lieu of
替代

Generic object
泛化对象

Scheme
机制、模式

Early binding
前期绑定

Late binding
后期绑定

Make a function call in the traditional sense.
产生一个传统意义上的函数调用

The primary twist
最重要的妙诀


Cope with
处理

Encapsulate
封装

In a sense
在某种意义上

Pure substitution
纯粹替代

Substitution principle
替代原则

Iteration
迭代

Fundamental gateways
重要门槛

Type equivalence
类型等价性

From this
在此基础上

Shape
几何形

Type hierarchy
类型层次结构

Original class(called the base class or superclass or parent class)
源类（被称为基类、超类或者父类）

"clone"(called the derived class or inherited class or subclass or child class)
副本（被称为导出类、继承类或者子类）

The filled diamond
实心菱形

“has-a"
拥有

Composition
组合

Aggregation
聚合

Reusing
复用

Package access
包访问权限

Compile-time
编译时期

Access specifier
访问指定词

Cohesiveness of the object
对象的内聚性

In a simple fashion
以某种简单的方式

Using the parlance
按照通用的说法

An object has state, behavior and identity
对象具有状态、行为以及标识

Manipulate
操作

Built-in
内置

As if
就像

A set of objects
对象集合

Substitutability
可替代性

The lingo
行话

UML（Unified Modelling Language 统一建模语言）

Predefined class
预定义类

In terms of
根据

Comprise the implementation
构成了实现

Problem that is actually being solved
实际待解决问题

Solution space
解空间

Which is the place where you're implementing that solution
这是你对问题建模的地方

Assembly language
汇编语言

Imperative language
命令式语言

As a side effect
作为一种副作用

Chains of decisions
决策链

Cast into
转换成

Algorithmic
算法形式的

Java编程专业术语

jave binary code injection (java 二进制代码增强的方式）

Inversion of Control(IoC)
控制反转原则
Ioc英文为 Inversion of Control，即反转模式，这里有著名的好莱坞理论：你呆着别动，到时我会找你。后被Martin Fowler改名为 Dependency Injection 依赖注入，也就是将类之间的关系通过第三方进行注入，不需要类自己去解决调用关系。


Spring是反向控制（IOC）和面向切面编程(AOP)的组合体。它是一个非侵入式的框架，增强了POJO的功能。从服务上讲(With a service abstraction)，它将程序代码从J2EE环境解耦到普通的java对象（自然，这些代码可以脱离J2EE而在多种环境中运行）。它还在很多功能上提供了除EJB之外的选择－－比如为所有的POJO提供声明式事务。Spring被广泛运用到很多项目中，从小的web程序到大的企业应用程序。

NoSQL无需事先为要存储的数据建立字段，随时可以存储自定义的数据格式。而在关系数据库里，增删字段是一件非常麻烦的事情。如果是非常大数据量的表，增加字段简直就是一个噩梦。这点在大数据量的web2.0时代尤其明显。

POJO:plain ordinary java object 简单无规则java对象

Exception translation
异常转译：高层的实现应该捕获底层的异常，同时抛出一个可以按照高层抽象进行解释的异常。


loose coupling
松散耦合

striping
数据分片


level
级别

Provided that
如果

fire
触发

recipe
例子，示例

wrapped
封装

expose
公开
handler
处理

auto-unregistered
自动注销的

register
寄存

Objects
对象

Abstraction
抽象

Interface
接口

The hidden implementatin
被隐藏的具体实现

Reusing the Implementation
复用具体实现

Inheritance
继承

Is-a vs. is-like-a relationships
“是一个”与“像是一个”的关系

Interchangeable objects with polymorphism
伴随多态的可互换对象

The singly rooted hierarchy
单根继承结构

Containers
容器

Parameterized types (Generics)
参数化类型（泛型）

Object creation & lifetime
对象的创建和生命期

Exception handling: dealing with errors
异常处理：处理错误

Concurrent programming
并发编程

Client-side programming
客户端编程

Server-side programming
服务器端编程

You manipulate objects with references
你需要引用操纵对象

Where storage lives
存储到什么地方

Special case: primitive types
特例：基本类型

Arrays
数组

destroy an object
销毁对象

Scoping
作用域

Scope of objects
对象的作用域

Creating new data types: class
创建新的数据类型：类

Fields
字段，域

methods
方法

arguments
参数
return values
返回值

The argument list
参数列表

Name visibility
名字可见性

components
构件

static keyword
static关键字

Java program
Java程序

Compiling
编译

running
运行

Comments
注释

embedded documentation
嵌入式文档

Comment documentation
注释文档

Syntax
语法

Embedded HTML
嵌入式HTML

example tags
标签示例

Documentation example
文档示例

Coding style
编码风格


Operators
操作符

Simpler print statements
更简单的打印语句

Java operators
Java操作符

Precedence
优先级

Assignment
赋值

Aliasing
别名问题

method calls
方法调用

Mathematical operators
算术操作符

Unary minus and plus operators
一元加、减操作符

Auto increment and decrement
自动递增和递减

Relational operators
关系操作符

Testing object equivalence
测试对象的等价性

Logical operators
逻辑操作符

Short-circuiting
短路

Literals
直接常量

Exponential notation
指数记数法

Bitwise operators
按位操作符

Shift operators
移位操作符

Ternary if-else operator
三元操作符 if-else

String operator
字符串操作符+ 和 +=

Common pitfalls when using operators
使用操作符常犯的错误

Casting operators
类型转换操作符

Truncation and rounding
截尾和舍入

Promotion
提升

Java has no “sizeof”
java没有“sizeof”

A compendium of operators
操作符小结

Controlling Execution
控制执行流程

Iteration
迭代

The comma operator
逗号操作符

Foreach syntax
Foreach 语法

The infamous “goto”
臭名昭著的goto

Annotation
注解

Initialization & Cleanup
初始化与清理

Guaranteed initialization with the constructor
用构造器确保初始化

Method overloading
方法重载

Distinguishing overloaded methods
区分重载方法

Overloading with primitives
涉及基本类型的重载

Overloading on return values
以返回值区分重载方法

Default constructors
默认构造器

The this keyword
this关键字

Calling constructors from constructors
在构造器中调用构造器

The meaning of static
static的含义

Cleanup: finalization and garbage collection
清理：终结处理和垃圾回收

What is finalize() for?
finalize()的用途何在？

You must perform cleanup
你必须实施清理

The termination condition
终结条件

How a garbage collector works
垃圾回收器如何工作

Member initialization
成员初始化

Specifying initialization
指定初始化

Constructor initialization
构造器初始化

Order of initialization
初始化顺序

static data initialization
静态数据的初始化

Explicit static initialization
显式的静态初始化

Non-static instance initialization
非静态实例初始化

Array initialization
数组初始化

Variable argument lists
可变参数列表

Enumerated types
枚举类型

Access Control
访问权限控制

package: the library unit
包：库单元

Code organization
代码组织

Creating unique package names
创建独一无二的包名

A custom tool library
定制工具库

Using imports to change behavior
使用import改变行为

Package caveat
对使用包的忠告

Java access specifiers
Java访问指定词

Package access
包访问权限

public: interface access
public:接口访问权限

private: you can’t touch that!
private:你无法访问

protected: inheritance access
protected:继承访问权限

Interface and implementation
接口和实现

Class access
类的访问权限

Reusing Classes
复用类

Composition syntax
组合语法

Inheritance syntax
继承语法

Initializing the base class
初始化基类

Delegation
代理
Combining composition and inheritance
结合使用组合和继承

Guaranteeing proper cleanup
确保正确清理

Name hiding
名称屏蔽

Choosing composition vs. inheritance
在组合和继承之间选择

Upcasting
向上转型

Why “upcasting”?
为什么称为向上转型？

Composition vs. inheritance revisited
再论组合与继承

The final keyword
final关键字

final data
final数据

final methods
final方法

final classes
final类

final caution
有关final的忠告

Initialization and class loading
初始化以及类的加载

Polymorphism
多态

Upcasting revisited
再论向上转型

Forgetting the object type
忘记对象类型

The twist
转机

Method-call binding
方法调用绑定

Producing the right behavior
产生正确的行为

Extensibility
可扩展性

Pitfall: “overriding” private methods
缺陷：“覆盖”私有方法

Pitfall: fields and static methods
缺陷：域与静态方法

Constructors and polymorphism
构造器和多态

Order of constructor calls
构造器的调用顺序

Behavior of polymorphic methods inside constructors
构造器内部多态方法的行为

Covariant return types
协变返回类型

Designing with inheritance
用继承进行设计

Substitution vs. extension
纯继承与扩展

Downcasting and runtime type information
向下转型与运行时类型识别

Interfaces
接口

Abstract classes and methods
抽象类和抽象方法

Complete decoupling
完全解耦

“Multiple inheritance” in Java
多重继承

Extending an interface with inheritance
通过继承来扩展接口

Name collisions when combining Interfaces
组合接口时的名字冲突

Adapting to an interface
适配接口

Fields in interfaces
接口中的域

Initializing fields in interfaces
初始化接口中的域

Nesting interfaces
嵌套接口

Interfaces and factories
接口与工厂

Inner Classes
内部类

Creating inner classes
创建内部类

The link to
the outer class
链接到外部类


upcasting
向上转型

Inner classes in
methods and scopes
在方法和作用域内的内部类

Anonymous
匿名

Factory Method revisited
再访工厂方法

Nested classes
嵌套类

Classes inside interfaces
接口内部的类

Reaching outward from
a multiplynested class
从多层嵌套类中访问外部类

Why inner classes?  
为什么需要内部类

Closures & callbacks
闭包与回调

control frameworks
控制框架

Inheriting from
inner classes
内部类的继承

Local inner classes
局部内部类

Inner-class identifiers
内部类标识符

Holding Your Objects
持有对象

Generics and
type-safe containers .
泛型和类型安全的容器

Basic concepts
基本概念

Adding groups
of elements
添加一组元素

Printing containers
容器的打印

Iterator
迭代器

Foreach and iterators
foreach与迭代器

The Adapter Method idiom
适配器方法惯用法


Error Handling
with Exceptions 313
通过异常处理错误

Basic exceptions
基本异常

Exception arguments  
异常参数
Catching an exception
捕获异常

The try block
try 块

Exception handlers
异常处理程序

Creating your
own exceptions
创建自定义异常

Exceptions and logging
异常与记录日志

The exception
specification
异常说明

Catching any exception
捕获所有异常

The stack trace
栈轨迹

Rethrowing an exception
重新抛出异常

Exception chaining
异常链

Standard Java
exceptions
标准Java异常

Special case:
RuntimeException
特例：RuntimeException

Performing cleanup
with finally
使用finally进行清理

What’s finally for?
finally用来做什么

Using finally during return
在return中使用finally

Pitfall: the lost exception
缺憾：异常丢失

Exception restrictions
异常的限制

Constructors
构造器

Exception matching
异常匹配

Alternative approaches
其他可选方式

History
历史

Perspectives
观点

Passing exceptions
to the console
把异常传递给控制台

Converting checked
to unchecked exceptions
把“被检查的异常”转换为“不检查的异常”

Exception guidelines
异常使用指南

Strings
字符串

Immutable Strings
不可变strings

Overloading ‘+’ vs.
StringBuilder
重载“+”与StringBuilder

Unintended recursion
无意识的递归

Operations on Strings
strings上的操作

Formatting output
格式化输出

The Formatter class
Formatter类

Format specifiers
格式化说明符

Formatter conversions
Formatter 转换


Regular expressions
正则表达式

Basics
基础

Creating regular expressions
创建正则表达式

Quantifiers
量词

Replace operations
替换操作



Scanning input
扫描输入

Scanner delimiters
Scanner定界符

Scanning with
regular expressions
用正则表达式扫描

Type Information 393
类型信息

The Class object
类对象

Class literals
类字面常量

Generic class references
泛化的类引用

New cast syntax
新的转型语法

Checking before a cast
在类型转换前先做检查

Using class literals
使用类字面常量

A dynamic instanceof
动态的instanceof

Counting recursively
递归计数

Registered factories
注册工厂

instanceof vs. Class
equivalence.
instanceof 与类的等价性

Reflection: runtime
class information
反射：运行时的类信息

A class method extractor
类方法提取器

Dynamic proxies
动态代理

Null Objects
空对象

Mock Objects & Stubs
模拟对象与桩

Interfaces and
type information
接口与类型信息

Generics 439
泛型

Comparison with C++
与C++的比较

Simple generics
简单泛型

A tuple library
一个元组类库

A stack class
一个堆栈类

Generic interfaces
泛型接口

Generic methods
泛型方法

Leveraging type
argument inference
杠杆利用类型参数推断

Varargs and generic methods
可变参数与泛型方法

A generic method
to use with Generators
用于Generators的泛型方法

A general-purpose Generator
一个通用的Generator

Simplifying tuple use
简化元组的使用

A Set utility
一个Set实用工具

Anonymous
inner classes
匿名内部类

Building
complex models
构建复杂模型

The mystery of erasure
擦除的神秘之处

The C++ approach
C++ 的方式

Migration compatibility
迁移兼容性

The problem with erasure
擦除的问题

The action at the boundaries
边界处的动作

Compensating
for erasure
擦除的补偿

Creating instances of types
创建类型实例

Arrays of generics
泛型数组

Bounds
边界

Wildcards
通配符

How smart is the compiler?
编译器有多聪明

Contravariance
逆变

Unbounded wildcards
无界通配符

Capture conversion
捕获转换

Issues
问题

No primitives
as type parameters
任何基本类型都不能作为类型参数

Implementing
parameterized interfaces
实现参数化接口

Casting and warnings
转型和警告

Overloading
重载

Base class hijacks an interface
基类劫持了接口

Self-bounded types
自限定的类型

Curiously recurring generics
古怪的循环泛型

Self-bounding
自限定

Argument covariance
参数协变

Dynamic type safety
动态类型安全

Exceptions
异常

Mixins
混型

Mixins in C++
C++中的混型

Mixing with interfaces
与接口混合

Using the Decorator pattern
使用装饰器模式

Mixins with dynamic proxies
与动态代理混合

Latent typing
潜在类型机制

Compensating for
the lack of latent typing
对缺乏潜在类型的补偿

Reflection
反射

Applying a method
to a sequence
将一个方法应用于序列

When you don’t happen
to have the right interface
当你并未碰巧拥有正确的接口时

Simulating latent typing
with adapters
用适配器仿真潜在类型机制

Using function objects
as strategies  
将函数对象用作策略

Summary: Is casting
really so bad?
总结：转型真的如此之糟吗？

Further reading
进阶读物

Arrays
数组

Why arrays are special
数组为什么特殊

Arrays are
first-class objects
数组是第一级对象

Returning an array
返回一个数组

Multidimensional
arrays
多维数组

Arrays and generics
数组与泛型
Creating test data
创建测试数据

Data Generators
数据生成器

Creating arrays
from Generators
从生成器中创建数组

Arrays utilities
数组的实用功能

Copying an array
复制数组

Comparing arrays
数组的比较

Array element comparisons
数组元素的比较

Sorting an array
数组排序

Searching a sorted array
在已排序的数组里查找


Containers in Depth
容器深入研究

Full container taxonomy
完整的容器分类法

Filling containers
填充容器

A Generator solution
一种生成器的解决方案

Map generators
Map 生成器

Using Abstract classes
使用Abstract类

Collection
functionality
Collection的功能方法

Optional operations
可选操作

Unsupported operations
未获支持的操作

List functionality
List的功能方法

Sets and storage order
Sets和存储顺序


Queues
队列

Priority queues
优先级队列

Deques
双向队列

Understanding Maps
理解Map

Performance
性能

Hashing and hash codes
散列与散列码

Understanding hashCode()
理解hashCode()

Hashing for speed
为速度而散列

Overriding hashCode()
覆盖hashCode()

Choosing
an implementation
选择一个具体实现

A performance
test framework
性能测试框架

Choosing between Lists
对list的选择

Microbenchmarking dangers
微基准测试的危险

Choosing between Sets
对Set的选择

Choosing between Maps
对Map的选择

Utilities
实用方法

Sorting and searching Lists
list的排序和查询

Making a Collection
or Map unmodifiable
设定Collection或者Map为不可修改

Synchronizing a
Collection or Map
Collection或者Map的同步控制

Holding references
持有引用


Java 1.0/1.1 containers
Java 1.0/1.1的容器



I/O
I/O系统

The File class
File类

A directory lister
目录列表器

Directory utilities
目录实用工具

Checking for
and creating directories
目录的检查以及创建

Input and output
输入和输出

Types of InputStream
InputStream类型

Types of OutputStream
OutputStream类型

Adding attributes
and useful interfaces
添加属性和有用的接口

Reading from an InputStream
with FilterlnputStream
通过FilterlnputStream从InputStream读取数据

Writing to an OutputStream
with FilterOutputStream
通过FilterOutputStream向 OutputStream写入

Sources and sinks of data
数据的来源和去处

Modifying stream behavior
更改流的行为

Unchanged classes
未发生变化的类

Off by itself:
RandomAccessFile
自我独立的类：RandomAccessFile

Typical uses
of I/O streams
I/O流的典型使用方式

Buffered input file
缓冲输入文件

Input from memory
从内存输入

Formatted memory input
格式化的内存输入

Basic file output
基本的文件输出

Storing and recovering data
存储和恢复数据

Reading and writing
random-access files
读写随机访问文件

Piped streams
管道流

File reading
& writing utilities
文件读写的实用工具

Reading binary files
读取二进制文件

Standard I/O
标准 I/O

Reading from standard input
从标准输入中读取

Changing System.out
to a PrintWriter
将System.out转换为PrintWriter

Redirecting standard I/O
标准 I/O重定向

Process control
进程控制

New I/O
新I/O

Converting data
转换数据

Fetching primitives
获取基本类型

View buffers
视图缓冲器

Data manipulation
with buffers
用缓冲器操纵数据

Buffer details
缓冲器的细节

Memory-mapped files
内存映射文件

File locking
文件加锁

Compression
压缩

Simple compression
with GZIP
用GZIP进行简单压缩

Multifile storage with Zip
用Zip进行多文件保存

Java ARchives (JARs)
Java档案文件（JARs）

Object serialization
对象序列化

Finding the class
寻找类

Controlling serialization
序列化的控制

Using persistence
使用“持久性”

Enumerated Types
枚举类型

Basic enum features
基本enum特性

Using static imports
with enums
将静态导入用于enums

Adding methods
to an enum
向enum中添加新方法

Overriding enum methods
覆盖enum的方法

enums in
switch statements
switch语句中的enum

The mystery
of values()
values（）的神秘之处

Implements,
not inherits
实现，而非继承

Random selection
随机选取

Using interfaces
for organization
使用接口组织枚举

Using EnumSet
instead of flags
使用EnumSet替代标志

Using EnumMap
使用 EnumMap

Constant-specific
methods  
常量相关的方法

Chain of Responsibility
with enums  
使用enum的职责链

State machines with enums
使用enum的状态机

Multiple dispatching
多路分发

Dispatching with enums
使用enum分发

Using
constant-specific methods
使用常量相关的方法

Dispatching
with EnumMaps
使用EnumMaps分发

Using a 2-D array
使用二维数组

Annotations
注解

Basic syntax
基本语法

Defining annotations
定义注解

Meta-annotations
元注解

Writing
annotation processors
编写注解处理器

Annotation elements
注解元素

Default value constraints
默认数值限制

Generating external files
生成外部文件

Annotations don’t
support inheritance
注解不支持继承

Implementing the processor
实现处理器

Using apt to
process annotations
使用apt处理注解

Using the Visitor pattern
with apt
将观察者模式用于apt

Annotation-based
unit testing
基于注解的单元测试

Using @Unit with generics
将@Unit用于泛型

No “suites” necessary
不需要任何“套件”

Implementing @Unit
实现@Unit

Removing test code
移除测试代码

Concurrency
并发

The many faces of
concurrency
并发的多面性

Faster execution
更快的执行

Improving code design
改进代码设计

Basic threading
基本的线程机制

Defining tasks  
定义任务

The Thread class
线程类

Using Executors
使用Executors

Producing return values
from tasks
从任务中产生返回值

Sleeping
休眠

Priority
优先级

Yielding
让步

Daemon threads  
后台线程

Coding variations
编码的变体

Terminology
术语

Joining a thread
加入一个线程

Creating responsive
user interfaces
创建有响应的用户界面

Thread groups
线程组

Catching exceptions
捕获异常

Sharing resources
共享受限资源

Improperly
accessing resources
不正确的访问资源

Resolving shared
resource contention
解决共享资源竞争

Atomicity and volatility
原子性以及易变性

Atomic classes
原子类

Critical sections
临界区

Synchronizing on
other objects
在其他对象上同步

Thread local storage
线程本地存储

Terminating tasks
终结任务

The ornamental garden
装饰性花园

Terminating when blocked
在阻塞时终结

Interruption
中断

Checking for an interrupt
检查中断

Cooperation
between tasks
线程之间的协作

Producers and consumers
生产者与消费者

Producer-consumers
and queues
生产者-消费者与队列

Using pipes for I/O
between tasks
任务间使用管道进行输入/输出

Deadlock
死锁

New library
components
新类库中的构件

The greenhouse controller
with ScheduledExecutor
使用ScheduledExecutor的温室控制器


Simulation
仿真

Bank teller simulation
银行出纳员仿真

The restaurant simulation
饭店仿真

Distributing work
分发工作

Performance tuning
性能调优

Comparing
mutex technologies
比较各类互斥技术

Lock-free containers
免锁容器

Optimistic locking
乐观加锁


Active objects
活动对象

Further reading
进阶读物

Graphical
User Interfaces
图形化用户界面

Swing basics
Swing基础

A display framework
一个显示框架

Making a button
创建按钮

Capturing an event
捕获事件

Text areas
文本区域

Controlling layout
控制布局

Absolute positioning
绝对定位

The best approach?
最好的方式是什么?

The Swing event model
Swing事件模型

Event and listener types
事件与监听器的类型

Tracking multiple events
跟踪多个事件

A selection of
Swing components
Swing组件一览

Buttons
按钮

Icons
图标

Tool tips
工具提示

Text fields
文本域

Borders
边框

A mini-editor
一个迷你编辑器

Check boxes
复选框
CheckBox控件俗称复选框，OptionButton控件俗称单选框


Radio buttons
单选按钮


Combo boxes
(drop-down lists)
组合框
（下拉列表）

List boxes
列表框

Tabbed panes
页签面板

Message boxes  
消息框

Menus
菜单

Pop-up menus
弹出式菜单

Drawing
绘图

Dialog boxes
对话框

File dialogs
文件对话框

HTML on
Swing components
Swing组件上的HTML

Sliders and progress bars
滑块与进度条

Selecting look & feel
选择外观

Trees, tables & clipboard
树、表格和剪贴板


Concurrency & Swing
Swing与并发

Long-running tasks
长期运行的任务

Visual threading
可视化线程机制

Visual programming
and JavaBeans
可视化编程与JavaBean

What is a JavaBean?
JavaBean是什么？

Extracting Beanlnfo
with the Introspector
使用Introspector抽取出Beanlnfo

A more sophisticated Bean
一个更复杂的Bean

JavaBeans and
synchronization
JavaBeans与同步

Packaging a Bean
把Bean打包

More complex Bean support
对Bean更高级的支持

More to Beans
有关Bean的其他读物

Alternatives to Swing
Swing的可替代选择

Building Flash Web
clients with Flex
用Flex构建Flash Web客户端
  
Compiling MXML
编译MXML

Containers and controls
容器与控制

Effects and styles
效果与样式

Events
事件

Connecting to Java
连接到Java

Data models
and data binding  
数据模型与数据绑定

Building and deploying
构建和部署

Creating SWT
applications
创建SWT应用

Installing SWT
安装SWT


Eliminating redundant code
根除冗余代码

Menus
菜单

Tabbed panes, buttons,
and events
页签面板、按钮以及事件

Graphics
图形

Concurrency in SWT
SWT中的并发

SWT vs. Swing?
SWT还是Swing？

Resources
资源