1.this的两种用法：（1）当成员变量和局部变量重名是，可以用关键字this来区分 。this代表对象，代表的是this所在函数所属对象的引用（哪个对象调用了this所在的函数，this就代表哪个对象）（一个类中的成员想要被执行就必须有对象调用。静态除外）  （2）this可以用于在构造函数中调用其它构造函数（注意：只能定义在构造函数的第一行，因为初始化时必须被先执行）

2.static关键字的特点：（1）static修饰符，使用于修饰成员（成员变量、成员函数） （2）static修饰的成员被所有的对象所共享

3.static优先于对象存在，因为static的成员随着类的加载就已经存在。static修饰的成员多了一种调用方式，可以直接用 类名.静态成员 调用。static修饰的数据是共享数据，对象中存储的是特有对象

4.成员变量（又叫实例变量）与静态变量（又叫类变量）的对比：（1）两个变量的声明周期不同：成员变量随着对象的创建而存在，随着对象的被回收而释放。静态变量随着类的加载而存在，随着类的消失而消失。（2）调用方式不同：成员变量只能被对象调用；静态变量可以被对象调用，还可以被类名调用 （3）别名不同：成员变量又叫实例变量；静态变量又叫类变量 （4）存储位置不同：成员变量存储在堆内存的对象中，所以也叫对象的特有资源；静态变量存储在 方法区（静态区），所以也叫对象的共享数据

5.静态使用的注意事项：（1）静态方法只能访问静态成员（静态变量、静态函数。）静态先在（随着类的加载而存在）、非静态后在（随着对象的创建而存在），先在的不可以访问后在的，后在的可以访问先在的，即静态的不可以访问非静态的，但非静态的可以访问静态多的 ，也可以访问非静态的 （2）静态方法中不能使用this或super关键字  （3） 主函数是静态的。

6.想要调用一个方法有两种方式：类调用、方法调用。

7.方法区分为静态区和非静态区。非静态区里所有成员都有一个this所属，因为非静态区只能被对象调用。静态区中所属都是类名。静态成员前省略的是类名，非静态前省略的是this

8.静态什么时候用？

（1）静态变量：当分析对象中所具备的成员变量值都是相同的时，这个成员变量可以用静态修饰；只要数据在对象中都是不同的，就是对象的特有属性，必须存储在对象中，是非静态的。

（2）静态函数：函数是否用静态修饰，就参考一点，就是该函数是否有访问到对象的特有属性，简单点说从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的；如果不需要，可以将该功能定义成静态的，当然也可以定义成非静态的。（对象是封装特有数据的，如果方法没有访问特有数据，则对象的创建是没有意义的，没有访问特有数据，可以将该功能定义成静态的，直接用类名调用即可）

（3）静态代码块：随着类的加载而执行，而且只执行一次。

作用：用于给类进行初始化（注意：并不是所有的类都通过构造函数初始化的，有的类是不需要创建对象就可以完成初始化操作。如果类中全是静态成员，则类不需要对象，只用静态代码块即可初始化类）

（4）构造代码块：可以给所有的对象进行初始化。（具备对象初始化的通用性）

（5）构造函数：是给对应的对象进行针对性的初始化（具备针对特定对象的初始化）

（6）局部代码块：限定局部变量的声明周期

 1 /**
 2  * 需求： 写一段代码，分别验证静态代码块、代码块、构造函数在
 3  * 1、初始化对象的时候的执行顺序
 4  * 2、直接用类名调用该类的静态变量时的执行的顺序
 5  * @param args
 6  */
 7 //执行顺序：静态代码块-->代码块-->构造函数
 8 public class TestFirstDemo {
 9
10     public static void main(String[] args) {
11
12         new StaticCodeConstructor();//初始化对象
13         String haha = StaticCodeConstructor.test;
14         sop(haha);
15     }
16     //重新定义打印功能
17     public static void sop(Object obj){
18         System.out.println(obj);
19     }
20 }
21
22 class StaticCodeConstructor{
23     //静态代码块
24     static {
25         System.out.println("静态代码块-->");
26     }
27     //代码块
28     {
29         System.out.println("代码块-->");
30     }
31     //构造函数
32     StaticCodeConstructor(){
33         System.out.println("构造函数-->");
34     }
35     //定义一个静态变量
36     public static final String test = "静态变量";
37 }

9.执行顺序：静态代码块-->构造代码块-->构造函数

10.23种设计模式：对问题行之有效的解决方式，是一种解决问题的思想。

单例设计模式解决的问题是：可以保证一个类在内存中的唯一性。

必须对于多个程序使用同一个配置信息对象时，需保证该对象的唯一性，那么如何保证对象的唯一性？

（1）不允许其他程序用new 创建该类对象

（2）在该类中创建一个本类实例

（3）对外提供一个方法，让其他程序可以获取该对象

11.单例模式步骤：（1）私有化该类的构造函数 （2）通过new，在本类中创建一个本类对象  （3）定义一个公有的方法，将创建的对象返回

12.单例的例子：

 1 public class Single {
 2     private static final Single s = new Single();//通过new在本类中创建一个本类对象
 3     private Single(){};//私有化该类的构造函数
 4     public static Single getInstance(){//定义一个公有的方法，将创建的对象返回
 5         return s;
 6     }
 7 }
 8
 9 class SingleDemo{
10     public static void main(String[] args){
11 //        饿汉式或者懒汉式
12     }
13 }

13.继承：（抽取）

java仅支持单继承

单继承：一个子类只能有一个直接父类

多继承：一个子类可以有多个直接父类（java不支持，但进行了改良），不直接支持的原因是，当多个父类中有相同成员时，会产生调用的不确定性

14.java支持多重继承（多层继承即继承体系），当要使用一个继承体系时 （1）查看该体系顶层类，了解该体系基本功能  （2）创建该体系中的最子类对象，完成调用

15.当本类中的成员和局部变量同名时用this区分（this代表本类对象的引用）

当子父类中的成员变量同名时，用super区分，super代表父类

当子父类中出现成员函数一样情况，会首先用子类函数，这种现象叫 覆盖。

子类不能直接调用父类中私有的属性成员，如果父类对外提供方法，子类可以通过 super.方法名 间接调用

16.函数的两个特性：（1）重载（overloading）：同一个类中   （2）覆盖（重写overriding）：在子类中，故需要有继承关系

17.重载：可以改变返回值类型，口诀：两同、三不同即同一个类、同一方法名、参数列表（方法签名）的个数、类型、顺序不同

18.覆盖（重写）注意事项：

（1）子类方法覆盖父类方法时，子类权限必须大于等于父类权限

（2）静态子类只能覆盖静态父类

19.覆盖即保留父类功能，实现子类特有内容。那么应该什么时候使用覆盖操作：

当对一个类进行子类扩展时，子类需要保留父类的功能声明。但是要定义子类中该功能的特有内容，那么就应该使用覆盖来完成。

20.当子类构造对象时，发现访问子类的构造函数，父类也被访问。原因是：在子类的构造函数的第一行有隐式的super();这是默认的

21.子类的实例化过程都会默认去访问父类的空参构造方法。如果子类想访问父类的含参构造方法，则在子类构造方法中，手动写入super（参数）

22.为什么子类实例化的时候要访问父类的构造函数？

super语句，必须定义在子类构造函数第一行，因为父类初始化动作要先完成。

23.抽象类中有构造函数吗？ 有，用于给子类对象初始化

24.抽象类中可以不定义抽象方法吗？可以，但是很少见，目的就是不让类创建对象

25.抽象关键字abstract不可以和哪些关键字共存？

private 原因：抽象方法要被子类方法覆盖，如果私有，隐藏方法，则子类方法无法完成覆盖

static   原因：如果成员变静态，成为共享数据，则不需要对象；抽象类也不需要对象，可以直接使用类名.方法名（），抽象方法体运行无意义，因为无内容

final     原因: final的作用是修饰变量：表示此变量不可修改；修饰方法：表示此方法不可被重写（覆盖）；修饰类：表示此类不可被继承。abstract修饰抽象方法，需要子类实现其抽象方法。因此不可与final一同使用

26.抽象类与一般类的特点：

相同点：抽象类与一般类都用来描述事物，都在内部定义了成员

不同： （1）一般类有足够的描述信息；抽象类描述事物的信息可能不足

　　　（2）一般类中不能定义抽象方法，只能定义非抽象方法；抽象类中可以定义抽象方法，同时也可定义非抽象方法

　　　（3）一般类可以被实例化；抽象类不可以被实例化

27.抽象类一定是父类吗？ 是的，因为需要子类覆盖其方法，才可以对子类进行实例化。

28.类与类之间是继承关系；类与接口之间是实现关系；接口与接口之间是继承关系，而且可以多继承

实现：接口中的方法都是未实现的，用的时候都得自己实现

29.一个类在继承另一个类的同时，还可以扩展功能，实现多个接口，接口的出现避免了单继承的局限性。

30.抽象类与接口的区别？

（1）抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现，即实现多个接口

（2）抽象类中可以定义抽象方法与非抽象方法，子类继承后可以直接调用非抽象方法；接口中只能定义抽象方法（即接口中全部是未实现的方法），子类必须全部实现其方法，否则子类只能被定义为抽象类

（3）抽象类之间是继承，is a 关系，是定义该体系的基本共性内容（抽取而来）；接口的实现是like a关系，是定义体系额外的扩展功能

31.多态（一个对象，多种形态），在代码中的体现：父类或接口的引用指向子类的对象

32.多态的好处：提高了代码的扩展性，前期定义的代码后期可用

弊端：前期定义的内容，不能使用（调用）后期子类的特有内容

33.多态的前提：（1）必须要有关系，继承或者实现关系  （2）要有覆盖

如有错误，欢迎大家指正！谢谢