基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法， io 的语法，虚拟机方面的语法。
（1）short s1 = 1; s1 = s1 + 1; 有错 。 说明：对于 short s1 = 1; s1 = s1 + 1; 由于 s1+1 运算时会自动提升表达式的类型，所以结果是 int 型，再赋值给 short 类型 s1 时，编译器将报告需要强制转换类型的错误。
（2） short s1 = 1; s1 += 1，没有错 。 说明：对于short s1 = 1; s1 += 1; 由于 += 是 java 语言规 定的运算符， java 编译器会对它进行特殊处理，因此可以正确编译。
（1）final修饰类，表示类不可变，不可继承
比如，String，不可变性
（1）final修饰方法，表示该方法不可重写
比如模板方法，可以固定我们的算法
（3）final修饰变量，这个变量就是常量
注意：
修饰的是基本数据类型，这个值本身不能修改。 修饰的是引用类型，引用的指向不能修改。
比如下面的代码是可以的 final Student student = new Student(1,“Andy”); student.setAge(18);//注意，这个是可以的！
是引用变量不能改变，引用变量所指向的对象中的内容还是可以改变的。 拓展：
基本数据类型：byte、short、int、long、float、double、char、boolean 引用类型：类(class)、接口(interface)、数组(array) 基本类型保存的值，引用类型保存了是对象的地址，所有基本类型赋值是按值传递（拷贝赋值），引用类型赋值是按引用传递。（1） == a.基本类型：比较的就是值是否相同； b.引用类型：比较的就是地址值是否相同； （2）equals a.不能比较基本数据类型，基本数据类型不是类类型； b.比较引用类型时（该方法继承自Object，在object中比较的是地址值）等同于” == ”；
package com.pbm; public class Test { public static void main(String[] args) { String aa = "asd"; String bb = "asd"; int cc=10; int dd = 10; System.out.println(aa==bb); //true System.out.println(aa.equals(bb)); //true System.out.println(cc==dd); //true //System.out.println(cc.equals(dd)); //报错 } }（1）在语法定义上的区别： 静态变量前要加static关键字，而实例变量前则不加。 （2）在程序运行时的区别：实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
public class Test11 { public static int staticVar = 0; public int instanceVar = 0; public Test11() { staticVar++; instanceVar++; System.out.println("staticVar=" + staticVar + ",instanceVar=" + instanceVar); } public static void main(String[] args) { Test11 test = new Test11(); Test11 test1 = new Test11(); Test11 test2 = new Test11(); } }①、Integer 是 int 封装类，int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean） ②、Integer 是类，默认值为null，int是基本数据类型，默认值为0； ③、Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值。
Math类中提供了三个与取整有关的方法： ceil （向上取整）、 floor（向下取整） 、 round （四舍五入：加上0.5再向下取整）。
package com.sxt.test; public class MathTest{ public static void main(String[] args) { double a = 11.5; double b = -11.5; //四舍五入 System.out.println("Math.round(a):"+Math.round(a)); //输出Math.round(a):12 System.out.println("Math.round(b):"+Math.round(b)); //输出Math.round(b):-11 //向上取整 System.out.println("Math.ceil(a):"+Math.ceil(a)); //输出Math.ceil(a):12.0 System.out.println("Math.ceil(b):"+Math.ceil(b)); //输出Math.ceil(b):-11.0 //向下取整 System.out.println("Math.floor(a):"+Math.floor(a)); //输出Math.floor(a):11.0 System.out.println("Math.floor(b):"+Math.floor(b)); //输出Math.floor(b):-12.0 } }（1）overload（重载，覆盖），是一个类中多态性的一种表现。 a.方法名相同 b.参数个数不同、参数类型不同、参数列表顺序不同 c.在参数个数、参数类型、参数列表顺序不同时，返回值可以不同。
（2）override（重写），是父类与子类之间多态性的一种表现。 a.方法名相同 b.参数个数、参数类型、参数列表顺序相同 c.返回值相同 d.子类重写父类方法时，修饰权限只能等于或大于父类的权限。 e.子类编译时只能比父类抛出更少的异常。
构造方法也叫构造器（construtor），用于给对象进行初始化操作，即为成员变量赋初始值。 说明格式:修饰符 类名(形参列表){} 构造器construtor不能被继承，因此不能被重写，但可以被重载。
（1）接口可以继承接口
public interface InterfaceA { } interface InterfaceB extends InterfaceA{ }（2）抽象类可以实现接口
public interface InterfaceA { } abstract class TestA implements InterfaceA{ }（3）抽象类可以继承实体类(但前提是实体类必须有明确的构造函数)
public class TestA{ } abstract class TestB extends TestA{ }（4）抽象类可以有静态的main方法 拓展：抽象类使用abstract 关键字，静态方法使用static关键字
面向对象的编程语言有封装、继承、抽象、多态等4个主要的特征。 （1）封装是保证软件部件具有优良的模块性的基础 封装 的目标就是要实现软件部件的“高内聚、低耦合”， 防止程序相互依赖性而带来的变动影响。 （2）在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并 可以 加入若干新的内容 ，或修改原来的方法使之更适合特殊的需要，这就是继承 。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系提高了软件的可重用性和可扩展性 。 （3）抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。 （4）多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象 ，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
（1）概念 抽象类：被abstract修饰的类叫抽象类。比如abstract class A{}，抽象类的作用为了子类继承它，提高代码重用性。 接口：我们可以把它看做是一种特殊的抽象类，接口中的所有方法都必须是抽象的，接口中的方法定义默认为 public abstract 类型，接口中的成员产量类型默认为 public static final。
（2）异同点 相同点： a.两者都不能实例化 b.一个类若继承了抽象类或实现了接口，都需要对里面的抽象方法全部进行实现，否则还需要被声明为抽象类。
不同点：
String不是最基本的数据类型。 基本数据类型包括byte 、 int 、 char 、 long 、 float 、 double 、 boolean 和 short 。 java.lang.String是final类型的，是不可以继承这个类、不能修改这个类。为了提高效率、节省空间，建议用StringBuffer类。
没有。因String 被设计成不可变类，所以它的所有对象都是不可变象。在这段代码中， s 原先指向一个 String 对象，内容是 " Hello"，然后我们对 s 进行了 操作，s 所指向的那个对象是没有发生了改变的。这时， s 不指向原来那个对象了，而指向了另一个 String 对象，内容为 “HelloWorld!”，原来那个对象还存在于内存之中，只是 s 这个引用变量不再指向它了。
相同点：可以储存和操作字符串，即包含多个字符的字符数据。 不同点： （1）String是不可变类，String对象一旦被创建，其值不能被改变；StirngBuffer是可变类，当对象被创建后，仍然可以对其值进行修改。 （2）String 覆盖了 equals 方法和 hashCode方法； StringBuffer 没有覆盖 equals 方法和 hashCode 方法。
数组没有length() 方法，但有length属性，返回表示该数组的长度； String有length()方法，但没有length属性，返回便是该字符串的长度。
去掉对web.xml的监听，把jsp提前编辑成servlet。 有富余物理内容的情况，加大Tomcat使用的jvm的内存。
（1）HTTP请求概述 HTTP协议称为超文本传输协议，目的是保证客户端与服务器之间的通信。HTTP的工作方式是客户端与服务器之间的请求–应答协议。在客户端与服务器之间进行请求和响应时，有两种基本的请求方式：get和post，其中get请求是指从指定的资源请求数据，post请求表示向指定的资源提交要被处理的数据。
（2）HTTP请求格式： 在HTTP请求中，首先是请求行；其次是，请求头（header）；然后空一行，紧接着是请求的具体内容（request-body）
（3）get请求和post请求的异同 相同点： a） get和post请求都是客户端与服务器之间得交互，请求—应答模式的协议
不同点： a） get是从服务器上获取数据；post是向服务器传送数据，一般用于更新资源信息 b） get请求时通过URL直接请求数据，数据信息可以在URL中直接看到，比如浏览器访问；而post请求是放在请求头中的，我们是无法直接看到的 c） get提交有数据大小的限制，一般是不超过2KB，而POST理论上默认是没有限制 d） get请求因为数据参数是暴露在URL中的，所以安全性比较低，如密码不能暴露的就不能用get请求；post请求中，请求信息是放在请求头的，安全性较高，可以使用。
Servlet是一种独立于平台和协议的服务端的java技术，可以生成动态WEB页面与传统的CGI（计算机图形接口）和其他类似的CGI技术相比。Servlet具有更好的可移植性。更强大的功能，更少的投资，更高的效率，更好的安全性。
servlet是使用java Servlet应用程序接口（API）及相关类和方法的java程序。java语言能够实现的功能Servlet基本都能够实现。（除了图形化界面）。Servlet 主要用于处理客户端传来的Http 请求，并返回一个响应，通常来说Servlet就是指HttpServlet,用于处理Http请求，其能够处理的请求有doGet(),doPost(),service()等方法，开发servlet时可以直接结成javax.servlet,http.HttpServlet.
Servlet需要在web.xml中进行描述，例如。映射执行servlet的名字，配置servlet类，初始化参数，进行安全配置，URL映射和设置启动优先权。Servlet不仅可以生成HTML脚本输出，也可以生成二进制表单输出。
Servlet应用广泛，现在许多流行框架都离不开Servlet的支持，比如SHH,Spring 容器启动的时候，要在web,xml中装载Spring容器和Actioncontext来初始化Spring的一些参数。如依赖注入，数据库表的映射，初始化系统的安全配置设置read等属性进行一些相关的操作。
Servlet生命周期分为实例化、初始化、响应请求调用service()方法、消亡阶段调用destroy()方法。 执行过程如下： 1）当浏览器发送一个请求地址，tomcat会接收这个请求 2）tomcat会读取项目中的web.xml中的配置 3）当请求地址符合servlet-mapping标签映射的地址，会进入这个servlet 4）servlet首先会实例化（构造），然后初始化执行init()方法，init()方法至始至终执行一次，servlet对象是单实例 5）根据请求的方式是get或post，在service()方法中调用doget()或dopost()方法，完成此次请求 6）当服务器停止，会调用destroy()方法，销毁实例
forward是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。 redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取，并且从浏览器的地址栏中可以看到跳转后的链接地址。前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接；在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。
总结：forward是程序内部跳转，不会跳出tomcat服务器，redirect可以外部跳转，从一个服务器跳转到另一个服务器。
转发：request.getRequestDispatcher (“demo.jsp"). forward(request, response); 重定向：response.sendRedirect(“demo.jsp");
可以验证客户是否来自可信的网络，可以对客户提交的数据进行重新编码，可以从系统里获得配置的信息，可以过滤掉客户的某些不应该出现的词汇，可以验证用户是否登录，可以验证客户的浏览器是否支持当前的应用，可以记录系统的日志等等。
<%@page language=”java” contenType=”text/html;charset=gb2312” session=”true” buffer=”64kb” autoFlush=”true” isThreadSafe=”true” info=”text” errorPage=”error.jsp” isErrorPage=”true” isELIgnored=”true” pageEncoding=”gb2312” import=”java.sql.*”%> isErrorPage：是否能使用Exception对象；isELIgnored：是否忽略EL表达式； <%@include file=”filename”%> <%@taglib prefix=”c”uri=”http://……”%>
JSP中的请求转发可利用forward动作实现：<jsp:forward />； Serlvet中实现请求转发的方式为： getServletContext().getRequestDispatcher(path).forward(req,res)。
1）数据库连接出现乱码 是数据库连接中加入useUnicode=true&characterEncoding=utf-8; 2）设置页面编码，若是jsp页面，需编写代码 <%@page language=“java” pageEncoding=“UTF-8” contentType=“text/html;charset=UTF-8” %> 若是html页面，在网页头部（）中添加下面这段代码
3）将form表单提交方式变为post方式，即添加method="post"；）在Servlet类中编写代码request.setCharacterEncoding("UTF-8")，而且必须写在第一行。 4）如果是get请求，在Servlet类中编写代码 byte [] bytes = str.getBytes("iso-8859-1"); String cstr = new String(bytes,"utf-8"); 或者直接修改Tomcat服务器配置文件server.xml增加内容： URIEncoding="utf-8"1）两者的作用范围不同： Session对象是用户级的，而Application是应用程序级别的 一个用户一个session对象，每个用户的session对象不同，在用户所访问的网站多个页面之间共享同一个session对象 一个Web应用程序一个application对象，每个Web应用程序的application对象不同，但一个Web应用程序的多个用户之间共享同一个application对象。
两者的生命周期不同： session对象的生命周期：用户首次访问网站创建，用户离开该网站 (不一定要关闭浏览器) 消亡。 application对象的生命周期：启动Web服务器创建，关闭Web服务器销毁。
JSP共有以下9种基本内置组件 request：用户端请求，此请求会包含来自GET/POST请求的参数； response：网页传回用户端的回应； pageContext：网页的属性是在这里管理； session：与请求有关的会话期； application：servlet正在执行的内容； out：用来传送回应的输出； config：servlet的构架部件； page：JSP网页本身； exception：针对错误网页，未捕捉的例外
JSP共有以下6种基本动作 jsp:include：在页面被请求的时候引入一个文件。 jsp:useBean：寻找或者实例化一个JavaBean。 jsp:setProperty：设置JavaBean的属性。 jsp:getProperty：输出某个JavaBean的属性。 jsp:forward：把请求转到一个新的页面。 jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
动态INCLUDE用jsp:include动作实现，<jsp:include page=included.jsp flush=true />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数 ，先将嵌入的jsp页面编译，然后把编译后的内容放入到主页面进行处理，编译两次。 静态INCLUDE用include伪码实现，使用jsp指令引用<%@ include file=included.htm %>，不会检查所含文件的变化，适用于包含静态页面，先将内容先包含到主页面然后在一起编译，只编译一次。
JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。
Request、session、application、cookie等
1）cookie数据存放在客户的浏览器上，session数据放在服务器上。 2）cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗考虑到安全应当使用session。 3）session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能考虑到减轻服务器性能方面，应当使用COOKIE。 4）单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
触发器是一中特殊的存储过程，主要是通过事件来触发而被执行的。它可以强化约束，来维护数据的完整性和一致性，可以跟踪数据库内的操作从而不允许未经许可的更新和变化。可以联级运算。如，某表上的触发器上包含对另一个表的数据操作，而该操作又会导致该表触发器被触发。
存储过程是一个预编译的SQL语句，优点是允许模块化的设计，就是说只需创建一次，以后在该程序中就可以调用多次。如果某次操作需要执行多次SQL，使用存储过程比单纯SQL语句执行要快。 调用： 1）可以用一个命令对象来调用存储过程。 2）可以供外部程序调用，比如：java程序。
优点： 1）存储过程是预编译过的，执行效率高。 2）存储过程的代码直接存放于数据库中，通过存储过程名直接调用，减少网络通讯。 3）安全性高，执行存储过程需要有一定权限的用户。 4）存储过程可以重复使用，可减少数据库开发人员的工作量。 缺点：移植性差
索引就一种特殊的查询表，数据库的搜索可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。
唯一、不为空、经常被查询的字段
逻辑上： Single column 单行索引 Concatenated 多行索引 Unique 唯一索引 NonUnique 非唯一索引 Function-based函数索引 Domain 域索引 物理上： Partitioned 分区索引 NonPartitioned 非分区索引 B-tree： Normal 正常型B树 Rever Key 反转型B树 Bitmap 位图索引
事务就是被绑定在一起作为一个逻辑工作单元的SQL语句分组，如果任何一个语句操作失败那么整个操作就被失败，以后操作就会回滚到操作前状态，或者是上有个节点。为了确保要么执行，要么不执行，就可以使用事务。要将有组语句作为事务考虑，就需要通过ACID测试，即原子性，一致性，隔离性和持久性。 锁：在所以的DBMS中，锁是实现事务的关键，锁可以保证事务的完整性和并发性。与现实生活中锁一样，它可以使某些数据的拥有者，在某段时间内不能使用某些数据或数据结构。当然锁还分级别的。
优点： 1）对数据库的访问，因为视图可以有选择性的选取数据库里的一部分。 2）用户通过简单的查询可以从复杂查询中得到结果。 3）维护数据的独立性，试图可从多个表检索数据。 4）对于相同的数据可产生不同的视图。 缺点： 性能：查询视图时，必须把视图的查询转化成对基本表的查询，如果这个视图是由一个复杂的多表查询所定义，那么，即使是视图的一个简单查询，也把它变成一个复杂的结合体，需要花费一定的时间。
内连接、自连接、外连接（左、右、全）、交叉连接 内连接：只有两个元素表相匹配的才能在结果集中显示。 外连接： 左外连接:左边为驱动表，驱动表的数据全部显示，匹配表的不匹配的不会显示。 右外连接:右边为驱动表，驱动表的数据全部显示，匹配表的不匹配的不会显示。 全外连接：连接的表中不匹配的数据全部会显示出来。 交叉连接： 笛卡尔效应，显示的结果是链接表数的乘积。
主键在本表中是唯一的、不可唯空的，外键可以重复可以唯空；外键和另一张表的主键关联，不能创建对应表中不存在的外键。
1.建索引 2.减少表之间的关联 3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据 量大的表排在前面 4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据 5.尽量用PreparedStatement来查询，不要用Statement
第一范式（1NF）：字段具有原子性,不可再分。所有关系型数据库系统都满足第一范式。 数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为一个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的字段。 第二范式（2NF）：是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。 要求数据库表中的每个实例或行必须可以被惟一地区分。通常需要为表加上一个列，以存储各个实例的惟一标识。这个惟一属性列被称为主关键字或主键。 第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来 形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。 第三范式（3NF）：必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。 所以第三范式具有如下特征： 1，每一列只有一个值 2，每一行都能区分。 3，每一个表都不包含其他表已经包含的非主关键字信息。 例如，帖子表中只能出现发帖人的id，而不能出现发帖人的id，还同时出现发帖人姓名，否则，只要出现同一发帖人id的所有记录，它们中的姓名部分都必须严格保持一致，这就是数据冗余。
UNION在进行表链接后会筛选掉重复的记录，所以在表链接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最常见的是过程表与历史表UNION。 UNION ALL只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有重复的数据，那么返回的结果集就会包含重复的数据了。 从效率上说，UNION ALL 要比UNION快很多，所以，如果可以确认合并的两个结果集中不包含重复的数据的话，那么就使用UNION ALL。
Char的长度是固定的，而varchar2的长度是可以变化的，比如，存储字符串“abc”对于char(20)，表示你存储的字符将占20个字节，包含17个空，而同样的varchar2（20）只占了3个字节，20只是最大值，当你存储的字符小于20时，按实际长度存储。 char的效率要被varchar2的效率高。 目前varchar是varchar2的同义词，工业标准的varchar类型可以存储空字符串，但是oracle不能这样做，尽管它保留以后这样做的权利。Oracle自己开发了一个数据类型varchar2,这个类型不是一个标准的varchar，他将在数据库中varchar列可以存储空字符串的特性改为存储null值，如果你想有向后兼容的能力，oracle建议使用varchar2而不是varchar
1）库函数不同。 2）Oracle是用表空间来管理的，Mysql不是。 3）显示当前所有的表、用户、改变连接用户、显示当前连接用户、执行外部脚本的语句的不同。 4）分页查询时候时候，mysql用limt oracle用rownum 5）sql的语法的不同。
Oracle语句分三类：DDL、DML、DCL。 DDL（Data Definition Language）数据定义语言，包括： Create语句：可以创建数据库和数据库的一些对象。 Drop语句：可以删除数据表、索引、触发程序、条件约束以及数据表的权限等。 Alter语句：修改数据表定义及属性。 Truncate语句：删除表中的所有记录,包括所有空间分配的记录被删除。 DML（Data Manipulation Language）数据操控语言，包括： Insert语句：向数据表张插入一条记录。 Delete语句：删除数据表中的一条或多条记录，也可以删除数据表中的所有记录，但是它的操作对象仍是记录。 Update语句：用于修改已存在表中的记录的内容。 Select语句：用于查询已存在表中的记录的内容。 DCL（Data Control Language）数据库控制语言，包括： Grant语句：允许对象的创建者给某用户或某组或所有用户（PUBLIC）某些特定的权限。 Revoke语句：可以废除某用户或某组或所有用户访问权限
使用rownum，两种如下： 第一种： select * from (select t.,rownum row_num from mytable t) b where b.row_num between 1 and 10 第二种： select * from ( select a., rownum rn from mytable a where rownum <= 10 ) where rn >= 1 使用rowid，如下： select * from scott.emp where rowid in (select rd from (select rowid as rd ,rownum as rn from scott.emp ) where rn<=6 and rn>3)
select * from (select * from t_example order by dbms_random.random) where rownum <= 50
order by 排序查询、asc升序、desc降序 group by 分组查询、having 只能用于group by子句、作用于组内，having条件子句可以直接跟函数表达式。使用group by 子句的查询语句需要使用聚合函数。
oracle的commit就是DML语句提交数据（这里是释放锁不是锁表），在未提交前你前面的操作更新的都是内存，没有更新到物理文件中。 执行commit从用户角度讲就是更新到物理文件了，事实上commit时还没有写date file，而是记录了redo log file，要从内存写到data物理文件，需要触发检查点，由DBWR这个后台进程来写，这里内容有点多的，如果不深究的话你就理解成commit即为从内存更新到物理文件。
1）使用decode函数 2）使用case when语句
PL/SQL是一种程序语言，叫做过程化SQL语言（Procedural Language/SQL）。PL/SQL是Oracle数据库对SQL语句的扩展。在普通SQL语句的使用上增加了编程语言的特点，所以PL/SQL把数据操作和查询语句组织在PL/SQL代码的过程性单元中，通过逻辑判断、循环等操作实现复杂的功能或者计算。PL/SQL 只有 Oracle 数据库有。 MySQL 目前不支持 PL/SQL 的。
Oracle使用序列来生成唯一编号，用来处理一个表中自增字段。 Oracle序列是原子对象，并且是一致的。也就是说，一旦您访问一个序列号，Oracle将在处理下一个请求之前自动递增下一个编号，从而确保不会出现重复值。
视图其实就是一条查询sql语句，用于显示一个或多个表或其他视图中的相关数据。 表就是关系数据库中实际存储数据用的。
1）字符串类型 char、nchar、varchar、varchar2、nvarchar2 2）数字类型 81 number、integer 3）浮点类型 binary_float、binary_double、float 4）日期类型 date、 timestamp 5）LOB类型 blob、clob、nclob、bfile
TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同：二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少。 DELETE 语句每次删除一行，并在事务日志中为所删除的每行记录一项。 TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放。 TRUNCATE,DELETE,DROP放在一起比较： TRUNCATE TABLE：删除内容、释放空间但不删除定义。 DELETE TABLE:删除内容不删除定义，不释放空间。 DROP TABLE：删除内容和定义，释放空间。
select to_char(sysdate, ‘yyyy-MM-dd HH24:mi:ss’) from dual;
使用distinct关键字
A(id ,name,regdate) B(id,groupid) C(id,name2) 写出下面的SQL语句 A)统计A表中每个月注册用户数 select count(),to_char(regdate,‘yyyymm’) from A group by to_char(regdate,‘yyyymm’); B)统计A表中有姓名相同的用户数 select count() from (select name from A group by name having count() >1); C)如果表A中有姓名相同的用户,把相同的查出,写入表C中 nsert into C(name2) select name from A group by name having count() >1; D)A中ID有多个相同的数据,A中姓名相同的ID只保留注册时间最大的数据 delete from E where e.regdate < (select max(regdate) from a X where E.id = X.id);
Student(S#,SN,SD)学生表 Course(C#,CN,T#)课程表 SC（S#,C#,score）成绩表 1.查询选了课程‘税收’的学生的学号和名字 答： select SN,SD from Student where S# in( select S# from Course C , SC where C.C#=SC.C# and CN=’税收基础’); 2.查询选课数量大于5的学生的学号和名字 答： select SN,SD from Student where S# in ( select S# from SC group by S# having count(distinct C#) > 5); )
3.建立一个学生表students，包括name,age,head_teacher,id,score(姓名，年龄，班主任，学号，成绩) Create table students ( Id number(9) not null primary key, Name varchar2(40) not null, Age int check(age between 0 and 100), Head_teacher vachar2(40), Score float ); 4.对上表插入一条记录，姓名：张三，年龄：18，班主任：李四，学号：22 Insert into student(id,name,age,head_teacher) values(‘22’,’张三’,’18’,’李四’)； 5.对上表中的age+name创建一个索引，并说明它的作用和使用方法 Create index student_index on students(age,name);
查成这样一个结果
SELECT YEAR, SUM ( CASE WHEN MONTH = 1 THEN amount ELSE 0 END ) AS m1, SUM ( CASE WHEN MONTH = 2 THEN amount ELSE 0 END ) AS m2, SUM ( CASE WHEN MONTH = 3 THEN amount ELSE 0 END ) AS m3, SUM ( CASE WHEN MONTH = 4 THEN amount ELSE 0 END ) AS m4 FROM tmp_table_201307 a GROUP BY YEAR ORDER BY 1;期望的输出结果如下：
SELECT ICPNO, SERVICE_ID, SUM ( MT_RECV_OK ) TOTAL FROM ismg_icp_flow WHERE STAT_MIN BETWEEN to_date ( '2003-1-1', 'yyyy-mm-dd' ) AND to_date ( '2003-2-1', 'yyyy-mm-dd' ) GROUP BY ICPNO, SERVICE_ID ORDER BY TOTAL;（1）spring是一个轻量级框架，设计原则是非侵入性的。spring的核心是IOC容器，IOC是一种编程思想，是一种框架技术，用来管理控制生命周期和对象之间的关系，通过配置文件进行注入，很好地实现了对象与对象之间的解耦。 （2）IOC工作原理：IOC实现了工厂模式，通过读取application.xml配置文件的标签的类，注入到IOC容器中，通过构造或set方法注入，产生BeanFactory，BeanFactory通过getBean方法获取对象。 （3）Spring还提供了另外一种重要编程思想AOP，AOP称为面向切面编程，可以动态的将主线业务逻辑代码与实现功能代码分离，为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。 （4）Spring提供了很多第三方框架的整合，如：hibernate、struts、mybatis、web service等，使用IOC管理所有的Java bean，这样可以让框架与框架之间偶尔度降低，方便项目的管理，提高开发效率。
Aspect Oriented Programming (面向方面编程) OOP是面向对象编程,AOP是在OOP基础之上一种更高级的设计思想. OOP和AOP之间也存在一些区别,OOP侧重于对象的提取和封装. AOP侧重于方面组件,方面组件可以理解成封装了通用功能的组件, 方面组件可以通过配置方式灵活的切入到某一批目标对象方法上. aop是面向切面编程，可以动态的将主线业务逻辑代码与实现功能代码分离，没有侵入性。为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
通知决定了方面组件功能在目标对象方法执行的时机。 Spring框架提供了以下5中类型通知：
前置通知 < aop:before >
方面功能在目标方法之前调用.
后置通知 < aop:afterRerurning > 方面功能在目标方法之后调用.(如果目标方法抛出异常则不会执行方面功能)
最终通知 < aop:after > 方面功能在目标方法之后调用.(目标方法有无异常都会执行方面功能)
环绕通知 < aop:around > 方面功能在目标方法之前和之后调用.
异常通知 < aop:afterThrowing > 方面功能在目标方法抛出异常之后调用.
MVC是一种开发模式，把业务逻辑代码与视图代码分离，通过控制器连接业务逻辑与视图。 MVC将一个应用程序分为三部分： Model：业务逻辑的处理 View：代表和用户交互的界面 Controller ：控制器，连接模型层与视图层。
优点: 1)代码结构层次清晰 2)就是低耦合 3)重用性高 缺点:一个应用程序分成了三个部分开发，增加开发工作量。
目前，scope的取值有5种。 在Spring 2.0之前，有singleton和prototype两种 在Spring 2.0之后，为支持web应用的ApplicationContext，推出另外三种：request，session和global session类型 singleton：在IOC容器中只存在一个实例 prototype：在IOC容器中只存在多个实例 request：使用在web应用中，相当于Servlet中的Request session：使用在web应用中，相当于Servlet中的Session global session：使用在web应用中，相当于Servlet中的application
spring有四种依赖注入方式，常用1.2两种
set方法注入构造器注入静态工厂方法注入实例工厂方法注入1）.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。 2）.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller. 3）.DispatcherServlet请求提交到目标Controller 4）.Controller进行业务逻辑处理后，会返回一个ModelAndView 5）.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 6）.视图对象负责渲染返回给客户端。
