面型过程，面向对象，封装，继承，多态，抽象-----》总结文

面向过程与面向对象：

面向过程：就是分析解决问题的步骤，然后一步步的使用函数去实现，需要的时候就依次调用函数即可
面向对象：就是把构成问题事务分解成各个对象，构建对象的目的不是为了完成某一个步骤，而是描述事物在解决整个问题的步骤中的行为。

面向过程：下棋：白子走–>绘制棋盘–>黑子走—->绘制棋盘—判断输赢—->一次轮回
面向对象：棋子对象（接受用如输入的棋子），棋盘系统（绘制棋盘），判断系统（判断输赢）

封装：

封装：就是将属性和方法封装到类里面，然后添加访问修饰符进行访问权限控制，从而隐藏对象的具体实现细节，仅仅暴露一个接口供外部使用。
比如javabean，就是属性都是使用private修饰的，然后提供getset方法，然后再set方法中进行一些年龄值的判断，此时对于属性的操作就进行了限制。并且隐藏了具体的实现细节。这样保护了类的内部状态，提高了代码的模块化和安全性，增加了代码的可维护性以及移植性。

继承：

继承：子类无需重写父类的代码，即可获得父类的所有功能，并且还可以在此基础上进行扩展。
1、子类继承父类非私有的属性和方法，但是如果父类公有的方法中对自己的私有属性进行了操作，子类也是可以调用父类该公有方法的，此时间接操作了父类的私有属性，此时子类是是使用了私有属性的。
2、子类不可以继承父类的构造方法，但是在实例化子类的时候会调用父类的构造方法，如果父类提供了无参构造，那么子类不用显式调用父类的构造函数，默认调用父类的无参构造。如果父类没有提供无参构造函数，那么子类构造函数中必须显示调用父类的构造函数。当有父类的时候，在实例化对象的时候，先执行父类的构造函数，然后再执行子类的构造函数。
3、java中修饰符的作用是封装类中的属性和方法使其对外是否可见，继承是为了更好提高代码的重用性，而封装是保护了代码不可见的部分。
4、我们会继承父母的东西，但是我们继承的是父母的财产，父母的精神我们继承不了，但其精神却会影响着我们

继承：

1、子类继承父类非私有属性及方法。
2、只支持单继承，但是支撑多重继承
3、子类抛出的异常不能比父类多
4、子类的访问权限不能比父类低

多态

父类引用指向子类对象，或者接口指向不同的实例。
对于父类引用指向子类对象的时候：除了static和final方法外，其他方法都是动态绑定的。即子类重写父类的静态方法，当其访问时，访问的是仍是父类的方法，子类重写父类的非静态方法，当其访问时，访问的是子类的方法，如果要访问父类的方法，需要使用super关键字。如果父类与子类具有相同的属性（静态或非静态），访问的都是父类的成员变量。

重写和重载：

重写：方法名相同，形参列表相同，返回值相同。如果其他相同，但是返回值不同，此时会报错。如果出现两个仅仅返回值不同的方法也会报错。
重载：方法名相同给你，形参列表不同（参数类型–>参数传入的是int a,和String a 是两个方法，参数顺序，参数个数），仅仅返回值的不同，不算是重载。

//下面是两个方法
    public String add12(int a) {
        // TODO Auto-generated method stub
        return "a";
    }

    public String add12(String a) {
        // TODO Auto-generated method stub
        return "a";
    }

接口：

接口：接口中没有构造方法，不能实例化对象。
接口中的方法必须都是抽象方法，并且只能使用public abstract修饰，如果不写，默认是public abstract。如果写则为public或者public abstract。
接口中不能包含成员变量，除了static和final变量。（final变量要在定义或者在构造方法中赋初值，因为接口中没有构造方法，所以这里的成员变量一定要赋初值，而且默认为public static final）。默认为public static final，意思是使用三个关键字的任意组合修饰方式都是可以的。

抽象类：

除了不能实例化对象以外，其他的和普通类没有什么区别
使用abstract关键字修饰的类称为抽象类
1、abstract类中可以有main方法，可以有静态方法，可以有静态成员变量，也可以有静态代码块，但是不能有静态的抽象方法。
2、抽象类中的抽象方法不可以用private，static，synchronized,native访问修饰符修饰。原因：private：抽象方法没有方法体，是用来被继承的，抽象方法必须要重写。而private修饰的方法不能被继承。static：修饰的方法是通过类名访问该方法（即方法的方法体），因此抽象方法用static修饰没有意义。synchronized：是为方法加一个锁，如果该关键字修饰的方法是static方法，则使用的锁就是class锁，如果修饰普通方法，那么使用的锁就是this锁。

接口和抽象类的区别：

1、抽象类中可以有非抽象方法，但是接口中只能是抽象方法
2、抽象类中，成员变量可以是任何类型的，但是接口中的成员变量只能是public static final 修饰的
3、抽象类中可以有静态方法，静态代码块，构造方法，但是接口中不可以存在
4、一个类只能继承一个抽象类，但是可以实现多个接口

java程序初始化工作的执行顺序

java程序初始化工作的执行顺序：父类静态变量，父类静态代码块，子类静态变量，子类静态代码块，父类非静态变量，父类非静态代码块，父类构造函数，子类非静态变量，子类非静态代码块，子类构造函数

抽象:

多态父类引用指向子类对象面试题：

package cn.lq.test;

public class Test2 {
    public static void main(String[] args)  {
        Shape1 shape = new Circle1();
        System.out.println(shape.name);
        shape.printType();
        shape.printName(); //这个会输出shape
        Cricle1.printName();  //这个才会输出circle
    }
}

class Shape1 {
    public String name = "shape";

    public Shape1(){
        System.out.println("shape constructor");
    }

    public void printType() {
        System.out.println("this is shape");
    }

    public static void printName() {
        System.out.println("shape");
    }
}

class Circle1 extends Shape1 {
    public String name = "circle";

    public Circle1() {
        System.out.println("circle constructor");
    }

    public void printType() {
        System.out.println("this is circle");
    }

    public static void printName() {
        System.out.println("circle");
    }
}
//shape constructor
circle constructor
shape
this is circle
shape
circle

加载顺序面试题

package cn.lq.test;

public class Test1 {
    public static void main(String[] args)  {
        new Circle();
    }
}

class Draw {

    public Draw(String type) {
        System.out.println(type+" draw constructor");
    }
}

class Shape {
    private Draw draw = new Draw("shape");

    public Shape(){
        System.out.println("shape constructor");
    }
}

class Circle extends Shape {
    private Draw draw = new Draw("circle");
    public Circle() {
        System.out.println("circle constructor");
    }
}
//shape draw constructor
shape constructor
circle draw constructor
circle constructor