N年前，刚刚毕业不久，去网秦面试过，那时候的笔试题，我面试回来后把面试题和我的解法都记录下来了，最近整理笔记发现的，就发出来，纪念一下吧。

1，单例模式的介绍和示例。

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界 访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

package singleton;
/**
 * @author lei
 * 单例模式的五种写法：
 * 1、懒汉
 * 2、恶汉
 * 3、静态内部类
 * 4、枚举
 * 5、双重校验锁
 * 2011-9-6
 */
/**
 *五、 双重校验锁，在当前的内存模型中无效
 */
class LockSingleton{
 private volatile static LockSingleton singleton;
 private LockSingleton(){}
 
 //详见：http://www.ibm.com/developerworks/cn/java/j-dcl.html
 public static LockSingleton getInstance(){
  if(singleton==null){
   synchronized(LockSingleton.class){
    if(singleton==null){
     singleton=new LockSingleton();
    }
   }
  }
  return singleton;
 }
 
}
/**
 * 四、枚举，《Effective Java》作者推荐使用的方法，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
 */
enum EnumSingleton{
 INSTANCE;
 public void doSomeThing(){
 }
}
/**
 * 三、静态内部类 优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading
 */
class InternalSingleton{
 private static class SingletonHolder{
  private final static InternalSingleton INSTANCE=new InternalSingleton();
 }
 private InternalSingleton(){}
 public static InternalSingleton getInstance(){
  return SingletonHolder.INSTANCE;
 }
}
/**
 * 二、恶汉,缺点：没有达到lazy loading的效果
 */
class HungrySingleton{
 private static HungrySingleton singleton=new HungrySingleton();
 private HungrySingleton(){}
 public static HungrySingleton getInstance(){
  return singleton;
 }
}
/**
 * 一、懒汉，常用的写法
 */
class LazySingleton{
 private static LazySingleton singleton;
 private LazySingleton(){
 }
 public static LazySingleton getInstance(){
  if(singleton==null){
   singleton=new LazySingleton();
  }
  return singleton;
 }
}

2，外观设计模式的简介，用处和示例代码。

外观模式是软件工程中常用的一种软件设计模式。它为子系统中的一组接口提供一个统一的高层接口。这一接口使得子系统更加容易使用。

/**
*外观设计模式
*即为调用模块提供一个本模块的外观类
*改类中组合了调用者需要的功能
*@authorhm
*
*/
publicclassFacedTest{
 publicstaticvoidmain(String[]args){
  newFaced().generator();
 }
}
/**
*第一个模块接口
*/
interfaceA{
 publicvoida();
}
/**
*第二个模块接口
*/
interfaceB{
 publicvoidb();
}
/**
*第三个模块接口
*/
interfaceC{
 publicvoidc();
}
/*第一个模块接口的实现*/
classAImplimplementsA{
 @Override
 publicvoida(){
  System.out.println("a");
 }
}
/*第二个模块接口的实现*/
classBImplimplementsB{
 @Override
 publicvoidb(){
  System.out.println("b");
 }
}
/*第三个模块接口的实现*/
classCImplimplementsC{
 @Override
 publicvoidc(){
  System.out.println("c");
 }
}
/**
*定义一个外观类
*/
classFaced{
 publicvoidgenerator(){
  newAImpl().a();
  newBImpl().b();
  newCImpl().c();
 }
}

3，线程通信问题：一个线程打印1~52，一个线程打印A~Z，打印结果如12A34B56C......Z。

/**
 * <写两个线程，一个线程打印1-52，另一个线程打印字母A-Z。打印 顺序为12A34B56C……5152Z>
 * 
 * @author snowday88
 */
public class ThreadDemo
{
    // 测试
    public static void main(String[] args) throws Exception
    {
        Object obj = new Object();
        // 启动两个线程
        Thread1 t1 = new Thread1(obj);
        
        Thread2 t2 = new Thread2(obj);
        
        t1.start();
        t2.start();
    }
    
}
// 一个线程打印1-52
class Thread1 extends Thread
{
    private Object obj;
    
    public Thread1(Object obj)
    {
        this.obj = obj;
    }
    
    public void run()
    {
        synchronized (obj)
        {
            // 打印1-52
            for (int i = 1; i < 53; i++)
            {
                System.out.print(i + " ");
                if (i % 2 == 0)
                {
                    // 不能忘了 唤醒其它线程
                    obj.notifyAll();
                    try
                    {
                        obj.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
        
    }
    
}
// 另一个线程打印字母A-Z
class Thread2 extends Thread
{
    private Object obj;
    
    public Thread2(Object obj)
    {
        this.obj = obj;
    }
    
    public void run()
    {
        synchronized (obj)
        {
            // 打印A-Z
            for (int i = 0; i < 26; i++)
            {
                System.out.print((char)('A' + i) + " ");
                // 不能忘了 唤醒其它线程
                obj.notifyAll();
                try
                {
                    // 最后一个就不要等了
                    if (i != 25)
                    {
                        obj.wait();
                    }
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                
            }
            
        }
    }
    
}

另一个方法：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 线程通信问题：一个线程打印1~52，一个线程打印A~Z，打印结果如12A34B56C......Z。
 * **/
public class ConditonDemo {
    public static ReentrantLock lock = new ReentrantLock(false);
    public static Condition condition = lock.newCondition();
    public static void main(String[] args) {
        new Thread(new PrintChar()).start();
        new Thread(new PrintNum()).start();
    }
}
class PrintNum implements Runnable {
    public void run() {
        ConditonDemo.lock.lock();
        try {
             for (int i = 0; i <= 26; i++) {
                if (i == 26) {
                    System.out.println("=====");
                    ConditonDemo.condition.signalAll();
                    return;
                } else {
                    System.out.println(i);
                }
                ConditonDemo.condition.signalAll();
                ConditonDemo.condition.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            ConditonDemo.lock.unlock();
        }
    }
}
class PrintChar implements Runnable {
    public void run() {
        ConditonDemo.lock.lock();
        try {
             for (int i = 0; i <= 26; i++) {
                if (i == 26) {
                    System.out.println("++++++");
                    ConditonDemo.condition.signalAll();
                    return;
                } else {
                    System.out.println((char)('A' + i) + " ");
                }
                ConditonDemo.condition.signalAll();
                ConditonDemo.condition.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            ConditonDemo.lock.unlock();
        }
    }
}

4，输入正整数1234输出4321，写一个函数。

public class NiInt {
 public static void main(String[] args) {
  System.out.println(ni(234567));
 }
  public static int ni(int num){
   String tmp=""+num;
   StringBuffer sBuffer=new StringBuffer(tmp);
   return Integer.parseInt(sBuffer.reverse().toString());
  }
}