1、Java中间件，分布式系统、分布式缓存、消息队列
JAVA中间件：包括服务框架中间件：解决集群间的访问通信问题。消息中间件：解决应用之间的消息传递、解耦、异步的问题。数据访问中间件：解决应用访问数据库的共性问题。
分布式系统：一定是有多个节点组成的系统，一般一个节点就是一台服务器，节点之间是相互连通协作的，这些连通的节点上部署了我们的组件，共同服务于一个大型系统。比如淘宝网，在对浏览器发送请求的背后，是一个大型的分布式系统为我们服务，整个系统有的负责请求处理，有的负责存储，有的负责计算，最终通过相互的协作把请求的结果返回给浏览器，并呈现给我们。
分布式缓存：就是把数据存放在不同的物理机器上，利用分布式缓存中间件进行处理数据。Redis和memcached缓存系统都是以key-value的形式存储和访问数据，在内存中维护一张巨大的HashTable。但是redis比memcached支持的数据类型更多，有五种数据类型：String、Hash、List、Set、ZSet（有序集合）。注意：分布式缓存系统需要用到一致哈希算法，它的的好处在于节点个数发生变化（减少或增加）时无需重新计算哈希值，避免大量key的重新映射，保证数据储存或读取时可以正确、快速地找到对应的节点。
消息队列(中间件)：负责消息的收发管理，利用高效可靠的异步消息传递机制集成到分布式系统。五大优点：解耦、异步、横向扩展、安全可靠、顺序保证。常见的有activeMQ（支持多语言，实现jms1.1），RabbitMQ（支持更多语言，基于AMQP规范），kafka(高吞吐量，分布式，分区，O(1)磁盘顺序提供消息持久化)
2、常用的开源项目框架理解
Spring
Spring是轻量级的IoC和AOP的容器框架，是进行对象管理、对象关联、解耦的一个中间层框架。是面向Bean的编程，实现了组件的解耦。
IoC(DI)依赖注入实现的技术：反射机制、工厂模式。其中pring的BeanFactory主要实现步骤如下，
解析配置文件（bean.xml）
使用反射机制动态加载每个class节点中配置的类
为每个class节点中配置的类实例化一个对象
使用反射机制调用各个对象的seter方法，将配置文件中的属性值设置进对应的对象
将这些对象放在一个存储空间（beanMap）中
使用getBean方法从存储空间（beanMap）中取出指定的JavaBean
AOP实现的技术： JDK动态代理技术 和 CGLIB技术(动态字节码增强技术) 。尽管实现技术不一样，但都是基于代理模式 ， 都是生成一个代理对象 。
JDK动态代理技术：主要使用到 InvocationHandler 接口和 java.lang.reflect.Proxy类的newProxyInstance() 方法。通过使用接口，使系统松耦合。
CGLIB(动态字节码增强)技术：是继承被代理对象，然后Override需要被代理的方法。使用继承，代码写起来更简单。
Struts2
Struts2是基于servlet、MVC设计模式的Web应用框架，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。
Struts2框架采用Filter（StrutsPrepareAndExecuteFilter）作为核心控制器实现。是类级别的拦截，每次请求对应实例一个新的Action，然后调用setter getter方法把request中的数据注入。一个Action对象对应一个request上下文。
Struts2流程分析：
①当在浏览器中输入相应网址，会加载web.xml中的核心控制器
②核心控制器会拦截所有请求，加载struts.xml的配置文件，找到和请求名字相同的action
③创建Class属性指定类的对象
④执行method属性指定的方法，返回一个字符串结果
⑤找Name等于此字符串的result，转到相应页面或action
⑥在页面中执行相关代码：通过EL表达式或者OGNL表达式取当前类属性的值
SpringMVC
SpringMVC是基于Servlet 、MVC设计模式的一个松耦合的web应用框架，使用前端控制器模式来进行设计，再根据请求映射规则分发给相应的后端控制器进行处理。
SpringMVC框架采用Servlet作为核心控制器实现。是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去。一个方法对应一个Request上下文，所以方法直接基本上是独立的，独享request，response数据。、
开发效率对比：
由于SpringMVC基于方法的拦截，有加载一次单例模式bean注入。而Struts2是类级别的拦截，每次请求对应实例一个新的Action，需要加载所有的属性值注入，所以，SpringMVC开发效率和性能高于Struts2
SpringMVC的工作流程如下：
1.用户发送请求至前端控制器(DispatcherServlet)
- DispatcherServlet收到请求调用处理器映射器(HandlerMapping)
- 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器对象一并返回给DispatcherServlet
- DispatcherServlet通过处理器适配器(HandlerAdapter)调用具体的处理器(Controller)
- 处理器即后端控制器(Controller)执行具体的业务操作，完成后返回ModelAndView
- HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
- DispatcherServlet将ModelAndView传给ViewReslover视图解析器
- ViewReslover解析后返回具体View DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
- DispatcherServlet响应用户
MyBatis
MyBatis 是一个基于 Java 的 持久层 框架， MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索。 把实体类和SQL语句之间建立了映射关系，是一种半自动化的ORM实现。
MyBatis的特点：
基于SQL语法，SQL语句封装在配置文件中，便于统一管理与维护。
自动化程度低、手工映射SQL，灵活程度高。
Hibernate
Hibernate是优秀的Java 持久化层解决方案、对象-关系映射（ORM）工具、简化了JDBC 繁琐的编码。
Hibernate特点：
Hibernate对象-关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。
编写程序的时候，HQL语句操作，以面向对象的方式处理数据。而保存数据的时候，却以关系型数据库的方式存储。
SpringBoot
SpringBoot是基于Spring4.0的一套快速搭建Spring框架的整合包。方便对各种框架的整合，让他们集成在一起更加简单，简化了我们在集成过程中的模板化配置。遵循”约定大于配置”，实现零配置。
特点：
- 创建独立的Spring应用程序
- 嵌入的Tomcat，无需部署WAR文件
- 简化Maven配置
- 自动配置Spring
- 提供生产就绪型功能，如指标，健康检查和外部配置
微服务
微服务是一种可以让软件职责单一、松耦合、自包含、可以独立运行和部署的架构思想。微服务架构是让微服务与微服务之间在结构上“松耦合”，而在功能上则表现为一个统一的整体。目的是有效的拆分应用，实现敏捷开发和部署。
关键思想就是：拆分、单一、独立、组件化。把原本一个庞大、复杂的项目按业务边界拆分一个一个独立运行的小项目，通过接口的方式组装成一个大的项目。
Dubbo
首先了解一下ESB（企业数据总线）：一般采用集中式转发请求，适合大量异构系统集成，侧重任务的编排，性能问题可通过异构的方式来进行规避，无法支持特别大的并发。
Dubbo（服务注册管理），采用的是分布式调用，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。其侧重服务的治理，将各个服务颗粒化，各个子业务系统在程序逻辑上完成业务的编排。是远程服务调用的分布式框架（告别Web Service模式中的WSdl，以服务者与消费者的方式在dubbo上注册）
其核心部分包含:
- 远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
- 集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。
- 自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。
服务注册中心：Zookeeper 服务调用方式： RPC
Spring Cloud
Spring cloud是基于spring boot以及结合Netflix 相关思想和代码对微服务理念的java实现。提供了一些可以用于快速构建分布式系统通用模式的工具（例如：配置管理、服务注册与发现、断路器、智能路由、微代理、控制总线），在本质上是一种分布式的解决方案。
五大核心组件：
- 服务注册发现 - Netflix Eureka
- 配置中心 - spring cloud config
- 负载均衡-Netflix
- Ribbon 断路器 - Netflix Hystrix
- 路由(网关) - Netflix Zuu
服务注册中心：Netflix Eureka 服务调用方式：REST API
Zookeeper
ZooKeeper是一种分布式应用程序协调服务，用于管理大型主机。它是集群的管理者，监视着集群中各个节点的状态，根据节点提交的反馈进行下一步合理操作。最终，将简单易用的接口和性能高效、功能稳定的系统提供给用户。
Zookeeper作用：
1.命名服务 2.配置管理 3.集群管理 4.分布式锁 5.队列管理
Zookeeper设计目的：
1.最终一致性：client不论连接到哪个Server，展示给它都是同一个视图，这是zookeeper最重要的性能。
2.可靠性：具有简单、健壮、良好的性能，如果消息被到一台服务器接受，那么它将被所有的服务器接受。
3.实时性：Zookeeper保证客户端将在一个时间间隔范围内获得服务器的更新信息，或者服务器失效的信息。但由于网络延时等原因，Zookeeper不能保证两个客户端能同时得到刚更新的数据，如果需要最新数据，应该在读数据之前调用sync()接口。
4.等待无关（wait-free）：慢的或者失效的client不得干预快速的client的请求，使得每个client都能有效的等待。
5.原子性：更新只能成功或者失败，没有中间状态。
6.顺序性：包括全局有序和偏序两种：全局有序是指如果在一台服务器上消息a在消息b前发布，则在所有Server上消息a都将在消息b前被发布；偏序是指如果一个消息b在消息a后被同一个发送者发布，a必将排在b前面。
Docker
Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口。Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。程序在这个虚拟容器里运行，就好像在真实的物理机上运行一样。有了 Docker，就不用担心环境问题。
总体来说，Docker 的接口相当简单，用户可以方便地创建和使用容器，把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。
Docker 主要用途。
（1）提供一次性的环境。比如，本地测试他人的软件、持续集成的时候提供单元测试和构建的环境。
（2）提供弹性的云服务。因为 Docker 容器可以随开随关，很适合动态扩容和缩容。
（3）组建微服务架构。通过多个容器，一台机器可以跑多个服务，因此在本机就可以模拟出微服务架构。
Redis
Redis 是一个开源的，基于高级的key-value存储在内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。
Redis优点
(1) 速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
(2) 支持丰富数据类型，支持string，list，set，sorted set，hash
(3) 支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
(4) 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除
Memcached
Memcached基于一个存储键/值对的hashmap。Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。
Memcached特征：
- 协议简单
- 基于libevent的事件处理
- 内置内存存储方式
- memcached不互相通信的分布式
Memcache与Redis的区别都有哪些？
1)、存储方式 Memecache把数据全部存在内存之中，断电后会挂掉，数据不能超过内存大小。 Redis有部份存在硬盘上，这样能保证数据的持久性。
2)、数据支持类型 Memcache对数据类型支持相对简单。 Redis有复杂的数据类型。
3)、使用底层模型不同 它们之间底层实现方式 以及与客户端之间通信的应用协议不一样。 Redis直接自己构建了VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求。
3、远程服务调用 RPC、REST API
RPC 即远程过程调用（Remote Procedure Call Protocol，简称RPC），像调用本地服务(方法)一样调用服务器的服务(方法)。通常的实现有 XML-RPC , JSON-RPC , 通信方式基本相同, 不同的只是传输数据的格式。
RPC架构里包含如下4个组件:
1、 客户端(Client)：服务调用方
2、 客户端存根(Client Stub)：存放服务端地址信息，将客户端的请求参数打包成网络消息，再通过网络发送给服务方
3、 服务端存根(Server Stub)：接受客户端发送过来的消息并解包，再调用本地服务
4、 服务端(Server)：真正的服务提供者。
RPC架构目的是把调用、编码/解码的过程封装起来，让用户像调用本地服务一样的调用远程服务。要做到对客户端（调用方）透明化服务， RPC框架需要考虑解决如下问题：
- 服务端提供的服务如何发布，客户端如何发现服务；
- 如何对请求对象和返回结果进行序列化和反序列化；
- 如何更高效进行网络通信。
REST 即表述性状态传递（Representational State Transfer，简称REST），是Roy Fielding博士在2000年他的博士论文中提出来的一种软件架构风格。它是一种针对网络应用的设计和开发方式，可以降低开发的复杂性，提高系统的可伸缩性。
REST通过资源的角度观察网络( 通过HTTP协议定义的通用动词方法(GET、PUT、DELETE、POST) )，以URI对网络资源进行唯一标识，响应端根据请求端的不同需求，通过无状态通信，对其请求的资源进行表述。
REST使用HTTP+URI+XML 来实现其要求的架构风格：HTTP协议和URI用于统一接口和定位资源，文本、二进制流、XML、JSON等格式用来作为资源的表述。
满足REST约束条件和原则的架构或接口，就被称为是RESTful架构或RESTful接口。就像URL都是URI(统一资源标识)的表现形式一样，RESTful是符合REST原则的表现形式。
————————————————————————————————————————————————————————————————————————————————————
1.java中的接口
（1）它只是定义，而不去具体实现，比如一个水桶，你想用它去装水，那么你就在下面的方法中具体写出怎么装水，这个接口只是负责让你装，如果你要装油，那你就具体定义怎么装油，这是的接口也不管你怎么实现，接口只是接受你给参数，至于怎么用要在继承的方法中实现。
（2）接口就是个招牌。
比如说你今年放假出去杭州旅游，玩了一上午，你也有点饿了，突然看到前面有个店子，上面挂着KFC，然后你就知道今天中饭有着落了。
KFC就是接口，我们看到了这个接口，就知道这个店会卖炸鸡腿（实现接口）。
那么为神马我们要去定义一个接口涅，这个店可以直接卖炸鸡腿啊（直接写实现方法），是的，这个店可以直接卖炸鸡腿，但没有挂KFC的招牌，我们就不能直接简单粗暴的冲进去叫服务员给两个炸鸡腿了。
要么，我们就要进去问，你这里卖不卖炸鸡腿啊，卖不卖汉堡啊，卖不卖圣代啊（这就是反射）。很显然，这样一家家的问实在是非常麻烦（反射性能很差）。
要么，我们就要记住，中山路108号卖炸鸡，黄山路45号卖炸鸡（硬编码），很显然这样我们要记住的很多很多东西（代码量剧增），而且，如果有新的店卖炸鸡腿，我们也不可能知道（不利于扩展）。
2.java中的框架
（1）框架就是别人帮你搭好了舞台，怎么表演，那要看你自己啦。
（2）框架很简单的，你可以认为它是一个工具，甚至一个插件。
框架的作用，就是将一个公用的，常用的技术，封装起来，
帮你处理一些基础的东西，可以让你不用再去写那些繁琐的东西。
就拿你要学的struts来说：他本质上也是用java写的，和我们自己写的类没有区别，他实现的东西我们自己也可以实现。
比如接收客户端的数据，我们是用request.getParameter（）来的，但是如果有很多个参数，我们要写很多个，很麻烦。struts它就帮我们实现，不用我们写，直接写个属性，就可以得到。其实本质还是用request.getParameter（）。。
所以你不要再在意框架是什么东西，等你接触了就知道了。你把它当做一个工具来用，这就是框架。
（3）比如像盖房子吧
框架就像是房子搭好的骨架一样，你要完成房子的建造，就只需要在该房窗户的地方装上窗户。
在需要门的地方装上门。。。。。
其实，框架能做的事 不用框架同样可以做的出来，而且有可能会效率更高。
之所以有框架主要是因为框架给我们提供了很多的功能和模板！
有些繁琐的事情可以通过配置文件进行配置进行解决！
用到了 慢慢体会就会明白是个什么东西了 但是要用到熟练 掌握精髓
3.JDK
JDK根据提供的功能不同，将类库划分为若干个包，比如用于操作输入输出的java.io包，java程序语言设计基础类的java.lang包，提供各种数学运算的java.math包，基于网络应用的java.net包，以及一些共用程序类所在的java.util包等等。
4.返回值和无返回值
有返回值的就是：我问你叫什么，你回答了我。你的回答就是返回。
无返回值的就是：我指着一辆汽车告诉你说，这叫汽车。你可以不理我，我也不知道你懂不懂。
从上述两种情况看。为了减小沟通的障碍，我们的程序在绝大部分情况下，都应该要有返回值的。
5参数与返回
（1）有没有见过自动售货机，扔硬币进去，饮料出来， 自动售货机相当于方法，硬币相当于参数，饮料就是返回（返回有参）
（2）有没有见过自动售货机，扔硬币进去，饮料没出来， 自动售货机相当于方法，硬币相当于参数，饮料没返回（没返回有参）
（3）有没有见过自动售货机，没扔硬币进去，饮料没出来（无参无返回值）
（4）有没有见过自动售货机，没扔硬币进去，饮料出来了（无参有返回值）
6重载和重写
重写就是再写一遍，重载就是再多一个。
重写：父类里有，子类再照猫画虎写一个。
重载：自己类里面有，觉得不够再写一个。
- 二进制
二进制就像我们常用的十进制、钟表上的12进制，历史上的秦朝的16进制（16两为1斤，所以有半斤八两的成语）；二进制就是逢二进一，只是二进制在平常的生活中不常用所以不容易理解，用得多了也就理解了。
二进制数字是计算机能够理解的唯一数字，但每个二进制数字所代表的意义是认为规定的：比如0x00，在ascii码中有一个定义，送到显卡中显示白色（定义0x00为白），在程序中作为数据为0，在指针中表示0x00地址，等等。所以计算机的程序有严格的格式划分和定义，否则就很容易造成运行错误。
所以当我们用字处理软件打开一个二进制的程序代码的时候会出现很多乱码就是这个原因。
8注册表
就是电脑里的一些可运行文件，像我们上学有了学生证才被认可进入校园的第一步，电脑里的学生好比可执行文件，要是没有在注册表注册它的来历，那么它就不能正常运行！在运行里输入regedit 回车 可以看到你安装过的文件里边都会有记录的！
9脚本
类似于演戏时用到的脚本，script 其实就是一系列指令——演员看了指令就知道自己该表演什么，说什么台词；计算机看了指令就知道自己该做什么事情。所以 script 其实就是短小的、用来让计算机自动化完成一系列工作的程序，这类程序可以用文本编辑器修改，不需要编译，通常是解释运行的。
在网站前端编程的语境下，脚本通常是指在浏览器里运行的小程序，就像剧本一样，它可以用来控制网页上的各类元素该怎么表演给观众看——比如知乎主页右边那个回到页首的小箭头就是个演员，你可以用脚本告诉它只在屏幕下拉到某个特定长度的时候才出现。
（脚本并不是个很好的翻译，问题就出在“脚”这个字上，相当地莫名其妙。Script 一词的词根是“书写”。）
————————————————————————————————————————————————————————————————————————————————————
“专业术语”，程序员在对JVM 做任何的性能和垃圾回收调整之前理解和记住这些“专业术语”是非常重要的。那么学习java有哪些专业名词是程序员必须记的呢?下面为大家汇总了Java名词解释大全，希望对同学们学习java有帮助!
面向对象:面向对象程序设计(Object-Oriented Programming)是一种起源于六十年代，发展已经将近三十年的程序设计思想。其自身理论已十分完善，并被多种面向对象程序设计语言(Object-Oriented Programming Language,以下简称OOPL)实现。对象是对现实世界实体的模拟，由现实实体的过程或信息牲来定义。一个对象可被认为是一个把数据(属性)和程序(方法)封装在一起的实体，这个程序产生该对象的动作或对它接受到的外界信号的反应。这些对象操作有时称为方法。区别面向对象的开发和传统过程的开发的要素有：对象识别和抽象、封装、多态性和继承。(参见百度百科：面向对象)
面向对象要素：封装、多态、继承
Java名词解释：
API：应用程序接口的缩写，Java API是Java平台定义的一套类和接口的程序库。
类：类是一个模板，它描述了同一类对象都具有的数据和行为。 Java中的类将这些数据和行为进行封装，形成一种复合数据类型。
对象：对象是在其类模型基础上构造出的，是类的具体的实例。一个类可以生成任意多的对象。
封装：将对象的数据与操作数据的方法结合起来，通过方法将对象的数据和实现细节保护起来，称为封装。
继承：子类继承父类的状态（变量）和行为（方法），可以重用父类中的这部分代码。程序员可以在父类中对一些共同的操作和属性只说明一次而在子类中基于子类的特性进行扩展或改变。
多态：多态的含义可以表达为：对外一个接口，内部多种实现分为编译时多态和运行时多态。
重载：在同一个类中，一个方法名被用来定义多个方法，要求参数表必须不同，以此区分不同方法体，但返回类型、修饰符可相同或不相同。它实现了Java的编译时多态。
重写：当子类成员方法与父类成员方法具有相同的名字、参数列表、返回值类型时，子类方法重写了父类方法，在父类中定义的方法就被隐藏。它实现了Java的运行时多态。
构造方法：构造方法是类的一种特殊方法，方法名与类名相同，在类实例化对象时被调用，用于初始化类的成员变量、分配资源或其他辅助工作。
包：包是类和接口的集合，它把同一种类型的类（接口）组织在一起，使得程序功能清楚、结构分明，更重要的是可实现不同程序间类的重用。
接口：接口是由一些抽象方法和常量组成的一个集合，它不是一个类，不能用来实例化一个对象。接口好比一个契约，保证每个实现它的类都包含该接口所声明的方法，且可以扩展其他接口。
事件（Event）：当用户在界面上执行一个操作（如按下键盘或单击、拖动鼠标）时，都将产生一个事件。可见，事件用来描述不同类型用户操作的对象。Java有很多不同类型的事件类，对应不同类型的用户动作
事件源（Event source）：产生事件的组件就是一个事件源。例如，在一个Button上单击鼠标时，将产生一个ActionEvent类型的事件，那么这个Button就是事件源。
事件处理器（Event handle）：事件处理器就是一个方法，它接收一个事件对象，对其进行解释，并做出相应的处理。
异常：Java程序中，由于程序员的疏忽或环境的变化，在程序运行时出现的打断正常程序流程的不正常情况。
输入流：Java可以打开一个从某种数据源（如文件、内存等）到程序的一个流，从这个流中读取数据，这就是输入流。它只能从流中读出，不能向流中写入。21、输出流：Java可以打开一个从程序到某种数据宿（如文件、内存等）的一个流，把数据顺序写入这个流以便输出，这就是输出流。它只能向流中写入，不能从流中读出。
Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。
Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。
Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。
Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿名类。
Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。
API 应用程序接口:提供特定功能的一组相关的类和方法的集合。
Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。在Java中作为对象处理。
Automatic variables 自动变量:也称为方法局部变量method local variables，即声明在方法体中的变量。
AWT抽象窗口工具集:一个独立的API平台提供用户界面功能。
Base class 基类:即被扩展继承的类。
Blocked state 阻塞状态:当一个线程等待资源的时候即处于阻塞状态。阻塞状态不使用处理器资源。
Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。
Casting 类型转换 :即一个类型到另一个类型的转换，可以是基本数据类型的转换，也可以是对象类型的转换。
char 字符:容纳单字符的一种基本数据类型。
Child class 子类:见继承类Derived class
Class 类:面向对象中的最基本、最重要的定义类型。
Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。
Class methods 类方法:类方法通常是指的静态方法，即不需要实例化类就可以直接访问使用的方法。
Class variable 类变量:见静态变量Static variable。
Collection 容器类:容器类可以看作是一种可以储存其他对象的对象，常见的容器类有Hashtables和Vectors。
Collection interface 容器类接口:容器类接口定义了一个对所有容器类的公共接口。
Collections framework 容器类构架:接口、实现和算法三个元素构成了容器类的架构。
Constructor 构造函数:在对象创建或者实例化时候被调用的方法。通常使用该方法来初始化数据成员和所需资源。
Containers容器:容器是一种特殊的组件，它可以容纳其他组件。
Declaration 声明:声明即是在源文件中描述类、接口、方法、包或者变量的语法。
Derived class 继承类:继承类是扩展继承某个类的类。
Encapsulation 封装性:封装性体现了面向对象程序设计的一个特性，将方法和数据组织在一起，隐藏其具体实现而对外体现出公共的接口。
Event classes 事件类:所有的事件类都定义在java.awt.event包中。
Event sources 事件源:产生事件的组件或对象称为事件源。事件源产生事件并把它传递给事件监听器event listeners。
Exception 异常:异常在Java中有两方面的意思。首先，异常是一种对象类型。其次，异常还指的是应用中发生的一种非标准流程情况，即异常状态。
Extensibility扩展性:扩展性指的是面向对象程序中，不需要重写代码和重新设计，能容易的增强源设计的功能JAVA常见名词解释大全JAVA常见名词解释大全。
Finalizer 收尾:每个类都有一个特殊的方法finalizer，它不能被直接调用，而被JVM在适当的时候调用，通常用来处理一些清理资源的工作，因此称为收尾机制。
Garbage collection 垃圾回收机制:当需要分配的内存空间不再使用的时候，JVM将调用垃圾回收机制来回收内存空间。
Guarded region 监控区域:一段用来监控错误产生的代码。
Heap堆:Java中管理内存的结构称作堆。
Identifiers 标识符:即指定类、方法、变量的名字。注意Java是大小写敏感的语言。
Import statement 引入语法:引入语法允许你可以不使用某个类的全名就可以参考这个类。
Inheritance 继承:继承是面向对象程序设计的重要特点，它是一种处理方法，通过这一方法，一个对象可以获得另一个对象的特征。
Inner classes 内部类:内部类与一般的类相似，只是它被声明在类的内部，或者甚至某个类方法体中。
Instance 实例:类实例化以后成为一个对象。
Instance variable 实例变量:实例变量定义在对象一级，它可以被类中的任何方法或者其他类的中方法访问，但是不能被静态方法访问。
Interface 接口:接口定义的是一组方法或者一个公共接口，它必须通过类来实现。
Java source file Java源文件:Java源程序包含的是Java程序语言计算机指令。
Java Virtual Machine (JVM) Java虚拟机:解释和执行Java字节码的程序，其中Java字节码由Java编译器生成。
javac Java编译器:Javac是Java编译程序的名称。
JVM Java虚拟机:见Java虚拟机
Keywords 关键字:即Java中的保留字，不能用作其他的标识符。
Layout managers 布局管理器:布局管理器是一些用来负责处理容器中的组件布局排列的类。
Local inner classes 局部内部类:在方法体中，或者甚至更小的语句块中定义的内部类。
Local variable 局部变量:在方法体中声明的变量
Member inner classes 成员内部类:定义在封装类中的没有指定static修饰符的内部类。
Members 成员:类中的元素，包括方法和变量。
Method 方法:完成特定功能的一段源代码，可以传递参数和返回结果，定义在类中。
Method local variables 方法局部变量:见自动变量Automatic variables
Modifier 修饰符:用来修饰类、方法或者变量行为的关键字。
Native methods 本地方法:本地方法是指使用依赖平台的语言编写的方法，它用来完成Java无法处理的某些依赖于平台的功能。
Object 对象:一旦类实例化之后就成为对象JAVA常见名词解释大全文章JAVA常见名词解释大全出自http://www.gkstk.com/article/wk-78500001155671.html，转载请保留此链接！。
Overloaded methods 名称重载方法:方法的名称重载是指同一个类中具有多个方法，使用相同的名称而只是其参数列表不同。
Overridden methods 覆盖重载方法:方法的覆盖重载是指父类和子类使用的方法采用同样的名称、参数列表和返回类型。
Package 包:包即是将一些类聚集在一起的一个实体。
Parent class 父类:被其他类继承的类。也见基类。
Private members 私有成员:私有成员只能在当前类被访问，其他任何类都不可以访问之。
Public members 公共成员:公共成员可以被任何类访问，而不管该类属于那个包。
Runtime exceptions 运行时间异常:运行时间异常是一种不能被你自己的程序处理的异常。通常用来指示程序BUG。
Source file 源文件:源文件是包含你的Java代码的一个纯文本文件。
Stack trace 堆栈轨迹:如果你需要打印出某个时间的调用堆栈状态，你将产生一个堆栈轨迹。
Static inner classes 静态内部类:静态内部类是内部类最简单的形式，它于一般的类很相似，除了被定义在了某个类的内部。
Static methods 静态方法:静态方法声明一个方法属于整个类，即它可以不需要实例化一个类就可以通过类直接访问之。
Static variable 静态变量:也可以称作类变量。它类似于静态方法，也是可以不需要实例化类就可以通过类直接访问。
Superclass 超类:被一个或多个类继承的类。
Synchronized methods 同步方法:同步方法是指明某个方法在某个时刻只能由一个线程访问。
Thread 线程:线程是一个程序内部的顺序控制流。
Time-slicing 时间片:调度安排线程执行的一种方案。
Variable access 变量访问控制:变量访问控制是指某个类读或者改变一个其他类中的变量的能力。
Visibility 可见性: 可见性体现了方法和实例变量对其他类和包的访问控制。
容器：充当中间件的角色。
WEB容器：给处于其中的应用程序组件(JSP，SERVLET)提供一个环境，使JSP,SERVLET直接更容器中的环境变量接口交互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。
EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。
WEB容器和EJB容器在原理上是大体相同的，更多的区别是被隔离的外界环境。
WEB容器更多的是跟基于HTTP的请求打交道。
而EJB容器不是。它是更多的跟数据库、其它服务打交道。
但他们都是把与外界的交互实现从而减轻应用程序的负担。例如SERVLET不用关心HTTP的细节，直接引用环境变量session,request,response就行、EJB不用关心数据库连接速度、各种事务控制，直接由容器来完成。
RMI/IIOP:远程方法调用/internet对象请求中介协议，他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。
JNDI:JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
JMS:JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JAVAMAIL:JAVA邮件服务。提供邮件的存储、传输功能。他是JAVA编程中实现邮件功能的核心。相当MS中的EXCHANGE开发包。
JTA：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JAF:JAVA安全认证框架提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。
EAI:企业应用集成。是一种概念，从而牵涉到好多技术。J2EE技术是一种很好的集成实现。
其他缩写名词:
DTO:Data Transport Object 数据传输对象
JDO:Java Data Object
DAO:Database Access Object 数据库访问对象
POJO:Proterozoic Java Object Java原生对象
VO:Value Object 值对象
SOAP:Simple Object Access Protocol 简单对象访问协议
abstract schema name 抽象结构名称
annotation 注释
attribute 属性
build 构建
column 字段
constructor 构造函数
delegate 委托
deployment descriptor 部署描述文件
detached 游离
distributed object 分布式对象
cagely fetch 立即获取
EJB object ejb对象
element 元素
endpoint interface 端点接口
entity listener entity监听器
field 数据成员
heuristic decision 试探性决策
loacl interface 本地接口
managed 托管
message destination 消息目标地址
method 成员函数
modeling 建模
named 命名的
operator 操作符
partial XML deployment 部署描述片段
phantom read 幻读
property 属性
proxy 代理
relationship 关联
remote interface 远程接口
response time 响应时间
standalon application 独立桌面应用程序
stub 存根
transaction-aware 事务感知
transaction demarcation 事务划分
transient property 瞬时属性
undeploy 卸载
unqualified class name 非限定类名
warpper type 封装类
J2EE平台是由一整套服务（Services）、应用程序接口（APIs）和协议构成。
J2EE包括以下技术:
EJB:Enterprise JavaBeans 企业JavaBean组件
IDL:Interface Definition Language 接口定义语言
JMS:Java Message Service Java消息服务
JNDI:Java Naming and Directory Interface Java命名目录接口
RMI:Remote Method Invocation 远程方法调用
JTA:Java Transaction API Java事务API
JTS:Java Transaction Service Java事务服务
Object Serialization:对象序列化
JavaMail:Java邮件服务
JDBC:数据库访问API
JSP:Java Server Pages
EJB分为三种:
Session Bean(会话BEAN)
Entity Bean(实体BEAN)
Message Driver Bean(消息驱动BEAN)
Session Bean分为两种:
Stateless Session Bean(无状态会话Bean)
Statefull Session Bean(有状态会话Bean)
Entity Bean分为两种:
CMP:Container Manager Persistence(容器管理持久性)
BMP:Bean Manager Persistence(Bean管理持久性)
————————————————————————————————————————————————————————————————————————————————————
包
在Java中常说某个包下面的某个类。那么什么是包呢？在平时操作电脑时，我们常江某个文档，视频，音频等问价放在某个文件夹下，而这个文件夹在Java中就就叫做包。其实饱和文件夹在某种意义上来说是等同的，只是在Java中将其叫做包而不叫做文件夹。
类
放在包下面的一个个并且是以.java结尾的文件就是类。前面有说道对想是Java程序的核心，而类描述了对象的属性和对象的行为，类是对象模板【类是对对象的抽象，对象是对类的实例化】
类按类型分为普通类，抽象类，接口，嵌套类等。按层级分又分为父类和子类。
普通类
【访问修饰符】 class 类名 【implements/extends 类名】{ }，其中有一种特殊的类object类，object类是所有类的父类，如果一个类没有用extends明确指出继承于某个类，那么它默认继承Object类。
抽象类
当一个类中没有足够的信息描述一个具体的书屋时，这个类就是抽象类。
语法：【访问修饰符】 abstract class 类名{ }
特点：
1、抽象类不能实例化
2、抽象类可以拥有构造方法
3、抽象类可以声明实例变量，也可以声明静态变量，也可以存在普通方法和静态方法，变量在抽象类中可以初始化
4、抽象类中还可以有抽象方法 语法：【访问修饰符】 abstract 返回值类型 方法名 （【参数】）；
5、抽象类抽象方法，有抽象类的子类来实现
6、如果一个类是抽象类，那么这个类的不一定有抽象方法，但如果一个类有抽象方法，那么这个类一定是抽象类
7、如果抽象类的子类没有吧抽象类中的所有抽象方法实现，则子类也需要定义成抽象类，有子类的子类负责实现剩余的抽象方法。
8、普通方法在子类中与普通类一样，可以实现也可以不实现。
接口
就是对外提供了一系列功能的生命（也可以说接口中定义的方法只有方法的生命，没有方法体）
语法：【访问修饰符】 interface 接口名 {
//常量和方法的声明
}
1 public interface demo{
2 int i=0;
3 public void add() ;
4 }
特点：
1、接口中声明的方法没有方法体，只有方法的声明；
2、接口中声明的成员属性都是静态的而且都是不可变的，因为接口中的成员属性默认都是public static final 来修饰的；
3、接口没有构造方法，也不能被实例化；
4、接口可以实现多继承，接口之间用逗号隔开；
5、接口中的方法只能被public来修饰，就算没有明确的神明访问修饰符，默认也是public通过implements来实现接口，语法：【访问修饰符】 class 类名 implements 接口1，接口2{ }。
嵌套类
声明在类的内部的类称之为嵌套类
语法：【访问修饰符】 class 类名{
【访问修饰符】【static】 class 类名{
}
}
分类：内部类：非静态嵌套类；
静态嵌套类：用static修饰的嵌套类。
内部类：内部类作为外部类的一个成员存在，与外部类的成员变量，成员方法并列；
局部内部类：在方法体内声明的类，可以访问他所在方法中的final参数和final局部变量；
静态嵌套类中可声明static成员或非静态成员变量，但只能访问外部类中的静态成员。
方法
方法就是实现某个功能的代码块
方法的定义语法：
1、无返回值无参数的方法 【访问修饰符】 void 方法名（）{ //方法的功能代码 }
说明：void就是表示该方法是无返回值得（也就是说调用完该方法不会返回一个结果）
2、无返回值有参数的方法 【访问修饰符】 void 方法名（数据类型 参数名，…）{//方法的功能代码}
说明：方法中的参数又称为形参（形式意义的参数），调用该方法时传递的数据称为实参（实际的数据），传递的参数要和方法中的参数类型匹配
3、有返回值无参数的方法 【访问修饰符】 返回值类型 方法名称（）{ return 返回值； }
说明：1、返回值类型有放回值来决定
2、在由返回值得方法的最后一句代码，一定是 return 返回值；。
4、有返回值有参数的方法 【访问修饰符】 返回值类型 方法名（参数列表）{ return 返回值}
变量
定义：在Java中用来存储数据的元素，而且该元素所存放的数据时可以变化的，所以称为变量
注意：变量也是标识符的一部分
语法：1、变身名变赋值 数据类型 变量名称=变量值
2、先声明后赋值 数据类型 变量名称；变量名称=变量值；
定义变量的四个步骤：
1、声明数据类型其实就是为了根据数据类型开辟相应的内存空间
2、给变量命名，其实就会说为了能够把变量名和数据类型所对应的内存空间进行关联
3、给变量赋值，其实就是把数据存放到变量名所对应的内存空间
4、使用变量，其实就是把变量所对应的内存空间中的数据读取出来
常量
定义：在程序中他的值是不可变的，这样的冤死及时常量
语法：final 数据类型 常量名称=常量值；
建议：常量名称一般全部大写
标识符
标识符就是类名，方法名，参数名，包名等元素命名时，所写的字符序列就统称为标识符
标识符的命名规则：
1、有字幕，数字，下划线，和$组成
2、不能以数字开头
3、严格区分大小写
4、长度无限制
5、不能是Java的关键字和保留关键字
建议：见名知意
访问修饰符
在定义类、属性、方法时都需要指定访问修饰符，以此来限定类、属性、方法的可访问范围。Java中的访问修饰符有以下几个关键字：
public：公共。该类或非该类均可访问
private：私有的。只有在类的主体中才可以访问。只能修饰属性和方法，不能修饰类
protected：受保护。该类及子类的成员均可以访问，同一个包中的类也可以访问。只能修饰属性和方法，不能修饰类
默认：不使用修饰符。只有相同包中的类才可以访问
位置private默认protectedpublic同一个类是同一个包内的类否是不同保内的类不同包内不同类
关键字
在Java中被赋予了一定特殊意义和用途的单词保留关键字也是关键字，只是目前没有任何的特殊意义和用途，保留使用。
this关键字
使用范围：this关键字只能使用在没有被static关键字修饰的方法中
作用：this关键字就会说对当类某个对象的引用（简单来说就是可以把this看做当前类的一个对象，哪个对象调用当前的方法，this关键字就指向该对象）
【当局部变量和成员变量完全一致时，以局部变量为主，即就近原则】
用法：
1、当方法中的参数名或变量名和成员变量完全一致时，可以通过this关键字来区分作用域
2、当this关键字以this（参数列表）的形式，出现在构造方法的第一句时，就表示当前构造方法调用了该类中其他的构造方法。
final关键字
1、final修饰的变量等同于常量，一旦赋值就无法更改（是指引用变量不能变，引用变量所指向的对象的内容还是可以改变的）【final无论修饰全局变量还是局部变量，在定义时都必修要初始化才能使用】
2、final修饰方法中的参数称为最终参数，在方法体中同样也不能为最终参数重新赋值
3、final修饰类，该类不能被继承
4、final修饰的方法，不能被重写
staitic关键字
static可以修饰变量，方法，代码块
static修饰变量，也称为类变量，因为static关键字修饰的变量，方法，代码块都属于类，而不属于某个对象
【实例变量：没有被static修饰的成员属性或方法都属于某个对象，也叫做实例属性或实例方法，对象存在了，才会有实例变量开辟空间】
static修饰的属相、方法可以通过：类名.属性名或l类名.方法（参数）的形式来调用
特点：
1、静态方法中只能访问静态方法和静态的成员变量
2、在非静态方法中，既可以访问非静态的方法、属性，也可以访问静态属性和静态方法
3、在静态方法中不能使用this和supper关键字，因为this和supper表示对对象的引用，而static修饰的方法是属于类，所以在语法上存在一定的冲突
静态代码块：静态代码块只能出现在类的内部，任何方法的外部
静态代码块语法：static{ }
静态代码块作用：就是给静态的成员属性进行初始化
静态代码块的优先级比构造方法的优先级高
方法中参数的传递
在Java中无论是基本数据类型还是引用数据类型，在进行参数的传递时，都是采用的值传递（也就是传递的都是具体的数据）
基本数据类型在进行参数传递时，传递的值是副本，也就是说当把当前数据复制一份，然后再进行穿丝，所以目标方法中，对参数进行修改，这个值得本身是没有任何变化的。
引用数据类型字进行参数的传递时，传递的是数据所在的内存地址，所以在目标方法中，对参数进行修改，这个值本身也会发生相应的变化。
向上转型和向下转型
向上转型：把一个子类的对象，赋值给父类，就会把该对象当做父类对象来用
动态（延迟）绑定机制：在程序运行期间，会根据对象的真正的创建者来决定调用那个方法
发生动态绑定机制的条件：
1、继承
2、重写
3、向上转型
4、用向上转型的对象调用被子类重写的方法
向下转型：把一个父类对象，复制给某个子类，需要加上强制转换符，向下转型一定是在向上转型的基础上类型的还原，向下转型调用子类中的没有重写的方法，可以通过instanceof关键字来判断某个独享是否属于某各类
————————————————————————————————————————————————————————————————————————————————————
1）类与对象
类：生活中一些对象共同点的集合、主观的、以人的意识存在的
对象：客观存在的，类的实体
2）面向对象
java是一门面向对象的开发语言，c是面向过程的开发语言，两种编程思想的不同：
生活中一件事 = 对象（执行者） + 过程（执行流程）
面向对象————关注对象（关注事情的执行者） ->>结果不确定（灵活）
面向过程————关注过程（关注事情的执行流程） ->>结果确定（死板）
面向对象三大特性：继承性、多态性、封装性
3）基本语法：
1.一个类对应一个java文件
2.属性（特征）的定义格式：访问权限 类型 属性名;
3.方法（行为）的定义格式：访问权限 返回类型 方法名（参数列表）｛｝
4.创建对象的格式：类名 对象名 = new 类名（）；
5.调用属性：对象名.属性名
6.调用方法：对象名.方法名（参数）
7.程序入口：public static void main(String[] args){}
代码示例1.1：
[图片上传中...(image.png-6515f5-1559722384053-0)]
运行结果：
对于JButton一个有参，一个无参
同时这也是构造函数的重载，关于JButton的构造函数重载，可由API查得
6）继承（子类和父类）
关键字：extends
定义：子类可以继承父类的所有非私有属性和方法，子类可以有额外的属性和方法
作用：动态的拓展类的功能，一般情况下子类比父类更强大
代码举例：
8）转型：父类引用指向子类引用
定义：无论是上转还是下转都是为了让类的使用范围和适用范围发生变化，以便操作不同范围的变量或者方法。
1）上转型是指将子类对象使用父类引用进行引用。通俗地说就是是将子类对象转为父类对象。
得：上转型对象可以操作和使用子类继承或者重写的方法。
失：上转型对象丧失了对子类新增成员变量或新增的方法的操作和使用。
2）与向上转型相反，即是把父类对象转为子类对象：作用也与上转相反。向下转型需要用到强制类型转换。
向上转型代码举例：
若把上面代码的主函数部分改成
9）多态
定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
作用：消除类型之间的耦合关系。
理解：现实中多态的举例有很多，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。
多态存在的三个必要条件
1）要有继承
2）要有重写
3）父类引用指向子类对象
多态的好处：
1.可替换性。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
4.灵活性。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
关于多态的一个练习：
10）当前类对象this
理解：代码执行前，或没执行到之前，this是没有指向的，执行时，指回当前对象，如果类有属性，this.XXX就是指这个类的xxx属性，有方法的，this.xx().就是指这个类的xx()方法。
理解举例：
文章转载于https://blog.csdn.net/Coder_Chang/article/details/51532374