1.面向对象的三个基本特征是：封装、继承、多态

封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

在Java中类中成员的属性有：public， protected， <default>， private，这四个属性的访问权限依次降低。

封装主要在于实现了我们能修改自己实现的代码，而不用调用修改程序的片段
封装的优点：良好的封装能够减少耦合，类内部结构可以自由修改，可以对成员变量进行准确控制，隐藏信息实现细节。

为了实现良好的封装，将类的成员声明为priviate,通过public方法对变量进行访问，对一个变量的操作，一般有读取和赋值的2个操作，为了实现这两个操作，一个是getXX(XX表示成员要访问变量的名字）用来读取成员变量，另一个是setXX()用来对变量赋值

多态
多态是同一个行为具有不同表现形式或形态能力
多态是同一个接口，使用不同实例而执行不同操作
多态是面向对象语言重要特性，类似指针或引用派生类的对象，在具体访问时实现方法的动态绑定

多态存在三个必要条件
继承，重写，父类引用指向子类对象

2.重写和重载的区别

重写:
重写（Override）是父类与子类之间多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Override)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

重载：
重载（Overload）是一个类中多态性的一种表现。如果在一个类中定义了多个同名的方法，它们参数列表不同，则称为方法的重载(Overload)

区别：重载实现于一个类中;重写实现于子类中。

重载(Overload)：是一个类中多态性的一种表现，指同一个类中不同的函数使用相同的函数名，但是函数的参数个数或类型不同。可以有不同的返回类型;可以有不同的访问修饰符;可以抛出不同的异常。调用的时候根据函数的参数来区别不同的函数。

重写（Override): 是父类与子类之间的多态性，是子类对父类函数的重新实现。函数名和参数与父类一样，子类与父类函数体内容不一样。子类返回的类型必须与父类保持一致；子类方法访问修饰符的限制一定要大于父类方法的访问修饰（public>protected>default>private）；子类重写方法一定不能抛出新的检查异常或者比被父类方法申明更加宽泛的检查型异常。

重载

package com.etime09;

public class Goods {  //创建一个商品类 
private String ID;
private int price;
private String name;
private String manufactureDate;
//实现构造函数的重载 参数个数或类型不同
public Goods() {
    super();
    // TODO Auto-generated constructor stub
}
public Goods(String iD) {
    super();
    ID = iD;
}
public Goods(String iD, int price) {
    super();
    ID = iD;
    this.price = price;
}
public Goods(String iD, int price, String name) {
    super();
    ID = iD;
    this.price = price;
    this.name = name;
}
public Goods(String iD, int price, String name, String manufactureDate) {
    super();
    ID = iD;
    this.price = price;
    this.name = name;
    this.manufactureDate = manufactureDate;
}

}

重写

package com.etime09;

public class Person {  //创建一个父类Person
private String name;
private int age;
//父类中写一个eat()方法
    public void eat() {
        System.out.println("人都要吃饭");
        }
}
---------------------------------------------
package com.etime09;

public class Student extends Person {  //Student子类继承Person父类
@Override
//重写eat()方法   方法名，参数，返回类型相同；方法体内容不同
public void eat() {
    System.out.println("学生喜欢吃肉");
            }
}

image.png

多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
多态存在的三个必要条件：继承，重写，父类引用指向子类对象

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

是否可以继承string类? 不可以

3.JAVA 类支持多继承嘛？ 可以实现多接口嘛？ JAVA不支持多继承，但类可以实现多个接口，间接实现多继承，也可以通过内部类

抽象类
抽象类必须用 abstract 修饰，子类必须实现抽象类中的抽象方法，如果有未实现的，那么子类也必须用 abstract 修饰。抽象类默认的权限修饰符为 public，可以定义为 public 或 procted，如果定义为 private，那么子类则无法继承。抽象类不能创建对象

抽象类和普通类的区别
抽象类必须用public、procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public

抽象类无法创建对象
如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么必须定义为 abstract

接口
接口中的变量隐式的使用 public static final 修饰，并且需要给出初始值。方法隐式的使用 public abstract 修饰(并且只能是 public ，如果是 private，procted，那么就编译报错)。接口中的方法默认不能有具体的实现（JDK1.8开始可以有默认的实现）

4.接口和抽象类的区别

1.抽象类只能继承一次，但是可以实现多个接口
接口和抽象类必须实现其中所有的方法，抽象类中如果有未实现的抽象方法，那么子类也需要定义为抽象类。抽象类中可以有非抽象的方法

2.接口中的变量必须用 public static final 修饰，并且需要给出初始值。所以实现类不能重新定义，也不能改变其值。

3.接口中的方法默认是 public abstract，也只能是这个类型。不能是 static，接口中的方法也不允许子类覆写，抽象类中允许有static 的方法。

接口和抽象都是继承树的上层，共同点如下：
1.都是上层的抽象层
2.都不能实现实例化
3.都能包含抽象的方法，这些抽象的方法，用于描述类具备的功能

区别如下：
1.在抽象类中可以写非抽象的方法，从而避免在子类中重复书写他们，这样可以代码的复用性，这是抽象类的优势，接口中只能有抽象方法
2.抽象级别（从高到低），接口》抽象类》实现类
3.接口的设计目的，是对类的行为进行约束，侧重与动作，而抽象类的设计目的是代码复用，
4.抽象类是 is a 关系，而接口是 has a 关系（实现多接口）

5.简要叙述下Java中修饰符的作用域及可见性？

public：修饰的成员可以在任何范围内直接访问，只是一种最宽松的访问控制等级。需要注意的，所谓的直接访问仍需要先创建或获得一个相应类的对象然后才可以使用”对象名.成员“的方式访问其属性或调用其方法，但是出于信息封装和隐藏的需要一般不提倡把成员声明为public的，而构造方法和需要外界直接调用的普通方法则适合声明为public.

protected：修饰的成员可以在其所在类中、同一包中及子类中（无论子类在不在同一个包）被直接访问，但不能在位于不同包中的非子类中被直接访问，这里需要特别声明：在位于不同包的子类中必须是子类的对象才能直接访问其父类的protected成员，而父类自身的对象反而不能访问其所在类中声明的protected成员。

default：缺省访问修饰符的成员只能在其所在类中或包中直接访问，在不同包中即使是不同包的子类也不能直接访问。

private：成员只能在所在类中被直接访问，是4种访问等级最高的一个。

image.png

equals() 和 “==” 操作用于对象的比较，检查对象的相等性，前者是方法，后者是操作符。

总结：
1.一般使用==比较原生类型如：boolean,int,char等等，使用equals()比较对象
2.如果两个引用指向相同的对象==返回true,equals()的返回依赖于具体业务实现，一般重写equals方法，同样重写hashcode方法，默认的equals实现是与“==”一样的
3.字符串的使用对比使用equals()代替==操作符

6.一个static 方法内可以调用非static方法嘛？

不可以，因为非static要与关联对象关联在一起，必须创建一个对象后，才能在对象上进行方法调用，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中，发出对非static方法的调用,static方法是静态方法，是属于类的方法，非static方法是属于对象的方法，所以在static方法中想要调用非static方法，要先创建一个对象，再有这个对象来调用非static方法。

7.Java静态变量与实例变量的区别

(1) 在语法定义上区别：静态变量前要加static关键字，而实例变量前则不加
(2) 程序运行时的区别：实例变量属于某个对象属性，必须创建了实例对象，其中实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而属于类，所以称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，只分配一次，静态变量就可以被使用。总之，实例变量必须创建对象后才能通过这个对象使用，静态变量可以直接使用类来引用。

8.int和Integer的区别

1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用，而int变量不需要
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0

9. StringBuilder,StringBuffer和String区别

1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String
（为啥字符串是最低的工作效率呢？String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。）

2. StringBuilder：线程非安全的
   　 StringBuffer：线程安全的

(当我们在字符串缓冲去被多个线程使用时候，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。）

对于三者使用的总结：
1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

StringBuffer和StringBuilder的相同点就是，他们都是可变长度 的字符串，他们两者之间的方法使用几乎可以互通。而且相比于字符串来说，StringBuffer和StringBuilder的执行效率要高出很多。

StringBuffer和StringBuilder的不同点我们可以从以下几个方面来谈

首先，两者的英文名称就不一样，StringBuffer是字符串缓冲，StringBuilder是字符创生成器

其次，StringBuffer是线程安全的，StringBuilder是非线程安全。正因为他们有这样的线程不同点，所以导致StringBuilder的执行效率远比StringBuffer要强悍很多。StringBuffer起始于jdk 1.0、StringBuilder起始于jdk 1.5

当然了，这也需要分场景和业务需求，若果单线程下面操作字符串缓冲的话，我建议使用StringBuilder。若果是多线程下字符串缓冲操作，我建议使用StringBuffer。因为StringBuffer使用了线程同步，他会对当前的线程进行一个小小的检查，保证其安全运行。虽然执行速度不高，但是换回来了安全也是值得的，毕竟我们都知道，Java语言把安全看的比什么都要重要。

image.png

10. JAVA 初始化原则

使用场景
在java程序中，当实例化对象时，对象的所在类的所有成员变量首先要进行初始化，只有当所有类成员完成初始化后，才会调用对象所在类的构造函数创建对象。

原则
变量优先于块、静态优先于非静态。
父类优先于派生类初始化。
按照成员变量定义的顺序来进行初始化，即使变量定义散布于方法定义之中，它们仍然在任何方法（包括构造器）被调用前初始化。

初始化顺序
父类静态变量
父类静态代码块
子类静态变量
子类静态代码块
父类非静态变量
父类非静态代码块
父类构造函数
子类非静态变量
子类非静态代码块
子类构造函数

11. 当try,catch中有return返回时，finally中代码会执行嘛

一、无论有没有异常，finally中的代码都会执行
二、当try、catch中有return时，finally中的代码依然会继续执行
三、finally是在return后面的表达式运算以后执行的，此时并无返回运算以后的值，而是把值保存起来，无论finally对该值作任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算以前就肯定了的。
四、若是return的数据是引用数据类型，而在finally中对该引用数据类型的属性值的改变起做用，try中的return语句返回的就是在finally中改变后的该属性的值。
五、finally代码中最好不要包含return，程序会提早退出，也就是说返回的值不是try或catch中的值测试

先执行try中的语句，包括return后面的表达式，
有异常时,先执行catch中的语句，包括return后面的表达式,
而后执行finally中的语句,若是finally里面有return语句，会提早退出，
最后执行try中的return，有异常时执行catch中的return。指针

在执行try、catch中的return以前必定会执行finally中的代码（若是finally存在），若是finally中有return语句，就会直接执行finally中的return方法，因此finally中的return语句必定会被执行的。编译器把finally中的return语句标识为一个warning.

11. final,finally和finalizie的区别

1.简单区别：
final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。

2.中等区别：
虽然这个单词在Java中都存在，但是并没太多关联：
final：java中的关键字，修饰符。
A).如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。因此，一个类不能同时被声明为abstract抽象类的和final的类。
B).如果将变量或者方法声明为final，可以保证它们在使用中不被改变.
1)被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
2)被声明final的方法只能使用，不能重载。

finally：java的一种异常处理机制。
　　finally是对Java异常处理模型的最佳补充。finally结构使代码总会执行，而不管无异常发生。使用finally可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。

finalize：Java中的一个方法名。
Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没被引用时对这个对象调用的。它是在Object类中定义的，因此所的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。

12. JAVA遇到的异常错误

Java.lang.NullPointerException
　　这个异常大家肯定都经常碰到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（假如要调用的话）

2. java.lang.ClassNotFoundException
　　这个异常是很多原本在JB等开发环境中开发的程序员，把JB下的程序包放在WTk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，假如是在JB下做的程序包，一般都是默认加上Package的，所以转到WTK下后要注重把Package的路径加上。

3. java.lang.ArithmeticException
　　这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。

4. java.lang.ArrayIndexOutOfBoundsException
　　这个异常相信很多朋友也经常碰到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太轻易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。

5. java.lang.IllegalArgumentException
　　这个异常的解释是"方法的参数错误"，很多J2ME的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数假如写成负数就会出现这个异常，再比如g.setColor(int red,int green,int blue)这个方法中的三个值，假如有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。

6. java.lang.IllegalAccessException
　　这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注重这个异常。

13. JAVA中的异常框架

image.png

Throwable
　　Throwable是 Java 语言中所有错误或异常的超类。
　　Throwable包含两个子类: Error 和 Exception。它们通常用于指示发生了异常情况。
　　Throwable包含了其线程创建时线程执行堆栈的快照，它提供了printStackTrace()等接口用于获取堆栈跟踪数据等信息。

Exception
Exception及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

RuntimeException
RuntimeException是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
　　编译器不会检查RuntimeException异常。例如，除数为零时，抛出ArithmeticException异常。RuntimeException是ArithmeticException的超类。当代码发生除数为零的情况时，倘若既"没有通过throws声明抛出ArithmeticException异常"，也"没有通过try…catch…处理该异常"，也能通过编译。这就是我们所说的"编译器不会检查RuntimeException异常"！
　　如果代码会产生RuntimeException异常，则需要通过修改代码进行避免。例如，若会发生除数为零的情况，则需要通过代码避免该情况的发生！

Error
和Exception一样，Error也是Throwable的子类。它用于指示合理的应用程序不应该试图捕获的严重问题，大多数这样的错误都是异常条件。
和RuntimeException一样，编译器也不会检查Error。比如说内存溢出

Java异常分类：
1 被检查的异常(Checked Exception)，
2 运行时异常(RuntimeException)，
3 错误(Error)。

(01) 运行时异常
定义: RuntimeException及其子类都被称为运行时异常。
特点: Java编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。例如，除数为零时产生的ArithmeticException异常，数组越界时产生的IndexOutOfBoundsException异常，fail-fail机制产生的ConcurrentModificationException异常等，都属于运行时异常。
　　虽然Java编译器不会检查运行时异常，但是我们也可以通过throws进行声明抛出，也可以通过try-catch对它进行捕获处理。
　　如果产生运行时异常，则需要通过修改代码来进行避免。例如，若会发生除数为零的情况，则需要通过代码避免该情况的发生！

(02) 被检查的异常
定义: Exception类本身，以及Exception的子类中除了"运行时异常"之外的其它子类都属于被检查异常。
特点: Java编译器会检查它。此类异常，要么通过throws进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译。例如，CloneNotSupportedException就属于被检查异常。当通过clone()接口去克隆一个对象，而该对象对应的类没有实现Cloneable接口，就会抛出CloneNotSupportedException异常。
　　被检查异常通常都是可以恢复的。

(03) 错误
定义: Error类及其子类。
特点: 和运行时异常一样，编译器也不会对错误进行检查。
　　当资源不足、约束失败、或是其它程序无法继续运行的条件发生时，就产生错误。程序本身无法修复这些错误的。例如，VirtualMachineError就属于错误。
　　按照Java惯例，我们是不应该是实现任何新的Error子类的！

14. JAVA中的异常框架

Java GC（Garbage Collection，垃圾收集，垃圾回收）机制，是Java与C++/C的主要区别之一，在使用JAVA的时候，一般不需要专门编写内存回收和垃圾清理代 码。这是因为在Java虚拟机中，存在自动内存管理和垃圾清扫机制。

电脑的内存大小的不变的，当我们使用对象的时候，如使用New关键字的时候，就会在内存中生产一个对象，但是我们在使用JAVA开发的时候，当一个对象使用完毕之后我们并没有手动的释放那个对象所占用的内存，就这样在使用程序的过程中，对象越来越多，当内存存放不了这么多对象的时候，电脑就会崩溃了，JAVA为了解决这个问题就推出了这个自动清除无用对象的功能，或者叫机制，这就是GC，有个好听是名字叫垃圾回收，其实就在用来帮你擦屁股的，好让你安心写代码，不用管内存释放，对象清理的事情了。