写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会，主要是和一些java基础知识点相关的，所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE相关的、和Java中各个框架相关的内容。经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。1. JVM相关(包括了各个版本的特性)对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资深开发者来说，不会JVM几乎是不可接受的。JVM作为java运行的基础，很难相信对于JVM一点都不了解的人可以把java语言吃得很透。我在面试有超过3年Java经验的开发者的时候， JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证java开发能力的高低。在JVM这个大类中，我认为需要掌握的知识有：JVM内存模型和结构GC原理，性能调优调优：Thread Dump， 分析内存结构class 二进制字节码结构， class loader 体系 ， class加载过程 ， 实例创建过程方法执行过程Java各个大版本更新提供的新特性(需要简单了解)2. Java的运行（基础必备）这条可能出看很简单，java程序的运行谁不会呢？不过很多时候， 我们只是单纯通过IDE去执行java程序，底层IDE又是如何执行java程序呢？很多人并不了解。这个知识点是最最基本的java开发者需要掌握的，初学java，第一个肯定是教你如何在命令行中执行java程序，但是很多人一旦把java学完了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。 这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。在这里需要掌握的知识有：javac 编译java文件为 class 文件java 命令的使用， 带package的java类如何在命令行中启动java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)3. 数据类型这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断主要知识点：基本类型： int， long， float， double， boolean ， 。。。对应的对象类型： Integer 等类型到基本类型的转换， 装箱和拆箱Object类型： equals， hashcodeString 类型的特点4. 对象和实例，对象的创建在这方面，开发者需要了解class和instance的概念以及之间的差别， 这是java面向对象特性的一个基础。主要知识点有：Class和 Instance 的概念Instance 创建的过程：1。 无继承：分配内存空间， 初始化变量， 调用构造函数2。 有继承：处理静态动作， 分配内存空间， 变量定义为初始值 ， 从基类->子类， 处理定义处的初始化， 执行构造方法需要注意的点：静态属性等从基类->子类进行初始化默认无参构造方法相关的特性5. 访问控制这也是java封装特性的一个基础，需要掌握的有：public protected default private 对于class， method， field 的修饰作用6. 流程控制Java 流程控制的基础， 虽然有些语法不一定很常用，但是都需要了解，并且在合适的地方使用它们。需要掌握的有：if， switch， loop， for， while 等流程控制的语法7. 面向对象编程的概念这是一个java的核心概念，对于任何java开发者都需要熟练掌握。Java中很多特性或者说知识点都是和java面向对象编程概念相关的。在我的理解，一个好的开发者不仅仅需要了解这些特性（知识点）本身，也更需要知道这些对象在java的面向对象编程概念中是如何体现出来的，这样更有利于开发者掌握java这门开发语言，以及其他面向对象编程的语言。在这里只是简单罗列了一下，主要的知识点包括有：面向对象三大特性：封装，继承，多态; 各自的定义概念，有哪些特性体现出来，各自的使用场景静态多分派，动态单分派的概念重载的概念和使用继承：接口多实现，基类单继承抽象，抽象类，接口多态：方法覆盖的概念和使用接口回调8. Static静态属性在java日常开发中也是经常使用，需要了解和 static 关键字相关的用法，还有和其他关键字的配合使用， 如是否可以和 abstract， final 等关键字联合使用。主要需要掌握的有：静态属性的定义，使用，以及类加载时如何初始化静态方法的定义和使用静态类的定义和使用静态代码块的定义和初始化时机9. 基础知识点这里主要罗列一些散落的，没有系统归类的一些java知识点。在日常的开发中用到也不少。 这块内容其实还有很多，目前只是暂时归纳了这几个在这里：包括有：equals ， hashcode ， string/stringbuffer ，final ， finally ， finalize10.集合框架这个是一个需要多加掌握的部分，做java开发，可以说没有不用到集合框架的，这很重要。但是这里的知识点并不难，但是对于集合最好要了解内部的实现方式，因为这样有助于你在各个不同的场景选择适合的框架来解决问题，比如有1W个元素的集合，经常要进行contains判断操作，知道了集合的特性或者内部实现，就很容易做出正确的选择。这里包括了如下内容(并发相关不包含在内)：集合框架的体系： 基础Collection ，Map具体集合实现的内容， List ，Set ，Map 具体的实现，内部结构， 特殊的方法， 适用场景等集合相关的工具类 Collections 等的用法11.异常框架异常在java的开发中可能没有那么被重视。一般遇到异常，直接上抛，或者随便catch一下处理之后对于程序整体运行也没有什么大的影响。不过在企业级设计开发中， 异常的设计与处理的好坏，往往就关系着这个系统整体的健壮性。一个好的系统的异常对于开发者来说，处理应该统一，避免各处散落很多异常处理逻辑；对于系统来说，异常应该是可控的，并且是易于运维的，某些异常出现后，应该有应对的方法，知道如何运维处理，所以虽然异常框架很简单，但是对于整个企业级应用开发来说，异常处理是很重要的，处理好异常就需要了解Java中的异常体系。这部分需要掌握的知识点不多，主要就是：异常的体系：ThrowableExceptionRuntimeExceptionErrorRuntimeException 和 一般 Exception 的区别， 具体处理方法等Java学习交流QQ群：589809992 我们一起学Java！12. Java IOIO 在java中不仅仅是文件读写那么简单，也包括了 socket 网络的读写等等一切的输入输出操作。比如说 标准HTTP请求中Post的内容的读取也是一个输出的过程，等等…对于IO，Java不仅提供了基本Input、Output相关的api，也提供了一些简化操作的Reader、Writer等api，在某些开发（涉及大量IO操作的项目）中也很重要，一般日常的开发中也会涉及（日志，临时文件的读写等）。在这中的知识点主要有：基本IO的体系： 包括有InputStream ， OutputStream， Reader/Writer， 文件读取，各种流读取等NIO 的概念， 具体使用方式和使用场景13.多线程并发多线程是Java中普遍认为比较难的一块。多线程用好了可以有效提高cpu使用率， 提升整体系统效率， 特别是在有大量IO操作阻塞的情况下；但是它也是一柄双刃剑， 如果用不好，系统非但提升不大，或者没有提升，而且还会带来多线程之间的调试时等问题。在多线程中内容有很多，只是简单说明一下Java中初步使用多线程需要掌握的知识点，以后有机会单独再详细介绍一些高级特性的使用场景。多线程的实现和启动callable 与 runable 区别syncrhoized ，reentrantLock 各自特点和比对线程池future 异步方式获取执行结果concurrent 包lock..14.网络Java中也是提供了可以直接操作 TCP协议、UDP协议的API。在需要强调网络性能的情况下，可以直接使用TCP/UDP 进行通讯。在查看Tomcat等的源码中，就可以看到这些相关API的使用情况。不过一般也比较少会直接使用TCP，会使用诸如MINA、Netty这样的框架来进行处理，因为这个方面的开发涉及不多，所以就不再详细罗列了。15.时间日期处理几乎对于每个应用来说，时间日期的处理也是绕不过去的，但是JDK8 之前的时间相关API用法并不友好。在那个时代，可以选择Joda等时间框架。到了JDK8 发布之后，全新的时间API基本融合了其他框架的优点，已经可以很好的直接使用了。对于Java开发者来说，需要熟练地使用API来对时间和日期做相关的处理。具体知识点不再罗列，会在以后再写个专门的文章来总结一下JDK8中时间日期API的用法。16.XML解析/ JSON解析其实这两块内容都不是J2SE里面的内容，但是在日常开发中，和其他程序交互，和配置文件交互，越来越离不开这两种格式的解析。不过对于一个开发者来说，能够了解一些XML/JSON具体解析的原理和方法，有助于你在各个具体的场景中更好的选择合适你的方式来使得你的程序更有效率和更加健壮。XML： 需要了解 DOM解析和 SAX解析的基本原理和各自的适用场景JSON： 需要了解一些常用JSON框架的用法， 如 Jackson， FastJson， Gson 等。。17.Maven的使用Maven也不是Java里面的内容，但是maven是革命性的，给java开发带来了巨大的便利。从依赖的引入和管理，开发流程的更新和发布产出，乃至版本的更新，使用maven可以大大简化开发过程中的复杂度，从而节省大量时间。可以说，maven已经成为java开发者的标配了。所以我把maven也作为一个java开发者对于基础必备的知识点。以后会再放上一些我的一些对于maven使用的经验和技巧等，这里就不再细说了。18.泛型这是JDK5开始引入的新概念，其实是个语法糖，在编写java代码时会有些许便利， 一般的应用或者是业务的开发，只需要简单使用，不一定会用到定义泛型这样的操作， 但是开发一些基础公共组件会使用到，可以在需要的时候再细看这个部分，一般情况下只要会简单使用即可。19.标注也是jdk5 之后引入的。spring是个优秀的框架，最开始就以xml作为标准的配置文件。不过到了Spring3 之后，尤其是 spring-boot 兴起之后，越来越推崇使用标注来简化xml配置文件了，对于开发者来说，可以节省不少xml配置的时间。但是劣势是在于标注散落在各个类中，不像xml，可以对所有配置有个全局性的理解和管理，所以还没有办法说完全就取代所有的xml。对于一般开发者，会使用标注即可，一些公共组建的开发者可能会需要了解标注的定义和实现，可以在具体需要的时候再细看。20.RMIRemoteMethodInvocation ，Java语言特有的远程调用接口，使用还是比较简单方便。不过需要跨语言的情况下，就需要使用 webservice 等其他方式来支持。一般来说，程序都不需要使用RMI，不过可以在特定的情况下使用，我就在一个项目中，使用RMI来进行程序远程启动停止的控制。21.JNIJava Native Interface，可以允许Java中调用本地接口方法，一般用于C/C++代码的调用。需要注意的是在java中加载so/dll文件的路径问题，本身调用接口并不复杂，但是经常在是否加载了所需的本地接口库中花费较多时间。以上也只是简单介绍了下我对于这些

宏观上：1.技术广度方面至少要精通多门开源技术吧，研究过strutsspring等的源码。2.项目经验方面从头到尾跟过几个大项目，头是指需求阶段，包括需求调研。尾是指上线交付之后，包括维护阶段。3.架构经验方面有过分布式系统的架构和开发经验。对于跨系统的结构优化，数据存储的性能指标等有丰富经验。什么缓存啊、数据库的垂直切分什么的，业务的抽象和水平拆分啊，这些应该都轻车熟路吧。4.行业领域方面最起码得精通一到两门业务吧，所谓精通，就是比如做金融证券业务的，至少等当半个经融分析师。做电力业务的，至少等当半个电力工程师。5.个人修为有自己一些独到的见解，不会人云亦云啦。微观上：1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF，J2EEDP)以及综合模式。你应该十分了解UML，尤其是class，object，interaction以及statediagrams。2.你需要学习JAVA语言的基础知识以及它的核心类库(collections，serialization，streams，networking， multithreading，reflection，event，handling，NIO，localization，以及其他)。3.你应该了解JVM，classloaders，classreflect，以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。4.如果你将要写客户端程序，你需要学习WEB的小应用程序(applet)，必需掌握GUI设计的思想和方法，以及桌面程序的SWING，AWT， SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。5.你需要学习java数据库技术，如JDBCAPI并且会使用至少一种persistence/ORM构架，例如Hibernate，JDO， CocoBase，TopLink，InsideLiberator(国产JDO红工厂软件)或者iBatis。6.你还应该了解对象关系的阻抗失配的含义，以及它是如何影响业务对象的与关系型数据库的交互，和它的运行结果，还需要掌握不同的数据库产品运用，比如:oracle，mysql，mssqlserver。7.你需要学习JAVA的沙盒安全模式(classloaders，bytecodeverification，managers，policyandpermissions，codesigning， digitalsignatures，cryptography，certification，Kerberos，以及其他)还有不同的安全/认证 API，例如JAAS(JavaAuthenticationandAuthorizationService)，JCE (JavaCryptographyExtension)，JSSE(JavaSecureSocketExtension)，以及JGSS (JavaGeneralSecurityService)。8.你需要学习Servlets，JSP，以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。9.你需要熟悉主流的网页框架，例如JSF，Struts，Tapestry，Cocoon，WebWork，以及他们下面的涉及模式，如MVC/MODEL2。10.你需要学习如何使用及管理WEB服务器，例如tomcat，resin，Jrun，并且知道如何在其基础上扩展和维护WEB程序。11.你需要学习分布式对象以及远程API，例如RMI和RMI/IIOP。12.你需要掌握各种流行中间件技术标准和与java结合实现，比如Tuxedo、CROBA，当然也包括javaEE本身。13.你需要学习最少一种的XMLAPI，例如JAXP(JavaAPIforXMLProcessing)，JDOM(JavaforXMLDocumentObjectModel)，DOM4J，或JAXR(JavaAPIforXMLRegistries)。14.你应该学习如何利用JAVAAPI和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC)，SAAJ (SOAPwithAttachmentsAPIforJava)，JAXB(JavaArchitectureforXMLBinding)，JAXM(JavaAPIforXMLMessaging)， JAXR(JavaAPIforXMLRegistries)，或者JWSDP(JavaWebServicesDeveloperPack)。15.你需要学习一门轻量级应用程序框架，例如Spring，PicoContainer，Avalon，以及它们的IoC/DI风格(setter，constructor，interfaceinjection)。16.你需要熟悉不同的J2EE技术，例如JNDI(JavaNamingandDirectoryInterface)，JMS (JavaMessageService)，JTA/JTS(JavaTransactionAPI/JavaTransactionService)，JMX (JavaManagementeXtensions)，以及JavaMail。17.你需要学习企业级JavaBeans(EJB)以及它们的不同组件模式：Stateless/StatefulSessionBeans，EntityBeans(包含Bean- ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL)，或者 Message-DrivenBeans(MDB)。18.你需要学习如何管理与配置一个J2EE应用程序服务器，如WebLogic，JBoss等，并且利用它的附加服务，例如簇类，连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。19.你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩写为AOP)，以及他们的主流JAVA规格和执行。例如AspectJ和AspectWerkz。20.你需要熟悉对不同有用的API和frame work等来为你服务。例如Log4J(logging/tracing)，Quartz (scheduling)，JGroups(networkgroupcommunication)，JCache(distributedcaching)， Lucene(full-textsearch)，JakartaCommons等等。21.如果你将要对接或者正和旧的系统或者本地平台，你需要学习JNI (JavaNativeInterface) and JCA (JavaConnectorArchitecture)。 22.你需要熟悉JINI技术以及与它相关的分布式系统，比如掌握CROBA。23.你需要JavaCommunityProcess(JCP)以及他的不同JavaSpecificationRequests(JSRs)，例如Portlets(168)，JOLAP(69)，DataMiningAPI(73)，等等。24.你应该熟练掌握一种JAVAIDE例如sunOne，netBeans，IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了：)25.JAVA(精确的说是有些配置)是冗长的，它需要很多的人工代码(例如EJB)，所以你需要熟悉代码生成工具，例如XDoclet。26.你需要熟悉一种单元测试体系(JNunit)，并且学习不同的生成、部署工具(Ant，Maven)。27.你需要熟悉一些在JAVA开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。28.你需要能够深入了解加熟练操作和配置不同的操作系统，比如GNU/linux，sunsolaris，macOS等，做为跨平台软件的开发者。29.你还需要紧跟java发展的步伐，比如现在可以深入的学习javaME，以及各种java新规范，技术的运用，如新起的web富客户端技术。30.你必需要对opensource有所了解，因为至少java的很多技术直接是靠开源来驱动发展的，如java3D技术。Java学习交流QQ群：589809992  禁止闲聊，非喜勿进！宏观上：1.技术广度方面至少要精通多门开源技术吧，研究过strutsspring等的源码。2.项目经验方面从头到尾跟过几个大项目，头是指需求阶段，包括需求调研。尾是指上线交付之后，包括维护阶段。3.架构经验方面有过分布式系统的架构和开发经验。对于跨系统的结构优化，数据存储的性能指标等有丰富经验。什么缓存啊、数据库的垂直切分什么的，业务的抽象和水平拆分啊，这些应该都轻车熟路吧。4.行业领域方面最起码得精通一到两门业务吧，所谓精通，就是比如做金融证券业务的，至少等当半个经融分析师。做电力业务的，至少等当半个电力工程师。5.个人修为有自己一些独到的见解，不会人云亦云啦。微观上：1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF，J2EEDP)以及综合模式。你应该十分了解UML，尤其是class，object，interaction以及statediagrams。2.你需要学习JAVA语言的基础知识以及它的核心类库(collections，serialization，streams，networking， multithreading，reflection，event，handling，NIO，localization，以及其他)。3.你应该了解JVM，classloaders，classreflect，以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。4.如果你将要写客户端程序，你需要学习WEB的小应用程序(applet)，必需掌握GUI设计的思想和方法，以及桌面程序的SWING，AWT， SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。5.你需要学习java数据库技术，如JDBCAPI并且会使用至少一种persistence/ORM构架，例如Hibernate，JDO， CocoBase，TopLink，InsideLiberator(国产JDO红工厂软件)或者iBatis。6.你还应该了解对象关系的阻抗失配的含义，以及它是如何影响业务对象的与关系型数据库的交互，和它的运行结果，还需要掌握不同的数据库产品运用，比如:oracle，mysql，mssqlserver。7.你需要学习JAVA的沙盒安全模式(classloaders，bytecodeverification，managers，policyandpermissions，codesigning， digitalsignatures，cryptography，certification，Kerberos，以及其他)还有不同的安全/认证 API，例如JAAS(JavaAuthenticationandAuthorizationService)，JCE (JavaCryptographyExtension)，JSSE(JavaSecureSocketExtension)，以及JGSS (JavaGeneralSecurityService)。8.你需要学习Servlets，JSP，以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。9.你需要熟悉主流的网页框架，例如JSF，Struts，Tapestry，Cocoon，WebWork，以及他们下面的涉及模式，如MVC/MODEL2。10.你需要学习如何使用及管理WEB服务器，例如tomcat，resin，Jrun，并且知道如何在其基础上扩展和维护WEB程序。11.你需要学习分布式对象以及远程API，例如RMI和RMI/IIOP。12.你需要掌握各种流行中间件技术标准和与java结合实现，比如

这是我自己早前听课时整理的java基础全套知识，使用于初学者，也可以适用于中级的程序员，我做成了chm文档的类型，你们可以下载 笔记是比较系统全面，可以抵得上市场上90%的学习资料。讨厌那些随便乱写的资料还有拿出来卖钱的人！在这里我免费的分享出来供大家使用！在这个平台真的可以学习到不少的东西！有很多的人都在无私的奉献着他们的智慧与知识。希望对于学习者有所帮助！ 如果你觉得好的话，就在评论出给予回应,谢谢。这是我劳动成果！希望给予鼓励！点击下载之前的链接有人说失效了！现在我又重新更新了！这次打不开的就直接来我的QQ群吧：589809992

写在前面技术源于分享，所以今天抽空把自己之前用java做过的小游戏整理贴出来给大家参考学习。java确实不适合写桌面应用，这里只是通过这个游戏让大家理解oop面向对象编程的过程，纯属娱乐。代码写的很简单，也很容易理解，并且注释写的很清楚了，还有问题，自己私下去补课学习。完整代码敌飞机12345678910111213141516171819202122232425262728293031323334353637import java.util.Random;   敌飞机: 是飞行物，也是敌人 public class Airplane extends FlyingObject implements Enemy {    private int speed = 3;  //移动步骤     /** 初始化数据 */    public Airplane(){        this.image = ShootGame.airplane;        width = image.getWidth();        height = image.getHeight();        y = -height;                 Random rand = new Random();        x = rand.nextInt(ShootGame.WIDTH - width);    }     /** 获取分数 */    @Override    public int getScore() {         return 5;    }     /** //越界处理 */    @Override    public     boolean outOfBounds() {          return y>ShootGame.HEIGHT;    }     /** 移动 */    @Override    public void step() {          y += speed;    } }分数奖励123456789/** * 奖励 */ public interface Award {     int DOUBLE_FIRE = 0;  //双倍火力     int LIFE = 1;   //1条命     /** 获得奖励类型(上面的0或1) */     int getType(); }蜜蜂12345678910111213141516171819202122232425262728293031323334353637383940414243import java.util.Random;  /** 蜜蜂 */ public class Bee extends FlyingObject implements Award{     private int xSpeed = 1;   //x坐标移动速度     private int ySpeed = 2;   //y坐标移动速度     private int awardType;    //奖励类型      /** 初始化数据 */     public Bee(){         this.image = ShootGame.bee;         width = image.getWidth();         height = image.getHeight();         y = -height;         Random rand = new Random();         x = rand.nextInt(ShootGame.WIDTH - width);         awardType = rand.nextInt(2);   //初始化时给奖励     }      /** 获得奖励类型 */     public int getType(){         return awardType;     }      /** 越界处理 */     @Override     public boolean outOfBounds() {         return y>ShootGame.HEIGHT;     }      /** 移动，可斜着飞 */     @Override     public void step() {               x += xSpeed;         y += ySpeed;         if(x > ShootGame.WIDTH-width){               xSpeed = -1;         }         if(x < 0){             xSpeed = 1;         }     } }子弹类：是飞行物体1234567891011121314151617181920212223242526/** * 子弹类:是飞行物 */ public class Bullet extends FlyingObject {     private int speed = 3;  //移动的速度      /** 初始化数据 */     public Bullet(int x,int y){         this.x = x;         this.y = y;         this.image = ShootGame.bullet;     }      /** 移动 */     @Override     public void step(){            y-=speed;     }      /** 越界处理 */     @Override     public boolean outOfBounds() {         return y<-height;     }  }敌人的分数1234567/** * 敌人，可以有分数 */ public interface Enemy {     /** 敌人的分数  */     int getScore(); }飞行物(敌机，蜜蜂，子弹，英雄机)123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475import java.awt.image.BufferedImage;  /** * 飞行物(敌机，蜜蜂，子弹，英雄机) */ public abstract class FlyingObject {     protected int x;    //x坐标     protected int y;    //y坐标     protected int width;    //宽     protected int height;   //高     protected BufferedImage image;   //图片      public int getX() {         return x;     }      public void setX(int x) {         this.x = x;     }      public int getY() {         return y;     }      public void setY(int y) {         this.y = y;     }      public int getWidth() {         return width;     }      public void setWidth(int width) {         this.width = width;     }      public int getHeight() {         return height;     }      public void setHeight(int height) {         this.height = height;     }      public BufferedImage getImage() {         return image;     }      public void setImage(BufferedImage image) {         this.image = image;     }      /**     * 检查是否出界     * @return true 出界与否     */     public abstract boolean outOfBounds();      /**     * 飞行物移动一步     */     public abstract void step();      /**     * 检查当前飞行物体是否被子弹(x,y)击(shoot)中     * @param Bullet 子弹对象     * @return true表示被击中了     */     public boolean shootBy(Bullet bullet){         int x = bullet.x;  //子弹横坐标         int y = bullet.y;  //子弹纵坐标         return this.x<x && x<this.x+width && this.y<y && y<this.y+height;     }  }英雄机123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106import java.awt.image.BufferedImage;  /** * 英雄机:是飞行物 */ public class Hero extends FlyingObject{      private BufferedImage[] images = {};  //英雄机图片     private int index = 0;                //英雄机图片切换索引      private int doubleFire;   //双倍火力     private int life;   //命      /** 初始化数据 */     public Hero(){         life = 3;   //初始3条命         doubleFire = 0;   //初始火力为0         images = new BufferedImage[]{ShootGame.hero0, ShootGame.hero1}; //英雄机图片数组         image = ShootGame.hero0;   //初始为hero0图片         width = image.getWidth();         height = image.getHeight();         x = 150;         y = 400;     }      /** 获取双倍火力 */     public int isDoubleFire() {         return doubleFire;     }      /** 设置双倍火力 */     public void setDoubleFi

一图胜千言，下面图解均来自Program Creek 网站的Java教程，目前它们拥有最多的票选。1、字符串不变性下面这张图展示了这段代码做了什么String s = "abcd";s = s.concat("ef");2、equals()方法、hashCode()方法的区别HashCode被设计用来提高性能。equals()方法与hashCode()方法的区别在于：如果两个对象相等(equal)，那么他们一定有相同的哈希值。如果两个对象的哈希值相同，但他们未必相等(equal)。3、Java异常类的层次结构图中红色部分为受检查异常。它们必须被捕获，或者在函数中声明为抛出该异常。4、集合类的层次结构注意Collections和Collection的区别。（Collections包含有各种有关集合操作的静态多态方法）5、Java同步Java同步机制可通过类比建筑物来阐明。6、别名别名意味着有多个变量指向同一可被更新的内存块，这些别名分别是不同的对象类型。7、堆和栈图解表明了方法和对象在运行时内存中的位置。8、Java虚拟机运行时数据区域图解展示了整个虚拟机运行时数据区域的情况。我有一个微信公众号，经常会分享一些Java技术相关的干货。如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

面试的时候经常会遇见诸如：“java中的HashMap是怎么工作的”，“HashMap的get和put内部的工作原理”这样的问题。本文将用一个简单的例子来解释下HashMap内部的工作原理。首先我们从一个例子开始，而不仅仅是从理论上，这样，有助于更好地理解，然后，我们来看下get和put到底是怎样工作的。我们来看个非常简单的例子。有一个”国家”(Country)类，我们将要用Country对象作为key，它的首都的名字（String类型）作为value。下面的例子有助于我们理解key-value对在HashMap中是如何存储的。1. Country.javapackage org.arpit.javapostsforlearning;public class Country {String name;long population;public Country(String name, long population) {super();this.name = name;this.population = population;}public String getName() {return name;}public void setName(String name) {this.name = name;}public long getPopulation() {return population;}public void setPopulation(long population) {this.population = population;}// If length of name in country object is even then return 31(any random number) and if odd then return 95(any random number).// This is not a good practice to generate hashcode as below method but I am doing so to give better and easy understanding of hashmap.@Overridepublic int hashCode() {if(this.name.length()%2==0)return 31;elsereturn 95;}@Overridepublic boolean equals(Object obj) {Country other = (Country) obj;if (name.equalsIgnoreCase((other.name)))return true;return false;}}2. HashMapStructure.java(main class)import java.util.HashMap;import java.util.Iterator;public class HashMapStructure {/*** @author Arpit Mandliya*/public static void main(String[] args) {Country india=new Country("India",1000);Country japan=new Country("Japan",10000);Country france=new Country("France",2000);Country russia=new Country("Russia",20000);HashMap<country,string> countryCapitalMap=new HashMap<country,string>();countryCapitalMap.put(india,"Delhi");countryCapitalMap.put(japan,"Tokyo");countryCapitalMap.put(france,"Paris");countryCapitalMap.put(russia,"Moscow");Iterator<country> countryCapitalIter=countryCapitalMap.keySet().iterator();//put debug point at this linewhile(countryCapitalIter.hasNext()){Country countryObj=countryCapitalIter.next();String capital=countryCapitalMap.get(countryObj);System.out.println(countryObj.getName()+"----"+capital);}}}现在，在第23行设置一个断点，在项目上右击->调试运行(debug as)->java应用(java application)。程序会停在23行，然后在countryCapitalMap上右击，选择“查看”（watch）。将会看到如下的结构：从上图可以观察到以下几点：1. 有一个叫做table大小是16的Entry数组。2. 这个table数组存储了Entry类的对象。HashMap类有一个叫做Entry的内部类。这个Entry类包含了key-value作为实例变量。我们来看下Entry类的结构。Entry类的结构：static class Entry implements Map.Entry{final K key;V value;Entry next;final int hash;...//More code goes here} `3. 每当往hashmap里面存放key-value对的时候，都会为它们实例化一个Entry对象，这个Entry对象就会存储在前面提到的Entry数组table中。现在你一定很想知道，上面创建的Entry对象将会存放在具体哪个位置（在table中的精确位置）。答案就是，根据key的hashcode()方法计算出来的hash值（来决定）。hash值用来计算key在Entry数组的索引。4. 现在，如果你看下上图中数组的索引10，它有一个叫做HashMap$Entry的Entry对象。5. 我们往hashmap放了4个key-value对，但是看上去好像只有2个元素！！！这是因为，如果两个元素有相同的hashcode，它们会被放在同一个索引上。问题出现了，该怎么放呢？原来它是以链表(LinkedList)的形式来存储的(逻辑上)。上面的country对象的key-value的hash值是如何计算出来的。<code>Japan的Hash值是95，它的长度是奇数。 India的Hash值是95，它的长度是奇数。 Russia的Hash值是31，它的长度是偶数。 France，它的长度是偶数。  </code>下图会清晰的从概念上解释下链表。所以，现在假如你已经很好地了解了hashmap的结构，让我们看下put和get方法。Put :让我们看下put方法的实现：/*** Associates the specified value with the specified key in this map. If the* map previously contained a mapping for the key, the old value is* replaced.** @param key* key with which the specified value is to be associated* @param value* value to be associated with the specified key* @return the previous value associated with <tt>key</tt>, or <tt>null</tt>* if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return* can also indicate that the map previously associated* <tt>null</tt> with <tt>key</tt>.)*/public V put(K key, V value) {if (key == null)return putForNullKey(value);int hash = hash(key.hashCode());int i = indexFor(hash, table.length);for (Entry<k , V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;addEntry(hash, key, value, i);return null;}现在我们一步一步来看下上面的代码。对key做null检查。如果key是null，会被存储到table[0]，因为null的hash值总是0。key的hashcode()方法会被调用，然后计算hash值。hash值用来找到存储Entry对象的数组的索引。有时候hash函数可能写的很不好，所以JDK的设计者添加了另一个叫做hash()的方法，它接收刚才计算的hash值作为参数。indexFor(hash,table.length)用来计算在table数组中存储Entry对象的精确的索引。在我们的例子中已经看到，如果两个key有相同的hash值(也叫冲突)，他们会以链表的形式来存储。所以，这里我们就迭代链表。如果在刚才计算出来的索引位置没有元素，直接把Entry对象放在那个索引上。如果索引上有元素，然后会进行迭代，一直到Entry->next是null。当前的Entry对象变成链表的下一个节点。如果我们再次放入同样的key会怎样呢？逻辑上，它应该替换老的value。事实上，它确实是这么做的。在迭代的过程中，会调用equals()方法来检查key的相等性(key.equals(k))，如果这个方法返回true，它就会用当前Entry的value来替换之前的value。Get:现在我们来看下get方法的实现：/*** Returns the value to which the specified key is mapped, or {@code null}* if this map contains no mapping for the key.** <p>* More formally, if this map contains a mapping from a key {@code k} to a* value {@code v} such that {@code (key==null ? k==null :* key.equals(k))}, then this method returns {@code v}; otherwise it returns* {@code null}. (There can be at most one such mapping.)** &l

会在不适合使用java的地方不用java！作为一名软件开发者，要追求的，应该是不断地提升自己分析问题把握事物关键点，实事求是地给出切实可行且能“一剑封喉”的优雅解决方案的能力，再提升一点境界，就是要不断提升自己创新的能力（即创造新东西、提出新思路、解决新问题的能力）。我个人认为，花费大量的时间去"精通"某种语言、某个平台和某些工具，其实是本末倒置。所以，不要追这种"精通"，看上去学富五车很牛逼，其实孔乙己一个罢了。我读书时候，我的老师是这么教导我的说你们啊，编程要做到，将来无论什么时候，看到任何一个东西都能在脑子里想出来，如何用编程来将其实现做到这一步，你们就基本上算是懂编程了其实不管是学习编程语言还是学习外语都是一样的你应该不断滴challenge你自己，看看有哪些还是你不会做，不能做的然后想想怎么做出来，随着你能做的越来越多，慢慢你的能力就提升了至于精通不精通，这个是别人说的，你自己说了不算感觉不到 Java 的存在，只是认为自己在实现某些逻辑，而不是在写 Java举例来说，大多数中国人，都是称自己在“说话”，而不是在“说中文”。 而你会说，你在“说英文”，而不是在“说话”。这里的“说话”，就是所谓的精通的境界我有一个微信公众号，经常会分享一些Java技术相关的干货。如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

这个问题来自于QQ网友，一句两句说不清楚，索性写个文章。我刚开始做Web开发的时候，根本没有前端，后端之说。原因很简单，那个时候服务器端的代码就是一切：接受浏览器的请求，实现业务逻辑，访问数据库，用JSP生成HTML，然后发送给浏览器。即使后来Javascript在浏览器中添加了一些AJAX的效果，那也是锦上添花，绝对不敢造次。因为页面的HTML主要还是用所谓“套模板”的方式生成：美工生成HTML模板，程序员用JSP,Veloctiy,FreeMaker等技术把动态的内容添加上去，仅此而已。那个时候最流行的图是这个样子：在最初的J2EE体系中，这个表示层可不仅仅是浏览器中运行的页面，还包括Java写的桌面端，只是Java在桌面端太不争气， 没有发展起来。每个程序员都是所谓“全栈”工程师，不仅要搞定HTML, JavaScript, CSS，还要实现业务逻辑，编写访问数据库的代码。等到部署的时候，就把所有的代码打成一个WAR包，往Tomcat指定的目录一扔，测试一下没问题，收工回家！不差钱的公司会把程序部署到Weblogic，Websphere这样的应用服务器中，还会用上高大上的EJB。虽然看起来生活“简单”又“惬意”，但实际上也需要实现那些多变的、不讲逻辑的业务需求，苦逼的本质并没有改变。1. 前后端的分离随着大家对浏览器页面的视觉和交互要求越来越高，“套模板”的方式渐渐无法满足要求，这个所谓的表示层慢慢地迁移到浏览器当中去了，一大批像Angular, ReactJS之类的框架崛起，前后端分离了！后端的工程师只负责提供接口和数据，专注于业务逻辑的实现，前端取到数据后在浏览器中展示，各司其职。像Java这样的语言很适合去实现复杂的业务逻辑，尤其是一些MIS系统，行业软件如税务、电力、烟草、金融，通信等等。  所以剥离表示层，只做后端挺合适的。 但是如果仅仅是实现业务逻辑，那后端也不会需要这么多技术了，搞定SSH/SSM就行了。 2. 后端技术互联网，尤其是移动互联网开始兴起以后，海量的用户呼啸而来，一个单机部署的小小War包肯定是撑不住了，必须得做分布式。 原来的单个Tomcat得变成Tomcat的集群，前边弄个Web服务器做请求的负载均衡，不仅如此，还得考虑状态问题，session的一致性。业务越来越复杂，我们不得不把某些业务放到一个机器（或集群）上，把另外一部分业务放到另外一个机器（或集群）上，虽然系统的计算能力，处理能力大大增强，但是这些系统之间的通信就变成了头疼的问题，消息队列（MQ)，RPC框架（如Dubbo）应运而生，为了提高通信效率，各种序列化的工具(如Protobuf)也争先空后地问世。单个数据库也撑不住了，那就做数据库的读写分离，如果还不行，就做分库和分表，把原有的数据库垂直地切一切，或者水平地切一切， 但不管怎么切，都会让应用程序的访问非常麻烦，因为数据要跨库做Join/排序，还需要事务，为了解决这个问题，又有各种各样“数据访问中间件”的工具和产品诞生。为了最大程度地提高性能，缓存肯定少不了，可以在本机做缓存(如Ehcache)，也可以做分布式缓存(如Redis)，如何搞数据分片，数据迁移，失效转移，这又是一个超级大的主题了。互联网用户喜欢上传图片和文件，还得搞一个分布式的文件系统（如FastDFS），要求高可用，高可靠。数据量大了，搜索的需求就自然而然地浮出水面，你得弄一个支持全文索引的搜索引擎(如Elasticsearch ,Solr)出来。林子大了，什么鸟都有，必须得考虑安全，数据的加密/解密，签名、证书，防止SQL注入，XSS/CSRF等各种攻击。3. “大后端”前面提到了这么多的系统，还都是分布式的，每次上线，运维的同学说：把这么多系统协调好，把老子都累死了。得把持续集成做好，能自动化地部署，自动化测试（其实前端也是如此），后来出现了一个革命化的技术docker， 能够让开发、测试、生成环境保持一致，系统原来只是在环境（如Ngnix, JVM,Tomcat,MySQL等）上部署代码，现在把代码和环境一并打包， 运维的工作一下子就简化了。公司自己购买服务器比较贵，维护也很麻烦，又难于弹性地增长，那就搞点虚拟的服务器吧，硬盘、内存都可以动态扩展（反正是虚拟的）， 访问量大的时候多用点，没啥访问量了就释放一点，按需分配，很方便，这就是云计算的一个场景。随着时间的推移，各个公司和系统收集的数据越来越多，都堆成一座大山了，难道就放在那里白白地浪费硬盘空间吗？有人就惊奇地发现，咦，我们利用这些数据搞点事情啊， 比如把数据好好分析一下，预测一下这个用户的购买/阅读/浏览习惯，给他推荐一点东西嘛。可是这么多数据，用传统的方式计算好几天甚至好几个月才能出个结果，到时候黄花菜都凉了，所以也得利用分布式的技术，想办法把计算分到各个计算机去，然后再把计算结果收回来， 时势造英雄，Hadoop及其生态系统就应运而生了。之前听说过一个大前端的概念，把移动端和网页端都归结为“前端”，我这里造个词“大后端”，把那些用户直接接触不到的、发生在服务器端的都归结进来。4. 怎么学？现在无论是前端还是后端，技术领域多如牛毛，都严重地细分了，所以我认为真正的全栈工程师根本不存在，因为一个人精力有限，不可能搞定这么多技术领域，太难了。培训机构所说的“全栈”，我认为就是前后端还在拉拉扯扯，藕断丝连，没有彻底分离的时候的“全栈”工程师。那么问题来了， 后端这么多东西，我该怎么学？Java后端学习流程首先，我个人比较推崇的学习方法是：先学java前端，也就是HTML，css，js，因为学习java以后肯定是往java ee方向发展的，学习完前端，在学习后端很多东西比计较容易理解！其中J2SE是关键，如果学好了java se 部分，基础扎实了，后面进阶学习也比较轻松！补充说明一下：我觉得学习java比较合适的方法是先把所有的知识点过一遍，然后把所有的知识点串起来，边做开发边补充，就像写文章一样，先写好框架，然后再去润色填充。因为前期在学习的时候你不知道用在哪里，不知道用途，没有学习的目的，所以很多概念就很难理解，时间久了也容易遗忘。但是如果你直接从实践开始学习，很多知识点都充串联起来了，而且会印象深刻，当然前提条件是你已经入门，已经能写一些简单的程序，我个人现在也是按照这个方式在学习了，感觉很有效。说明：本文介绍的内容过于详尽，这里我补充一些基本的学习路线，相对比较简略，但是比较可行：基础语法。也就是我们常说，各种编程语言都有的部分，数据类型，数组，for循环，do-while,switch……等等，是学习任何编程语言的基础，很关键；面对对象：①类和对象；②Java的三大特性（封装、继承、多态）；工具类：①异常和异常处理；②集合框架（主要是List和Map）；常用的流（stream）：①输入流；②输出流；③缓冲流；网络与线程：①Socket ； ②多线程（Thread，Runnable）；数据操作：①Mysql、Oracle; ②JDBC；web基础：①Html/css；②Javascript；③JQuery；框架。只要学会上面的前7条，基本上从前台到后台开发常见的应用还是没太大问题的，当然学习了框架以后，那就最好了，但关键还是要学好基础，说实话，像下面这个表格中所列的知识点，真正能全面掌握还是有难度的，所以凡事还是要踏踏实实的静下心学习，不要只看学习的进度，要看学习的效果。第一阶段技术名称技术内容J2SE(java基础部分)java开发前奏计算机基本原理，Java语言发展简史以及开发环境的搭建，体验Java程序的开发，环境变量的设置，程序的执行过程，相关反编译工具介绍，java开发工具Eclipse的安装和使用，javadoc的说明。Java基础语法Java语法格式，常量和变量，变量的作用域，方法和方法的重载，运算符，程序流程控制，数组和操作数组的类，对数组循环遍历以及针对数组的常用查找、排序算法原理，最后使用Java程序进行功能实现。面向对象编程理解对象的本质，以及面向对象，类与对象之间的关系，如何用面向对象的思想分析和解决显示生活中的问题，并java程序的手段编写出来。如何设计类，设计类的基本原则，类的实例化过程，类元素：构造函数、this关键字、方法和方法的参数传递过程、static关键字、内部类，Java的垃圾对象回收机制。对象的三大特性：封装、继承和多态。子类对象的实例化过程、方法的重写和重载、final关键字、抽象类、接口、继承的优点和缺点。对象的多态性：子类和父类之间的转换、父类指向子类的引用、抽象类和接口在多态中的应用、多态优点。常用设计模式如单利、模版等模式。什么是异常 异常的捕捉和抛出 异常捕捉的原则 finally的使用，package的应用 import关键字。多线程应用多线程的概念，如何在程序中创建多线程(Thread、Runnable)，线程安全问题，线程的同步，线程之间的通讯、死锁问题的剖析。javaAPI详解JavaAPI介绍、String和StringBuffer、各种基本数据类型包装类，System和Runtime类，Date和DateFomat类等。常用的集合类使用如下：Java Collections Framework：Collection、Set、List、ArrayList、Vector、LinkedList、Hashset、TreeSet、Map、HashMap、TreeMap、Iterator、Enumeration等常用集合类API。IO技术什么是IO，File及相关类，字节流InputStream和OutputStream，字符流Reader和Writer，以及相应缓冲流和管道流，字节和字符的转化流，包装流，以及常用包装类使用，分析java的IO性能。网络编程Java网络编程，网络通信底层协议TCP/UDP/IP，Socket编程。网络通信常用应用层协议简介：HTTP、FTP等，以及WEB服务器的工作原理。java高级特性递归程序，Java的高级特性：反射、代理和泛型、枚举、Java正则表达式API详解及其应用。 第二阶段技术名称技术内容数据库技术Oracle 基础管理Oracle背景简介，数据库的安装，数据库的用户名和密码，客户端登录数据库服务SQLPLUS，数据库基本概。SQL语句数据库的创建，表的创建，修改，删除，查询，索引的创建，主从表的建立，数据控制授权和回收，事务控制，查询语句以及运算符的详解，sql中的函数使用。多表连接和子查询等值和非等值连接，外连接，自连接；交叉连接，自然连接，using子句连接，完全外连接和左右外连接，子查询使用以及注意事项。触发器、存储过程触发器和存储过程使用场合， 通过实例进行详解。数据库设计优化WHERE子句中的连接顺序，选择最有效率的表名顺序，SELECT子句中避免使用 ‘ * ‘ 计算记录条数等等。数据备份与移植移植技巧，备份方案；导入导出等。 第三阶段技术名称技术内容jdbc技术JDBC基础JDBC Connection、Statement、PreparedStatement、CallableStatement、ResultSet等不同类的使用。连接池技术了解连接池的概念，掌握连接池的建立、治理、关闭和配置。ORM与DAO封装对象关系映射思想，jdbc的dao封装，实现自己的jdbc。可以把第四阶段的知识提前一点，特别是对哪些刚开始接触面向对象编程的同学，我刚开始就学java se，感觉入门很不容易。先学web部分，有利于理解面向对象的概念，另外，web部分相对比较简单，也比较直观，写完直接就可以看见效果，有助于提升大家的学习积极性。第四阶段技术名称技术内容web基础技术(项目实战)Xml技术使用jdom和dom4j来对xml文档的解析和生成操作，xml 的作用和使用场合。html/cssJava掌握基本的html标签的格式和使用，css层叠样式表对div的定义，实现对网站布局的基本实现。Javascript了解javascript的基本语法以及相关函数的使用，并结合html页面实现流程控制和页面效果展示。什么是异常 异常的捕捉和抛出 异常捕捉的原则 finally的使用，package的应用 import关键字。jsp/servletServlet和SP 技术、上

Java学习这一部分是今天的重点，这一部分用来回答很多群里的朋友所问过的问题，那就是你是如何学习Java的，能不能给点建议？今天我是打算来点干货，因此咱们就不说一些学习方法和技巧了，直接来谈每个阶段要学习的内容甚至是一些书籍。这一部分的内容，同样适用于一些希望转行到Java的同学。在大家看之前，我要先声明两点。1、由于我本人是Java后端开发出身，因此所推荐的学习内容是Java Web和Java后端开发的路线，非Java Web和Java后端开发的同学请适当参考其学习思想即可，切勿照搬。2、下面对于【第一部分】的推荐内容，目的是让你尽快成为一个可以参加工作的Java开发者，更适用于处于待业状态，准备转行Java的同学。如果你是在校学生，务必要在学好基础（比如计算机系统、算法、编译原理等等）的前提下，再考虑去进行下面的学习。第一部分：对于尚未做过Java工作的同学，包括一些在校生以及刚准备转行Java的同学。一、Java基础首先去找一个Java的基础教程学一下，这里可以推荐一个Java学习交流的QQ群（群号码：589809992）你可以到这个群里找相应的视频教程。学习Java基础的时候，应该尽量多动手，很多时候，你想当然的事情，等你写出来运行一下，你就会发现不是这么回事儿，不信你就试试。学完以上内容以后，你应该对Java有一个基本的了解了，你可以用Java语言写出一些简单的程序，并且你用的是最简单的编辑器，比如记事本。这个时候，不要急于进入下一部分，留下几天好好写一些程序，尽可能熟悉这些基础内容。二、Web开发等你写上几天程序以后，你往往会比较迷茫，因为你写的东西似乎看起来毫无用处，比如实现一个简单的计算器，读取一个文件等。这个时候你就应该去学着写一些让你觉得有意思的东西了，所以你应该学习更多的知识。这些内容主要是Web开发相关的内容，包括HTML/CSS/JS（前端页面）、Servlet/JSP（J2EE）以及Mysql（数据库）相关的知识。它们的学习顺序应该是从前到后，因此最先学习的应该是HTML/CSS/JS（前端页面），这部分内容你可以去上面的那个runoob网站上找。你可以试着自己写一些页面，当然，你可以尽你最大的努力让它变得最漂亮。这部分内容对于后端Java来说，理论上不是特别重要，但至少要达到可以自己写出一些简单页面的水平。接下来，你需要学习的是Servlet/JSP（J2EE）部分，这部分是Java后端开发必须非常精通的部分，因此这部分是这三部分中最需要花精力的，而且这个时候，你要学会使用开发工具，而不能再使用记事本了，可以选择eclipse。当你下载安装好eclipse以后，请视频中的教程一步一步去学习，一定要多动手。关于Servlet/Jsp部分视频的选择，业界比较认可马士兵的视频，因此推荐给大家。当然了，我本人并没有看过他的视频，所以不好说的太绝对，如果大家自己有更好的选择，可以坚持自己的，不要被我干扰。原本我也是打算出教学视频的，但是由于时间问题，还是决定放弃了。但是如果你看视频的过程中遇到了问题，欢迎来我的交流群提问（群号码：589809992），最后一步，你需要学会使用数据库，mysql是个不错的入门选择，而且Java领域里主流的关系型数据库就是mysql。这部分一般在你学习Servlet/Jsp的时候，就会接触到的，其中的JDBC部分就是数据库相关的部分。你不仅要学会使用JDBC操作数据库，还要学会使用数据库客户端工具，比如navicat，sqlyog，二选一即可。三、开发框架当你学会以上内容以后，这个时候你还不足以参加工作，你还需要继续深造。公司里为了提高开发的效率，会使用一些Java Web框架，因此你还需要学习一些开发框架。目前比较主流的是SSM框架，即spring、springmvc、mybatis。你需要学会这三个框架的搭建，并用它们做出一个简单的增删改查的Web项目。你可以不理解那些配置都是什么含义，以及为什么要这么做，这些留着后面你去了解。但你一定要可以快速的利用它们三个搭建出一个Web框架，你可以记录下你第一次搭建的过程，相信我，你一定会用到的。还要提一句的是，你在搭建SSM的过程中，可能会经常接触到一个叫maven的工具。这个工具也是你以后工作当中几乎是必须要使用的工具，所以你在搭建SSM的过程中，也可以顺便了解一下maven的知识。在你目前这个阶段，你只需要在网络上了解一下maven基本的使用方法即可，一些高端的用法随着你工作经验的增加，会逐渐接触到的。四、找工作当你完成开发框架的学习以后，你就该找工作了，在校的找实习，毕业的找全职。与此同时，在找工作的同时，你不应该停下你的学习，准确的说，是你在以后都不能停下学习。上面这些内容你只是囫囵吞枣的学会了使用，你可以逐步尝试着去了解更多的东西，网络是你最重要的老师。第二部分：对于参加工作一年以内的同学。恭喜你，这个时候，你已经拥有了一份Java的工作。这个阶段是你成长极快的阶段，而且你可能会经常加班。但是加班不代表你就可以松懈了，永远记得我说的那句话，从你入行那一刻起，你就要不停的学习。在这一年里，你至少需要看完《Java编程思想》这本书。这本书的内容是帮助你对于Java有一个更加深入的了解，是Java基础的升级版。这本书很厚，当初看这本书，我花了整整三个月。正常速度的话，应该可以在半年左右看完。我这里不要求过高，只要你在一年以内把这本书看完即可。当然了，我所说的看完，是充分吸收，而不是读一遍就完事了，因此有些内容你可能会看不止一遍。总而言之，这个阶段的核心学习思想就是，在工作中实践，并且更加深入的了解Java基础。第三部分：对于参加工作1年到2年的同学。这部分时间段的同学，已经对Java有了一个更加深入的了解。但是对于面向对象的体会可能还不够深刻，编程的时候还停留在完成功能的层次，很少会去考虑设计的问题。于是这个时候，设计模式就来了。我当时看的是《大话设计模式》这本书，并且写了完整版的设计模式博客。因此，我要求大家，最多在你工作一年的时候，必须开始写博客，而设计模式就是你博客的开端。请记住，我所提的基本都是最低要求，因此不要有任何松懈的心理，否则五年后，你不要去羡慕别人高于你的工资，也不要去羡慕别人进入了某公司。这一年，你必须对于设计模式了如指掌，《大话设计模式》可以作为你的开端。此外，设计模式并不是你这一年唯一的任务，你还需要看一些关于代码编写优化的书。比如《重构 改善既有代码的设计》，《effective java》。总而言之，这个阶段，你的核心任务就是提高你的代码能力，要能写出一手优雅的代码。第四部分：对于参加工作2年到3年的同学有的同学在这个时候觉得自己已经很牛逼了，于是忍不住开始慢慢松懈。请记住，你还嫩的多。这个阶段，有一本书是你必须看的，它叫做《深入理解Java虚拟机》。这本书绝对是Java开发者最重要的书，没有之一。在我眼里，这本书的重要性还要高于《Java编程思想》。这本书的内容是帮助你全面的了解Java虚拟机，在这个阶段，你一定已经知道Java是运行在JVM之上的。所以，对于JVM，你没有任何理由不了解它。另外，在过去2年的工作当中，你肯定或多或少接触过并发。这个时候，你应该去更加深入的了解并发相关的知识，而这部分内容，我比较推荐《Java并发编程实战》这本书。只要你把这本书啃下来了，并发的部分基本已经了解了十之六七。与此同时，这个阶段你要做的事情还远不止如此。这个时候，你应该对于你所使用的框架应该有了更深入的了解，对于Java的类库也有了更深入的了解。因此，你需要去看一些JDK中的类的源码，也包括你所使用的框架的源码。这些源码能看懂的前提是，你必须对设计模式非常了解。否则的话，你看源码的过程中，永远会有这样那样的疑问，这段代码为什么要这么写？为什么要定义这个接口，它看起来好像很多余？由此也可以看出，这些学习的过程是环环相扣的，如果你任何一个阶段拉下来了，那么你就真的跟不上了，或者说是一步慢步步慢。而且我很负责的告诉你，我在这个阶段的时候，所学习的东西远多于这里所罗列出来的。因此千万不要觉得你已经学的很多了，我所说的这些都只是最低要求，不光是我，很多人在这个时间段所学习的内容都远超本文的范围。如果你不能跟上节奏的话，若干年后，如果不是程序猿市场还不错的话，你很可能不仅仅是工资比别人低，公司没别人好，而是根本就找不到工作。总而言之，这个阶段，你需要做的是深入了解Java底层和Java类库（比如并发那本书就是Java并发包java.concurrent的内容），也就是JVM和JDK的相关内容。而且还要更深入的去了解你所使用的框架，方式比较推荐看源码或者看官方文档。另外，还有一种学习的方式，在2年这个阶段，也应该启用了，那就是造轮子。不要听信那套“不要重复造轮子”的论调，那是公司为了节省时间成本编造出来的。重复造轮子或许对别人没有价值，因为你造的轮子可能早就有了，而且一般情况下你造出来的轮子还没有现存的好。但是对别人没有价值，不代表对你自己没有价值。一个造轮子的过程，是一个从无到有的过程。这个过程可以对你进行系统的锻炼，它不仅考察你的编码能力，还考察你的框架设计能力，你需要让你的轮子拥有足够好的扩展性、健壮性。而且在造轮子的过程中，你会遇到各种各样的难题，这些难题往往又是你学习的契机。当你把轮子造好的时候，你一定会发现，其实你自己收获了很多。所以，这个阶段，除了上面提到的了解JVM、JDK和框架源码以外，也请你根据别人优秀的源码，去造一个任何你能够想象出来的轮子。第五部分：参加工作3年到4年的同学这个阶段的同学，提升已经是很难了，而且这个阶段的学习往往会比较多样化。因为在前3年的过程中，你肯定或多或少接触过一些其它的技术，比如大数据、分布式缓存、分布式消息服务、分布式计算、软负载均衡等等。这些技术，你能精通任何一项，都将是你未来面试时巨大的优势，因此如果你对某一项技术感兴趣的话，这个时候可以深入去研究一下。这项技术不一定是你工作所用到的，但一定是相关的。而且在研究一门新技术时，切忌朝三暮四。有的同学今天去整整大数据，搞搞Hadoop、hbase一类的东西。过不了一段时间，就觉得没意思，又去研究分布式缓存，比如redis。然后又过不了一段时间，又去研究分布式计算，比如整整Mapreduce或者storm。结果到最后，搞得自己好像什么都会一样，在简历上大言不惭的写上大数据、分布式缓存、分布式计算都了解，其实任何一个都只是浮于表面。到时候面试官随便一问，就把你给识破了。一定要记住，作为一个程序猿，平日里所接触的技术可能会很多，但是想要让一门技术成为你的优势，那么一定是你对这门技术的了解强过绝大多数人才行。因此在这个阶段，你就不能再简单的去学习前3年的内容了，虽然前面的学习如果还不够深入的话依旧要继续，但这个时候你应该更多的考虑建立你的优势，也可以称为差异性。差异性相信不难理解，就是让你自己变得与众不同。你前面三年的学习足够你成为一名基本合格的Java开发者，但你离成为一名优秀的Java开发者还有很大的距离。所谓优秀，即能别人所不能。而你前三年所学习的内容，是很多做过几年的Java开发都能够掌握的。那么为了让自己有差异性，你就需要另辟蹊径，找一个方向深入研究下去，以期在将来，你能够成为这个领域的专家，比如分布式计算领域的专家，大数据领域的专家，并发领域的专家等等。此外，你除了建立你的差异性之外，还要去弥补你基础上的不足，直到现在，我都没有提及基础知识。原因是基础是很枯燥无味的，学的太早不仅容易懵逼，而且懵逼的同时还容易产生心理阴影，以至于以后再不想去研究这些基础。但基础又是你深入研究一些领域时所必须掌握的，比如你去研究分布式计算，你不懂算法你玩个毛毛？比如你去做分布式缓存，你对计算机系统的内存不了解，你如何去做缓存？如果你的基础本来就非常强，那么恭喜你，相信你在之前的工作中已经充分体会到了这些基础对你的帮助。但我相信大部分人的基础都很薄弱，哪怕是科班毕业的人，很多人也不敢说自己当初的基础学的多么强大，比如算法、计算机系统原理、编译原理这些。但是每个人时间都是有限的，而且这些基础的书籍每一本读下来，没个一年半载的，还真拿不下来，因此还是要有所抉择的。虽然艺多不压身，但问题是艺多是有代价的，是需要你付出时间和精力的，而我个人更赞成在同等代价的情况下获

最近换了个公司，从三月底开始面，面到四月底，面了有快二十家公司。我是一个喜欢总结经验的人，每经过一场面试，我在回来的路上都会仔细回想今天哪些问题可以答的更好，或者哪些问题是自己之前没遇到过的，或者是哪个知识点今天又问了等等。四月中旬的时候，我就在构思要写一篇面经，主要是想着可能对那些跟我相同处境的人有点帮助，再者就是稍微记录下这为期一个月的面试过程。个人介绍：首先介绍下我面试时的自身条件情况，我把自己的情况分为优势和劣势来说可能更有利于你们比较自身情况。劣势：1.15年7月毕业后开始到上海工作，面试的时候是17年3月到4月，一年多的经验，勉强算两年经验。分析：一年多经验我认为是比较尴尬的，处于一个不上不下的位置，很多公司比较喜欢招三年经验的，或者直接招应届生来培养。2.毕业于一个非985/211，勉强上一本的高校。分析：这个相对影响较小，因为有工作经验后，公司对学校的要求就没那么高了，只要是本科就基本没问题，但是还是有个别叼毛公司只要985/211。3.前一家公司是传统电信行业，加入项目组时，项目已经上线有段时间了，我们的任务就是有需求就开发，有bug就优化，其他时间就聊骚，各干各的，工作一年多跟在养老一样，用一句话说就是编程5分钟，扯淡2小时，项目经验严重不足，没开发过很难的需求。分析：这一点是最伤的，公司招有经验的就想看你都干了些什么牛批的东西，结果你告诉面试官我写的需求都是垃圾。优势：1.大学时拿过比较多的奖，每年都是校级优秀学生，毕业时是市级优秀毕业生，拿过省级ACM二等奖等。分析：大学的荣誉对一个有工作经验的人来说，公司不一定会看重，但是可能会对面试官产生微妙的影响，特别是ACM奖，我碰到过有的面试官也是搞过ACM的，有共同的话题聊起来总是比较容易的，但是也要注意不能把这一栏篇幅写的过于多，只能当作点缀用，我当时是放在简历最后一栏，简要的写了最主要的几个奖。2.良好的沟通交流能力。分析：这个能力不会是关键性的，但是可以加分。3.较强的学习能力和逻辑思维能力。分析：有些公司和面试官还是比较看重一个人的学习能力的，经验代表着你现在在什么级别，而学习能力则代表着你将来能到达什么级别。学习过程：看了我的优劣势介绍，你会发现我的优势相对于我的劣势来说，简直不值一提。我自己对此也有清晰的认识，因此从过完年之后，我就开始抓紧空闲时间学习。学习的过程如下：1.看面试题正常人第一步肯定都会看面试题，我也不例外，在看的过程中，我发现有些文章写的不错，对我帮助不小值得推荐，如下：Java面试题全集（上）很多基础的东西，建议先看。各大公司Java后端开发面试题总结面试心得与总结—BAT、网易、蘑菇街关于Java面试，你应该准备这些知识点2.深入学习在看面试题的过程，你会遇到一些自己没接触过的或者以前没深入学习过的知识，例如最常问的HashMap内部实现原理，这就促使你得开始去看jdk的源码或者是学习一些新的东西。看源码是很重要的一步，起步很难，但是会让你收益良多，看源码的过程如果碰到无法理解的地方，可以百度看下别人的理解。我学习源码的过程中，看过几个人的关于源码的文章写的很不错，如下：五月的仓颉占小狼zhangshixi的Core java系列3.熟悉项目找出自己工作以来开发过的最叼的功能，将整个功能的流程和涉及的东西吃透。项目是面试中必问的环节，一般是以一个功能点为基础展开问，因此你必须对这个功能有很深的认识，不能有模糊的地方。如果有时间，能把涉及到的知识点也搞懂最好。4.做面试题有不少公司是有面试的，如果你没有准备过，很容易在各种小地方犯错，建议去一些面试题网站多做些题目，我自己是用的牛客网。5.学习记录把自己每天的学习时间和学习内容记录下来，可以让自己更有动力的学习，学习是一个枯燥的过程，你必须让自己时刻保持有动力。投简历、约面试环节1.在哪些网站投？拉勾网、BOSS直聘、猎聘网。2.是否该海投？投简历分为两个情况。1）没有社招面试经验：建议采取海投的方式，只要职位要求跟自己比较匹配都可以投，累计面试经验。这个环节可以把投简历的网站增加两家：智联和无忧。2）自认为社招面试经验已经足够：投那些职位匹配、公司满意的职位。公司评价可以去看准网、百度、知乎等查询。3.一天约几家面试合适？最理想的情况为2家面试，上午一般在10点左右，下午一般在2点左右。建议把理想的公司放下午，因为下午的时间比较充足，可以让公司更充分的了解你。我开始面的时候，每次都是上午面的不好，下午面的不错。4.投简历经常没下文？我当初也没想到简历筛选这关有这么难，可能是我的简历确实亮点不多，再者HR很多都不是行内人，因此他们看得最直接的就是你上家的公司和你毕业的学校，如果你不是从牛逼的公司/学校出来，可能会碰到和我一样的情况，应对的办法就是多投。5.是否该裸辞？我一开始是边上班边投，然后利用调休时间，或者请假去面试。后来，面试机会越来越多，请假太频繁了，自己都不好意思了，并且自己也已经有足够的信心，这个时候我选择了裸辞。裸辞还有一个原因是，在面试过程中你会发现，有的公司要人要的紧，如果你的辞职流程过长可能会导致你错过这个公司。6.注意事项1）面试前一天把路线和时间算好，最好别迟到。2）背个书包，带好简历、充电宝、纸巾、雨伞。面试环节1.笔试常见的问题？面试常见的问题上面给的面试题链接基本都有。我只提几点：1）写SQL：写SQL很常考察group by、内连接和外连接。2）手写代码：手写代码一般考单例、排序、线程、消费者生产者。我建议排序算法除了冒泡排序，最好还能手写一种其他的排序代码。试想：如果一般面试者都写的冒泡排序，而你写的是快速排序/堆排序，肯定能给面试官留下不错的印象。2.面试流程？1）让你自我介绍2）问Java基础知识3）问项目4）情景问题，例如：你的一个功能上了生产环境后，服务器压力骤增，该怎么排查。5）你有什么想问面试官的3.面试常问的知识点？1）集合相关问题（必问）：HashMap、LinkedHashMap、ConcurrentHashMap、ArrayList、LinkedList的底层实现。HashMap和Hashtable的区别。ArrayList、LinkedList、Vector的区别。HashMap和ConcurrentHashMap的区别。HashMap和LinkedHashMap的区别。HashMap是线程安全的吗。ConcurrentHashMap是怎么实现线程安全的。2）线程相关问题（必问）：创建线程的3种方式。什么是线程安全。Runnable接口和Callable接口的区别。wait方法和sleep方法的区别。synchronized、Lock、ReentrantLock、ReadWriteLock。介绍下CAS(无锁技术)。什么是ThreadLocal。创建线程池的4种方式。ThreadPoolExecutor的内部工作原理。分布式环境下，怎么保证线程安全。Java学习交流QQ群：589809992 我们一起学Java！3）JVM相关问题：介绍下垃圾收集机制（在什么时候，对什么，做了什么）。垃圾收集有哪些算法，各自的特点。类加载的过程。 双亲委派模型。有哪些类加载器。能不能自己写一个类叫java.lang.String。4）设计模式相关问题（必问）：先问你熟悉哪些设计模式，然后再具体问你某个设计模式具体实现和相关扩展问题。5）数据库相关问题，针对Mysql（必问）：给题目让你手写SQL。有没有SQL优化经验。Mysql索引的数据结构。SQL怎么进行优化。SQL关键字的执行顺序。有哪几种索引。什么时候该（不该）建索引。Explain包含哪些列。Explain的Type列有哪几种值。6）框架相关问题：Hibernate和Mybatis的区别。Spring MVC和Struts2的区别。Spring用了哪些设计模式。Spring中AOP主要用来做什么。Spring注入bean的方式。什么是IOC，什么是依赖注入。Spring是单例还是多例，怎么修改。Spring事务隔离级别和传播性。介绍下Mybatis/Hibernate的缓存机制。Mybatis的mapper文件中#和$的区别。Mybatis的mapper文件中resultType和resultMap的区别。Mybatis中DAO层接口没有写实现类，Mapper中的方法和DAO接口方法是怎么绑定到一起的，其内部是怎么实现的。Java学习交流QQ群：589809992 我们一起学Java！7）其他遇到问题：介绍下栈和队列。IO和NIO的区别。接口和抽象类的区别。int和Integer的自动拆箱/装箱相关问题。 常量池相关问题。==和equals的区别。重载和重写的区别。String和StringBuilder、StringBuffer的区别。静态变量、实例变量、局部变量线程安全吗，为什么。 try、catch、finally都有return语句时执行哪个。介绍下B树、二叉树。ajax的4个字母分别是什么意思。xml全称是什么。分布式锁的实现。分布式session存储解决方案。常用的linux命令。一些经验：1.先投一些普通公司，等面出了心得再去投理想的公司。2.不熟悉的技术不要主动提。3.对于那种实习期6个月还打8折的公司，除非你没有其他选择了，否则不要去。4.小公司喜欢在薪水上压你，开的时候适当提高。5.不要去参加招聘会，纯粹是浪费时间。6.把面试当作一次技术的交流，不要太在意是否能被录取。7.公司一般面完就决定是否录取了，让你回去等消息这种情况一般没戏，无论你自己觉得面的有多好。8.尽量少通过电话面试，效果不好。9.在面试的日子里，要保持每天学习，无论是学习新东西还是复习旧东西。10.拿到offer了，问问自己这个公司让自己100%满意了吗，如果不是，请继续努力找更好的。11.通过面试官可以大概判断这家公司的情况。12.拉勾投的简历很多会被筛掉，但是拉勾还是面试机会的最主要来源。13.理想的公司可以多投几次，我有好几次都是第一次投被筛掉，多投几次就过的经验。我有一个微信公众号，经常会分享一些Java技术相关的干货。如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

这是我自己早前听课时整理的Java全套知识，适用于初学者，也可以适用于中级进阶的人，你们可以下载，我认为是比较系统全面的，可以抵得上市场上90%的学习资料。讨厌那些随便乱写的资料还有拿出来卖钱的人！在这里我免费的分享出来供大家使用！在这个平台真的可以学习到不少的东西！有很多的人都在无私的奉献着他们的智慧与知识。希望对于Java学习者有所帮助！ 如果你觉得好的话，就在评论出给予回应,谢谢。这是我劳动成果！希望给予鼓励！点击下载之前的链接有人说失效了！现在我又重新更新了！这次打不开的就直接来我的QQ群吧：589809992

社区中并不缺少有关软件工程师职业发展的文章，甚至可以说是泛滥。很多人都能在这个话题上说两句，三五年工作经验的编程老鸟也好，架构师也好，技术 VP 也好，CTO 也好，都有各自的看法与实践经验。没有哪一套方法是适用于所有人的，这一套软件工程师职业发展纲要，也不过是在你踽踽前行的路上，迷茫时可用来参考借鉴。你的核心竞争力，永远是你的自身实力。切记！一、专业技能学习捷径1、爱上你的编码神器众所周知，软件工程师要做的工作就是写代码，准确地说，你的目标应该是写出满足业务需求并且无法找出 Bug 的代码，而不是写一大堆没用的文字。既然你的任务是写出高质量的代码，那么你首先应该训练的就是打字速度，你需要掌握键盘盲打技能，甚至还要爱上你的“编码神器”，并做到将此工具的用法烂熟于心，闭上眼睛都能正确敲中你想要的快捷键。2、熟悉底层技术原理当你完全驾驭了计算机的输入设备以后，你需要进一步了解计算机的内部工作原理，不是让你把机器大卸八块，而是你需要全面了解计算机的组成结构与工作原理。如果你不是计算机科班出生也没关系，在网上买一本关于计算机组成原理的书自学即可。你无需做到精通，能全面了解即可，因为接下来你需要在编程的世界中，慢慢去体会计算机的工作感受，你就是计算机的管理者。3、深入一门编程语言好了，现在是时候学习一门编程语言了，最好的选择是 Java，为什么呢？原因很简单，因为市场需求量最大，我敢保证，你学 Java 肯定比学 PHP 更容易找到工作（希望 PHP 程序员们淡定一些，其实我始终认为 PHP 是世界上最好的编程语言）。当你在学习 Java 时，首先需要掌握它啰里吧嗦的编程语法，此时没有什么比写一个“Hello World”来得更爽快一些。随后你需要深刻理解的是 Java 的面向对象概念（每次我说到面向对象，总会被一些单身汉吐槽，其实我想说，对象是可以 new 出来的），这些概念看上去比较虚，但是它们却能撑起一个强大的软件架构。所以，在面向对象技术上面花再多功夫都不为过，因为它能训练我们对业务的抽象能力，就像当初我们学习数学一样，它能训练我们的逻辑思维能力。4、选择一位对的老师看书、看视频、看源码、看技术文档，其实这些都是较为低效的学习方法，掌握编程技能的捷径就是拜一位资深的程序员为师，你可以尊称他为“码神”，记得一定要把他伺候好，让他愿意传授一些编程技能给你，其实也就是一个微笑外加一顿小龙虾的事情，他就能被你征服。一定要看他写的代码，思考为什么他会这样写，一定要将你不理解的地方记录下来，并且在下班之前紧紧地抓住他，让他一次给你讲个够，此时你一定会有一种打通任督二脉的畅快之感。所谓“师傅领进门，修行在个人”，你需要比你师傅更加努力，甚至十倍于他人的付出，才能在编程之路上尝到甜头。此时你需要学习更加高深的武功，研究更加优秀的源码，实践更有挑战的项目，还需要花整块时间，系统地看技术文档以及技术参考书。假如你想成为架构师，不妨看看我所著的《架构探险》这本书，也许它会对你的专业技能有所帮助。5、乐于分享你的技能你最好要让自己变成一位豁达开朗之人，千万不要吝啬，一定要懂得分享你所学的专业技能。可以尝试做点自己的开源项目，并让这个开源项目变得更加开放，不妨结合开源，写点技术博客，并厚着脸皮给你身边的朋友阅读。这件事情一定要持之以恒，不要担心有人吐槽你，你肯定会被吐槽，那是因为大家在关注你，此时你需要更加努力，让自己变得足够专业。当你成为真正的“大神”时，就不会有人再吐槽你了，他们只会吐槽自己的技术不如你，此时你将得到的是无限的膜拜和称赞。相信我，这绝不是奇迹。在学习专业技能之路上，多一点自信，多一点勤奋，多一点思考，再争取一点机会，你就会成功。二、不可或缺的软技能1、软技能 ≠ 务虚如果将专业技能比喻为“硬技能”，那么在我们的职场中，与专业性无关的技能就可以归纳为“软技能”了。但每当我提到软技能时，难免会让人误解为这是“务虚”的一种功夫，我们虽然是“吃软饭的”（做软件开发的），但我们却十分讨厌虚伪。没错！我也很厌恶虚伪之人，尤其是在职场中遇到这样的人物，我从心底鄙视他们，但我从来不会和他们发生任何冲突，反而还能和他们愉快地共事，这种本领靠的就是软技能。软件工程师每天都在和机器打交道，机器是没有感情的，你告诉它是0，它一定不会认为是1。但我们与人打交道却不一样，你告诉他是真，他却可能认为是假。与人打交道，正是软件工程师们最为欠缺的方面，有些软件工程师甚至害怕与人交流，害怕在公开场合讲话，害怕抛头露面，害怕做一些组织性的工作。如果你也有以上这些心里负担，那么恭喜你！因为你即将从本文中找到克服这些困难的灵丹妙药，至少我希望是这样。需要强调的是，软技能是一种职场必备的核心技能，我敢直言，如果缺乏这方面的技能，你的职业生涯将会变得非常糟糕。软技能包括的方面非常广泛，沟通、协调、组织、气场这些都是最基本的软技能，甚至情商也是一种软技能，会不会讲话，听不听得明白，这些都是软技能。那么我们不妨先从沟通这项软技能开始吧，因为我认为他是软件工程师最重要的软技能之一。2、口语流利 ≠ 会沟通很多人都容易将沟通理解为讲话，说一个人语言很流利，很会讲话，口若悬河，夸夸其谈，其实并非他的沟通能力很强。我认为，沟通可以理解为两方面，即“沟”和“通”。“沟”指的是你将心中所想很清晰地表达出来给对方听，考验的是你的表达能力；“通”指的是让你确信对方是否真明白你所表达的意思，考验的是你的倾听能力。所以，我们很多时候都是在“沟”，往往忽略了“通”，从而形成了“沟而不通”的情况，因此，现在全世界人民都在提倡如何“有效沟通”。还是用一个示例来说话吧。当领导交给你一项棘手的工作，但你不知道如何开始进行这项工作，此时你应该如何应对当前的挑战呢？绝大多数人会硬着头皮去做，他们希望通过自己的努力，可以顺利完成任务，但结果往往却无法让领导满意。少数人会主动向领导咨询，以寻求领导对自己的帮助。此时应该如何与领导对话呢？似乎并非很多人都清楚。下面这段话是我的套路，仅供参考。我：勇哥（他是我的领导），最近我遇到了一点麻烦的事情，想听听您的看法（勾起领导的兴趣，让他认真听我说下去，记得一定要说“您”，而不是“你”）。领导：哦？说来听听（证明领导此时不忙，他有时间让我占用，如果他此时很忙，你应该能感受出来的）。我：感谢您对我的信任，昨天您交给我一项任务，回到家我一直都在想这项任务，我在想……（一定要对领导表示感激，是他给了我这次锻炼自己的机会，并强调我是“回到家”都在思考，而不是只在在公司里思考，道理你懂的）领导：可能是我没说清楚，你把这项任务想复杂了，其实……（可见这是一位 nice 的领导，跟着他，你能学到很多东西）我：我还想再清楚一下，您期待这项工作的结果是怎样的？（一定要明确领导想要的结果，他只会为结果买单）领导：我希望……（领导娓娓道来，此处省略1万字，你千万不要打断领导的讲话，他讲累了自然就会停，你只需要认真听他怎么讲）我：好的，我明白了，您希望我……（一定要学会复述领导讲过的话，而且要用自己的理解来表达，不要当复读机）领导：没错，就是这样。（领导表示认可了，此时你应该表示给领导一个微笑，让他感到欣慰）我：感谢勇哥！如果我在执行过程中遇到问题，可以再向您请教吗？（一定要感谢，而且要表现出虚心向领导请教，为下一次求救做好准备）领导：当然，随时交流。（你真心拿他当领导，他才会无条件帮助你，你不懂得用好这位领导，那是你自己的损失）沟通是不是很有趣？其实沟通是一门学问，我们花一辈子时间都在学习，都在改进自己的沟通方式，目的仅为愉快地和身边的人一起“玩耍”，让此生感到愉悦。当你已经掌握了必备的专业技能，也具备了让你脱颖而出的软技能，那么接下来你将思考的是自己该走那条路了，继续做软件工程师，还是做软件工程师的 leader？下面这段话将告诉你答案。三、正确制定职业路线1、给自己提几个问题首先要澄清的是：我并非职业导师，更不是人生教父，所有的路都由你自己选择，我的责任是告诉你，我认为行之有效的方法。当你正走在职场的十字路口徘徊，思考走技术，还是走管理？我的答案只有一个：根据你自己的优势来决定。合理利用好自己的优势，会让自己走的更加顺畅，让自己无怨无悔。还是举一个例子来说明吧。前段时间有位朋友在微信上私聊我，他也遇到了这个问题，继续做技术，还是转管理？我当时是这样问他的，但我希望你可以用这样的方式来问自己。我：你工作多久了？朋友：时间不长，写了10年的代码。我：那相当资深啊，现在还对写代码有激情吗？朋友：喜欢写，周末有时都会宅在家里写。我：那你还在纠结什么呢？朋友：我都工作10年了，身边的人要么当 CTO，要么做总监，自己却还在撸代码，我现在到底该不该转管理？我：你为什么会考虑转管理？说说你在管理上的优势吧。朋友：我觉得自己对技术有一定深度，可以帮助团队解决一些技术难题。我：如果你团队中有位小伙伴遇到一个很棘手的技术问题，没辙了，你会做些什么？朋友：撸起袖子，就地帮他解决掉。我：建议你走技术专家路线，这条路也许更加适合你。朋友：……2、转管理之前，先理解管理当我们在纠结是否应该转管理时，不妨首先理解一下什么是管理？以及什么是管理者？只有当我们正确理解了这些概念以后，再来思考自己是否具备这样的特征，才能顺利帮助自己转型。管理（management）是协调和监督他人的工作，从而使他人的工作可以有效率且有成效地完成。效率（efficiency）指的是以尽可能少的投入，以获得尽可能多的产出，效率常常被说成“正确地做事”，即不浪费资源。成效（effectiveness）常常被称为“做正确的事”，即做那些可以实现目标的工作活动。管理者（manager）就是完成所有管理工作，并使组织目标能够实现的人。管理者的工作包括计划（planning）、组织（organizing）、领导（leading）和控制（controlling）四种职能。以上都是管理学告诉我们的知识，如果你想成为一名管理者，那么你必须首先正确理解这些概念的真实含义，才能完全驾驭管理者的岗位，否则你会从管理岗位上摔下来，自己一定伤得不轻。如果你想成为一名优秀的管理者，那么你需要做些什么呢？亲自且专业地给团队激励。激励团队完成你无法独立完成的任务。对问题提供指导和指引。对团队的表现给予反馈。帮助团队改善绩效。使团队对组织的改变知情。改善团队小伙伴们的生活。如果团队和你共事过，那么团队应该觉得他们是幸运的，因为你能够让他们更加愉快和高效地工作。写在最后不论选择技术还是管理，在任何时候都不要放弃你的硬技能，因为它是你的“生存之本”，同时你也需要具备强大的软技能，因为它是你的“发展之源”。学习硬技能其实是有捷径的，你无需一味地学习这些知识点，更多的其实是与人交流以及加以应用。软技能其实是可以训练的，你只需抓住一切可以抓住的机会，有意识地加以训练和反思，你就能悟出很多宝贵的经验。软件开发是一门艺术，你需要能够静得下心，不断地优化和雕琢你的作品，因此你需要具备工匠精神。如果你想成为一名工匠领袖，那么你就应该比他人思考得更多、更高、更深、更全面，你需要更多的软技能。你只有认识到自己的优势，才能正确地选择自己的职业路线。祝你成功！我有一个微信公众号，经常会分享一些Java技术相关的干货。如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。原文：https://my.oschina.net/huangyong/blog/1633257#comment-list

引如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。很多人都对其中的一些概念不够明确，如同步、并发等等，让我们先建立一个数据字典，以免产生误会。多线程：指的是这个程序（一个进程）运行时产生了不止一个线程并行与并发：并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。 并发与并行线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果，如不加事务的转账代码：同步：Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时，提高性能，才是优秀的程序。线程安全的优先级高于性能。好了，让我们开始吧。我准备分成几部分来总结涉及到多线程的内容：扎好马步：线程的状态内功心法：每个对象都有的方法（机制）太祖长拳：基本线程类九阴真经：高级多线程控制类扎好马步：线程的状态先来两张图：  各种状态一目了然，值得一提的是"Blocked"和"Waiting"这两个状态的区别：线程在Running的过程中可能会遇到阻塞(Blocked)情况对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。从jdk源码注释来看，blocked指的是对monitor的等待（可以参考下文的图）即该线程位于等待区。线程在Running的过程中可能会遇到等待（Waiting）情况线程可以主动调用object.wait或者sleep，或者join（join内部调用的是sleep，所以可看成sleep的一种）进入。从jdk源码注释来看，waiting是等待另一个线程完成某一个操作，如join等待另一个完成执行，object.wait()等待object.notify()方法执行。Waiting状态和Blocked状态有点费解，我个人的理解是：Blocked其实也是一种wait，等待的是monitor，但是和Waiting状态不一样，举个例子，有三个线程进入了同步块，其中两个调用了object.wait()，进入了waiting状态，这时第三个调用了object.notifyAll()，这时候前两个线程就一个转移到了Runnable,一个转移到了Blocked。从下文的monitor结构图来区别：每个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态Blocked,从jstack的dump中来看是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是Waiting，表现在jstack的dump中是 “in Object.wait()”。此外，在runnable状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。内功心法：每个对象都有的方法（机制）synchronized, wait, notify 是任何对象都具有的同步工具。让我们先来了解他们 他们是应用于同步问题的人工线程调度工具。讲其本质，首先就要明确monitor的概念，Java中的每个对象都有一个监视器，来监测并发代码的重入。在非多线程编码时该监视器不发挥作用，反之如果在synchronized 范围内，监视器发挥作用。wait/notify必须存在于synchronized块中。并且，这三个关键字针对的是同一个监视器（某对象的监视器）。这意味着wait之后，其他线程可以进入同步块执行。当某代码并不持有监视器的使用权时（如图中5的状态，即脱离同步块）去wait或notify，会抛出java.lang.IllegalMonitorStateException。也包括在synchronized块中去调用另一个对象的wait/notify，因为不同对象的监视器不同，同样会抛出此异常。再讲用法：synchronized单独使用：代码块：如下，在多线程环境下，synchronized块中的方法获取了lock实例的monitor，如果实例相同，那么只有一个线程能执行该块内容直接用于方法： 相当于上面代码中用lock来锁定的效果，实际获取的是Thread1类的monitor。更进一步，如果修饰的是static方法，则锁定该类所有实例。synchronized, wait, notify结合:典型场景生产者消费者问题/*** 生产者生产出来的产品交给店员*/public synchronized void produce(){if(this.product >= MAX_PRODUCT){try{wait();System.out.println("产品已满,请稍候再生产");}catch(InterruptedException e){e.printStackTrace();}return;}this.product++;System.out.println("生产者生产第" + this.product + "个产品.");notifyAll(); //通知等待区的消费者可以取出产品了}/*** 消费者从店员取产品*/public synchronized void consume(){if(this.product <= MIN_PRODUCT){try{wait();System.out.println("缺货,稍候再取");}catch (InterruptedException e){e.printStackTrace();}return;}System.out.println("消费者取走了第" + this.product + "个产品.");this.product--;notifyAll(); //通知等待去的生产者可以生产产品了}volatile多线程的内存模型：main memory（主存）、working memory（线程栈），在处理数据时，线程会把值从主存load到本地栈，完成操作后再save回去(volatile关键词的作用：每次针对该变量的操作都激发一次load and save)。 针对多线程使用的变量如果不是volatile或者final修饰的，很有可能产生不可预知的结果（另一个线程修改了这个值，但是之后在某线程看到的是修改之前的值）。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的，本质上，volatile就是不去缓存，直接取值。在线程安全的情况下加volatile会牺牲性能。太祖长拳：基本线程类基本线程类指的是Thread类，Runnable接口，Callable接口Thread 类实现了Runnable接口，启动一个线程的方法：Thread类相关方法：关于中断：它并不像stop方法那样会中断一个正在运行的线程。线程会不时地检测中断标识位，以判断线程是否应该被中断（中断标识值是否为true）。终端只会影响到wait状态、sleep状态和join状态。被打断的线程会抛出InterruptedException。Thread.interrupted()检查当前线程是否发生中断，返回booleansynchronized在获锁的过程中是不能被中断的。中断是一个状态！interrupt()方法只是将这个状态置为true而已。所以说正常运行的程序不去检测状态，就不会终止，而wait等阻塞方法会去检查并抛出异常。如果在正常运行的程序中添加while(!Thread.interrupted()) ，则同样可以在中断后离开代码体Thread类最佳实践：写的时候最好要设置线程名称 Thread.name，并设置线程组 ThreadGroup，目的是方便管理。在出现问题的时候，打印线程栈 (jstack -pid) 一眼就可以看出是哪个线程出的问题，这个线程是干什么的。如何获取线程中的异常Runnable与Thread类似Callablefuture模式：并发模式的一种，可以有两种形式，即无阻塞和阻塞，分别是isDone和get。其中Future对象用来存放该线程的返回值以及状态九阴真经：高级多线程控制类以上都属于内功心法，接下来是实际项目中常用到的工具了，Java1.5提供了一个非常高效实用的多线程包:java.util.concurrent, 提供了大量高级工具,可以帮助开发者编写高效、易维护、结构清晰的Java多线程程序。1.ThreadLocal类用处：保存线程的独立变量。对一个线程类（继承自Thread)当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。常用于用户登录控制，如记录session信息。实现：每个Thread都持有一个TreadLocalMap类型的变量（该类是一个轻量级的Map，功能与map一样，区别是桶里放的是entry而不是entry的链表。功能还是一个map。）以本身为key，以目标为value。主要方法是get()和set(T a)，set之后在map里维护一个threadLocal -> a，get时将a返回。ThreadLocal是一个特殊的容器。2.原子类（AtomicInteger、AtomicBoolean……）如果使用atomic wrapper class如atomicInteger，或者使用自己保证原子的操作，则等同于synchronized该方法可用于实现乐观锁，考虑文中最初提到的如下场景：a给b付款10元，a扣了10元，b要加10元。此时c给b2元，但是b的加十元代码约为：AtomicReference对于AtomicReference 来讲，也许对象会出现，属性丢失的情况，即oldObject == current，但是oldObject.getPropertyA != current.getPropertyA。这时候，AtomicStampedReference就派上用场了。这也是一个很常用的思路，即加上版本号3.Lock类lock: 在java.util.concurrent包内。共有三个实现：ReentrantLockReentrantReadWriteLock.ReadLockReentrantReadWriteLock.WriteLock主要目的是和synchronized一样， 两者都是为了解决同步问题，处理资源争端而产生的技术。功能类似但有一些区别。区别如下：lock更灵活，可以自由定义多把锁的枷锁解锁顺序（synchronized要按照先加的后解顺序）提供多种加锁方案，lock 阻塞式, trylock 无阻塞式, lockInterruptily 可打断式， 还有trylock的带超时时间版本。本质上和监视器锁（即synchronized是一样的）能力越大，责任越大，必须控制好加锁和解锁，否则会导致灾难。和Cond

最近有些网友问我如何自学 Java 后端，还有些是想从别的方向想转过来，但都不太了解 Java 后端究竟需要学什么，究竟要从哪里学起，哪些是主流的 Java 后端技术等等，导致想学，但又很迷茫，不知从何下手。我就以过来人的经历，写在这篇博客里，不一定都对，但都是我根据自己的经历总结出来的，供你们的参考。Java 基础Java 是一门纯粹的面向对象的编程语言，所以除了基础语法之外，必须得弄懂它的 oop 特性：封装、继承、多态。此外还有泛型、反射的特性，很多框架的技术都依赖它，比如 Spring 核心的 Ioc 和 AOP，都用到了反射，而且 Java 自身的动态代理也是利用反射实现的。此外还有 Java 一些标准库也是非常常见，比如集合、I/O、并发，几乎在 Web 开发中无处不在，也是面试经常会被问到的，所以在自学 Java 后端之前，不妨先打好这些基础，另外还有 Java8 的一些新特性，也要重点关注，比如 Lambda 表达式、集合的 Stream 流操作、全新的 Date API 等等，关于新特性，我也写了几篇关于这方面的博客，请自行找吧，就不贴出来了。关于书籍推荐，我是不建议初学者一开始就拿着「Java 编程思想」啃的，因为当初我就是那个当天下午决定自学 Java，晚上就抱着这本书啃的人，说实话，我当时真的不懂它在说啥，因为我没有一点的面向对象语言编程的基础，而这本书又写得太博大精深了，在当时的我来说，完全是天书，但是我认为它仍然是 Java 界的圣经，每读一次都有所收获。我在这里推荐你们一开始先看「Java 核心技术」，这本书讲得比较通俗易懂，初学者比较能接受。关于视频推荐，我当初就是听某客的毕向东老师讲的 Java 基础教程（可以关注我的微信公众号获取），毕老师讲的实在是太生动有趣了，不知不觉把我带进 Java 的坑里无法自拔，有时候我会听他视频时笑出声来，也许是我那段自学阶段最有趣的时刻了。数据库关于 sql 方面：SQL 教程、MySQL 教程我是了解了一些基础语法之后，就直接跟着视频的老师做一些表操作实战练习了，比如单表查询、多表查询等。我建议学 sql 切勿眼高手低，需多加练习，不要只看懂了就行，因为工作中写得一手简练的 sql 是非常重要的。在这里我说下我在项目一直秉承着 sql 语句是能避免多表查询就避免多表查询，能够分开多条语句就分开多条语句，因为这里涉及到多表查询性能和数据库扩展的问题。关于 JDBC 方面：JDBC 教程、 JDBC 获取连接对象源码分析你需要弄懂 JDBC API 的用法，其实它只是一组规范接口，所有数据库驱动只要实现了 JDBC，那么我们就可以通过标准的 API 调用相应的驱动，完全不用知道驱动是怎么实现的，这就是面向接口编程的好处。而且对于 JDBC 我是直接看视频去理解的，跟着视频做了一个基于 Apache Dbutils 工具做了一个具有事务性的小工具，我特意用思维导图总结了一下：jdbc-utils源码地址：jdbc-utilsWeb 基础曾经开源中国创始人红薯写了一篇文章「初学 Java Web 开发，请远离各种框架，从 Servlet 开发」，我觉得他说的太对了，在如今 Java 开发中，很多开发者只知道怎么使用框架，但根本不懂 Web 的一些知识点，其实框架很多，但都基本是一个套路，所以在你学习任何框架前，请把 Web 基础打好，把 Web 基础打好了，看框架真的是如鱼得水。关于 Http 协议，这篇文章就写得很清楚：Http协议关于 Web 基础这方面数据推荐，我当时是看的是「Tomcat 与 Java Web 开发技术详解」，很详细地讲解了整个 Java Web 开发的技术知识点，但现在看来，我觉得里面讲的有一些技术确实有点老旧了，不过可以了解一下 Java Web 开发的历史也是不错的。所以在 Web 基础这方面我都是看某客的崔老师讲的「超全面 Java Web 视频教程」，讲得很详细很生动，还有实战项目！关于 JSP，你只要了解它其实就是一个 Servlet 就行了，关于它的一些标签用法，我认为可以直接忽略，因为现在互联网几乎没哪间公司还用 JSP，除了一些老旧的项目。现在都是流行前后端分离，单页应用，后端只做 API 接口的时代了，所以时间宝贵，把这些时间重点放在 Servlet 规范上面吧。关于 Tomcat，它是一个 Web 容器，我们写的后端项目都要部署到Web容器才能运行，它其实是一个遵循 Http，通过 Socket 通信与客户端进行交互的服务端程序：Tomcat结构及处理请求过程Web 主流框架Java Web 框架多如牛毛，等你有一定经验了，你也可以写一个 Web 框架，网上很多说 Spring、Struts2、Hibernate 是 Java 三架马车，我只想说，那是很久远的事情了，我严重不推荐 Struts2、Hibernate，相信我，一开始只需要上手 Spring、SpringMVC、Mybatis 就可以了，特别是 Spring 框架，其实 Spring 家族的框架都是很不错的。但是提醒一点就是，千万不要沉迷于各种框架不能自拔，以会多种用法而沾沾自喜，导致知其然而不知其所以然。Spring其核心思想就是 IOC 和 AOP：谈谈对 Spring IOC 的理解Spring 面向切面编程SpringMVC 它的思想是全部请求统一用一个 Servlet 去做请求转发与控制，这个 Servlet 叫 DispatcherServlet：SpringMVC 初始化过程SpringMVC 处理请求过程Mybatis 它可实现动态拼装 sql，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集：mybatis 入门教程Mybatis 深入浅出系列Web 框架进阶使用了 SSM 框架后，你会觉得框架也不过这么回事，如果你对 Spring 有过大概了解，你也会产生想写一个「山寨版」Spring 的心思了，一个轻量级 Web 框架主要具备以下功能：可读取用户自定义配置文件，并以此来初始化框架；具备 Bean 容器，管理项目的类的对象生命周期；具备依赖注入，降低类之间的耦合性；具备 AOP 功能，使项目可进行横向编程，可不改变原有代码的情况增加业务逻辑；具备 MVC 框架模式。其实除了 SSM 之外，Web 框架可谓是百家齐放，其中以 Spring 全家桶最为耀眼，在这里我极力推荐两个 Spring 家族框架：SpringBoot 和 SpringCloud。SpringBoot 弥补了 Spring 配置上的缺点，再也不用为繁杂的 xml 费劲精力了，堪称是 Java 后端开发的颠覆者，推荐书籍「Java EE 开发的颠覆者：SpringBoot实战」SpringBoot 构建 web 项目SpringBoot 自动化配置源码分析自定义 SpringBoot Starterspring-boot-starter-tutorialSpringCloud 是一个微服务架构，能够将项目按照业务分成一个个微服务，每个微服务都可独立部署，服务之间互相协调。当一个项目越来越大时，随之而来的是越来越难以维护，此时将项目拆分成若干个微服务、单独维护、单独部署，也可以降低项目不同业务间的耦合度。推荐书籍「Spring Cloud 与 Docker 微服务架构实战」，这本书将 Docker 与微服务完美地结合在一起，堪称完美！Spring Cloud 中文官网史上最简单的 Spring Cloud 教程我写的有关于 Spring Cloud 的博客：SpringCloud微服务架构之服务注册与发现SpringCloud微服务架构之服务消费者SpringCloud微服务架构之断路器SpringCloud微服务架构之服务网关其它技术Redis：一个高性能的 key-value 数据库，当有并发量很高的请求时，将数据缓存在 Redis 中，将提高服务器的响应性能，大大减轻数据库的压力。redis 中文官网redis 教程Git：世界上最先进的分布式版本控制系统，建议所有初学者从命令行开始使用 Git！Git 官网最全 Git 教程Git 的一些常用命令Maven：一个用于构建项目的工具，将项目间的依赖通过 xml 完美地组织到一起，可通过编译插件将项目编译成字节码文件。还有类似的 Gradle 也是不错的选择。maven 的 pom.xml 文件详解Linux：至少要求常用的命令会用，能够在 linux 环境下部署项目。Linux 命令大全最全的 SSH 连接远程终端教程Docker：简直是项目部署神器啊，来不及解释了，看我 Docker 系列博客，开启 Docker 之旅吧！推荐书籍「Docker 技术入门与实战」，中国首部 Docker 著作！Docker 实战（一）Docker 实战（二）Docker 实战（三）docker-deploy-tutorial开发工具工欲善其事，必先利其器，以下是我推荐的一些开发工具：Intellij IDEA：Java 开发最好的 IDE，这个是公认的，我一开始是用 Eclipse 的，后来用了 Intellij IDEA，才发现 Eclipse 就是一坨屎，所以我以过来人劝你们不要使用 Eclipse，直接 Intellij IDEA！IntelliJ IDEA 使用教程Iterm2：macOS 最好用的终端！Iterm2 使用指南Chrome：人生苦短，请用 Chrome，来不及解释了，快上车！Postman：很好用的一个接口调试工具。Postman 官网我有一个微信公众号，经常会分享一些Java技术相关的干货；如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

基础并发编程的模型分类在并发编程需要处理的两个关键问题是：线程之间如何通信 和 线程之间如何同步。通信通信 是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存 和 消息传递。在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过明确的发送消息来显式进行通信。同步同步 是指程序用于控制不同线程之间操作发生相对顺序的机制。在共享内存的并发模型里，同步是显式进行的。程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行。在消息传递的并发模型里，由于消息的发送必须在消息的接收之前，因此同步是隐式进行的。Java 的并发采用的是共享内存模型，Java 线程之间的通信总是隐式进行，整个通信过程对程序员完全透明。JAVA 内存模型的抽象在 Java 中，所有实例域、静态域 和 数组元素存储在堆内存中，堆内存在线程之间共享。局部变量、方法定义参数 和 异常处理器参数 不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。Java 线程之间的通信由 Java 内存模型（JMM）控制。JMM 决定了一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM 定义了线程与主内存之间的抽象关系：线程之间的共享变量存储在主内存中，每一个线程都有一个自己私有的本地内存，本地内存中存储了该变量以读／写共享变量的副本。本地内存是 JMM 的一个抽象概念，并不真实存在。JMM 抽象示意图：从上图来看，如果线程 A 和线程 B 要通信的话，要如下两个步骤：1、线程 A 需要将本地内存 A 中的共享变量副本刷新到主内存去2、线程 B 去主内存读取线程 A 之前已更新过的共享变量步骤示意图：举个例子：本地内存 A 和 B 有主内存共享变量 X 的副本。假设一开始时，这三个内存中 X 的值都是 0。线程 A 正执行时，把更新后的 X 值（假设为 1）临时存放在自己的本地内存 A 中。当线程 A 和 B 需要通信时，线程 A 首先会把自己本地内存 A 中修改后的 X 值刷新到主内存去，此时主内存中的 X 值变为了 1。随后，线程 B 到主内存中读取线程 A 更新后的共享变量 X 的值，此时线程 B 的本地内存的 X 值也变成了 1。整体来看，这两个步骤实质上是线程 A 再向线程 B 发送消息，而这个通信过程必须经过主内存。JMM 通过控制主内存与每个线程的本地内存之间的交互，来为 Java 程序员提供内存可见性保证。重排序在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序分三类：1、编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。2、指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。3、内存系统的重排序。由于处理器使用缓存和读／写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。从 Java 源代码到最终实际执行的指令序列，会分别经历下面三种重排序：上面的这些重排序都可能导致多线程程序出现内存可见性问题。对于编译器，JMM 的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。对于处理器重排序，JMM 的处理器重排序规则会要求 Java 编译器在生成指令序列时，插入特定类型的内存屏障指令，通过内存屏障指令来禁止特定类型的处理器重排序（不是所有的处理器重排序都要禁止）。JMM 属于语言级的内存模型，它确保在不同的编译器和不同的处理器平台之上，通过禁止特定类型的编译器重排序和处理器重排序，为程序员提供一致的内存可见性保证。处理器重排序现代的处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时，通过以批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，可以减少对内存总线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读/写操作的执行顺序，不一定与内存实际发生的读/写操作顺序一致！举个例子：假设处理器A和处理器B按程序的顺序并行执行内存访问，最终却可能得到 x = y = 0。具体的原因如下图所示：处理器 A 和 B 同时把共享变量写入在写缓冲区中（A1、B1），然后再从内存中读取另一个共享变量（A2、B2），最后才把自己写缓冲区中保存的脏数据刷新到内存中（A3、B3）。当以这种时序执行时，程序就可以得到 x = y = 0 的结果。从内存操作实际发生的顺序来看，直到处理器 A 执行 A3 来刷新自己的写缓存区，写操作 A1 才算真正执行了。虽然处理器 A 执行内存操作的顺序为：A1 -> A2，但内存操作实际发生的顺序却是：A2 -> A1。此时，处理器 A 的内存操作顺序被重排序了。这里的关键是，由于写缓冲区仅对自己的处理器可见，它会导致处理器执行内存操作的顺序可能会与内存实际的操作执行顺序不一致。由于现代的处理器都会使用写缓冲区，因此现代的处理器都会允许对写-读操作重排序。内存屏障指令为了保证内存可见性，Java 编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。JMM 把内存屏障指令分为下列四类：屏障类型指令示例说明LoadLoad BarriersLoad1; LoadLoad; Load2确保 Load1 数据的装载，之前于 Load2 及所有后续装载指令的装载。StoreStore BarriersStore1; StoreStore; Store2确保 Store1 数据对其他处理器可见（刷新到内存），之前于 Store2 及所有后续存储指令的存储。LoadStore BarriersLoad1; LoadStore; Store2确保 Load1 数据装载，之前于 Store2 及所有后续的存储指令刷新到内存。StoreLoad BarriersStore1; StoreLoad; Load2确保 Store1 数据对其他处理器变得可见（指刷新到内存），之前于 Load2 及所有后续装载指令的装载。StoreLoadBarriers 会使该屏障之前的所有内存访问指令（存储和装载指令）完成之后，才执行该屏障之后的内存访问指令。HAPPENS-BEFOREJSR-133 内存模型使用 happens-before 的概念来阐述操作之间的内存可见性。在 JMM 中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须要存在 happens-before 关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。与程序员密切相关的 happens-before 规则如下：程序顺序规则：一个线程中的每个操作，happens-before 于该线程中的任意后续操作。监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。传递性：如果 A happens-before B，且 B happens-before C，那么 A happens-before C。注意，两个操作之间具有 happens-before 关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before 仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前（the first is visible to and ordered before the second）。happens-before 与 JMM 的关系如下图所示：如上图所示，一个 happens-before 规则对应于一个或多个编译器和处理器重排序规则。数据依赖性如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖性。数据依赖分下列三种类型：名称代码示例说明写后读a = 1; b = a;写一个变量之后，再读这个位置。写后写a = 1; a = 2;写一个变量之后，再写这个变量。读后写a = b; b = 1;读一个变量之后，再写这个变量。上面三种情况，只要重排序两个操作的执行顺序，程序的执行结果将会被改变。前面提到过，编译器和处理器可能会对操作做重排序。编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。注意，这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，不同处理器之间和不同线程之间的数据依赖性不被编译器和处理器考虑。AS-IF-SERIAL 语义as-if-serial 语义的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变。编译器，runtime 和处理器都必须遵守 as-if-serial 语义。为了遵守 as-if-serial 编译器和处理器不会对存在数据依赖关系的操作做重排序，因为这种重排序会改变执行结果。但是如果操作之间没有数据依赖关系，这些操作就可能被编译器和处理器重排序。举个例子：double pi = 3.14; //Adouble r = 1.0; //Bdouble area = pi * r * r; //C上面三个操作的数据依赖关系如下图所示：如上图所示，A 和 C 之间存在数据依赖关系，同时 B 和 C 之间也存在数据依赖关系。因此在最终执行的指令序列中，C 不能被重排序到 A 和 B 的前面（C 排到 A 和 B 的前面，程序的结果将会被改变）。但 A 和 B 之间没有数据依赖关系，编译器和处理器可以重排序 A 和 B 之间的执行顺序。下图是该程序的两种执行顺序：在计算机中，软件技术和硬件技术有一个共同的目标：在不改变程序执行结果的前提下，尽可能的开发并行度。编译器和处理器遵从这一目标，从 happens-before 的定义我们可以看出，JMM 同样遵从这一目标。重排序对多线程的影响举例：class Demo {int a = 0;boolean flag = false;public void write() {a = 1; //1flag = true; //2}public void read() {if(flag) { //3int i = a * a; //4}}}由于操作 1 和 2 没有数据依赖关系，编译器和处理器可以对这两个操作重排序；操作 3 和操作 4 没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。1、当操作 1 和操作 2 重排序时，可能会产生什么效果？如上图所示，操作 1 和操作 2 做了重排序。程序执行时，线程 A 首先写标记变量 flag，随后线程 B 读这个变量。由于条件判断为真，线程 B 将读取变量 a。此时，变量 a 还根本没有被线程 A 写入，在这里多线程程序的语义被重排序破坏了！2、当操作 3 和操作 4 重排序时会产生什么效果（借助这个重排序，可以顺便说明控制依赖性）。在程序中，操作 3 和操作 4 存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜测（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行线程 B 的处理器可以提前读取并计算 a * a，然后把计算结果临时保存到一个名为重排序缓冲（reorder buffer ROB）的硬件缓存中。当接下来操作 3 的条件判断为真时，就把该计算结果写入变量 i 中。从图中我们可以看出，猜测执行实质上对操作3和4做了重排序。重排序在这里破坏了多线程程序的语义！在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果（这也是 as-if-serial 语义允许对存在控制依赖的操作做重排序的原因）；但在多线程程序中，

Java知识点汇总，从基础到常用的API、还有常用的集合类，总结的很详细。图片是从论坛里面找到的，整理下来以便常复习。这是目前看到的比较详细完整的思维导图。1.Java基础知识 2.面向对象 3.常用API 4.集合IO 5.多线程、网络编程、反射、设计模式 我有一个微信公众号，经常会分享一些Java技术相关的干货。如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。