一、概述
面向对象除了封装、继承和多态三大特征之外，还有其他的特性，例如abstract抽象、interface接口等，抽象类主要作为多个类的模板，而接口则定义了多类应该遵守的规范，final关键字让java实现不可变类，让系统更加安全。
二、正文
1、构造器和初始化块
1.1 构造器
构造器是一种特殊方法，这个特殊方法用于创建实例时执行初始化，是创建对象的重要途径，如果程序员没有为JAVA类提供任何构造器，则系统会为这个类提供一个无参数的构造器，这个构造器的执行体为空，不做任何事情。无论如何，JAVA类至少包含一个构造器。
具体代码如下：
public class A{
private String name;
private int age;
A(String name){
//this关键字代表本来引用
this.name = name;
}
//自定义构造器，含两个参数，名称必须和类名相同
A(String name,int age){
this(name);
this.age = age;
}
}
class Test{
public static void main(String[] args){
//根据构造器生产对象
A a = new A("zhang",5);
A a1 = new A();
System.out.print("name"+a.name+"age"+a.age);
System.out.print("name"+a1.name+"age"+a1.age);
}
}
通过上面的程序我们可以看出，构造器是创建JAVA对象的重要途径，通过new 关键字创建构造器，一旦程序员提供了自定义的构造器，则系统不再提供默认的构造器,如果不自定义无参数构造器，将不能通过无参构造器创建对象，一个类可以有多个构造函数，名字必须相同，但参数不能相同。程序中this（name）用this关键字调用该类的无参构造函数，而且使用this必须放在第一条语句。
1.2 初始化快
Java通过构造器对单个对象进行初始化，与之功能类似的是初始化块，它也可以对对象进行初始块。具体语法格式如下：
[修饰符]
{
//初始化块的可执行代码......
}
修饰符只能是static，使用static修饰的称为静态初始化块，初始化块里的代码包括定义局部变量，调用其他对象的方法，以及使用分支、循环语句等。如果不写修饰符的称为普通初始化块。下面是一段简单的代码：
class Test{
//普通初始化块
{
//初始化块执行语句
}
//静态初始化块
static
{
//静态初始化块执行语句
}
Test（）
{
//无参数构造函数执行语句
}
}
上面程序如果执行Test test = new Test（）；时，那么它的执行顺序是先执行静态初始化块，然后普通初始化块，最后才是Test（）。
注意：初始化块随着类的加载而执行，只执行一次，对所有对象进行初始化。
2、抽象类
在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但是无法准确的知道这些子类如何实现这些方法，例如定义一个People类，这个类提供了一个eat（）方法，但不同的People子类的eat（）方法是不一样的，即People无法准确的描述eat（）方法。那么如何既能让People（）包含eat（）方法，又无须提供其他方法实现呢？这时使用抽象方法即可满足该要求。抽象方法和类的具体特征如下：
1、抽象类和方法必须使用abstract修饰，抽象方法不能有方法体。
2、抽象类不能被实例化。
3、抽象类和普通类没多大区别，可以包含成员变量、方法、构造器、初始化块和枚举类6种成分。抽象类的构造器不能创建实例，主要用于被其子类调用。
4、含有抽象方法的类，必须被定义成抽象类。
5、抽象类只能被子类继承，子类想要建立实例对象，必须复写所有抽象方法，如果只是复写了一部分，子类也必须是抽象类。
下面是一段简单的代码：
//定义抽象类
abstract class People{
//普通成员变量
private String name;
//构造函数
public People(String name){
this.name = name;
}
//普通方法
public void enjoy(){
System.out.println("people");
}
//声明抽象方法
public abstract void eat();
}
//student继承People，并复写了eat（）抽象方法
//这样student才能被创建实例，不复写的话student也必须是abstract
class student extends People{
public void eat(){
System.out.println("student");
}
}
注意：抽象类也可以不包含抽象方法，只能被继承。它是从多个具有相同特征的类中抽取出来的，具备相同的特征，以这个抽象类作为其子类模板，从而避免了子类设计的随意性。
3、接口
接口是一种特殊的抽象类，不能包含普通方法，接口中的所有方法都是抽象方法。具体语法如下：
[修饰符] interface 接口名 [extends 父接口名列表]{
[public] [static] [final] 常量;
[public] [abstract] 方法;
修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。
接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。
extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。
方法：接口中的方法只有定义而没有被实现。
那么接口在什么时候定义呢？比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。下面是一个简单的例子代码：
//定义接口A
interface A {
void a();
}
//定义接口B
interface B {
void b();
}
/接口C继承了A又实现了B
interface C extends A implements B {
void c（）；
}
//接口D实现了C，必须要复写了C中所有的抽象方法，即a（）和b（），不然
class D implements C{
public void a() {
System.out.println("a");
}
public void b() {
System.out.println("b");
public void c() {
System.out.println("c");
}
}
}
//
public class cam2 {
static public void main(String args[]) {
//生成的D的实例，并调用方法
D a=new D();
a.a();
a.b();
a.c();
}
}
上面代码有接口A和B，C继承了A实现了B，其实也可以同时实现AB，AB之间只需要逗号隔开就可以，后面D有实现了C，那么D就必须复写ABC中的所有抽象方法，不然就不能被实例化。
注意：接口是对外暴露的规则，接口可以继承接口，可以被多实现，通常情况下把事物的共性功能去被子类继承，扩展功能放在接口里被实现。
4、单例和final关键字
4.1 单例
单例是解决类在内存中只存在一个对象的最有效的方法，下面是一段代码：
//懒汉式
public class Singleton {
//私有化声明变量
private static Singleton uniqueInstance = null;
//私有化构造函数，保证不被其他类实例化
private Singleton() {
// Exists only to defeat instantiation.
}
//对外提供public static方法提供自身实例
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
// Other methods...
}
从代码可以看出，想要保证对象的唯一性，那么步骤是：
1.为避免其他程序建立该对象实例，必须私有化构造函数
2.在本类中创建一个本类实例
3.为了方便其他程序访问，可以对外提供访问方式
上面介绍的懒汉式单例方法，是延时加载，还有一种是饿汉式，具体代码如下：
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
//私有的默认构造子
private Singleton1() {}
//已经自行实例化
private static final Singleton1 single = new Singleton1();
//对外提供自身实例
public static Singleton1 getInstance() {
return single;
}
}
注意：开发中一般用饿汉式，懒汉式面试时用的多，因为懒汉式有缺点，容易造成多次创建实例，不能保证实例的唯一性。
4.2 final关键字
final可以修饰类、变量和方法，也可修饰局部变量和形参。那么他的特征是：
1.修饰变量时，说明该变量一旦被赋值就不可被改变，一般情况下格式是public static final int MAX，这个称为全局常量，注意常量名大写。
2.被final修饰的类不可被继承，防止被子类继承之后复写里面的方法。
3.被final修饰的方法不可被复写。
三、总结
上面介绍了构造器和初始化块，它们是用来给对象初始化用的，接口和抽象类提高了函数的复用性，大大提高开发效率，单例是一种设计模式，java还有很多这样的设计模式，为开发带来了很大的方便。