1. &和&&、|和||的区别

&: 按位与操作
只有对应的两个⼆进制数为1时，结果位才为1
1&1 = 1
1&0 = 0
0&1 = 0
0&0 = 0
| :按位或操作
有⼀个为1的时候，结果位就为1
1|1 = 1
1|0 = 1
0|1 = 1
0|0 = 0
&和&&都可表示“且”。& 两边都运算，而&& 先算 && 左侧，若左侧为false 那么右侧就不运算，判断语句中推荐使用 &&，效率更高。
| 和 || 都可表示“或”。| 和 || 和上面类似，||只要满足第⼀个条件，后⾯的条件就不再判断，而|要对所有的条件进行判断。

2.用最有效率的方法计算2乘以8

将一个数左移n位，相当于乘以2的n次方，位运算是CPU直接⽀持的，所以效率高。
左移运算：2<<3，表示2乘以2的三次方，即2乘以8。
右移运算：8>>1，表示8除以2的一次方，即8除以2。

3.Java基本类型，所占字节数，以及范围。

byte:1个字节，-128 ~ 127（2^7-1）。
boolean:1个字节，表示true或者false。
short:2个字节， -32768 ~ 32767（2^15-1）。
int:4个字节，-2147483648 ~ 2147483647（2^31-1）。
long:8个字节，-9223372036854775808 ~ 9223372036854775807（2^63-1）。
float:4个字节，可表示的最大值是3.4x1038。
double:8个字节，可表示的最大值是1.79x10308。
char:2个字节，Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符。

4.== 和equals的区别

基本数据类型比较要用==判断是否相等。
引用数据类型： ==比较的是内存地址是否一样，不同对象的内存地址不一样，equals比较的
是具体的内容， 也可以让开发者去定义什么条件去判断两个对象是否一样。

5.Exception和Error区别

Exception 和 Error 都是继承了 Throwable 类，在 Java 中只有 Throwable 类型的实例才可以被抛出（throw）或者捕获（catch），它是异常处理机制的基本组成类型。
Error 是指在正常情况下，不大可能出现的情况，绝大部分的 Error 都会导致程序（比如 JVM 自身）处于非正常的、不可恢复状态。既然是非正常情况，所以不便于也不需要捕获，常见的比如 OutOfMemoryError 之类，都是 Error 的子类。
Exception 又分为可检查（checked）异常和不检查（unchecked）异常，可检查异常在源代码里必须显式地进行捕获处理，这是编译期检查的一部分。前面介绍的不可查的 Error，是 Throwable 不是 Exception。不检查异常就是所谓的运行时异常，类似 NullPointerException、ArrayIndexOutOfBoundsException 之类，通常是可以编码避免的逻辑错误，具体根据需要来判断是否需要捕获，并不会在编译期强制要求。

异常.jpg

6.编写代码, 从⼀个txt文本里面，拷贝里面的内容到另外⼀个txt文本里面。

public static void main(String[] args) {
        try(
                FileInputStream fis = new FileInputStream("C:\\upload_file\\IOTest.txt");
                BufferedInputStream bis = new BufferedInputStream(fis);
                FileOutputStream fos = new FileOutputStream("C:\\upload_file\\Copy.txt");
                BufferedOutputStream bos = new BufferedOutputStream(fos)
                ){
            int size ;
            byte[] buf = new byte[1024];
            while((size = bis.read(buf)) != -1){
                bos.write(buf,0,size);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

7.编写代码：找出某目录下的所有子目录以及子文件并打印到控制台上。

public static void main(String[] args) {
        List<String> pathes = new ArrayList<>();
        File file = new File("C:\\workspace\\design-pattern");
        findAllPathes(file,pathes);
        for (String s:pathes){
            System.out.println(s);
        }
    }

    public static void findAllPathes(File file,List<String> pathes){
        File[] files = file.listFiles();
        if(files == null){
            return;
        }
        for (File f:files){
            if(f.isDirectory()){
                pathes.add(f.getPath());
                findAllPathes(f,pathes);
            }else{
                pathes.add(f.getName());
            }
        }
    }

8. String str = new String("Jessie"); 创建了几个对象？

创建⼀个对象：常量池存在，则直接new⼀个对象；
创建两个对象：常量池不存在，则在常量池创建⼀个对象，也在堆里面创建⼀个对象。

9.String，StringBuilder，StringBuffer的区别

String 是 Java 语言非常基础和重要的类，提供了构造和管理字符串的各种基本逻辑。它是典型的 Immutable 类，被声明成为 final class，所有属性也都是 final 的。也由于它的不可变性，类似拼接、裁剪字符串等动作，都会产生新的 String 对象。由于字符串操作的普遍性，所以相关操作的效率往往对应用性能有明显影响。
StringBuffer 是为解决上面提到拼接产生太多中间对象的问题而提供的一个类，我们可以用 append 或者 add 方法，把字符串添加到已有序列的末尾或者指定位置。StringBuffer 本质是一个线程安全的可修改字符序列，它保证了线程安全，也随之带来了额外的性能开销，所以除非有线程安全的需要，不然还是推荐使用它的后继者，也就是 StringBuilder。
StringBuilder 是 Java 1.5 中新增的，在能力上和 StringBuffer 没有本质区别，但是它去掉了线程安全的部分，有效减小了开销，是绝大部分情况下进行字符串拼接的首选。

10.JDK8里面接口新特性

1.interface中可以有static方法，但必须有方法实现体，该方法只属于该接口，接口名直接调用该方法。
2.接口中新增default关键字修饰的方法，default方法只能定义在接口中，可以在子类或子接口中重写被default定义的方法，必须有方法体。
3.父接口的default方法如果在子接口或子类被重写，那么子接口实现对象、子类对象，调用该方法，以重写为准。
4.本类、接口如果没有重写父类（即接口）的default方法，则在调用default⽅法时，使用父类
（接口） 定义的default方法逻辑。

interface Hello{
    void hello(String name);
    static void sayHello(){
        System.out.println("invoke sayHello method!");
    }
    default void sayHello2(){
        System.out.println("invoke sayHello2 method");
    }
}

//调用
public static void main(String[] args) {
        Hello.sayHello();
        Hello hello = new Hello() {
            @Override
            public void hello(String name) {

            }
        };
        hello.sayHello2();
    }

11.谈谈Java反射机制，动态代理是基于什么原理？

反射机制是 Java 语言提供的一种基础功能，赋予程序在运行时自省（introspect，官方用语）的能力。通过反射我们可以直接操作类或者对象，比如获取某个对象的类定义，获取类声明的属性和方法，调用方法或者构造对象，甚至可以运行时修改类定义。
java.lang 或 java.lang.reflect包下的Class、Field、Method、Constructor 等，就是我们去操作类和对象的元数据对应。
动态代理（Dynamic Proxy）的机制：可以在运行期动态创建某个interface的实例。很多场景都是利用类似机制做到的，比如用来包装 RPC 调用、面向切面的编程（AOP）。
先定义接口Hello，但是我们并不去编写实现类，而是先定义一个InvocationHandler，然后通过JDK提供的一个Proxy.newProxyInstance()创建一个Hello接口对象。这种没有实现类但是在运行期动态创建了一个接口对象的方式，我们称为动态代码。JDK提供的动态创建接口对象的方式，就叫动态代理。

public class Reflection {

    public static void main(String[] args) throws Exception {
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if ("hello".equals(method.getName())){
                    System.out.println("hello "+args[0]);
                }
                return null;
            }
        };
        
        Hello hello = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(),//传入ClassLoader
                new Class[] {Hello.class},//传入要实现的接口
                invocationHandler
        );

        hello.hello("Jessie");
    }

}
interface Hello{
    void hello(String name);
}

动态代理实际上是JDK在运行期动态创建class字节码并加载的过程，它并没有什么黑魔法。