java面试

1. == 和equals

（1）== 既可以比较基本类型，也可以比较引用类型（引用类型比较地址），new 出来的两个对象地址是不相等的。
（2）equals 是Object类的方法， 看是否被复写过，如果没有被复写过equals 就是== ，源代码149 行return (this==obj)；
如果被复写过，要看具体的规则。（equals 复写时，也要同时复写hashcode）

 2.String

题目1

public class TestString {
    public static void main(String[] args) {
        String s1=new String("abc");
        String s2="abc";
        String s3=new String("abc");
        System.out.println(s1==s2); //false
        System.out.println(s1==s3); //false
        System.out.println(s2==s3); //false

    }
}

String s1=new String("abc"); 先常量池abc ,堆里面new String("abc") ,s1 引用

String s2="abc"; 直接到常量池中获取，并建立引用 s2指向常量池中abc

String s3=new String("abc");  // new 中 的abc值可以直接复用常量池中的abc, new String("abc") 需要在堆里创建一个对象，然后s3 指向新创建的对象

 题目2：

public class TestString {
    public static void main(String[] args) {
        String s1=new String("abc");
        String s2="abc";
        String s3=new String("abc");
        System.out.println(s1==s2); //false
        System.out.println(s1==s3); //false
        System.out.println(s2==s3); //false

        System.out.println("==============");
        // intern 直接去常量池中找,看图
        System.out.println(s1==s1.intern());// fasle
        System.out.println(s2==s2.intern());// true
        System.out.println(s1.intern()==s2.intern()); // true

    }
}

 题目3：

常量找池，加变量找堆

public class TestString {
    public static void main(String[] args) {
        String s1=new String("abc");
        String s2="abc";
        String s3=new String("abc");
        System.out.println(s1==s2); //false
        System.out.println(s1==s3); //false
        System.out.println(s2==s3); //false

        System.out.println("==============");
        // intern 直接去常量池中找,看图
        System.out.println(s1==s1.intern());// fasle
        System.out.println(s2==s2.intern());// true
        System.out.println(s1.intern()==s2.intern()); // true

        //
        String s4= "java";
        String s5= "ja";
        String s6 ="va";
        System.out.println("==============");
        System.out.println(s4=="java");// ture
        System.out.println(s4==(s5+s6)); // false
        System.out.println(s4=="ja"+s6); // false
        System.out.println(s4=="ja"+"va"); // true

    }
}

 3. java 类加载机制

多态是运行时行为。

类加载顺序：从父到子，静态先行，普通代码块优于构造方法。

class Father{
    //构造方法
    public Father(){
        System.out.println("11111");
    }
    //普通代码块
    {
        System.out.println("22222");
    }
    // 静态代码块 静态代码块只加载一次
    static {
        System.out.println("33333");
    }
}
class Son extends Father{
    // 构造方法
    public Son(){
        System.out.println("44444");
    }
    // 普通代码块
    {
        System.out.println("55555");
    }
    // 静态代码块 静态代码块只加载一次
    static {
        System.out.println("66666");
    }

}
public class Test {
    public static void main(String[] args) {
        System.out.println("===============1===================");
        //第一次：
        Son son1 = new Son();
        /*
        * 运行后的执行顺序和结果：
        * 33333 # 先Father 中的静态代码块
        * 66666 # #再Son中的静态代码块
        * 22222 # Father 中的普通代码块
        * 11111 # Father 构造方法中的代码
        * 55555 # Son中的普通代码块
        * 44444 # Son 构造方法中的代码
        * 口诀：从父到子，静态先行，普通代码块由于构造方法中的代码块。
        *
        *
        * */
        System.out.println("===============2===================");
        //第二次：
        Son son2 = new Son();

        System.out.println("===============3===================");
        //第3次：
        Father father = new Father();

    }

}

运行以上代码的结果：

 4. JUC  java 线程

编写线程工程代码思维方式
* 1. 线程  操作  资源类
* 2. 高内聚 + 低耦合

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 资源类
class Ticket
{
    private int number=30; // 模拟票数
    private Lock lock = new ReentrantLock();
    public void sale(){
        lock.lock();
        try{
            if (number>0) {
                System.out.println(Thread.currentThread().getName() + "	卖出第:" + (number--) + "	还剩下:" + number);
//                Thread.sleep(4);
            }

        }catch (Exception e){

        }finally {
            lock.unlock();
        }

    }

}
/*编写线程工程代码思维方式
java 7 
* 1. 线程  操作  资源类
* 2. 高内聚 + 低耦合
* */
public class ThredDemo {
    public static void main(String[] args) throws InterruptedException {

        Ticket ticket = new Ticket();
        // 匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=1;i<=40;i++){
                    ticket.sale();
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=1;i<=40;i++){
                    ticket.sale();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=1;i<=40;i++){
                    ticket.sale();
                }
            }
        },"C").start();

        //

    }
}

 JAVA 8 lamada 表达式：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 资源类
class Ticket
{
    private int number=30; // 模拟票数
    private Lock lock = new ReentrantLock();
    public void sale(){
        lock.lock();
        try{
            if (number>0) {
                System.out.println(Thread.currentThread().getName() + "	卖出第:" + (number--) + "	还剩下:" + number);
//                Thread.sleep(4);
            }

        }catch (Exception e){

        }finally {
            lock.unlock();
        }

    }

}
/*编写线程工程代码思维方式
java 7
* 1. 线程  操作  资源类
* 2. 高内聚 + 低耦合
* */
public class ThredDemo {
    public static void main(String[] args) throws InterruptedException {
        Ticket ticket = new Ticket();// java 8 lamada 表达式做
        new Thread(()->{
            for (int i=1;i<=40;i++){
                    ticket.sale();
                }

        },"A").start();

        new Thread(()->{
            for (int i=1;i<=40;i++){
                ticket.sale();
            }

        },"B").start();
        new Thread(()->{
            for (int i=1;i<=40;i++){
                ticket.sale();
            }

        },"C").start();
    }
}