当我们用eclipse jbpm插件设计好流程图时，我们有时会要求把流程图显示到页面上去。

以下是一个可行的方案：

使用taglib标签，重写processImageTag,修改样式什么的（自己喜欢啦），在background-image:url中的指定你的输出流：

ProcessDefinition.getFileDefinition().getInputStream("processimage.jpg")

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

1. ctrl + shift + t :: 打开最后关闭的tab
2. ctrl + 1 ... 9 :: 切换到某个tab
3. ctrl + k :: 进入google搜索输入焦点
4. ctrl + w :: 关闭当前tab
5. ctrl + t :: 打开一个新tab
6. ctrl + l :: 进入地址栏
7. ctrl + tab / ctrl + shift + tab :: 循环进入前/后tab
8. ctrl + f :: 查找

Windows快捷键：

DELETE　　　　　　　　　删除被选择的选择项目，如果是文件，将被放入回收站
SHIFT+DELETE　　　　　　删除被选择的选择项目，如果是文件，将被直接删除而不是放入回收站
CTRL+A　　　　　　　　　全选
CTRL+N　　　　　　　　　新建一个新的文件
CTRL+O　　　　　　　　　打开“打开文件”对话框
CTRL+P　　　　　　　　　打开“打印”对话框
CTRL+S　　　　　　　　　保存当前操作的文件

CTRL+X　　　　　　　　　剪切被选择的项目到剪贴板
CTRL+INSERT 或 CTRL+C　 复制被选择的项目到剪贴板
SHIFT+INSERT 或 CTRL+V　粘贴剪贴板中的内容到当前位置
ALT+BACKSPACE 或 CTRL+Z 撤销上一步的操作
ALT+F4　　　　　　　　　关闭当前应用程序
win+L　　　　　　　　　  待机
win+D                              显示桌面
win+R                              运行
win+U+U 关机
win+U+R 重启
win+U+S 待机

Firefox快捷键：

首页： Alt+Home
打开文件： Ctrl+O
重新载入： F5 或 Ctrl+R
到页面底部： End
到页面顶部： Home
页面源代码： Ctrl+U
打印： Ctrl+P
页面另存为： Ctrl+S

复制： Ctrl+C
剪切： Ctrl+X
删除： Del
粘贴： Ctrl+V
重做： Ctrl+Y
全选： Ctrl+A
撤消： Ctrl+Z

关闭标签： Ctrl+W 或 Ctrl+F4
关闭窗口： Ctrl+Shift+W 或 Alt+F4
向左移动标签： Ctrl+左方向键 或 Ctrl+上方向键
向右移动标签： Ctrl+右方向键 或 Ctrl+下方向键
移动标签到开头： Ctrl+Home
移动标签到结尾： Ctrl+End
新建标签页： Ctrl+T
新建窗口： Ctrl+N

下一个标签页： Ctrl+Tab 或 Ctrl+PageDown
在新标签页打开网址： Alt+Enter
前一个标签页： Ctrl+Shift+Tab 或 Ctrl+PageUp
撤销关闭标签页： Ctrl+Shift+T
选择标签页 [1 to 8]： Ctrl+[1 到 8]
选择最后标签页： Ctrl+9
添加当前为书签： Ctrl+D
打开书签： Ctrl+B 或 Ctrl+I

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

style="overflow-y:hidden"   这个是y轴不出现滚动条  
  style="overflow-x:hidden"   这个是x轴不出现滚动条  
  加在body   或是div下

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

Java 部分

1 ．求两个数的最大公约数

解答：

欧几理德原理 : 辗转相除法

         public static int zdgys(int a,int b){

                   int x = a%b;

                   if(x==0) return b;

               else return zdgys(b,x);

         }

2．  关于 java 垃圾回收器的认识

解答：

对于 GC 来说，当程序员创建对象时， GC 就开始监控这个对象的地址、大小以及使用情况。通常， GC 采用有向图的方式记录和管理堆 (heap) 中的所有对象。通过这种方式确定哪些对象是 " 可达的 " ，哪些对象是 " 不可达的 " 。当 GC 确定一些对象为 " 不可达 " 时， GC 就有责任回收这些内存空间。可以。程序员可以手动执行 System.gc() ，通知 GC 运行，但是 Java 语言规范并不保证 GC 一定会执行。

3．  请问如何设计一个类，使其只能被初始化为一个实例。

解答：

Singleton 模式主要作用是保证在 Java 应用程序中，一个类 Class 只有一个实例存在。

第一种形式 : 定义一个类，它的构造函数为 private 的，它有一个 static 的 private 的该类变量，在类初始化时实例话，通过一个 public 的 getInstance 方法获取对它的引用 , 继而调用其中的方法。

附件：

package parent.career.blest;

class Singleton {

         private Singleton(){}// 在外部用 new 关键字会报错，只供内部使用

         // 注意这是 private 只供内部调用

         private static Singleton instance = new Singleton();

         // 这里提供了一个供外部访问本 class 的静态方法，可以直接访问　　

         public static Singleton getInstance() {

                return instance;

      }

      public void say(String str){

                System.out.println(str);

      }

}

class commonClass{

         public commonClass(){

                   System.out.println(" 这是一个普通类 ");

         }      

}

public class mySingleton{

         public static void main(String args[])

         {

                   Singleton sl = Singleton.getInstance();

                   Singleton sl2 = Singleton.getInstance();

                   sl.say("hello,world!");

                   sl2.say("hello,world again!");

                   System.out.println(sl==sl2);// 输出 true, 说明 sl,sl2 指向同一个实例

                   commonClass cC = new commonClass();

                   commonClass cC2 = new commonClass();

                   System.out.println(cC==cC2);// 输出 false, 说明 cC,cC2 分别指向不同的实例

         }

}

4 ．有一个 1001 个元素的数组 a[n] ，每个元素都在 1 到 1000 这些整数中取值，其中有一个数值重复了，现在要设计一个算法找出这个数字，且每个元素只能被访问一次。不能用辅助的存储容器。

解答：

This number = (a[0]+a[1]+a[3]+ …… a[1000])-(1+2+3+ …… +1000)

servlet 生命周期以及 servlet 基本构架

解答：

servlet 有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由 javax.servlet.Servlet 接口的 init,service 和 destroy 方法表达。

Servlet 的基本架构：
public class ServletName extends HttpServlet {
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws
         ServletException, IOException {
    }
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws
         ServletException, IOException {
    }
}

5．  死锁的四个必要条件

解答：

> 互斥条件：某段时间内某资源只能由一个进程使用。

> 请求和保持：进程因请求资源而阻塞时，对已分配给它的资源保持不放。

> 不剥夺条件：资源在未使用完前，不能被剥夺，由使用进程释放。

> 环路条件：发生死锁时，有向图必构成一环路。

7 ． EJB 是基于哪些技术实现的？并说出 SessionBean 和 EntityBean 的区别， StatefulBean 和 StatelessBean 的区别。

解答：

EJB 包括 Session Bean 、 Entity Bean 、 Message Driven Bean ，基于 JNDI 、 RMI 、 JAT 等技术实现。

SessionBean 在 J2EE 应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他 EJB 组件。 EntityBean 被用来代表应用系统中用到的数据。

对于客户机， SessionBean 是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。

对于客户机， EntityBean 是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。

Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean 都可以将系统逻辑放在 method 之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。 Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候， EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method 。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。

8 ． sleep() 和 wait() 有什么区别 ?

解答：

sleep 是线程类（ Thread ）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep 不会释放对象锁。

wait 是 Object 类的方法，对此对象调用 wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出 notify 方法（或 notifyAll ）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

9 ． forward 和 redirect 的区别

解答：

forward 是服务器请求资源，服务器直接访问目标地址的 URL ，把那个 URL 的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。

redirect 就是服务端根据逻辑 , 发送一个状态码 , 告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以 session,request 参数都可以获取。

10 ．冒泡排序算法

解答：

package parent.career.blest;

/**

  * 冒泡排序算法演示 : 从小到大排列数组元素

  * 原理：第一个元素和后面的一个元素比较，比较结果再和后面一个元素比较，依次类推

  *       接着，第二个和后面元素比较，依次类推

  */

public class Maopao{

         public static int[] mppx(int[] array){

                   for(int i =0;i<array.length; i++){

                            for(int j=i; j<array.length; j++){

                                     int temp;

                                     if(array[i]>array[j]){

                                               temp = array[i];

                                               array[i] = array[j];    

                                               array[j] = temp;

                                     }

                            }      

                   }

                   return array;

         }

         public static void main(String args[]){

                   // 测试

                   int[] ar ={12,23,1,23,45,11,42,9,45,2,16,77,86,56,43};    

                   ar = mppx(ar);

                   for(int i = 0;i<ar.length;i++){

                            System.out.print(ar[i]+"   ");

                   }      

         }      

}

11 ．从键盘接收一个整数，并用递归求其阶乘。

解答：

package parent.career.blest;

import java.io.*;

/**

  * 用递归求阶乘算法

  * 从键盘接收一个整数，然后求其阶乘

  */

  public class DG_JC{

         public static int DG(int n){

                   if(n==1) return 1;

                   else return n*DG(n-1);

         }

         public static void main(String args[]){

                   int n = 0;

                   System.out.print(" 请输入一个整数： ");

                   try{

                            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

                            n = Integer.parseInt(br.readLine());

                            br.close();

                   }catch(IOException e){

                            e.printStackTrace();                   

                   }

                   System.out.println(" 阶乘 "+n+"! = "+DG(n));

         }

  }

12 ．什么时候使用 assert?

解答： 断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true 。如果表达式计算为 false ，那么系统会报告一个 Assertionerror 。它用于调试目的：

断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

13 ． 谈谈 final, finally, finalize 的区别。

解答：

final— 修饰符（关键字）如果一个类被声明为 final ，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract 的，又被声明为 final 的。将变量或方法声明为 final ，可以保证它们在使用中不被改变。被声明为 final 的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为 final 的方法也同样只能使用，不能重载。

finally— 再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize— 方法名。 Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。 finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

14 ． Collection 和 Collections 的区别。

解答：

Collections 是个 java.util 下的类，它包含有各种有关集合操作的静态方法。
Collection 是个 java.util 下的接口，它是各种集合结构的父接口。

15 ．说出 ArrayList,Vector, LinkedList 的存储性能和特性
解答：

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

开发环境：

eclipse WTP 3.4

tomcat 5.5

M2 Plugin

Maven 2 install

maven配置

eclipse配置maven:

过程记录：

new project-->Dynamic web project

新建完后，Enable maven(点按右键)

用如下命令新建maven struts2 basic:

mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-struts -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.seedlife.onlineshop -DartifactId=onlineshop

 完成后,进入刚新建项目onlineshop目录下，运行：

mvn appfuse:full-source

注意settings.xml的
 <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ~/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
<localRepository>E:\SKY\appfuse\repository</localRepository>
localRepository这里不能有空格，这个好像是ant的造成。

 接着把maven项目onlineshop里面的src文件夹下main种test文件夹放到dynamic web project（我的是shop）src里面的，然后更改shop里面的.classpath文件和 .settings/org.eclipse.wst.common.component文件。（红色 代表更改地方）

.classpath：

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
	<classpathentry kind="src" path="src/test/java"/>
	<classpathentry kind="src" path="src/main/java"/>
	<classpathentry kind="src" path="src/test/resources"/>
	<classpathentry kind="src" path="src/main/resources"/>


	<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER">
		<attributes>
			<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
		</attributes>
	</classpathentry>
	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
	<classpathentry kind="con" path="org.eclipse.jst.server.core.container/org.eclipse.jst.server.tomcat.runtimeTarget/Apache Tomcat v5.5"/>
	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
	<classpathentry kind="output" path="target/classes"/>


</classpath>

 org.eclipse.wst.common.component：

<?xml version="1.0" encoding="UTF-8"?>
<project-modules id="moduleCoreId" project-version="1.5.0">
<wb-module deploy-name="shop">


<wb-resource deploy-path="/" source-path="/src/main/webapp"/>


<wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/java"/>
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/resources"/>
<property name="context-root" value="shop"/>
<property name="java-output-path" value="target/classes"/>


</wb-module>
</project-modules>

 再去把Dynamic web project(我的是shop)里面的build和WebContent文件夹删除掉。

最后修改shop的J2EE Module Dependencies：

点右键--Properties---J2EE Module Dependencies----maven Dependencies--Apply--OK

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

1. ctrl + shift + t :: 打开最后关闭的tab
2. ctrl + 1 ... 9 :: 切换到某个tab
3. ctrl + k :: 进入google搜索输入焦点
4. ctrl + w :: 关闭当前tab
5. ctrl + t :: 打开一个新tab
6. ctrl + l :: 进入地址栏
7. ctrl + tab / ctrl + shift + tab :: 循环进入前/后tab
8. ctrl + f :: 查找

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"，6，应该输出为"我ABC"而不是"我ABC+汉的半个"

package com.sing.demo;

class SplitString {
	public static void main(String[] args) {
		String str = "Atet中dd文dsaf中男大344";
		split(str, 9);
	}

	public static void split(String str, int byteleng) {
		byte[] bt = str.getBytes();
		byte[] temp;
		int leng;
		if (bt[byteleng - 1] < 0 && bt[byteleng - 2] > 0) {
			leng = byteleng - 1;
		} else {
			leng = byteleng;
		}
		temp = new byte[leng];
		for (int i = 0; i < temp.length; i++) {
			// System.out.println(bt[i]);
			temp[i] = bt[i];
		}
		System.out.println(new String(temp));
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

看到许多人都会迷惑JAVA类的初始化顺序，有时间自己也要看下书做下测试才能明白。所以记下来，其中的原理关于编译和JVM比较罗索，自行查书吧……

1.基类静态变量初始化或静态代码块执行，它们的顺序按照字面出现的顺序

2.派生类的 静态变量初始化或静态代码块执行，它们的顺序按照字面出现的顺序

3.基类实例变量初始化

4.基类代码块执行

5.基类构造方法执行

6.派生类实例变量初始化

7.派生类代码块执行

8.派生类构造方法执行

注意：上传调用时，变量为声明引用类型的变量值;调用方法则为创建对象（NEW）时类型的方法。

其实就是类加载时执行静态变量和静态代码块（只执行一次），然后实例变量和代码块，最后是构造（每次new 的时候都执行）。

package com.sing.demo;

class A {
  String name = isName();
  static String   as = print();
  public static String print(){
	  System.out.println("A.static .args()........");
	  return "";
  }
  String isName() {
    System.out.println("222222222");
    return "a";
  }

  A() {
    System.out.println("333333333");
  }
  static {
	  System.out.println("A.static.block........");
  }
 
}

class B extends A {
  String name = isNameb();
  
  String isNameb() {
    super.isName();
    System.out.println("1111111111");
    return "b";
  }
  static {
	  System.out.println("B.static block........");
  }
  {
	  System.out.println("B.block........");
  }
  static String   bs = print();
  public static String print(){
	  System.out.println("B.static .args()........");
	  return "";
  }
}

public class Demo {
  public static void main(String[] args) {
   A a =   new B();
 //  System.out.println(a.name);
//     new A();
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别?它们的区别在于 创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式?这主要考虑到软件的可伸缩、可扩展和可重用等软件设 计思想。

　　Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如：

　　 class c = Class.forName(“Example”);
　　factory = (ExampleInterface)c.newInstance();

　　其中ExampleInterface是Example的接口，可以写成如下形式：

　　 String className = "Example";
　　class c = Class.forName(className);

　　factory = (ExampleInterface)c.newInstance();

　　进一步可以写成如下形式：

　　 String className = readfromXMlConfig;//从xml 配置文件中获得字符串
　　class c = Class.forName(className);

　　factory = (ExampleInterface)c.newInstance();

　　上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类 Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。

　　从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保 证：1、这个类已经加载;2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加 载器，即加载java API的那个加载器。

　　现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。

　　最后用最简单的描述来区分new关键字和newInstance()方法的区别：

　　newInstance: 弱类型。低效率。只能调用无参构造。

　　new: 强类型。相对高效。能调用任何public构造。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

这些东东无聊得很 shit!

1.提供一个3升和一个5升的水桶,并提供无限多的水,你怎样用它们准确地量出四升和七升的水来呢??

装满3升,倒进5升,再装满3升,倒进5升,倒掉5升,把3升剩余倒进去,再装满3升,倒进5升

2.有八颗弹子球,其中1颗比其他7颗重(其他七颗重量相等),怎么使用天平只通过两次称量就可以找到这颗球??

任取六个球,分两份来称,同等重量,就将剩余两个称一下就知道,
如果不同,就把重的三个任取两个再称一下,

3.你让工人为你工作7天，给工人的回报是一根金条。金条平分成相连的7段，你必须在每天结束时给他们一段金条，
如果只许你两次把金条弄断，你如何给你的工人付费？

金条分成1／7、2／7和4／7三份。这样，第1天我就可以给他1／7；第2天我给他2／7，
让他找回我1／7；第3天我就再给他1／7，加上原先的2／7就是3／7；第4天我给他那块4／7，
让他找回那两块1／7和2／7的金条；第5天，再给他1／7；第6天和第2天一样；第7天给他找回的那个1／7

4.现在小明一家过一座桥，过桥时候是黑夜，所以必须有灯。现在小明过桥要1秒，小明的弟弟要3秒，小明的爸爸要6秒，
小明的妈妈要8秒，小明的爷爷要12秒。每次此桥最多可过两人，而过桥的速度依过桥最慢者而定，而且灯在点燃后30秒就会熄灭。
问小明一家如何过桥？

第一步，小明与弟弟过桥，小明回来，耗时4秒；第二步，小明与爸爸过河，弟弟回来，耗时9秒；
第三步，妈妈与爷爷过河，小明回来，耗时13秒；最后，小明与弟弟过河，耗时4秒，
总共耗时30秒，多么惊险！

5.一楼到十楼的每层电梯门口都放着一颗钻石，钻石大小不一。你乘坐电梯从一楼到十楼，
每层楼电梯门都会打开一次，只能拿一次钻石，问怎样才能拿到最大的一颗？

6.在房里有三盏灯，房外有三个开关，在房外看不见房内的情况，你只能进门一次，你用什么方法来区分那个开关控制那一盏灯？

开两盏灯，一个10分钟，一个30分钟，进去摸温度

7.有两根不均匀分布的香，每根香烧完的时间是一个小时，你能用什么方法来确定一段45分钟的时间？
 

一烧一头，一烧同时两头，一根烧完后即时点燃另根的另一头

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

小明和小强都是张老师的学生，张老师的生日是M月N日，2人都知道张老师的生日是下列10组中的一天，张老师把M值告诉了小明，把N值告诉了小强，找老师问他们知道他的生日是哪一天吗？
3月4日 3月5日 3月8日 6月4日 6月7日 9月1日
9月5日 12月1日 12月2日 12月8日
小明说：如果我不知道的话，小强肯定也不知道
小强说：本来我不知道，但是现在我知道了
小明说：哦，那我也知道
请根据以上对话推断出张老师的生日是哪一天。

答案应该是9月1日。
1）首先分析这10组日期，经观察不难发现，只有6月7日和12月2日这两组日期的
日数是唯一的。由此可知，如果小强得知的N是7或者2，那么他必定知道了老师的
生日。
2）再分析“小明说：如果我不知道的话，小强肯定也不知道”，而该10组日期的
月数分别为3，6，9，12，而且都相应月的日期都有两组以上，所以小明得知M后
是不可能知道老师生日的。
3）进一步分析“小明说：如果我不知道的话，小强肯定也不知道”，结合第2步
结论，可知小强得知N后也绝不可能知道。
4）结合第3和第1步，可以推断：所有6月和12月的日期都不是老师的生日，因为
如果小明得知的M是6，而若小强的N==7，则小强就知道了老师的生日。（由第
1步已经推出），同理，如果小明的M==12，若小强的N==2，则小强同样可以知道老师的生日。即：M不等于6和12。现在只剩下“3月4日 3月5日 3月8日 9月1日
9月5日”五组日期。而小强知道了，所以N不等于5（有3月5日和9月5日），此时，
小强的N∈（1，4，8）注：此时N虽然有三种可能，但对于小强只要知道其中的
一种，就得出结论。所以有“小强说：本来我也不知道，但是现在我知道了”，
对于我们则还需要继续推理
至此，剩下的可能是“3月4日 3月8日 9月1日”
5）分析“小明说：哦，那我也知道了”，说明M==9，N==1，（N==5已经被排除，3月份的有两组

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

both Table A and Table B.
SELECT * FROM TableA FULL OUTER JOIN TableB ON TableA.name = TableB.name id name id name -- ---- -- ---- 1 Pirate 2 Pirate 2 Monkey null null 3 Ninja 4 Ninja 4 Spaghetti null null null null 1 Rutabaga null null 3 Darth Vader Full outer join produces the set of all records in Table A and Table B, with matching records from both sides where available. If there is no match, the missing side will contain null.
SELECT * FROM TableA LEFT OUTER JOIN TableB ON TableA.name = TableB.name id name id name -- ---- -- ---- 1 Pirate 2 Pirate 2 Monkey null null 3 Ninja 4 Ninja 4 Spaghetti null null Left outer join produces a complete set of records from Table A, with the matching records (where available) in Table B. If there is no match, the right side will contain null.
SELECT * FROM TableA LEFT OUTER JOIN TableB ON TableA.name = TableB.name WHERE TableB.id IS null id name id name -- ---- -- ---- 2 Monkey null null 4 Spaghetti null null To produce the set of records only in Table A, but not in Table B, we perform the same left outer join, then exclude the records we don't want from the right side via a where clause.
SELECT * FROM TableA FULL OUTER JOIN TableB ON TableA.name = TableB.name WHERE TableA.id IS null OR TableB.id IS null id name id name -- ---- -- ---- 2 Monkey null null 4 Spaghetti null null null null 1 Rutabaga null null 3 Darth Vader To produce the set of records unique to Table A and Table B, we perform the same full outer join, then exclude the records we don't want from both sides via a where clause.

There's also a cartesian product or cross join, which as far as I can tell, can't be expressed as a Venn diagram:

SELECT * FROM TableA
CROSS JOIN TableB

This joins "everything to everything", resulting in 4 x 4 = 16 rows, far more than we had in the original sets. If you do the math, you can see why this is a very dangerous join to run against large tables.

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

Animal a = new Cate();   //Animal是编译时类型，Cate是运行时类型。运行时类型得是编译时类型的子类
    引用类型      对象类型
    主观类型      客观类型

    以子类覆盖了父类的方法为前提 
    1）运行时类型不变 
    2）只能对一个引用调用其编译时类型中定义的方法
    3）运行时会根据对象的运行时类型找覆盖之后的方法
  
    Animal a = new Cate();
   Cate d = new Cate();
    a = d;      //把子类引用赋值给父类引用，是合法的
    d = (Cate)a; //把父类引用赋值给自类引用，需要强转
 
 
 父类的引用赋值给子类的引用需要强制类型转换 ，而子类的引用赋值给父类的引用不需要强制类型转换

public class Test {

	public static void main(String[] args) {

		Cat cat = new Cat();
		System.out.println("cat.CHARACTERISTIC = " + cat.CHARACTERISTIC);
		System.out.println("cat.getClass() = " + cat.getClass());
		System.out.println("cat.name = " + cat.name);
		System.out.println("cat.getName() = " + cat.getName());

		System.out.println("**********************************************");

		Animal animal = (Animal) cat;
		System.out.println("animal.CHARACTERISTIC = " + animal.CHARACTERISTIC);
		System.out.println("animal.getClass() = " + animal.getClass());
		System.out.println("animal.name = " + animal.name);
		System.out.println("animal.getName() = " + animal.getName());
	}
}

class Animal {
	public static String CHARACTERISTIC = "Can not speak.";
	public String name = "Animal";

	public String getName() {
		return name;
	}

}

class Cat extends Animal {
	public static String CHARACTERISTIC = "Can not speak. Like eat fish.";
	public String name = "Cat";

	public String getName() {
		return name;
	}
}

cat.CHARACTERISTIC = Can not speak. Like eat fish.
cat.getClass() = class Cat
cat.name = Cat
cat.getName() = Cat
**********************************************
animal.CHARACTERISTIC = Can not speak.
animal.getClass() = class Cat
animal.name = Animal
animal.getName() = Cat

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱