JAVA学习随笔记录

1）静态修饰符，什么叫静态修饰符呢？大家都知道，在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，也就是只要程序在运行，那么这块内存就会一直存在。这样做有什么意义呢？ 
在Java程序里面，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用他的成员，那么普通情况下必须先实例化对象后，通过对象的引用才能够访问这些成员，但是有种情况例外，就是该成员是用static声明的（在这里所讲排除了类的访问控制），例如： 
未声明为static 
class ClassA{ 
int b; 
public void ex1(){ 
… 
} 
} 
class ClassB{ 
void ex2{ 
int i; 
ClassA a = new ClassA(); 
i = a.b; //这里通过对象引用访问成员变量b 
a.ex1; //这里通过对象引用访问成员函数ex1 
} 
} 

声明为static 
class ClassA{ 
static int b; 
static void ex1(){ 
… 
} 
} 
class ClassB{ 
void ex2{ 
int i; 
i = ClassA.b; //这里通过类名访问成员变量b 
ClassA.ex1; //这里通过类名访问成员函数ex1 
} 
} 
通过以上两种比较，就可以知道static用来修饰类成员的主要作用了，在java类库当中有很多类成员都声明为static，可以让用户不需要实例化对象就可以引用成员，最基本的有Integer.parseInt()，Float.parseFloat()等等用来把对象转换为所需要的基本数据类型。这样的变量和方法我们又叫做类变量和类方法。 
接下来讲一下被static修饰后的变量的值的问题，刚才在前面讲过，被static修饰后的成员，在编译时由内存分配一块内存空间，直到程序停止运行才会释放，那么就是说该类的所有对象都会共享这块内存空间，看一下下面这个例子： 
class TStatic{ 
static int i; 

public TStatic(){ 
i = 4; 
} 

public TStatic(int j){ 
i = j; 
} 

public static void main(String args[]){ 
TStatic t = new TStatic(5); //声明对象引用，并实例化 
TStatic tt = new TStatic(); //同上 
System.out.println(t.i); 
System.out.println(tt.i); 
System.out.println(t.i); 
} 
} 
这段代码里面Tstatic类有一个static的int变量I，有两个构造函数，第一个用于初始化I为4，第二个用于初始化i为传进函数的值，在main中所传的值是5，程序首先声明对象的引用t，然后调用带参数的构造函数实例化对象，此时对象t的成员变量I的值为5，接着声明对象tt，调用无参数的构造函数，那么就把对象tt的成员变量i的值初始化为4了，注意了，在这里i是static，那就是说该类的所有对象都共享该内存，那也就是说在实例化对象tt的时候改变了i的值，那么实际上对象t的i值也变了，因为实际上他们引用的是同一个成员变量。最后打印的结果是三个4

2)封装，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。

使用封装有三大好处：
          1、良好的封装能够减少耦合。
           2、类内部的结构可以自由修改。
          3、可以对成员进行更精确的控制。在封装的实体里控制变量的返回，超出这个范围报错
          4、隐藏信息，实现细节
就是框架中常用的实体类对象，利用get和 set去获取或者修改数据
3）继承，继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大大的提高开发的效率。

   1、子类拥有父类非private的属性和方法。
          2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
         3、子类可以用自己的方式实现父类的方法。（以后介绍）

4）多态，
一个方法名，参数不同，这叫方法重载。(Overload)
void foo(String str);void foo(int number);
父类与子类有同样的方法名和参数，这叫方法覆盖。(Override)
class Parent {    void foo() {        System.out.println("Parent foo()");    }}class Child extends Parent {    void foo() {        System.out.println("Child foo()");    }}
父类引用指向子类对象，调用方法时会调用子类的实现，而不是父类的实现，这叫多态。
Parent instance = new Child();instance.foo(); //==> Child foo()
我理解的多态与继承体系有关，与方法覆盖有关，与方法重载无关。


作者：Intopass
链接：https://www.zhihu.com/question/30082151/answer/46688599
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
作者：程序狗
链接：https://www.zhihu.com/question/30082151/answer/120520568
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

用一句话概括就是：事物在运行过程中存在不同的状态。先以教科书般举例说明,下文再举一个花木兰替父从军的例子帮助大家理解.   多态的存在有三个前提:
1.要有继承关系
2.子类要重写父类的方法
3.父类引用指向子类对,
但是其中又有很多细节需要注意。首先我们定义两个类，一个父类Animal，一个子类Cat。
父类Animal
class Animal {int num = 10;static int age = 20;public void eat() {System.out.println("动物吃饭");}public static void sleep() {System.out.println("动物在睡觉");}public void run(){System.out.println("动物在奔跑");}}

子类Cat
class Cat extends Animal {int num = 80;static int age = 90;        String name = "tomCat";public void eat() {System.out.println("猫吃饭");}public static void sleep() {System.out.println("猫在睡觉");}public void catchMouse() {System.out.println("猫在抓老鼠");}}
测试类Demo_Test1
class Demo_Test1 {public static void main(String[] args) {Animal am = new Cat();am.eat();am.sleep();am.run();//am.catchMouse();这里先注释掉，等会会说明        //System.out.println(am.name);//这里先注释，待会说明System.out.println(am.num);System.out.println(am.age);}}
以上的三段代码充分体现了多态的三个前提，即：
1、存在继承关系
Cat类继承了Animal类
2、子类要重写父类的方法
子类重写(override)了父类的两个成员方法eat()，sleep()。其中eat()是非静态的，sleep()是静态的（static）。
3、父类数据类型的引用指向子类对象。
测试类Demo_Test1中 Animal am = new Cat();语句在堆内存中开辟了子类(Cat)的对象，并把栈内存中的父类(Animal)的引用指向了这个Cat对象。
到此，满足了Java多态的的必要三个前提。
---------------------------------------------------华丽的分割线----------------------------------------------------------------------
如果再深究一点呢，我们可以看看上面测试类的输出结果，或许对多态会有更深层次的认识。猜一猜上面的结果是什么。
<img src="https://pic4.zhimg.com/50/521db7a41065f92441a95b0ff294e707_hd.png" data-rawwidth="671" data-rawheight="133" class="origin_image zh-lightbox-thumb" width="671" data-original="https://pic4.zhimg.com/521db7a41065f92441a95b0ff294e707_r.png">可以看出来可以看出来
子类Cat重写了父类Animal的非静态成员方法am.eat();的输出结果为：猫吃饭。
子类重写了父类(Animal)的静态成员方法am.sleep();的输出结果为：动物在睡觉
未被子类（Cat）重写的父类（Animal）方法am.run()输出结果为：动物在奔跑
System.out.println(am.num);//输出结果为10System.out.println(am.age);//输出结果为20
那么我们可以根据以上情况总结出多态成员访问的特点：
成员变量
编译看左边(父类),运行看左边(父类)
成员方法
编译看左边(父类)，运行看右边(子类)。动态绑定
静态方法
编译看左边(父类)，运行看左边(父类)。
(静态和类相关，算不上重写，所以，访问还是左边的)
只有非静态的成员方法,编译看左边,运行看右边 
---------------------------------------------------华丽的分割线----------------------------------------------------------------------
那么多态有什么弊端呢？有的，即多态后不能使用子类特有的属性和方法。往上面的代码看，子类Cat有一个特有的属性String name = "tomCat"; 并且还有一个特有的抓老鼠的方法catchMouse()。但是在测试类（Demo_Test）中，我们尝试调用子类特有的方法catchMouse()和打印子类特有的成员属性String name = "tomCat"; 就会报错。
am.catchMouse();System.out.println(am.name);
<img src="https://pic3.zhimg.com/50/a44f349a4179695f223c683d4eddb8a6_hd.png" data-rawwidth="302" data-rawheight="223" class="content_image" width="302">原因就是多态的弊端，就是：不能使用子类特有的成员属性和子类特有的成员方法。
--------------------------------------------------华丽的分割线----------------------------------------------------------------------
如果在代码执行过程中还想使用Cat类中特有的属性String name和它特有的成员方法catchMouse()了怎么办呢？那我们就可以把这个父类引用指向了子类对象的家伙am再强制变回Cat类型。这样am就是Cat类型的引用了，指向的也是Cat对象了，自然也能使用Cat类的一切属性和一切的成员方法。
class Demo_Test {public static void main(String[] args) {Animal am = new Cat();am.eat();am.sleep();am.run();//am.catchMouse();//System.out.println(am.name);System.out.println(am.num);System.out.println(am.age);System.out.println("------------------------------");Cat ct = (Cat)am;ct.eat();ct.sleep();ct.run();ct.catchMouse();}        }
<img src="https://pic3.zhimg.com/50/b224f6fa488db52088f02d500677448a_hd.png" data-rawwidth="677" data-rawheight="234" class="origin_image zh-lightbox-thumb" width="677" data-original="https://pic3.zhimg.com/b224f6fa488db52088f02d500677448a_r.png">很明显，执行强转语句Cat ct = (Cat)am;之后，ct就指向最开始在堆内存中创建的那个Cat类型的对象了。这就是多态的魅力吧，虽然它有缺点，但是它确实十分灵活，减少多余对象的创建，不用说为了使用子类的某个方法又去重新再堆内存中开辟一个新的子类对象。以上。。很明显，执行强转语句Cat ct = (Cat)am;之后，ct就指向最开始在堆内存中创建的那个Cat类型的对象了。这就是多态的魅力吧，虽然它有缺点，但是它确实十分灵活，减少多余对象的创建，不用说为了使用子类的某个方法又去重新再堆内存中开辟一个新的子类对象。以上。。
----------------------------------------------------------分割线------------------------------------------------------------------------
啦啦啦,收到这么多赞.很惊讶,举个通俗点的例子吧.
花木兰替父从军
大家都知道花木兰替父从军的例子，花木兰替父亲花弧从军。那么这时候花木兰是子类，花弧是父类。花弧有自己的成员属性年龄，姓名，性别。花木兰也有这些属性，但是很明显二者的属性完全不一样。花弧有自己的非静态成员方法‘骑马杀敌’，同样花木兰也遗传了父亲一样的方法‘骑马杀敌’。花弧还有一个静态方法‘自我介绍’，每个人都可以问花弧姓甚名谁。同时花木兰还有一个自己特有的非静态成员方法‘涂脂抹粉’。但是，现在花木兰替父从军，女扮男装。这时候相当于父类的引用（花弧这个名字）指向了子类对象（花木兰这个人），那么在其他类（其他的人）中访问子类对象（花木兰这个人）的成员属性（姓名，年龄，性别）时，其实看到的都是花木兰她父亲的名字（花弧）、年龄（60岁）、性别（男）。当访问子类对象（花木兰这个人）的非静态成员方法（骑马打仗）时，其实都是看到花木兰自己运用十八般武艺在骑马打仗。当访问花木兰的静态方法时（自我介绍），花木兰自己都是用她父亲的名字信息在向别人作自我介绍。并且这时候花木兰不能使用自己特有的成员方法‘涂脂抹粉’。-----多态中的向上转型
   那么终于一将功成万骨枯，打仗旗开得胜了，花木兰告别了战争生活。有一天，遇到了自己心爱的男人，这时候爱情的力量将父类对象的引用（花弧这个名字）强制转换为子类对象本来的引用（花木兰这个名字），那么花木兰又从新成为了她自己，这时候她完全是她自己了。名字是花木兰，年龄是28，性别是女，打仗依然那样生猛女汉子，自我介绍则堂堂正正地告诉别人我叫花木兰。OMG！终于，终于可以使用自己特有的成员方法‘涂脂抹粉’了。从此，花木兰完全回到了替父从军前的那个花木兰了。并且和自己心爱的男人幸福的过完了一生。-----多态中的向下转型
----------------------------------------------------------华丽的分割线---------------------------------------------------------------
大家记得哈，向上转型向下转型一定是在多态这个前提下哈，否则强制将女儿变成父亲，或者将父亲变成女人，就变成东方不败了，系统此时就会报错非法类型转换。哈哈哈哈哈。另外开发中一般是利用多态声明形式参数，并将创建子类的匿名对象作为实际参数。以上。
5）抽象方法需要子类重写，而静态的方法是无法被重写的。
6）一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开类的类名完全保持一致。
7）一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。
8）Java 中的final关键字有哪些用法？ 
(1)修饰类：表示该类不能被继承；(2)修饰方法：表示方法不能被重写；(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
9）String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");
10）列出一些你常见的运行时异常？ 
- ArithmeticException（算术异常） 
- ClassCastException （类转换异常） 
- IllegalArgumentException （非法参数异常） 
- IndexOutOfBoundsException （下标越界异常） 
- NullPointerException （空指针异常） 
- SecurityException （安全异常）
11）Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别? 
答：sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态，请参考第66题中的线程状态转换图）。wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。
12）请说出与线程同步以及线程调度相关的方法。 
- wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁； 
- sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常； 
- notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关； 
- notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；
提示：关于Java多线程和并发编程的问题，建议大家看我的另一篇文章《关于Java并发编程的总结和思考》。
补充：Java 5通过Lock接口提供了显式的锁机制（explicit lock），增强了灵活性以及对线程的协调。Lock接口中定义了加锁（lock()）和解锁（unlock()）的方法，同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象；此外，Java 5还提供了信号量机制（semaphore），信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前，线程必须得到信号量的许可（调用Semaphore对象的acquire()方法）；在完成对资源的访问后，线程必须向信号量归还许可（调用Semaphore对象的release()方法）。
下面的例子演示了100个线程同时向一个银行账户中存入1元钱，在没有使用同步机制和使用同步机制情况下的执行情况。
银行账户类：
/** * 银行账户 * @author 骆昊 * */public class Account {    private double balance;     // 账户余额    /**     * 存款     * @param money 存入金额     */    public void deposit(double money) {        double newBalance = balance + money;        try {            Thread.sleep(10);   // 模拟此业务需要一段处理时间        }        catch(InterruptedException ex) {            ex.printStackTrace();        }        balance = newBalance;    }    /**     * 获得账户余额     */    public double getBalance() {        return balance;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
存钱线程类：
/** * 存钱线程 * @author 骆昊 * */public class AddMoneyThread implements Runnable {    private Account account;    // 存入账户    private double money;       // 存入金额    public AddMoneyThread(Account account, double money) {        this.account = account;        this.money = money;    }    @Override    public void run() {        account.deposit(money);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
测试类：
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class Test01 {    public static void main(String[] args) {        Account account = new Account();        ExecutorService service = Executors.newFixedThreadPool(100);        for(int i = 1; i <= 100; i++) {            service.execute(new AddMoneyThread(account, 1));        }        service.shutdown();        while(!service.isTerminated()) {}        System.out.println("账户余额: " + account.getBalance());    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
在没有同步的情况下，执行结果通常是显示账户余额在10元以下，出现这种状况的原因是，当一个线程A试图存入1元的时候，另外一个线程B也能够进入存款的方法中，线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额，因此也是在原来的余额0上面做了加1元的操作，同理线程C也会做类似的事情，所以最后100个线程执行结束时，本来期望账户余额为100元，但实际得到的通常在10元以下（很可能是1元哦）。解决这个问题的办法就是同步，当一个线程对银行账户存钱时，需要将此账户锁定，待其操作完成后才允许其他的线程进行操作，代码有如下几种调整方案：
在银行账户的存款（deposit）方法上同步（synchronized）关键字
/** * 银行账户 * @author 骆昊 * */public class Account {    private double balance;     // 账户余额    /**     * 存款     * @param money 存入金额     */    public synchronized void deposit(double money) {        double newBalance = balance + money;        try {            Thread.sleep(10);   // 模拟此业务需要一段处理时间        }        catch(InterruptedException ex) {            ex.printStackTrace();        }        balance = newBalance;    }    /**     * 获得账户余额     */    public double getBalance() {        return balance;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
在线程调用存款方法时对银行账户进行同步
/** * 存钱线程 * @author 骆昊 * */public class AddMoneyThread implements Runnable {    private Account account;    // 存入账户    private double money;       // 存入金额    public AddMoneyThread(Account account, double money) {        this.account = account;        this.money = money;    }    @Override    public void run() {        synchronized (account) {            account.deposit(money);         }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
通过Java 5显示的锁机制，为每个银行账户创建一个锁对象，在存款操作进行加锁和解锁的操作
import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * 银行账户 *  * @author 骆昊 * */public class Account {    private Lock accountLock = new ReentrantLock();    private double balance; // 账户余额    /**     * 存款     *      * @param money     *            存入金额     */    public void deposit(double money) {        accountLock.lock();        try {            double newBalance = balance + money;            try {                Thread.sleep(10); // 模拟此业务需要一段处理时间            }            catch (InterruptedException ex) {                ex.printStackTrace();            }            balance = newBalance;        }        finally {            accountLock.unlock();        }    }    /**     * 获得账户余额     */    public double getBalance() {        return balance;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
按照上述三种方式对代码进行修改后，重写执行测试代码Test01，将看到最终的账户余额为100元。当然也可以使用Semaphore或CountdownLatch来实现同步。
13）阐述JDBC操作数据库的步骤。 
下面的代码以连接本机的Oracle数据库为例，演示JDBC操作数据库的步骤。
加载驱动。
    Class.forName("oracle.jdbc.driver.OracleDriver");
1
创建连接。
    Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
1
创建语句。
    PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");    ps.setInt(1, 1000);    ps.setInt(2, 3000);
1
2
3
执行语句。
    ResultSet rs = ps.executeQuery();
1
处理结果。
    while(rs.next()) {        System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));    }
1
2
3
关闭资源。
    finally {        if(con != null) {            try {                con.close();            } catch (SQLException e) {                e.printStackTrace();            }        }    }
1
2
3
4
5
6
7
8
9
提示：关闭外部资源的顺序应该和打开的顺序相反，也就是说先关闭ResultSet、再关闭Statement、在关闭Connection。上面的代码只关闭了Connection（连接），虽然通常情况下在关闭连接时，连接上创建的语句和打开的游标也会关闭，但不能保证总是如此，因此应该按照刚才说的顺序分别关闭。此外，第一步加载驱动在JDBC 4.0中是可以省略的（自动从类路径中加载驱动），但是我们建议保留。
14）简述一下你了解的设计模式。 
所谓设计模式，就是一套被反复使用的代码设计经验的总结（情境中一个问题经过证实的一个解决方案）。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式使人们可以更加简单方便的复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。 
在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中给出了三类（创建型[对类的实例化过程的抽象化]、结构型[描述如何将类或对象结合在一起形成更大的结构]、行为型[对在不同的对象之间划分责任和算法的抽象化]）共23种设计模式，包括：Abstract Factory（抽象工厂模式），Builder（建造者模式），Factory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式）；Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式），Composite（合成模式），Decorator（装饰模式），Flyweight（享元模式），Proxy（代理模式）；Command（命令模式），Interpreter（解释器模式），Visitor（访问者模式），Iterator（迭代子模式），Mediator（调停者模式），Memento（备忘录模式），Observer（观察者模式），State（状态模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibility（责任链模式）。 
面试被问到关于设计模式的知识时，可以拣最常用的作答，例如： 
- 工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作（多态方法）。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。 
- 代理模式：给一个对象提供一个代理对象，并由代理对象控制原对象的引用。实际开发中，按照使用目的的不同，代理可以分为：远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。 
- 适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作。 
- 模板方法模式：提供一个抽象类，将部分逻辑以具体方法或构造器的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法（多态实现），从而实现不同的业务逻辑。 
除此之外，还可以讲讲上面提到的门面模式、桥梁模式、单例模式、装潢模式（Collections工具类和I/O系统中都使用装潢模式）等，反正基本原则就是拣自己最熟悉的、用得最多的作答，以免言多必失。
91、用Java写一个单例类。 
答： 
- 饿汉式单例
public class Singleton {    private Singleton(){}    private static Singleton instance = new Singleton();    public static Singleton getInstance(){        return instance;    }}
1
2
3
4
5
6
7
懒汉式单例
public class Singleton {    private static Singleton instance = null;    private Singleton() {}    public static synchronized Singleton getInstance(){        if (instance == null) instance ＝ new Singleton();        return instance;    }}
1
2
3
4
5
6
7
8
注意：实现一个单例有两点注意事项，①将构造器私有，不允许外界通过构造器创建对象；②通过公开的静态方法向外界返回类的唯一实例。这里有一个问题可以思考：Spring的IoC容器可以为普通的类创建单例，它是怎么做到的呢？
15）用Java写一个冒泡排序。 
冒泡排序几乎是个程序员都写得出来，但是面试的时候如何写一个逼格高的冒泡排序却不是每个人都能做到，下面提供一个参考代码：
import java.util.Comparator;/** * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换) * @author骆昊 * */public interface Sorter {   /**    * 排序    * @param list 待排序的数组    */   public <T extends Comparable<T>> void sort(T[] list);   /**    * 排序    * @param list 待排序的数组    * @param comp 比较两个对象的比较器    */   public <T> void sort(T[] list, Comparator<T> comp);}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Comparator;/** * 冒泡排序 *  * @author骆昊 * */public class BubbleSorter implements Sorter {    @Override    public <T extends Comparable<T>> void sort(T[] list) {        boolean swapped = true;        for (int i = 1, len = list.length; i < len && swapped; ++i) {            swapped = false;            for (int j = 0; j < len - i; ++j) {                if (list[j].compareTo(list[j + 1]) > 0) {                    T temp = list[j];                    list[j] = list[j + 1];                    list[j + 1] = temp;                    swapped = true;                }            }        }    }    @Override    public <T> void sort(T[] list, Comparator<T> comp) {        boolean swapped = true;        for (int i = 1, len = list.length; i < len && swapped; ++i) {            swapped = false;            for (int j = 0; j < len - i; ++j) {                if (comp.compare(list[j], list[j + 1]) > 0) {                    T temp = list[j];                    list[j] = list[j + 1];                    list[j + 1] = temp;                    swapped = true;                }            }        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
95、用Java写一个折半查找。 
答：折半查找，也称二分查找、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组已经为空，则表示找不到指定的元素。这种搜索算法每一次比较都使搜索范围缩小一半，其时间复杂度是O(logN)。
import java.util.Comparator;public class MyUtil {   public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {      return binarySearch(x, 0, x.length- 1, key);   }   // 使用循环实现的二分查找   public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {      int low = 0;      int high = x.length - 1;      while (low <= high) {          int mid = (low + high) >>> 1;          int cmp = comp.compare(x[mid], key);          if (cmp < 0) {            low= mid + 1;          }          else if (cmp > 0) {            high= mid - 1;          }          else {            return mid;          }      }      return -1;   }   // 使用递归实现的二分查找   private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {      if(low <= high) {        int mid = low + ((high -low) >> 1);        if(key.compareTo(x[mid])== 0) {           return mid;        }        else if(key.compareTo(x[mid])< 0) {           return binarySearch(x,low, mid - 1, key);        }        else {           return binarySearch(x,mid + 1, high, key);        }      }      return -1;   }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
说明：上面的代码中给出了折半查找的两个版本，一个用递归实现，一个用循环实现。需要注意的是计算中间位置时不应该使用(high+ low) / 2的方式，因为加法运算可能导致整数越界，这里应该使用以下三种方式之一：low + (high - low) / 2或low + (high – low) >> 1或(low + high) >>> 1（>>>是逻辑右移，是不带符号位的右移）

构造方法不能被继承，也不能被重写，可以重载。

接口和抽象类有什么区别
你选择使用接口和抽象类的依据是什么？

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。
 http://hovertree.com/h/bjaf/to3l3tjm.htm
总结几句话来说：
1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。
 
1.抽象类 和 接口 都是用来抽象具体对象的. 但是接口的抽象级别最高2.抽象类可以有具体的方法 和属性,  接口只能有抽象方法和不可变常量3.抽象类主要用来抽象类别,接口主要用来抽象功能.
4、抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。

 
当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
 
抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的
所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。
 
接口的使用
 
接口：interface
在PHP中，我们可以规定，一个对象应该具有哪些公共的外部操作，即可使用interface来规定。
公共的方法就是接口。用于规定一个对象应该用于哪些公共的操作方法（接口），这个也叫接口（公共操作方法的集合）
即：接口（interface结构，公共方法集合）
公共方法（接口方法）
定义：用于限定某个对象所必须拥有的公共操作方法的一种结构，称之为接口（interface）
语法：定义接口结构，使用interface关键字。接口内定义的都是一些公共方法。
 
注意：
1.接口方法，访问权限必须是公共的 public
2.接口内只能有公共方法，不能存在成员变量
3.接口内只能含有未被实现的方法，也叫抽象方法，但是不用abstract关键字。
类实现接口，利用关键字implements完成。
 
 
这样，实现该接口的类，必须实现接口内所有的抽象方法。而且可以肯定，该方法一定是公共的外部操作方法。
多实现：该功能，在理论上可以通过抽象类来实现，但是抽象类，不专业。
使用接口则专业些，实现上，因为php支持多实现，而仅支持单继承。
php对象接口的支持，可以定义类常量，接口之间也可以继承
 
 
抽象方法和抽象类
在OOP 语言中，一个类可以有一个或多个子类，而每个类都有至少一个公有方法做为 
外部代码访问其的接口。而抽象方法就是为了方便继承而引入的，我们先来看一下抽象类和 
抽象方法的定义再说明它的用途。 
什么是抽象方法？我们在类里面定义的没有方法体的方法就是抽象方法，所谓的没有方 
法体指的是，在方法声明的时候没有大括号以及其中的内容，而是直接在声明时在方法名后 
加上分号结束，另外在声明抽象方法时还要加一个关键字“abstract”来修饰； 
例如： 
abstract function fun1(); 
abstract function fun2(); 
上例是就是“abstract”修饰的没有方法体的抽象方法“fun1()”和“fun2()”，不要忘记 
抽象方法后面还要有一个分号；那么什么是抽象类呢？只要一个类里面有一个方法是抽象方 
法，那么这个类就要定义为抽象类，抽象类也要使用“abstract”关键字来修饰；在抽象类里 
面可以有不是抽象的方法和成员属性，但只要有一个方法是抽象的方法，这个类就必须声明 
为抽象类，使用“abstract”来修饰。
 http://hovertree.com/menu/php/
上例中定义了一个抽象类“Demo”使用了“abstract”来修饰，在这个类里面定义了一 
个成员属性“$test”，和两个抽象方法“fun1”和“fun2”还有一个非抽象的方法fun3()；那 
么抽象类我们怎么使用呢？最重要的一点就是抽象类不能产生实例对象，所以也不能直接使 
用，前面我们多次提到过类不能直接使用，我们使用的是通过类实例化出来的对象，那么抽 
象类不能产生实例对象我们声明抽象类有什么用呢？我们是将抽象方法是做为子类重载的模 
板使用的，定义抽象类就相当于定义了一种规范，这种规范要求子类去遵守，子类继函抽象 
类之后，把抽象类里面的抽象方法按照子类的需要实现。子类必须把父类中的抽象方法全部 
都实现，否则子类中还存在抽象方法，那么子类还是抽象类，还是不能实例化对；为什么我 
们非要从抽象类中继承呢？因为有的时候我们要实现一些功能就必须从抽象类中继承，否则 
这些功能你就实现不了，如果继承了抽象类，就要实现类其中的抽象方法；