一、java基础知识点
1.面向对象的特征：封装，继承，多态
2.成员变量和局部变量的区别
（1）作用域不同，成员的作用于类中，局部的作用于方法或语句(for)中
（2）在内存中的位置是不同的，成员的存在于堆内存中，局部的存在于栈内存中。
3.匿名对象
（1）匿名对象是对对象的简化
（2）匿名对象使用场景
修改匿名对象属性没有任何意义，以后会被垃圾回收器回收。
匿名对象的方法只会使用一次
可以将匿名对象作为实际的参数传入
4.构造方法
如果一个类中没有构造方法，系统会默认的给他分配一个无参数的构造方法。但是一旦自己写了构造方法，系统就不会给该对象分配构造方法了。但是为了保险起见，最好在每一个对象中都写一个无参数的构造方法。
5.构造函数与构造代码块的区别
构造函数是给对应的对象初始化，构造代码块是给所有的对象统一初始化。
6.this使用
（1）this代表什么？哪个对象在调用this所在的函数，this就代表哪个对象。
（2）this用于区分成员变量与局部变量同名的情况
（3）一个类中函数之间的调用默认就是使用了this.函数名
（4）this表示构造函数之间的相互调用，this只能出现在构造函数的第一行。普通方法不能通过this调用构造函数
（5）this表示的是内存区
7.static
（1）static是一个修饰符，用来修改成员
（2）static表示的是方法区，共享区
（3）static随着类的加载而加载，静态是优于对象存在的。被所有对象所共有，通过类名调用。
（4）静态方法只能访问静态成员，静态方法不可以使用this,super关键字
（5）static的优点：对象共享，节省空间
（6）static的缺点：生命周期过长，访问有局限性，只能访问静态的
（7）静态的典型使用：工具类，里面的每一个方法是static的，通过类名调用
8.静态代码块是随类加载的
9.静态构造代码块，静态构造函数，构造代码块，构造函数的执行顺序
静态构造代码块>静态构造函数>构造代码块>构造函数
10.Person p = new Person("zhangsan",20)都做了什么？
加载类(.class)--静态属性或成员方法进方法区--加载静态代码块--开辟内存空间--成员属性默认初始化--执行非静态的构造代码块----构造函数的初始化
二、继承
（1）提高代码复用性。使类与类之间有了关系，产生了多态。
（2）java支持单继承，不支持多继承
（3）this表示的是本类，super表示的是父类。super在构造方法中出现在第一行。
（4）子类继承父类，成员变量和函数都会继承（不管是不是static）。同名的可以覆盖，覆盖之后默认调用的是子类的属性和方法，使用super可以调用父类的属性和方法。静态只能覆盖静态。构造函数不存在覆盖。
（5）调用子类的构造函数的时候会先调用父类的构造函数
（6）子类的访问权限不能变小，抛出的异常不能变大
三、抽象
（1）抽象类中可以有构造方法，但是不能用new创建对象
（2）抽象类中可以没有抽象方法
（3）抽象就是希望被子类实现的，所以不能有static，final,private修饰
四、接口
（1）接口中只有常量和抽象方法，没有构造方法
（2）接口可以多继承
五、多态
（1）提高程序的扩展性
（2）Fu fu = new Fu(); Fu fu2 = new Zi();
（3）Fu f = new Zi();
成员变量不管编译期还是运行期看的都是左边。方法编译期看左边，运行期看右边。
六、内部类
（1）内部类可以直接访问外部类的成员，包括私有。因为持有外部类的引用：外部类名.this
（2）外部类要访问内部类，需要建立内部类的对象
（3）在main中非静态内部类使用：Outer.Inner in = new Outer().new Inner()
在main中静态内部类使用：Outer.Inner in = new Outer. Inner()
使用的例子：
public class Test{
public static void main(String[] args) {
//不能直接使用内部类，因为一般非静态的都是依据外部类而存在的
//下面是使用的格式：左边是内部类的全名，右边表示有了外部类的对象才能有内部类的对象
Outer.Inner in = new Outer().new Inner();
in.function();
}
}
class Outer{
private int num = 2;
//private class Inner{内部类可以进行私有化
class Inner{
void function(){
//内部类直接访问外部类的数据,不管是不是私有的
System.out.println("num = "+num);
method();
}
}
public void method(){
//外部类访问内部类需要创建内部类的对象
Inner in = new Inner();
in.function();
}
}
（4）如果内部类中定义了静态成员，那么这个内部类一定是静态的。但是静态的内部类中不一定要有静态成员。但是内部类有static final修饰就是常量的时候内部类就不用是static的了。
（5）private，static，final的使用
只要是处在成员位置上的，包括内部类的成员位置上的都可以使用这三个修饰符。final可以修饰局部的，构造方法只能用private，类只能使用final.
（6）局部内部类访问局部变量的时候，局部变量只能是final的
1. public class AnonymousClass {
2. public Object makeInner(String localVal){
3. return new Object(){
4. private String s = localVal;
5. public String toString(){
6. return s;
7. }
8. };
9. }
10. public static void main(String[] args) {
11. AnonymousClass ac = new AnonymousClass();
12. Object ob = ac.makeInner("23");
13. System.out.println(o.toString());
14. }
15. }
程序new了一个类对象，然后调用了makeInner方法，传递了一个String类型的参数，进入到方法内部，返回了一个内部匿名类。匿名类中成员引用变量s跟参数localVal指向相同的内存地址，并在重写的toString方法中，返回了成员变量s。调用结束，localVal指向的内存空间释放，返回到主程序，调用ob的toString方法，输出s，但是此时的s指向的内存地址已经被释放了，所以程序是不会让你这么干的。所以内部类访问所在方法的参数或局部变量为什么必须是final的，因为方法结束之后他们空间并没有释放，依然是有效的。