1.面向对象基本概念
a.什么是对象？什么是面向对象编程？
对象是存在的具体的实体，是面向对象的编程的核心，具有明确的状态定义和行为。举个例子，现实中的车子就是一个具体的实体，我们可以把它看作一个对象，这个对象就有了颜色，型号的属性，还有加油，启动等行为。
面向对象编程中（简称：OOP），现实世界的所有事物全都被视为对象。OOP的目标是在计算机程序中，模拟现实世界中的概念，我们可以借助对象的描述就能够在计算机程序中用类似的实体模拟现实世界中的实体。同时OOP也是设计和实现软件系统的方法。
b.类和对象
类是对象的一种抽象关系，比如说，我们可以将中华田园犬当作一个对象，它具有咬和吠两种行为，且还有毛发，品种等属性，类对狗的一种抽象就是，将所有的狗当成一类，中华田园犬只是其中的一个对象，还有萨摩，二哈等。
类是对象的原型，所有属于同一个类的对象都具有相同的属性和行为，我们抽象了类之后，我们又可以用类定义实体。类是概念模型，对象是真实的模型。
c.面向对象的思想
面向对象的思想概括起来就有三个，封装，继承和多态
封装：有些对象自己的属性内部实现细节是不想让其他的对象知晓的，那么我们就可以把它封装起来。这就是封装的基本概念。
继承：就是指子类可以继承父类，从而使用父类的一些属性和操作。比如说儿子继承了父亲，儿子有了父亲强大的长相基因，同时学会了父亲的吃苦耐劳行为。
多态：多态指的是，同一的操作对于不同的对象表现形式不一样。举个例子，父亲有一个女儿，一个儿子，其中有一个撒娇的行为，比如女儿的撒娇的行为是嗲嗲的，而儿子的撒娇行为就是讨打的。
2.八大数据类型及其包装类
八大基本数据类型：byte,short,char,boolean,int,float,long,double
数字占一个字节Byte（8bit）,中文占两个字节
a.byte 有8位，作用范围在 -128~127
d.boolean 8位 作用范围 true/false
b.short 有16位，作用范围在 -2^15 ~2^15 - 1
c.char 有16位 ，作用范围 0~2^16-1
e.int 32 位 作用范围 -2^31~2^31-1
f.long 64位 作用范围 -2^63位~2^63位-1
g.float---第31位(占1bit)---第30-23位(占8bit)----第22-0位(占23bit)
h.double--第63位(占1bit)---第62-52位(占11bit)---第51-0位(占52bit)
这里解释一下为什么负数位比正数范围要多一点，因为规定 -0等于-1000 0000 -128
还有默认情况下 的整数为int（1）型，小数为double型（3.5），低精度向高精度会自动转型，高精度向低精度会（强制转换）丢失精度。还有如果想表示float类型在后面加f（3.5f）其他类型都一样，加上B,S,L,F都可以表示
自动类型转换
1）两种类型是彼此兼容的；2）转换后的目标类型占的空间范围一定要大于被转化的源类型由低字节向高字节自动转换（黑线表示无数据丢失的自动数据转换，红线表示转换中可能发生精度丢失）。
强制转换
将容纳更多信息的数据类型转换成一个容量更小的数据类型，可能存在精度损失的风险，编译器要求程序员进行强制类型转换。强制转换过程中可能发生数据溢出，必须警惕。 int a=(int)3.14;
还有一点运算符种如++，+=，--这种在运算时，遇到需要类型强制转换时，会自动处理，因为java编译器做了特殊的处理
ps:switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开 始，switch 支持字符串 String 类型了,long,float,double,bollean都不行
常见面试题：
1int a = 1; int b = 2; 怎么让a,b值交换?
^异或 两个中只有一个为1才为1
a=a^b; 01 ^ 10 = 11
b=a^b; 11 ^ 01 = 10
a=a^b；11 ^ 10 = 01
2.64位的JVM当中,int的长度是多少?
Java 中，int 类型变量的长度是一个固定值，与平台无关，都是 32 位。意思就是说，在 32 位 和 64 位 的Java 虚拟机中，int 类型的长度是相同的。
3.在Java中，如何跳出当前的多重嵌套循环？
答：在最外层循环前加一个标记如A，然后用break A;可以跳出多重循环。
4..float f=3.4;是否正确？
答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f=3.4F;。
5.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？
答：对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。
6.Integer和int的区别
int是java的8种内置的原始数据类型。Java为每个原始类型都提供了一个封装类，Integer就是int的封装类。
int变量的默认值为0，Integer变量的默认值为null，这一点说明Integer可以区分出未赋值和值为0的区别，比如说一名学生没来参加考试，另一名学生参加考试全答错了，那么第一名考生的成绩应该是null，第二名考生的成绩应该是0分。关于这一点Integer应用很大的。
Integer类内提供了一些关于整数操作的一些方法，例如上文用到的表示整数的最大值和最小值。
7.java 中 3*0.1 == 0.3 将会返回什么？true 还是 false？
答：false，因为浮点数不能完全精确的表示出来，一般都会损失精度。
8.基本类型和引用类型的区别。
java中的数据类型分为两大类：基本数据类型和引用数据类型
基本类型的值就是一个数字，一个字符，或者一个布尔值。存放在栈空间中，未初始化时为随机值。
引用类型是一个对象类型，值是指向内存空间的引用，就是地址。所指向的内存中保存着变量所表示的一个值或一组值。存放在堆空间中，未初始化时由默认的值，比如int未初始化时为0，boolean未初始化时为false。
9.java中基本数据类型存放的位置
一：在方法中声明的变量，即该变量是局部变量，每当程序调用方法时，系统都会为该方法建立一个方法栈，其所在方法中声明的变量就放在方法栈中，当方法结束系统会释放方法栈，其对应在该方法中声明的变量随着栈的销毁而结束，这就局部变量只能在方法中有效的原因
在方法中声明的变量可以是基本类型的变量，也可以是引用类型的变量。
（1）当声明是基本类型的变量的时，其变量名及值（变量名及值是两个概念）是放在方法栈中
（2）当声明的是引用变量时，所声明的变量（该变量实际上是在方法中存储的是内存地址值）是放在方法的栈中，该变量所指向的对象是放在堆类存中的。
二：在类中声明的变量是成员变量，也叫全局变量，放在堆中的（因为全局变量不会随着某个方法执行结束而销毁）。
同样在类中声明的变量即可是基本类型的变量 也可是引用类型的变量
（1）当声明的是基本类型的变量其变量名及其值放在堆内存中的
（2）引用类型时，其声明的变量仍然会存储一个内存地址值，该内存地址值指向所引用的对象。引用变量名和对应的对象仍然存储在相应的堆中
10.private,default,protected,public
这四个关键字的范围是
private只能在当前类
defalut只能在当前类和本包类
pritected可以在当前类，本包类，和子孙类中，不能在其他包使用
public 都可以
3.装箱/拆箱
装箱和拆箱是是从java1.5之后才有的，自动装箱时编译器调用valueOf将原始类型值转换成对象，同时自动拆箱时，编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。
如常见的，Integer i =3;//自动装箱，int j =i;//自动拆箱
常见问题：
如 1.Integer i =3;Integer j=3 System.out.println(i==j); true/fasle ?
Integer i =300;Integer j=300;System.out.println(i==j);true/false ?
通过运行程序结果我们可以知道，第一题的答案为 true,第二题的答案为 false
这是因为在自动装箱的过程时，Integer包装类里面将i>=-128&&i<=127存放在一个cache里面，大于的话则会返回新对象。
这里可以说明的是八大包装类中，Byte,Short,Integer,Char,Bollean,Long都是类似的，其中，float,double，不缓存，Bollean创建两个static ,final修饰的Boolean对象即可。
4.反射,动态代理，AOP
4.1反射
是在运行状态中，对于任意的一个类，都能够知道这个类的所有属性和方法，对任意一个对象都能够通过反射机制调用一个类的任意方法，这种动态获取类信息及动态调用类对象方法的功能称为java的反射机制
1.）获取对象的三种方式
2.）获得构造函数
3.）获取方法
4.)获取属性
5.）获取父类的方法属性值.getSuperClass()
ps:get_方法能获得当前类和父类的公有属性，getDeclared_能获得当前类公有且私有的，但是不能获取父类的方法和属性。
4.2.动态代理(Proxy,Cglib)
动态代理和静态代理的区别在于静态代理我们需要手动的去实现目标对象的代理类，而动态代理可以在运行期间动态的生成代理类。
- Proxy(JDK自带的代理)
1.）首先得定义接口
2.）创建类实现接口
3.）创建代理类
invoke 有三个参数，Object proxy 代理类的对象，Method method 被代理类的方法，args被代理方法的参数
4.）编写代理类的实际调用，利用Proxy类创建代理之后的类
newProxyInstance(
1.classLoader对象，定义了有哪个ClassLoader 对象来生成的代理对象进行加载
2.interface 一个interface数组，代理对象可以调用interface接口中的方法
3.invocationHandler对象 表示当我们这个动态代理对象，在调用方法时，会关联到哪一个InvocationHander对象中的invoke方法
)
- Cglib
1.导入.jar包
2.创建代理类
3.实现MethodInterceptor接口，对方法进行拦截处理
4.创建被代理类
利用Enhancer来生产被代理类，这样可以拦截方法，对方法进行前置和后置log的添加。
5.抽像/接口
5.1抽象
抽象类必须用 abstract 修饰，子类必须实现抽象类中的抽象方法，如果有未实现的，那么子类也必须用 abstract 修饰。抽象类默认的权限修饰符为 public，可以定义为 public 或 procted，如果定义为 private，那么子类则无法继承。抽象类不能创建对象。
- 抽线类属性值 默认为 public 类型
- 抽象方法必须在抽象类中，且抽象方法不能有方法体
-抽象类中可以存在抽象方法也可以不存在抽象方法，方法默认是由public修饰
-抽象类中可以有静态方法
-abstract 和 staic 不能一起使用
-抽线类中可以有构造函数
-抽象类只能被继承，不能被实例化，继承的类必须实现抽象类中的抽象方法，否则也可以定义为抽象方法不去实现
5.2接口
1.接口必须由Interface关键字修饰
2.接口没有构造函数
3.接口中的属性默认是由 public static final 修饰，必须提供初始值，且不能被private ,protecd修饰
4.接口中的方法默认是public abstract修饰，没有方法体
5.jdk1.8之后，接口中的方法如果拥有方法体必须使用 default来修饰，且不能和abstract 一起使用
6.接口中不能使用staic 关键字修饰方法
5.3两者相同
1.接口和抽象类中的方法都不能有方法体
2.不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象
3.抽象类里的抽象方法必须全部被子类所实现，子类不能全部实现父类抽象方法，那么该子类还只能是抽象类。一个类实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类
5.4两者不同
4. 抽象类可以有构造器，接口不能有构造器。
5. 一个类只能继承一个类，但是可以实现多个接口
6. 接口中的变量必须用 public static final 修饰，并且需要给出初始值。所以实现类不能重新定义，也不能改变其值。
7. 接口中的方法默认是 public abstract，也只能是这个类型。不能是 static，接口中的方法也不允许子类覆写，抽象类中允许有static 的方法
8.jdk1.8 接口可以用default 抽象类不行
使用抽象类是为了代码的复用(抽象类与子类是一般与特殊的关系)
使用接口是为了现实多态的效果(接口的实现类是这一类的事物应该有哪些特性，并没有一般与特殊的关系)
6.异常
6.1.什么是Exception和Error?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。
6.2.异常处理中的关键字
throw:有时我们明确要创建异常对象然后抛出它来停止程序的正常处理。throw关键字用于向运行时抛出异常来处理它。throw则是指抛出的一个具体的异常类型。
throws:将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理
try-catch：我们在代码中使用try-catch块进行异常处理。try是块的开始，catch是在try块的末尾处理异常。我们可以使用try有多个catch块，try-catch块也可以嵌套。catch块需要一个应该是Exception类型的参数。
finally：finally块是可选的，只能用于try-catch块。由于异常会暂停执行过程，因此我们可能会打开一些不会关闭的资源，因此我们可以使用finally块。finally块总是被执行，无论是否发生异常。
6.3.检查时异常和非检查时异常
检查型异常和非检查型异常的主要区别在于其处理方式。检查型异常都需要使用try,catch 和finally 关键字在编译器进行处理，否则会出现编译器报错。对于非检查型异常则不需要这样做。Java中所有继承 Exception 的类的异常都是检查型异常，所有继承RuntimeException 的异常都被称为 非检查型异常。
6.4几种常见的RuntimeException
1.NullPointerException - 空指针引用异常
2.IllegalArgumentException - 传递非法参数异常
3.IndexOutOfBoundsException - 下标越界异常
4.NoSuchMethodException - 方法未找到异常
5.NegativeArrayException - 数组负下标异常
6.ClassCastException - 类型强制转换异常
7.ArithmeticException - 算术运算异常
8.IOException - 输入输出异常
6.5几种常用的异常方法
1.e.getMessage();//返回创建异常时提供的异常消息，如上文的
2.e.printStackTrace();//打印堆栈跟踪信息，一般会指定到那些方法中
7.序列化和反序列化
序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象。序列化机制的核心作用就是对象状态的保存与重建。
1.首先被序列化的类都必须实现Serializable 接口否则将抛出NotSerializableException异常
2.使用ObjectOutputStream 下的 wirteObject(序列化对象)来进行序列化
3.使用ObjectInputStream 下的 readObject()进行返序列化
序列化的好处？
1--永久性保存对象，保存对象的字节序列到本地文件或者数据库中，实现了数据的持久化，通过序列化可以把数据永久的保存到硬盘上，
2--利用序列化实现远程通信，可以在网络上传送对象的字节序列。
3--在进程间传递对象
实现标记接口后，其中的 serialVersionUID 必须要指定吗？
serialVersionUID 是 Java 为每个序列化类产生的版本标识。它可以用来保证在反序列时，发送方发送的和接受方接收的是可兼容的对象。如果接收方接收的类的 serialVersionUID 与发送方发送的 serialVersionUID 不一致，会抛出 InvalidClassException。
如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值
不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。
transient 关键字
当某个字段被声明为 transient 后，默认序列化机制就会忽略该字段。
8.I/O流
File类 打印目录下的所有文件名
1.字节流和字符流（reader/writer --Inputstream/outputstream）
2.文件流（FileRead/FileWriter -- FileInputStream/FileOutPutStream）
3缓冲流（BufferReader/BufferWriter -- BufferInputStream/BufferOutputStream）
目的是为了减少IO操作
4序列化流（ObjectInputStream -- ObjectOutputStream）
5.字节转换流（字节转字符）InputStreamReader--OutputStreamWriter
6.打印流（printStream printWriter）
9.泛型
1.引入java泛型的原因及好处
泛型的好处可以让程序员对被泛化的类型编写相同的算法，这极大了的增强了编程语言的类型系统和抽象能力。
2.java如何泛型如何实现（类型擦除）
java 为什么使用类型擦除作为java泛型的实现呢，主要是因为java在第十年之后才引入了泛型为了能够向上兼容之前的版本，所以才引入了类型擦除，什么是类型擦除呢？类型擦除指的是在编译期间那些用了泛型的结合或方法都会被转换成原来的裸类型。比如ArrayList<Integer> 和ArrayList<String>编译期间都变成了ArrayList然后在使用时再使用原类型进行强制转换（String）List,(Integer)List
3.java泛型带来了那些缺陷呢？
1）.首先是对于原基本八大类型不能直接使用泛型必须使用他们的八大基本包装类。主要是因为八大基本类型不能与Object类进行强制转换
2.）由于集合类使用，对于八大基本类型的操作都会存在拆箱，装箱，强制装换，所以比较慢
3.）当泛型遇到重载时，不同类型的泛型参数不允许重载（因为编译的时候他们都是同一类型）
10.强引用，软引用，弱引用，虚引用？
- 强引用：强引用就是我们平时用到的最多的引用，最普遍的引用，如：Object sb =new Object();
- 软引用：常用来描述有用但不是必须的对象，用SoftReferenc类来表示，一般在内存不足的时候，常会被垃圾收集器回收
-弱引用：和软引用一样常用来描述有用但不是必须的对象，用WeakReference类来表示，一般只要发生GC操作，就会被回收
-虚引用:虚引用，顾名思义就是指，加上引用和没有被引用一样，用phantomReference表示，并不影响生命周期，任何时刻都有可能被垃圾收集器回收
11.java方法中的参数都是值传递
当一个实例对象被作为参数传进给方法参数时，方法参数只是对该实例对象的地址的拷贝，该方法参数可以修改实例对象中的内容，但是不能修改该实例的引用地址
查看以上代码可以发现，当我们将两个对象的作为参数传进方法中的时候，并且将两个对象的引用地址交换，但是并没有对方法的两个实例对象产生影响，看输出结果发现两则仍然是一致的。
12.内存泄漏以及内存泄漏的原因是什么？
内存泄漏是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成内存空间的浪费称为内存泄漏。内存泄露有时不严重且不易察觉，这样开发者就不知道存在内存泄露，但有时也会很严重，会提示你Out of memory。
Java内存泄漏的根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄漏，尽管短生命周期对象已经不再需要，但是因为长生命周期持有它的引用而导致不能被回收，这就是Java中内存泄漏的发生场景。
具体主要有如下几大类：
1.集合类中如 threadLocal
2.数据库连接没有及时关闭
13.java标识符命名规则
14.String Stringbuffer,stringbuilder
String类:是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁
StringBuffe:r对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。
StringBuilder:类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。主要是因为StringBuffer底层由Synchronzied修饰的
15.成员内部类，静态内部类，局部内部类，匿名内部类
1）.成员内部类：成员内部类可以无条件访问外部类的属性和方法，但是外部类想要访问内部类属性或方法时，必须要创建一个内部类对象，然后通过该对象访问内部类的属性或方法
2.）静态内部类和成员内部类相比多了一个static修饰符。它与类的静态成员变量一般，是不依赖于外部类的。同时静态内部类也有它的特殊性。因为外部类加载时只会加载静态域，所以静态内部类不能使用外部类的非静态变量与方法。
3.）局部内部类：定义在方法中的内部类，它相当于方法的局部变量，不能用访问修饰符和static修饰，只作用于该方法的范围之内。只能反问外部类的final修饰的变量
4.）匿名内部类：如果一个类在整个操作中，只使用一次的话，就可以将其定义成匿名内部类。方便开发
16.浅拷贝和深拷贝
1.首先我们知道java的copy函数都是浅拷贝，浅拷贝对于值类型来说是复制了一份值，对于引用类型来说，只是复制了一份指向原对象的指针
可以看到，对于被浅拷贝对象，我们修改了他的值类型，是不影响原对象的，但是修改了Score这个引用对象，可以看到将原对象的成员属性Score这个引用对象也一起修改了。所以也证实了，对于引用对象来说浅拷贝只是拷贝了引用对象的地址。
2.深拷贝,是将被拷贝对象中的所有引用类型，都会在堆内存中另开辟内存地址，然后复制里面的数据和内容。
我们将上面的拷贝函数修改一下，来实现深拷贝。
我们可以看到，如果我们想要对象进行深拷贝的话，无疑必须得将，对象中的所有引用对象都实现一个CloneAble接口，重写clone()函数。然后一一进行浅拷贝。
以上这种方法是非常的慢且复杂，可以使用序列化机制进行深拷贝和浅拷贝技术。
我们可以看到通过序列化机制实现深拷贝的话，只需要在原对象的类中，写一个方法即可，但是前提是，原对象及原对象中所有的引用对象，都必须实现Serializable接口！！
