Java面试笔试题大汇总(七)

149、JAVA代码查错

　　(1) 下面这段代码有什么错误？

abstract class Name {
   private String name;
   public abstract boolean isStupidName(String name) {}
}
　　答: abstract method必须以分号结尾，且不带花括号。

　　(2) 下面这段代码有错吗?

public class Something {
  void doSomething () {
    private String s = "";
    int l = s.length();
  }
}
　　答: 有错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

　　(3) 下面这段代码有错吗?

abstract class Something {
  private abstract String doSomething ();
}
　　答: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

　　(4)下面这段代码有什么错误？

public class Something {
  public int addOne(final int x) {
    return ++x;
  }
}
　　答: 这个错误比较明显。int x被修饰成final，意味着x不能在addOne method中被修改。

　　(5) 下面这段代码有错吗？

public class Something {
  public static void main(String[] args) {
    Other o = new Other();
    new Something().addOne(o);
  }

  public void addOne(final Other o) {
    o.i++;
  }
}

class Other {
  public int i;
}

　　答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。

　　(6) 下面这段代码有错吗？

class Something {
  int i;
  public void doSomething() {
    System.out.println("i = " + i);
  }
}
 　　答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。

　　(7) 和上面一题只有一个地方不同，就是多了一个final。下面这段代码有错吗？

class Something {
  final int i;

  public void doSomething() {
    System.out.println("i = " + i);
  }
}

　　答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

　　(8) 下面这段代码看上去很完美，错在哪里呢？

public class Something {
  public static void main(String[] args) {
    Something s = new Something();
    System.out.println("s.doSomething() returns " + doSomething());
  }

  public String doSomething() {
    return "Do something ...";
  }
}

　　答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。

　　(9) 此处Something类的文件名叫OtherThing.java

class Something {
  private static void main(String[] something_to_do) {       
    System.out.println("Do something ...");
  }
}
　　答案: 从没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同，错误，main一定是public的。

　　(10) 下面这段代码有错吗？

interface A {
  int x = 0;
}

class B {
  int x =1;
}

class C extends B implements A {
  public void pX(){
    System.out.println(x);
  }

  public static void main(String[] args) {
    new C().pX();
  }
}

　　答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

　　(11) 这个错误不容易发现

interface Playable {
  void play();
}

interface Bounceable {
  void play();
}

interface Rollable extends Playable, Bounceable {
  Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
  private String name;

  public String getName() {
    return name;
  }

  public Ball(String name) {
    this.name = name;       
  }

  public void play() {
    ball = new Ball("Football");
    System.out.println(ball.getName());
  }
}

　　答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。

150、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

　　以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。

public class ThreadTest1{
  private int j;

  public static void main(String args[]){
  ThreadTest1 tt=new ThreadTest1();
  Inc inc=tt.new Inc();
  Dec dec=tt.new Dec();
  for(int i=0;i<2;i++){
   Thread t=new Thread(inc);
   t.start();
   t=new Thread(dec);
   t.start();
  }
 }

 private synchronized void inc(){
  j++;
  System.out.println(Thread.currentThread().getName()+"-inc:"+j);
 }

 private synchronized void dec(){
  j--;
  System.out.println(Thread.currentThread().getName()+"-dec:"+j);
 }

 class Inc implements Runnable{
  public void run(){
   for(int i=0;i<100;i++){
    inc();
   }
  }
  }

  class Dec implements Runnable{
  public void run(){
   for(int i=0;i<100;i++){
    dec();
   }
   }
  }
}

6、 线程的基本概念、线程的本状态以及状态之间的关系
?新建 (Born) : 新建的线程处于新建状态?就绪 (Ready) : 在创建线程后，它将处于就绪状态，等待 start() 方法被调用?运行 (Running) : 线程在开始执行时进入运行状态?睡眠 (Sleeping) : 线程的执行可通过使用 sleep() 方法来暂时中止。在睡眠后，线程将进入就绪状态?等待 (Waiting) : 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。?挂起 (Suspended) : 在临时停止或中断线程的执行时，线程就处于挂起状态。?恢复 (Resume) : 在挂起的线程被恢复执行时，可以说它已被恢复。?阻塞 (Blocked) – 在线程等待一个事件时（例如输入/输出操作），就称其处于阻塞状态。?死亡 (Dead) – 在 run() 方法已完成执行或其 stop() 方法被调用之后，线程就处于死亡状态。 5、 串行化的注意事项以及如何实现串行化答：如果有循环引用是不可以串行化的。对象输出流的WriteObject方法和 对象输入流的ReadObect 方法
7、 线程的同步、如何实现线程的同步答：当两个或多个线程同时访问同一个变量，并且以个线程需要修改这个变量。就要用到线程同步。在Java 中，同步是通过 synchronized 关键字来定义的。 诺是想同步化某程序段，可以使用 synchronized(object){}方法，其中{}内的程序语句被同步化。

9、 socket通信（tcp/udp区别及JAVA的实现方式）TCP——传输控制协议，具有极高的可靠性，保证数据包按照顺序准确到达，但其也有着很高的额外负担。UDP——使用者数据元协议，并不能保证数据包会被成功的送达，也不保证数据包到达的顺序，但其传输速度很快。大多数我们会使用TCP，偶尔才会动用UDP，如声音讯号，即使少量遗失，也无        关紧要。

10、 JAVA的事件委托机制和垃圾回收机制
java 事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件。一旦事件被接受，监听器将处理这个事件，然后返回。垃圾回收机制 垃圾收集是将分配给对象但不在使用的内存回收或释放的过程。如果一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收

11、 JDBC调用数据库的基本步骤导入必要的类，装入JDBC驱动程序，识别数据源，分配一个Connection对象，分配一个Statement对象，使用Statement执行一个查询，从返回的ResultSet对象中检索数据，关闭ResultSet，关闭Statement对象，关闭Connection对象

12、 解析XML文件的几种方式和区别答：Dom解析 在内存中创建一个DOM树，能随机访问文件内容，也可以修改原文件内容SAX解析 线性解析，不能随机访问，也无法修改原文件Dom解析要先用SAX解析创建DOM树

13、 JAVA的四种基本权限的定义public private protected 默认

14、 JAVA的国际化  答：Java 中提供了诺干国际化明感类，来实现国际化的。例如：dateformat  timezone 等等。

5、 servlet的配置
<web-app></web-app><servlet></servlet><servlet-name></servlet-name>Admin<servlet-class></servlet-class>jb-aptech.adminservlet<init-param></init-param> <param-name></param-name> email <param-value></param-value> [e-mail]

16、 谈谈你对swing mvc模式的理解？
答：Swing号称是完全按照MVC的思路来进行设计的。在设计开始前，Swing的希望能够达到的目标就包括：
模型驱动（Model-Driven）的编程方式。 提供一套单一的API，但是能够支持多种视感（look-and-feel），为用户提供不同的界面。 严格的说，Swing中的MVC实际上是MVC的一个变体：M-VC。 Swing中只显示的定义了Model接口，而在一个UI对象中集成了视图和控制器的部分机制。View和Control比较松散的交叉组合在一起，而更多的控制逻辑是在事件监听者部分引入的。 但是，这并没有妨碍在Swing中体现MVC的精髓。事实上，在Swing的开发初期，Swing确实是按照标准的MVC模式来设计的，但是很快的问题就出现了：View和Controller实际上是紧密耦合的，很难作出一个能够适应不同View的一般化的Controller来，而且，一般也没有很大的必要。

18、 Java程序怎么优化？答：提高JAVA的性能，一般考虑如下的四个主要方面：
程序设计的方法和模式  （2） JAVA布署的环境。  （3） JAVA应用程序的实现 (4) 硬件和操作系统 为了提高JAVA程序的性能，需要遵循如下的六个步骤。 a) 明确对性能的具体要求 b) 了解当前程序的性能 c) 找到程序的性能瓶颈  d) 采取适当的措施来提高性能 e) 只进行某一方面的修改来提高性能 f) 返回到步骤c,继续作类似的工作，一直达到要求的性能为止。 

动态查询如何实现？表的结构变化后，如果不需要修改程序，如何设计和实现查询？答：讲查询封装进存储过程中，通过调用存储过程实现动态调用；表结构发生变化后修改相应的存储过程即可再不修改程序的情况下实现查询。

2、 如何优化数据库，如何提高数据库的性能？答：优化数据库主要是优化查询语句，通过高性能的查询语句提高数据库的性能。

3、 设计数据库应注意那些问题答：首先应尽量满足三范式的要求，在一定程度上打破3范式的要求以提高数据库的性能。

4、 表与表之间的关联关系答：分为3种：一对一、一对多、多对多。

5、 主键和外键的区别答：主键在本表中是唯一的、不可唯空的，外键可以重复可以唯空；外键和另一张表的主键关联，不能创建对应表中不存在的外键。

3. 数据类型之间的转换  如何将数值型字符转换为数字（Integer，Double）  如何将数字转换为字符  如何去小数点前两位，并四舍五入。

4. 日期和时间  如何取得年月日，小时分秒Date dat=new Date();dat.getYear();dat.getMonth();dat.getDay();dat.getHours();...
如何取得从1970年到现在的毫秒数long now=dat.getTime();如何获取某个日期是当月的最后一天如何格式化日期
DateFormate df=DateFormate.getInstance();df.Format(dat);

6. 文件和目录（I/O）操作  如何列出某个目录下的所有文件  如何列出某个目录下的所有子目录  判断一个文件或目录是否存在  如何读写文件

6. 文件和目录（I/O）操作  如何列出某个目录下的所有文件  如何列出某个目录下的所有子目录  判断一个文件或目录是否存在  如何读写文件

4. 描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理。
Cookie是在客户端开辟的一块可长期存储用户信息的地方；

8. 描述一下你最常用的编程风格。

(1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。

(2) 为了常规用途而创建一个类时，请采取“经典形式”，并包含对下述元素的定义：equals()hashCode()toString()clone()（implement Cloneable）implement Serializable

(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。

(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。

(5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。

(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议：一个复杂的开关语句：考虑采用“多形”机制数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现许多成员变量在特征上有很大的差别：考虑使用几个类

(7) 让一切东西都尽可能地“私有”——private。可使库的某一部分“公共化”（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素——只有private字段才能在非同步使用的情况下受到保护。

(8) 谨惕“巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。

(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。

(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的“用内部类改进代码”）。

(11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。

(12) 避免使用“魔术数字”，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。

(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常——如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续。

(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程错误。在采取象这样的方案之前，请确定finalize()能够在自己的系统中工作（可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。

(15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从句的try块，开始清除工作。

(16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。

(17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象“造型”到数组里。

(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象）类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体的实施细节。

(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中产生不可预知的结果（参见第7章的详细说明）。

(20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。

(21) 在现成类的基础上创建新类时，请首先选择“新建”或“创作”。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了继承，则整个设计会变得没有必要地复杂。

(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的：应直接使用一个“颜色”字段。

(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。

(24) 在Java 1.1 AWT中使用事件“适配器”时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示——只不过代码的工作就变得不正常了。

(25) 用合理的设计方案消除“伪功能”。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条“只生成其中一个”注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。

(26) 警惕“分析瘫痪”。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在考察细节的时候陷入“死逻辑”中。

(27) 警惕“过早优化”。首先让它运行起来，再考虑变得更快——但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。

(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能将你说服。

10. 如果系统要使用超大整数（超过long长度范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数加法运算）。

public class BigInt() {

public static final long maxlong = ^0;

long[] ArrOne = new long[1000];

String intString="";

 

public int[] Arr(String s){

intString = s;

for(int i=0;i

....................................

49、列出某文件夹下的所有文件；
50、调用系统命令实现删除文件的操作；
51、实现从文件中一次读出一个字符的操作；
52、列出一些控制流程的方法；
54、编写了一个服务器端的程序实现在客户端输入字符然后在控制台上显示，直到输入"END"为止，让你写出客户端的程序；

在Jdbc进行数据库调用时，你经常采用什么方式执行sql语句？为什么不用其他方式（比较一下即可）
int类型在java中有多少位？（如果面试题目中有这样的问题，不是公司太牛就是公司太差）
你用过线程吗？请启动4个线程对一个静态变量进行加1操作。
线程是如何启动的？
每个类实力化时都调用父类的构造函数吗？如果是，那么都调用object类的构造函数吗

你懂得Ftp协议吗？如果不懂请问我告诉你Ftp协议命令格式及数据包的解析方法，你能用多长时间用java基本apI搞定一个ftp客户端程序（是这样的问题主要看你个人学习能力，一般也就是一人五天的工作量，不必要害怕，一般他不会给你五天做的，就是想看一下你的自信心及对工作的理解能力）
你知道java与C的通信?吗你会用那些协议进行通信？（其实也就是问socret通信）
请问java中的网络通信有那些方式，有什么区别？
String a=“”For limit I=0;I<100000;I++)A=a+“A”把字符串成“A”连接100000次，上面方法不够好，请优化上面代码？（采用stringBuffer进行优化）

． 写出从数据库表Custom中查询No、Name、Num1、Num2并将Name以姓名显示、计算出的和以总和显示的SQL。SELECT  No ,  Name  AS  ‘姓名’ ，Num1 ，Num2，（Num1+Num2） AS  ‘总和’
FROM Custom

何为“事务处理”，谈谈你对它的理解。事务处理是指一个单元的工作，这些工作要么全做，要么全部不做。作为一个逻辑单元，必须具备四个属性：自动性、一致性、独立性和持久性。自动性是指事务必须是一个自动的单元工作，要么执行全部数据的修改，要么全部数据的修改都不执行。一致性是指当事务完成时，必须使所有数据都具有一致的状态。在关系型数据库中，所有的规则必须应用到事务的修改上，以便维护所有数据的完整性。所有的内部数据结构，在事务结束之后，必须保证正确。独立性是指并行事务的修改必须与其他并行事务的修改相互独立。一个事务看到的数据要么是另外一个事务修改这些事务之前的状态，要么是第二个事务已经修改完成的数据，但是这个事务不能看到正在修改的数据。

3. 常用的数据结构有哪些？请枚举一些。（不少于5个）链表、堆栈、二叉树、队列、图、堆，集合。

4. 什么是OOP？什么是类？请对比类和对象实例之间的关系。OOP是Object_oriented Programming(面向对象编程)的缩写。这主要是为了区别于以前的面向过程的程序设计！指的是用对象的观点来组织与构建系统，它综合了功能抽象和数据抽象，这样可以减少数据之间的耦合性和代码的出错几率。使用面向对象编程技术可以使得软件开发者按照现实世界里人们思考问题的模式编写代码,可以让软件开发者更好地利用代码直接表达现实中存在的对象,将问题空间直接映射到解空间!类：即class 在面向对象的程序设计中，专门用“类”来表示用户定义的抽象数据类型（user_defined abstract type）。它将具有相同状态、操作和访问机制的多个对象进行了抽象。类具有继承、数据隐藏和多态三种主要特性。利用类的这三种特性可以更好地表示现实世界中事物。类是同一类对象实例的共性的抽象，对象是类的实例化。对象通常作为计算机模拟思维，表示真实世界的抽象，一个对象就像一个软件模块，可以为用户提供一系列的服务---可以改变对象的状态、测试、传递消息等。类定义了对象的实现细节或数据结构。类是静态的，对象是动态的，对象可以看作是运行中的类。类负责产生对象，可以将类当成生产对象的工厂（Object factory）.

connection connconn.setAuto(false)//表示手动提交conn.commit// 提交conn.rollback();//事务回滚
-内联接use pubsselecｔ a.au_fname, a.au_lname, p.pub_name  from authors a inner join publishers p on a.city = p.city order by p.pub_name asc, a.au_lname asc,   a.au_fname asc
--左外联接use pubs  selecｔ a.au_fname, a.au_lname, p.pub_name  from authors a left join publishers p
on a.city = p.city  order by p.pub_name asc,  a.au_lname asc,   a.au_fname asc
-使用子查询USE pubs  GO  selecｔ distinct pub_name  FROM publishers  WHERE pub_id IN  (selecｔ pub_idFROM titlesWHERE type = 'business')  GO
--如果平均价格少于 $30，WHILE 循环就将价格加倍，然后选择最高价。
--如果最高价少于或等于 $50，WHILE 循环重新启动并再次将价格加倍。
--该循环不断地将价格加倍直到最高价格超过 $50  USE pubs  GO
WHILE (selecｔ AVG(price) FROM titles) < $30
BEGIN
   updatｅ titles
      SET price = price * 2
   selecｔ MAX(price) FROM titles
   IF (selecｔ MAX(price) FROM titles) > $50
      BREAK
   ELSE
      CONTINUE
END
---如果平均价格少于 $30，WHILE 循环就将价格加倍，然后选择最高价。
--如果最高价少于或等于 $50，WHILE 循环重新启动并再次将价格加倍。
--该循环不断地将价格加倍直到最高价格超过 $50
USE pubs
GO
WHILE (selecｔ AVG(price) FROM titles) < $30
BEGIN
   updatｅ titles
      SET price = price * 2
   selecｔ MAX(price) FROM titles
   IF (selecｔ MAX(price) FROM titles) > $50
      BREAK
   ELSE
      CONTINUE
END
CREATE PROCEDURE au_info
   @lastname varchar(40),
   @firstname varchar(20)
AS
selecｔ au_lname, au_fname, title, pub_name
   FROM authors a INNER JOIN titleauthor ta
      ON a.au_id = ta.au_id INNER JOIN titles t
      ON t.title_id = ta.title_id INNER JOIN publishers p
      ON t.pub_id = p.pub_id
   WHERE  au_fname = @firstname
      anｄ au_lname = @lastname
GO
EXECUTE au_info 'Dull', 'Ann'--或者
EXECUTE au_info @lastname = 'Dull', @firstname = 'Ann'--创建存储过程CREATE PROCEDURE titles_sum @TITLE varchar(40),@SUM money OUTPUT
AS
selecｔ @SUM = SUM(price)
FROM titles
WHERE title LIKE @TITLE
GO
DECLARE @TOTALCOST money
EXECUTE titles_sum 'The%', @TOTALCOST OUTPUT
selecｔ @TOTALCOST
go
CREATE PROCEDURE Oakland_authors
AS
selecｔ au_fname, au_lname, address, city, zip
FROM authors
WHERE city = 'Oakland'
and state = 'CA'
ORDER BY au_lname, au_fname
GO
--sp_helptext Oakland_authors
ALTER PROCEDURE Oakland_authors
AS
selecｔ au_fname, au_lname, address, city, zip
FROM authors
WHERE state = 'CA'
ORDER BY au_lname, au_fname
GO
--sp_helptext Oakland_authors
--提交事务后，所有书籍支付的版税增加 10%。
begin transaction MyTransaction
updatｅ roysched
set royalty = royalty * 1.10
commit transaction MyTransaction
--rollback transaction MyTransaction
selecｔ royalty from roysched
--selecｔ @@trancount
--1.创建试验实验表
create table temptrigger
( id_temp varchar(2) not null primary key,
  temp_name varchar(10) null,
  temp_age int null)go
inserｔ temptrigger values('01','张三','10')
inserｔ temptrigger values('02','李四','11')
inserｔ temptrigger values('03','王五','12')
inserｔ temptrigger values('04','赵六','11')
selecｔ * from temptrigger  go
--2.创建inserｔ , update触发器
create trigger temptrigger_modify
on temptrigger
for insert,update
as
begin
  if (selecｔ temp_age from inserted) > 15
    begin
      rollback transaction
      print '年龄不能超过15岁！'
    end
end
--inserｔ temptrigger values('04','大朋','17')
--inserｔ temptrigger values('05','大朋','17')
--inserｔ temptrigger values('05','大朋','14')
--updatｅ temptrigger set temp_age='18' where id_temp = '01'
--updatｅ temptrigger set temp_age='9' where id_temp = '01'
-3.创建deletｅ 触发器--drop trigger temptrigger_delete
create trigger temptrigger_delete
on temptrigger
for delete
as
begin
  print @@rowcount
  if @@rowcount > 1
  begin
    rollback transaction
    print '一次删除记录不能多于1条'
  end
end
--deletｅ from temptrigger
--deletｅ from temptrigger where id_temp='01'
--创建聚集索引create clustered index clindx_titleid  on roysched(title_id)--sp_help roysched
--创建非聚集索引create nonclustered index unclindx_titleid  on roysched(title_id)--sp_help roysched
--查看索引统计dbcc show_statistics(roysched,titleidind)
--更新索引统计updatｅ statistics authors
--重建索引dbcc dbreindex('roysched',unclindx_titleid)
--删除索引drop index roysched.unclindx_titleid-sp_help roysched
1--创建ssn(社会保险号)的基于varchar的自定义数据类型。
--用于存储11位社会保险号（999-99-999）的列。该列不能
--为null。use pubs  exec sp_addtype ssn , 'varchar(11)' , 'NOT NULL'
--查看创建的数据类型--sp_help ssn
--使用创建的数据类型create table mytable( myid varchar(2) primary key, myssn ssn) 
4-删除创建的数据类型--drop table mytable--exec sp_droptype ssn
?批是包含一个或多个 Transact-SQL 语句的组，从应用程序一次性地发送到 Microsoft SQL Server 执行。批作为一个整体执行，以GO命令结束。批处理是客户端作为一个单元发出的一个或多个 SQL 语句的集合。每个批处理编译为一个执行计划。
触发器?触发器是在对表进行插入、更新或删除操作时自动执行的存储过程?触发器通常用于强制业务规则?触发器可以确保数据的完整性和一致性
事务是用户定义的一个操作序列，这些操作要么全做要么全不做，是一个不可分割的工作单位(构成单一逻辑工作单元的操作集合)如果某一事务成功，则在该事务中进行的所有数据更改均会提交，成为数据库中的永久组成部分。
如果事务遇到错误且必须取消或回滚，则所有数据更改均被清除
?锁 是在多用户环境中对数据访问的限制封锁就是事务 T 在对某个数据对象（如表、记录等）操作之前，先向系统发出请求，对其加锁。加锁后事务 T 就对该数据对象有了一定的控制，在事务T释放它的锁之前，其它的事务不能更新此数据对象。（锁蕴含的基本概念是用户需要对表的排它访问）?从程序员的角度看：分为乐观锁和悲观锁。乐观锁：完全依靠数据库来管理锁的工作。悲观锁：程序员自己管理数据或对象上的锁处理。
子查询：一个 selecｔ 语句嵌套在另一个 selecｔ 语句中。
—索引—是一个数据库对象，它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单,然后根据指定的排序次序排列这些指针 —优点提高查询执行的速度。  强制实施数据的唯一性。  提高表之间联接的速度。 缺点 存储索引要占用磁盘空间。数据修改需要更长的时间，因为索引也要更新。
?视图?是一种虚拟表，通常是作为来自一个或多个表 的行或列的子集创建的。?视图本质上讲，就是保存在数据库中的select查询?视图并不是数据库中存储的数据值的集合。?对最终用户的好处– 结果更容易理解– 获得数据更容易
?对开发人员的好处– 限制数据检索更容易– 维护应用程序更方便
存储过程?使用一个名称存储的预编译T-SQL语句和流程控制语句的集合?由数据库开发人员或数据库管理员编写
?用来执行管理任务或应用复杂的业务规则  优点?执行速度更快?首次运行时，进行优化和编译得到执行计划并将该计划存储在系统表中，以后直接运行。?实现多个程序共享应用程序逻辑?组件式编程?能够屏蔽数据库的结构，实现更高的安全性
?减少网络流通量
数据库设计和建模必要性?好的数据库结构有利于：-节省数据的存储空间-能够保证数据的完整性-方便进行数据库应用系统的开发?设计不好的数据库结构将导致-数据冗余、存储空间浪费-内存空间浪费
不管数据库的大小和复杂程度如何，可以用下列基本步骤来设计数据库：–收集信息–标识对象–设计数据模型–标识每个对象 存储的信息类型–标识对象之间的关系
?数据模型是一种标识实体类型及其实体间联系的模型。典型的数据模型由网状模型、层次模型和关系模型。什么是规范化从关系数据库的表中，除去冗余数据的过程称为规范化。—精简数据库的结构—从表中删除冗余的列—标识所有依赖于其它数据的数据
三级范式第一范式的定义： 如果一个表中没有重复组（即行与列的交叉点上只有一个值，而不是一组值），则这个表属于第一范式（常记成1NF）。简而言之："每一字段只存储一个值"。例如:职工号，姓名，电话号码组成一个表（一个人可能有一个办公室电话 和一个家里电话号码） 第二范式的定义：如果一个表属于1NF，任何属性只依赖于关键字，则这个表属于第二范式（常记成2NF ）。简而言之：必须先符合1NF的条件，且每一行都能被唯一的识别。 将1NF转换成2NF的方法是添加主键。学号,课程名,成绩第三范式的定义：如果一个表属于2NF，且不包含传递依赖性，则这个表是第三范式（常记成3NF）。满足3NF的表中不包含传递依赖。简而言之：没有一个非关键属性依赖于另一个非关键属性。学号，课程号，成绩，学分学号，姓名，所在系，系名称，系地址

什么是类与对象？
所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。
类是具备某些共同特征的实体的集合，它是一种抽象的概念，用程序设计的语言来说，类是一种抽象的数据类型，它是对所具有相同特征实体的抽象。

属性与方法？
不同对象具有相同特点，就可能抽象为一定的类，那么这些特点基本上可以分为两类，一类是描述对象静态状态的，就是对象的属性，在程序设计中，可以称之为变量；另一类是描述对象的动作，就是对象的方法，在程序设计中我们称之为函数。属性和方法是一个对象所具备的两大基本要素，也是我们后面编程工作的核心。

什么是封装？
只要有足够的方法，就没必要直接去操作对象属性，只要调用这些方法就可以实现要完成的任务，这种现象称为封装，它通过对象方法对其属性的操作把对象属性封装在一个对象内部，对象与外界打交道全部通过其自身的方法来实现，有效的把对象属性隐藏在对象内部。

编写 java文件的注意事项？
在记事本中编写java文件，在保存时一定要把文件名和扩展名用双引号括起来，否则将默认保存为文本文件，如果要保存的java 文件名为Program1.java,则在保存时在文件名文本框中一定要输入”Program1.java”。

如何编译java程序？
单击开始|运行命令，在命令行上输入cmd，按回车键（在 window98中输入command，按回车键），即可打开一个命令窗口，将目录转换到编写java源程序所在的目录，输入javac filename.java

如何执行java程序？
同样在命令窗口中输入java filename，

基本数据类型？
Java的数据类型可以划分为4大类：整数，浮点数，字符型，布尔型。其中整数可以划分为：byte,short,int,long.浮点数可以划分为float,double.