一、概述

Java项目是日常工作最常见的项目了，因此，及时作为运维人员，适当了解java相关知识，也是必要的，本文用以记录日常java相关相关知识点摘录，用以笔记及后续学习回顾。

Java 是由 Sun 公司（已被Oracle （甲骨文）公司收购）于 1995 年 5 月推出的，它是面向对象程序设计语言和 Java 平台的总称。Java分为三个体系：

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）

JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)

JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

2005 年 6 月Java 的各版本名称中的数字 "2"被取消：J2EE 更名为 Java EE，J2SE 更名为Java SE，J2ME 更名为 Java ME。

Java 程序在 Java 平台上被编译为字节码格式，在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中，而Java 语言是动态的，在于它能适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。因此这个class文件可在任何系统中运行的Java 平台中运行，即程序的平台无关性。

=========================Java的第一个程序 “Hello World！”-------------------------------------------------------

#常用IDE：Eclipse、 IntelliJ IDEA、NetBeans 等。public class HelloWorld {public static void main(String[] args) {System.out.println("Hello World");}
}







知识链接：runoob学习网站；Eclipse；JetBrains；Netbeans；Visual Studio Code；

二、java初识

Java可运行于多个平台，如Windows, Mac OS，及其他多种UNIX版本的系统的高级程序设计语言。

Java的三种技术架构:

JAVA EE：Java Platform Enterprise Edition（即曾经的J2EE,java平台企业版），开发企业环境下的应用程序，主要针对web程序开发；

JAVASE：Java Platform Standard Edition(即曾经的J2SE,java平台标准版)，完成桌面应用程序的开发，是其它两者的基础；

JAVA ME：Java Platform Micro Edition(即曾经的J2ME,ava平台微型版)，开发电子消费产品和嵌入式设备，如手机中的程序；

1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。

2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。


1）Java 体系（编译与运行）结构


2）JMX 技术架构

JMX(Java Management Extensions Java 管理扩展)是一个为应用程序植入管理功能的框架 ，从Java5.0开始引入到标准Java技术平台中。JMX作为一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。如果一个 Java 对象可以由一个遵循 JMX 规范的管理器应用管理，那么这个Java 对象就可以称为一个可由 JMX 管理的资源。要使一个 Java 对象可管理，则必须创建相应的 MBean 对象，并通过这些 MBean 对象管理相应的 Java 对象。当拥有 MBean 类后，需要将其实例化并注册到 MBeanServer 上。JMX最常见的场景是监控Java程序的基本信息和运行情况，任何Java程序都可以开启JMX，然后使用JConsole/jvisualvm 或Visual VM进行预览。


层级说明，如上图所示，JMX从下到上，可分为4层：

1、Instrumentation Level(监控层/基础层)：主要作用就是使用MBean（Managed Beans 被管理的资源（MBean））来监控需关心的性能指标，通过上层jmx agent对对MBean所代表的资源进行查看、修改等操作。。基于多性能指标关注的考虑，通常情况下，在监控层我们会有多个MBean，每个MBean监控一类信息。比如：我们使用JMX可以监控服务器内存、CPU，可以监控JVM的堆内存、线程数等指标。JMX官方文档关于监控写到：要想利用JMX技术来管理资源，你首先必须用Java编程语言来监测(instrument)该资源。可使用叫做MBeans的Java对象来实现对该资源的监测信息的访问。MBean分为如下4种：
1）standard MBean ：这种类型的MBean最简单，它能管理的资源（包括属性，方法，时间）必须定义在接口中，然后MBean必须实现这个接口。它的命名也必须遵循一定的规范，例如我们的MBean为Hello，则接口必须为HelloMBean。
2）dynamic MBean ： 必须实现javax.management.DynamicMBean接口，所有的属性，方法都在运行时定义
3）open MBean： 此MBean的规范还不完善，正在改进中
4）model MBean： 与标准和动态MBean相比，你可以不用写MBean类，只需使用javax.management.modelmbean.RequiredModelMBean即可。RequiredModelMBean实现了ModelMBean接口，而ModelMBean扩展了DynamicMBean接口，因此与DynamicMBean相似，Model MBean的管理资源也是在运行时定义的。与DynamicMBean不同的是，DynamicMBean管理的资源一般定义在DynamicMBean中（运行时才决定管理那些资源），而model MBean管理的资源并不在MBean中，而是在外部（通常是一个类），只有在运行时，才通过set方法将其加入到model MBean中。

2、JMX Agent(代理层)： JMX Agent的核心组件是MBean server，它是一个被管理对象的服务器，MBeans在其中注册。一个JMX代理还包括一组用于管理MBeans的服务和至少一个通信适配器(adaptor)或连接器(connector) 以供管理程序访问。我们可以将JMX代理想象成一个容器，所有的MBean都注册到这个容器中，我们将这种容器称之为 MBean Server。这个容器可以接受外部的请求，返回MBean的监控信息。当我们想从远程获取某个MBean的检测信息，我们就给这个容器发送一个请求，由这个容器将这个MBean的检测信息返回给我们。JMX代理是内嵌在Java应用程序中的，不会启一个独立的进程来运行它；对于JMX而言，在不同版本JDK中，可能JMX代理的实现方式有所不同，但是只要其实现了JMX规范，MBean都可以运行。JMX Agent不需要知道它将会服务哪些资源，任何资源，只要其监测兼容JMX规范，就能够使用任何JMX Agent为这些资源提供它们所需要的服务。对于JMX而言，不管写的什么MBean，来监控什么指标， 只要符合JMX规范，就都可以在JMX代理上都跑。

3、发布层/接入层：这一层中提供了各种(adaptors/connectors client)以实现远程管理或提供远程访问的入口； 通常情况下，我们会用使用一个远程客户端连接MBean Server来获取MBean的监控信息。JMX 可以使用多种方式/协议来访问JMX技术监测信息；MBean server依赖**协议适配器(adaptors)和连接器(connectors)**来让JMX代理供管理程序(位于JMX代理所在的JVM之外)访问。每个适配器都通过一个特定的协议提供一个包含了所有注册在MBean Server中的MBeans的视图。 连接器提供一个 管理器侧的 接口，该接口处理管理程序和JMX Agent之间的通信。不同的连接器 通过不同的协议 提供相同的远程管理接口。当一个远程管理程序使用该接口时，它可以通过网络透明地连接到一个JMX Agent，而不用关心该协议是什么。JMX技术提供一个标准的方案，用于导出基于JMX技术的监测信息，供基于Java RMI的应用程序使用。

注意：MBean就是一种规范的JavaBean，通过集成和实现一套标准的Bean接口，这种叫MBean，Mbean注册到MBeanServer中。之后将被MBeanServer中注册过的Adapter(比如渲染为HTML的HtmlAdapter)渲染为直观的页面将MBean的属性和方法展示给用户。流程：MBean -> MBeanServer -> HtmlAdapter。用户需要访问HtmlAdapter页面还需要一个链接入口，通常都是提供rmi入口。rmi的核心是一个java.rmi.registry.Registry注册中心，需要暴露给客户端的自定义RMI服务接口会提前注册到这个Registry中，并声明好访问的链接，之后用户访问【自定义RMI服务接口】时就会链接到Registry并访问到和链接对应的【自定义RMI服务接口】，即 MBeanServer。javax.management.remote.JMXConnectorServer负责将MBeanServer与URL绑定（url类似格式：service:jmx:rmi:///jndi/rmi://localhost:1099/helloworld）并注册到localhost:1099的Registry注册中心。

3）

2.1 Java语言特性

1）Java语言是简单：Java语言的语法与C语言和C++语言很接近，特别地，Java语言不使用指针，而是引用。并提供了自动的废料收集，使得程序员不必为内存管理而担忧，且学习和操作简单。
2）Java语言是面向对象的：java语言提供类、接口和继承等面向对象的特性，，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，Java语言是一个纯的面向对象程序设计语言。
3）Java语言是分布式的：Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
4）Java语言是健壮的：Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。
5）Java语言是安全的：Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外，Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。
6）Java语言是体系结构中立的和可移植的：Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。Java还严格规定了各个基本数据类型的长度。Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。
7）Java语言是解释型的：Java程序在Java平台上被编译为字节码格式然后可以在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
8）java是高性能的：相比解释性高级语言，Java更偏高性能
9）Java语言是多线程的：在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为Thread(Runnable)的构造子类将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类创建的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，因此，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。
10）Java语言是动态的：Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

2.2 java环境变量的配置：

配置环境变量：让java安装目录下的jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉系统，可以找到该目录来调用对应的指令和工具，当使用该工具时，由系统帮我们去找指定的目录。

环境变量的配置：

1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin

2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin

特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。

classpath的配置:

1）：永久配置方式：classpath=.;c:;e:
2）：临时配置方式：set classpath=.;c:;e:\

注意：在定义classpath环境变量时，需要注意：如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；如果指定了classpath，那么会在指定的目录下查找要运行的类文件。如果classpath的值结尾处有分号（一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，便于调试程序），在具体路径中没有找到运行的类，会默认在当前目录再找一次。如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。

2.3 Java相关概念

java是分两部分的：一个是编译，一个是运行。Javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。生成了jvm可以识别的字节码文件（*.class）。也就是class文件，也就是java的运行程序。

java：负责运行的部分，通过启动jvm，加载运行时所需的类库,并对class文件进行执行。一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数。

1）Java分了5片内存。

1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。

栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；只要数据运算完成所在的区域结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。

1：每一个实体都有内存首地址值。

2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

3：垃圾回收机制。
 
2）面向对象理解：

1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。

3）匿名对象使用场景：

1：当对方法只进行一次调用的时候，可以使用匿名对象。

2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。

4）类成员

在类中定义的其实都称之为成员。成员有两种：

1：成员变量：其实对应的就是事物的属性。

2：成员函数：其实对应的就是事物的行为。

所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。

private int age; //私有的访问权限最低，只有在本类中的访问有效。

注意：私有仅仅是封装的一种体现形式而已。

私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。

好处：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。

总结：开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。

这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。

5）类中怎么没有定义主函数呢？

注意：主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。

主函数的解释：保证所在类的独立运行，是程序的入口，被jvm调用。

成员变量和局部变量的区别：

1：成员变量直接定义在类中。

局部变量定义在方法中，参数上，语句中。

2：成员变量在这个类中有效。

局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。

局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。

特点：

1：该函数的名称和所在类的名称相同。

2：不需要定义返回值类型。

3：该函数没有具体的返回值。

记住：所有对象创建时，都需要初始化才可以使用。

注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。

一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。

构造函数和一般函数有什么区别呢？

1：两个函数定义格式不同。

2：构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。

一般函数，是对象创建后，需要调用才执行，可以被调用多次。

什么时候使用构造函数呢？

分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。

构造代码块和构造函数有什么区别？

构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块，只要对象一建立，就会调用这个代码块。

构造函数：是给与之对应的对象进行初始化，它具有针对性。

6）ORM：（Object Relational Mapping，即对象关系映射）

它是以O/R原理设计的持久化框架（Framework），包括 O/R机制、SQL自动生成、事务处理和Cache管理等。ORM的实现思想就是将关系数据库中表的数据映射成为对象，以对象的形式来操作底层数据，让实体类属性和数据库表中字段对应。这样开发人员就可以把对数据库的操作转化为对这些对象的操作。方便开发人员以面向对象的思想来对数据库的进行业务逻辑处理。常用的ORM中间件有：

Apache OJB （Apache ObJectRelationalBridge - OJB）

Cayenne （Index of /cayenne）

Jaxor （http://jaxor.sourceforge.net）

Hibernate （http://www.hibernate.org）

iBatis （http://www.ibatis.com）

jRelationalFramework （http://ijf.sourceforge.net）

mirage （http://itor.cq2.org/en/oss/mirage/toon）

SMYLE （drjava.de）

TopLink （Technical Resources | Oracle）

其中，Hibernate 的轻量级 ORM 模型逐步确立了在 Java ORM 架构中领导地位，甚至取代复杂而又繁琐的 EJB 模型而成为事实上的 Java ORM 工业标准。而且其中的许多设计均被 J2EE 标准组织吸纳而成为最新 EJB 3.0 规范的标准。Hibernate是一种Java语言下的对象关系映射解决方案；它把对象模型表示的对象映射到基于SQL 的关系模型结构中去，为面向对象的领域模型到传统的关系型数据库的映射，提供了一个使用方便的框架。Hibernate 不仅管理Java 类到数据库表的映射（包括从Java数据类型到SQL数据类型的映射），还提供数据查询和获取数据的方法，可以大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间。将软件开发人员从大量相同的数据持久层相关编程工作中解放出来。无论是从设计草案还是从一个遗留数据库开始，开发人员都可以采用Hibernate。

Hibernate对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，它既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，J作为应用程序的数据访问层。最具革命意义的是，Hibernate可以在应用EJB（Enterprise JavaBeans是Java应用于企业计算的框架）的J2EE架构中取代CMP，完成数据持久化的重任。更多参见中文文档；

Hibernate API中的接口主要提供了：（1） 供访问数据库的操作的接口，包括session、Transaction、Query接口；（2） 用于配置Hibernate的接口，Configuration；（3） 处理应用程序接受Hibernate内部发生的事件的接口，会作出相关的回应，包括：Interceptor、Lifecycle、Validatable；（4） 用于扩展Hibernate功能的接口，如UserType、CompositeUserType、IdentifierGenerator接口。此外，Hibernate内部还封装了JDBC、JTA（Java Transaction API）和JNDI（Java Naming And Directory Interface）。其中，JDBC提供底层的数据访问操作，只要用户提供了相应的JDBC驱动程序，Hibernate几乎可以访问任何一个数据库系统。JTA和JNDI使Hibernate能够和J2EE应用服务器集成。下图是一个Hibernate典型应用架构：

三、 Java基本语法

我们可以认为一个 Java 程序就是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。其中：

对象：对象是类的一个实例（类的一个具体），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

类：类是一个模板，它描述一类对象的行为和状态。

方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。

实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

示例：Hello World 程序

public class HelloWorld {   声明类/* 第一个Java程序* 它将输出字符串 Hello World*/public static void main(String[] args) { 声明主方法System.out.println("Hello World"); // 方法的具体动作，输出 Hello World}
}

3.1 基本语法

1）编写 Java 程序时，应注意以下几点：

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。

类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。

方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。

主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

2）Java 标识符

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。关于 Java 标识符，有以下几点需要注意：

1> 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（）、或者下划线（）开始2>首字符之后可以是字母（A−Z或者a−z）,美元符（）、或者下划线（_）开始 2> 首字符之后可以是字母（A-Z 或者 a-z）,美元符（）、或者下划线（）​开始2>首字符之后可以是字母（A−Z或者a−z）,美元符（）、下划线（_）或数字的任何字符组合
3> 关键字不能用作标识符
4> 标识符是大小写敏感的
5>合法标识符举例：age、$salary、_value、__1_value;非法标识符举例：123abc、-salary

3）Java修饰符：抽象描述/声明

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。修饰符用来定义类、方法或者变量，通常放在语句的最前端。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private；使用访问控制符来保护对类、变量、方法和构造方法的访问。

非访问控制修饰符 : final, abstract, static, synchronized

示例：

public class ClassName {  //public 定义类// ...
}
private boolean myFlag; //定义变量
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {// 方法体
}

4）Java 变量：Java 中主要有如下几种类型的变量

1>局部变量:
2>类变量（静态变量）:
3>成员变量（非静态变量）:

5）Java 数组
数组是储存在堆上的对象，可以保存多个同类型变量。使用时需要声明、构造以及初始化。

6）Java 枚举：提前声明一个变量取值范围
Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

7）Java 关键字
Java 关键字，不能用于常量、变量、和任何标识符的名称。

类别 关键字 说明
访问控制 private 私有的
访问控制 protected 受保护的
访问控制 public 公共的
访问控制 default 默认
类、方法和变量修饰符 abstract 声明抽象
类、方法和变量修饰符 class 类
类、方法和变量修饰符 extends 扩充,继承
类、方法和变量修饰符 final 最终值,不可改变的
类、方法和变量修饰符 implements 实现（接口）
类、方法和变量修饰符 interface 接口
类、方法和变量修饰符 native 本地，原生方法（非 Java 实现）
类、方法和变量修饰符 new 新,创建
类、方法和变量修饰符 static 静态
类、方法和变量修饰符 strictfp 严格,精准
类、方法和变量修饰符 synchronized 线程,同步
类、方法和变量修饰符 transient 短暂
类、方法和变量修饰符 volatile 易失
程序控制语句 break 跳出循环
程序控制语句 case 定义一个值以供 switch 选择
程序控制语句 continue 继续
程序控制语句 default 默认
程序控制语句 do 运行
程序控制语句 else 否则
程序控制语句 for 循环
程序控制语句 if 如果
程序控制语句 instanceof 实例
程序控制语句 return 返回
程序控制语句 switch 根据值选择执行
程序控制语句 while 循环
错误处理 assert 断言表达式是否为真
错误处理 catch 捕捉异常
错误处理 finally 有没有异常都执行
错误处理 throw 抛出一个异常对象
错误处理 throws 声明一个异常可能被抛出
错误处理 try 捕获异常
包相关 import 引入
包相关 package 包
基本类型 boolean 布尔型
基本类型 byte 字节型
基本类型 char 字符型
基本类型 double 双精度浮点
基本类型 float 单精度浮点
基本类型 int 整型
基本类型 long 长整型
基本类型 short 短整型
变量引用 super 父类,超类
变量引用 this 本类
变量引用 void 无返回值
保留关键字 goto 是关键字，但不能使用
保留关键字 const 是关键字，但不能使用
保留关键字 null 空

8）Java注释
类似于 C/C++、Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略，空白行也会。示例如下：

public class HelloWorld {/* 这是第一个Java程序* 它将输出 Hello World* 这是一个多行注释的示例*/public static void main(String[] args){// 这是单行注释的示例/* 这个也是单行注释的示例 */System.out.println("Hello World"); }
}

9）类继承
在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
10）接口
在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

10）java编译过程：

3.2 Java 对象和类

Java中的对象是类的一个实例（类的具象），有状态和行为。这里的对象，我们称为软件对象，软件对象的状态就是属性，行为通过方法体现。

类：它是一个模板，java里就是创建 Java 对象的模板。它描述一类对象的行为（方法）和状态（属性）。

对应java的类文件代码如下：eat()、run()、sleep() 和 name() 都是 Dog 类的方法。

public class Dog { /*声明/创建一个类*/String breed;int size;        //1）属性（状态）String colour;int age;//类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。//成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。void eat() { //定义具体方法（行为）}void run() {  //2)行为}void sleep(){ //局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。}void name(){}
}

示例2：创建对象

public class Puppy{public Puppy(String name){//这个构造器仅有一个参数：nameSystem.out.println("小狗的名字是 : " + name ); }public static void main(String[] args){  //主方法// 下面的语句将创建一个Puppy对象Puppy myPuppy = new Puppy( "tommy" ); //调用Puppy方法创建类}
}

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

1》声明：声明一个对象，包括对象名称和对象类型。
2》实例化：使用关键字 new 来创建一个对象。
3》初始化：使用 new 创建对象时，会调用构造方法初始化对象。

3.3 构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{ //构造一个类public Puppy(){ //创建一个对象}public Puppy(String name){ //声明对象的构造方法，名称与类同名// 这个构造器仅有一个参数：name}
}

eg1：访问实例变量和方法

public class Puppy{int puppyAge;  //成员变量public Puppy(String name){// 这个构造器仅有一个参数：nameSystem.out.println("小狗的名字是 : " + name ); }public void setAge( int age ){ //1）声明构造一个方法puppyAge = age;   //给成员变量赋值}public int getAge( ){   //2）第2个方法System.out.println("小狗的年龄为 : " + puppyAge ); return puppyAge;  //获取成员变量的值并返回}public static void main(String[] args){/* 创建对象 */Puppy myPuppy = new Puppy( "tommy" );/* 通过方法来设定age；上述对象调用第一个方法 */myPuppy.setAge( 2 );/* 调用另一个方法获取age，调用第2个方法 */myPuppy.getAge( );/*你也可以像下面这样访问成员变量 */System.out.println("变量值 : " + myPuppy.puppyAge ); }
}

3.4 源文件声明规则:

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个 public 类---------->注意

一个源文件可以有多个非 public 类

源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。

如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。

如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。

import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

3.5 Java 包

Java包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

import 语句：

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，import java.io.*;命令行将会告诉编译器载入 java_installation/java/io 路径下的所有类。

3.6 程序样例：

创建一个源文件Employee.java，包含2个类：Employee 和 EmployeeTest。Employee 类有四个成员变量：name、age、designation 和 salary。该类显式声明了一个构造方法，该方法只有一个参数。程序都是从main方法开始执行。为了能运行这个程序，文件中还必须包含main方法并且创建一个实例对象。代码如下：

1）Employee.java文件

import java.io.*;  //放在最前public class Employee{ //声明类String name;int age;String designation;double salary;// Employee 类的构造器，显式声明类的构造方法，且只有一个参数public Employee(String name){this.name = name;  //成员变量赋值}// 设置age的值public void empAge(int empAge){ //声明方法age =  empAge;}/* 设置designation的值*/public void empDesignation(String empDesig){designation = empDesig;}/* 设置salary的值*/public void empSalary(double empSalary){salary = empSalary;}/* 打印信息 */public void printEmployee(){ //输出这几个变量都是成员（全局）变量System.out.println("名字:"+ name );System.out.println("年龄:" + age );System.out.println("职位:" + designation );System.out.println("薪水:" + salary);}
}

2）EmployeeTest.java文件

import java.io.*;
public class EmployeeTest{  //声明第2个类public static void main(String[] args){ //声明主方法/函数/* 使用构造器创建两个对象，以进行实例化 */Employee empOne = new Employee("RUNOOB1");Employee empTwo = new Employee("RUNOOB2");// 调用这两个对象的成员方法empOne.empAge(26);empOne.empDesignation("高级程序员");empOne.empSalary(1000);empOne.printEmployee();empTwo.empAge(21);empTwo.empDesignation("菜鸟程序员");empTwo.empSalary(500);empTwo.printEmployee();}
}

编译上述文件执行：

$ javac EmployeeTest.java
$ java EmployeeTest

输出结果：

名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0

四、Java框架

Java框架主要有：：SpringMVC、Spring、Mybatis、Dubbo、Maven、RabbitMQ、Log4j、Ehcache、Redis、Shiro。

1、SpringMVC，Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发。

2、Mybatis，MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。Mybatis 工作原理：




Mybatis分层框架图：

3、Spring，Spring框架是一个开放源代码的J2EE应用程序框架，以高性能著称，是针对bean的生命周期进行管理的轻量级容器。Spring提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring AOP： 通过配置管理特性，Spring AOP 模块直接将面向对象的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。


注：Spring Bean是Spring中最基本的组成单元；官方解释：在 Spring 中，构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。 bean 是由 Spring IoC 容器实例化、组装和管理的对象。即Bean是托管在Spring中一个叫IoC的容器中的一个被实例化的对象。而我们的程序是由一个个Bean构成的。Spring是通过声明式配置的方式来定义Bean的，所有创建Bean需要的前置依赖或者参数都是通过配置文件先声明，Spring启动以后会解析这些声明好的配置内容。

定义Spring Bean的三种方式：

1、基于XML的方式配置，主要适用于以下两类场景：

1）Bean实现类来自第三方类库、比如DataSource等
2）需要定义命名空间的配置，如：context、aop、mvc等。

2、基于注解扫描的方式配置；主要适用于：在开发中需要引用的类，如Controller、Service、Dao等。Spring主要提供了4种内置的注解用来声明Bean。它们分别是@Controller，声明为控制层组件的Bean，@Service，声明为业务逻辑层组件的Bean，@Repository，声明为数据访问层组件的Bean，当对组件的层次难以定位的时候使用@Component注解来声明。

3、基于Java类的配置：这种配置方式主要适用于以下两类场景：

1）需要通过代码控制对象创建逻辑的场景；
2）实现零配置，消除XML配置文件的场景。

Spring容器如何加载Bean:

Spring解析这些声明好的配置内容，将这些配置内容都转化为BeanDefinition对象，BeanDefinition中几乎保存了配置文件中声明的所有内容，再将BeanDefinition存到一个叫做beanDefinitionMap中。以beanName作为Key，以BeanDefinition对象作为Value。之后Spring容器，根据beanName找到对应的BeanDefinition，再去选择具体的创建策略。如下所示：


Bean生命周期：

4、Maven，Maven是一个项目管理工具，它包含了一个项目对象模型 (Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

5、Hibernate ：它是一种Java下的对象关系映射(ORM)开源的轻量型（性能非常好）解决方案。 它对JDBC进行了轻量级的对象封装，它可以把对象模型表示的对象映射到基于SQL 的关系模型结构中去，建立面向对象的领域模型到传统的关系型数据库的映射，提供了一个使用方便的框架。它可以作为数据库与用户界面之间的桥梁，使得Java开发人员可以使用面向对象的编程思想来操作数据库。对象可能是普通JavaBeans/POJO。Hibernate 不仅管理Java 类到数据库表的映射（包括从Java数据类型到SQL数据类型的映射），还提供数据查询和获取数据的方法，可以大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间。它的设计目标是将软件开发人员从大量相同的数据持久层相关编程工作中解放出来。它支持各种关系数据库，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，它既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。最具革命意义的是，Hibernate可以在应用EJB（Enterprise JavaBeans是Java应用于企业计算的框架）的J2EE架构中取代CMP，完成数据持久化的重任。Java程序中hibernate框架多应用在Java EE三层结构中的Dao层的框架，在dao层里面对数据库进行crud操作，简单说hibernate框架底层代码就是JDBC，它对JDBC 进行了封装，这样开发人员就不再需要写复杂的JDBC代码（导–>载–>连–>创–>执–>果–>放），不用写sql语句了。

Hibernate架构是分层的。 Hibernate中使用数据库和配置信息来为应用程序提供持久化服务（以及持久的对象）。下图为 Hibernate 应用程序架构视图：


在 Java Web 开发应用中，Hibernate可以作为应用程序的数据访问层。hibernate架构中有4层：Java应用层，hibernate框架层，api层和数据库层。其中，Hibernate框架使用许多对象会话工厂，会话，事务等以及现有的Java API，如JDBC(Java数据库连接)，JTA(Java事务API)和JNDI(Java命名目录接口)。

Hibernate架构的元素：

会话工厂(SessionFactory)：SessionFactory是ConnectionProvider的会话和客户端工厂。 它拥有数据的二级缓存(可选)。 org.hibernate.SessionFactory接口提供了工厂方法来获取Session的对象。

会话(Session)：Session对象提供应用程序和存储在数据库中的数据之间的接口。 它是一个短生命周期的对象并包装JDBC连接。 它是事务，查询和标准的工厂。 它拥有一级缓存(强制性)数据。 org.hibernate.Session接口提供插入，更新和删除对象的方法。 它还提供了事务，查询和标准的工厂方法。

事务(Transaction)：事务对象指定工作的原子单位,它是一个可选项。 org.hibernate.Transaction接口提供事务管理的方法。

连接提供者(ConnectionProvider)：它是一个JDBC连接工厂。 它从DriverManager或DataSource抽象出来的应用程序。 它是一个可选项。

事务工厂(TransactionFactory)：它是一个事务工厂，是一个可选项。

Hibernate工作原理：

Hibernate框架需要2种配置文件，分别是：hibernate.cfg.xml（存放数据库连接信息）与xxx.hbm.xml（确定持久类与数据表，数据列之间的对应关系）。

hibernate不再是直接调用JDBC访问，而是Session会话访问。在hibernate框架中，只有处于Seesion管理下的POJO对象才有持久化操作的能力。

其中：

① SessionFatory：hibernate关键对象，它是单个数据库映射关系经过编译后的内存镜像，线程安全。主要作用是生成Session的工厂，该对象可以为事务之间可重用的数据提供可选的二级缓存。

② Session：它是应用程序与持久储存层之间交互操作的一个单线程对象，是hibernate持久化操作的关键对象，所有的持久化对象必须在Session管理下才可以进行持久化操作。此对象的生命周期极短，底层封装了JDBC连接。Session对象持有一个必选的一级缓存，显式执行flush()之前，所有持久化操作的数据都缓存在Session对象处。

③ 持久化对象：系统创建的 POJO 实例，一旦与特定的Session关联，并对应数据表的指定记录，该对象就处于持久化状态，这一系列对象都被称为持久化对象。在程序中对持久化对象执行的修改，都将自动被转换为持久层的修改。持久化对象完全可以是普通的JavaBean，唯一特殊的是他们正与一个Session关联。

④ 事务（transaction）：具有数据库事务的概念，Hibernate 事务是对底层具体的JDBC、JTA、以及CORBA事务的抽象，在某些情况下，一个Transaction之内可能包含多个Session对象。虽然事务操作是可选的，但所有持久化操作都应该在事务管理下进行，即便是只读操作。

⑤ 连接提供者（ConnctionProvider）：生成 JDBC 连接的工厂，通过抽象将应用程序与底层的 DataSource 或 DriverManager 隔离开，该对象无须应用程序直接访问，仅在应用程序需要扩展时使用。注：实际开发中，很少有采用DriverManager来获取数据库连接， 通常都会使用DataSource来获取数据库连接。

⑥ 事务工厂（TransactionFactory）：是生成 Transaction 对象实例的工厂，该对象无须应用程序直接访问，它负责对底层具体的事务实现进行封装、将底层具体的事务抽象成Hibernate事务。

工作流程一般分为如下 7 步：

  • Hibernate 启动，Configruation 会读取并加载 Hibernate 核心配置文件和映射文件钟的信息到它实例对象中。
  • 通过 Configuration 对象读取到的配置文件信息，创建一个 SessionFactory 对象，该对象中保存了当前数据库的配置信息、映射关系等信息。
  • 通过 SessionFactory 对象创建一个 Session 实例，建立数据库连接。Session 主要负责执行持久化对象的增、删、改、查操作，创建一个 Session 就相当于创建一个新的数据库连接。
  • 通过 Session 对象创建 Transaction（事务）实例对象，并开启事务。Transaction 用于事务管理，一个 Transaction 对象对应的事务可以包含多个操作。需要注意的是，Hibernate 的事务默认是关闭的，需要手动开启和关闭。
  • Session 接口提供了各种方法，可以对实体类对象进行持久化操作（即对数据库进行操作），例如 get()、load()、save()、update()、saveOrUpdate() 等等，除此之外，Session 对象还可以创建Query 对象 或 NativeQuery 对象，分别使用 HQL 语句或原生 SQL 语句对数据库进行操作。
  • 对实体对象持久化操作完成后，必须提交事务，若程序运行过程中遇到异常，则回滚事务。
  • 关闭 Session 与 SessionFactory，断开与数据库的连接，释放资源。


Hibernate实体类的三种状态：

（1）瞬时状态：对象由new操作符创建，且尚未与Hibernate Session关联的对象，被认为处于瞬态。瞬态对象不会被持久化到数据库中，也不会被赋予持久化标示，如果程序中失去了瞬态对象的引用，瞬态对象将被垃圾回收机制销毁。使用Hibernate session可以让其变为持久化状态。

（2）持久化：持久化实例在数据库中有对应的记录，并拥有一个持久化标识（identifier），持久化的实例可以是刚保存的，也可以是刚被加载的。无论那种，持久化对象都必须与指定的Hibernate Session关联。Hibernate会检测到处于持久化状态对象的改动，在当前操作执行完成时将对象数据写回数据库。开发者不需要手动执行UPDATE。

（3）游离：某个实例曾经处于持久化状态，但随着与之关联的session被关闭，该对象就变成游离状态了。游离对象的引用依旧有效，对象可以继续被修改，只是不会同步到数据库中。如果重新让游离对象与某个session关联，该对象会重新转换为持久化状态。

Hibernate的优缺点：

  • 优点：
    a.Hibernate 使用 Java 反射机制 而不是字节码增强程序来实现透明性。
    b.Hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。
    c. 它支持各种关系数据库，从一对一到多对多的各种复杂关系。可移植性好，因不依赖特定关系型数据库，更换数据库时只需修改hibernate配置文件即可。
    d. 支持许多面向对象的特性，如组合、几次、多态等。
    \
  • 缺点：

    Hibernate限制所使用的对象模型。如，一个持久性类不能映射到多个表。
    不适合以数据为中心、大量使用存储过程的应用。
    不适合有大规模的批量插入、修改和删除的应用。

应用示例：把注册页面输入的用户名、密码、性别、年龄方面的信息存入数据库中。如果采用经典的MVC模式的话，那么各层的构建如下：

  • 视图层：注册页面(register.jsp)、反馈信息页面(reply.jsp)
  • 控制层：RegisterServlet.java
  • 模型层/数据访问层：基础类HibernateSessionFactory.java、持久化类Register.java、配置文件hibernate.cfg.xml、映射文件register.hbm.xml等等
  • 数据库层:采用MySQL数据库，数据表t_register

6、ibatis：ibatis是一款apache开源的、轻量级的、基于java持久层的、半自动方式的开发框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO），同时还提供一个利用这个框架开发的JPetStore实例。


它的最大的优点是可以有效的控制sql发送的数目，提高数据层的执行效率！它需要程序员自己去写sql语句，不象hibernate那样是完全面向对象的，自动化的，ibatis是半自动化的，通过表和对象的映射以及手工书写的sql语句，能够实现比hibernate等更高的查询效率。Ibatis只是封装了数据访问层，替我们做了部分的对象关系映射。但代价是必须要写xml配置文件，相对于Hibernate还要写很多sql。Hibernate通过工具直接从数据库模式生成实体类和基本的配置文件，而且大部分情况下不需要我们写sql，会较大的提升开发效率。

7、J2EE架构：J2EE核心是一组技术规范与指南，其中所包含的各类组件、服务架构及技术层次，均有共通的标准及规格，让各种依循J2EE架构的不同平台之间，存在良好的兼容性，解决过去企业后端使用的信息产品彼此之间无法兼容，导致企业内部或外部难以互通的窘境。


8、Hibernate 和 Mybatis 的比较

两者都作为当前最流行的ORM框架之一，都支持 JDBC 和 JTA 事务处理，前者对JDBC提供了较为完整的封装。Hibernate的O/R Mapping实现了 POJO 和数据库表之间的映射，以及SQL的自动生成和执行。后者主要着力于 POJO 与 SQL 之间的映射关系。然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定 POJO 。相对Hibernate“O/R”而言，Mybatis 是一种Sql Mapping的ORM实现。两者都通过 SessionFactoryBuider 由 XML 配置文件生成 SessionFactory，然后由 SessionFactory 生成 Session，最后由 Session 来开启执行事务和 SQL 语句。其中SessionFactoryBuider、SessionFactory 和 Session的生命周期都是差不多的。Hibernate框架中，DAO 层开发比 MyBatis 简单，Mybatis 需要维护SQL和结果映射。Hibernate 对对象的维护和缓存要比 MyBatis 好，对增删改查（CRUD）的对象的维护要方便。Hibernate 拥有完整的日志系统，mybatis 则欠缺一些。Hibernate 数据库移植性很好；MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。Hibernate 有更好的二级缓存机制，可以使用第三方缓存；MyBatis本身提供的缓存机制不佳。

MyBatis 作为一款优秀的持久层框架，它仅是半自动化的ORM实现，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Objects，普通的 Java 对象)映射成数据库中的记录。Mybatis底层也封装了JDBC，且使用了动态代理模式。

它们查询目标不同：使用Hibernate时，查询的是POJO实体类，而不再是数据库的表，如：hql语句 select count(*) from User，里面的User是一个Java类，而不是数据库表User。可以使用纯的面向对象的思维方式，查询POJO对象，查询条件是对象属性，不再需要有任何表、字段等关系的概念，这样java程序员就更容易做持久层的操作。Hibernate封装SQL，使用一种纯的面向对象查询语言 hql 代替 sql。而MyBatis 则是另外一种类型的持久化框架，它没有封装 SQL 也没有创建一种新的面向对象的查询语言，而是直接使用SQL作为查询语言，只是把结果填入 POJO 对象而已；查询速度快，可以灵活使用任意复杂的查询只要数据库支持，另外一层面，代表它sql 优化更方便，可以进行更为细致的SQL优化，可以减少查询字段。

五、

……未完待续。

Java入门第一课 初始概念和框架相关推荐

  1. 【这是一个还没有被证实是否有效的小白修炼手册】数据结构入门第一课基本概念

    数据结构是计算机中的存储.组织数据的方式. 通常情况下,精心选择的数据结构可以带来,最优效率的算法. Q1:如何在书架上摆放图书? 我家里的书都是按照颜色大小摆放的,或者按照小学初中大学,还有乱摆的. ...

  2. 大数据入门第一课 Hadoop基础知识与电商网站日志数据分析

    大数据入门第一课 Hadoop基础知识与电商网站日志数据分析 本课程从Hadoop核心技术入手,以电商项目为依托,带领你从0基础开始上手,逐步掌握大数据核心技术(如:HDFS.YARN.MapRedu ...

  3. 人工智能入门第一课：手写字体识别及可视化项目（手写画板）（mnist）

    人工智能入门第一课:手写字体识别及可视化项目(手写画板)(mnist),使用技术(Django+js+tensorflow+html+bootstrap+inspinia框架) 直接上图,项目效果 1 ...

  4. janusgraph 引入 java_JanusGraph入门第一课和官方文档踩坑

    入门第一课是在IDEA里创建一个项目,有些小曲折.这里运行的Demo是读取janusgraph示例的"神之图"(Graph of the Gods)数据并打印,采用Hbase+ES ...

  5. C#编程入门第一课 Visual studio 2019使用，cs文件构成，打开项目文件，两句最简单语句，运行前，运行程序，显示行号，设置字体

    C#编程入门第一课 文章目录 C#编程入门第一课 1 2 3 Visual Studio 2019 4. cs文件构成 5. 打开项目文件 6. 两句最简单语句 7. 运行前 8.运行程序 9.显示行 ...

  6. java面向对象第一课，定义类，模拟人的行为：吃饭工作休息

    java面向对象第一课,定义类,模拟人的行为:吃饭工作休息 /*** 定义类,模拟人的行为:吃饭工作休息*/ public class Person {//静态特征:成员变量 属性 fieldStri ...

  7. java 数组下标6,这里为什么用equals会错，改==就不会？java入门第一集6.8获取数组下标课后练习...

    源自:6-8 使用 foreach 操作数组 这里为什么用equals会错,改==就不会?java入门第一集6.8获取数组下标课后练习 public class practice_1_6_8 { pu ...

  8. Opencv入门第一课打开窗口

    Opencv入门第一课打开窗口 一.如何打开图片(代码解释如下) Mat src = imread("D:/images/lena.jpg"); 解释:imageread图片读取 ...

  9. 【C++】入门第一课

    文章目录 C++入门第一课 1. C++发展简史 2.C++关键字 3.C++运行环境 4.C++头文件以及输入输出 4.1 头文件 4.2输入输出 5.命名空间(namespace) 5.1命名空间 ...

最新文章

  1. 深度学习在三维环境重建中的应用
  2. pheatmap 参数整理
  3. Chrome反压缩JS代码：Pretty Print显示可读代码
  4. php 26个字母大写,英语26个字母大小写怎么写
  5. java 新区 老区_优学院《土地资源学》答案在线查题2020高校邦《Java核心开发技术【实境编程】》章测试答案...
  6. c语言编程 float p,C语言编程经典例题
  7. 从命令行获取两个路径名称并找出文件一样内容一样的两个文件
  8. Golang实践录：使用gin框架实现转发功能：利用nginx转发
  9. windows端口号速查表
  10. 倒计时 5 天！Apache Flink Meetup 7.10 北京站，Flink x TiDB 专场等你来！
  11. DATASNAP数据序列之FIREDAC的TFDJSONDataSets
  12. C语言代码自动生成工具
  13. Android pk8/x509生成keystore
  14. 悲剧!广电总局12月11日将封闭的网站目录!!!
  15. Hubble数据库x某股份制商业银行：一款混布数据库的“交易+分析”提速之路
  16. 显示器不亮电源灯闪_电脑开机显示器指示灯一闪一闪的屏幕就是不亮
  17. 随机抽样的python实现
  18. PHP 生成条形码每页44个
  19. torch+cuda gpu并行计算
  20. 计算机网络学习笔记：多路复用（频分多路复用、时分多路复用、波分多路复用、码分多路复用）

热门文章

  1. 2021主动降噪蓝牙耳机哪款好？这几款蓝牙耳机果然凭实力上榜
  2. Elasticsearch8.6启动异常：fatal exception while booting Elasticsearch
  3. 奢侈品电子商务元年：去纸化的利弊
  4. 速卖通、阿里国际站店铺运营技巧结合测评提升曝光
  5. banner设圆角_Xbanner圆角展示轮播图
  6. JZOJ 3912. 【NOIP2014模拟11.2B组】超氧化钾
  7. 前台、中台、后台的定位分别是什么？
  8. 简单的介绍进程的状态以及对应的英文字母表示
  9. Django增删改查--图书管理系统
  10. 中国五金门控发展情况 (zz)