零碎点

抽象类：规定一个或多个抽象方法的类别本身必须定义为abstract，抽象类只是用来派生子类，而不能用它来创建对象。

final类：又称“最终类”，它只能用来创建对象，而不能被继承，与抽象类刚好相反，而且抽象类与最终类不能同时修饰同一个类。

包：Java中的包是相关类和接口的集合，创建包须使用关键字package。 多态类：在java中，对象变量是多态的。而java中不支持多重继承。

接口：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

Java中的每一个类都是从Object类扩展而来的。 object类中的equal和toString方法。

equal用于测试一个对象是否同另一个对象相等。

toString返回一个代表该对象的字符串，每一个类都会从Object类继承该方法，有些类重写了该方法，以便返回当前状态的正确表示。

（toString 方法是一个很重要的方法）

通用编程：任何类类型的所有值都可以同object类型的变量来代替。

封装：就是把数据和行为结合起在一个包中，并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段（instance field）。

重载：当多个方法具有相同的名字而含有不同的参数时，便发生重载。编译器必须挑选出调用哪个方法进行编译。

重写：也可称为方法的“覆盖。”在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。值得注意的是，子类在重新定义父类已有的方法时，应保持与父类完全相同的方法头声明。

数组列表：ArrayList动态数组列表，是一个类库，定义在java.util包中，可自动调节数组的大小。

class类 object类中的getclass方法返回class类型的一个实例，程序启动时包含在

main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。

1.0 逻辑运算符：

&&和&都是表示与，区别是&&只要满足第一个条件，后面条件就不再判断。而&要对所有的条件都进行判断。

||（短路或）和|（或）都是表示“或”，区别是||只要满足第一个条件，后面的条件就不再判断，而|要对所有的条件进行判断。

2.0---new 关键字：

创建一个对象即new 一个对象其实做了三件事

1.在堆内存中开辟一块空间，2.然后在栈内存中创建一个引用名 3. 最后才把引用名指向之前开辟的空间的地址

3.0--父类指向子类对象：（多态）编译看左边，运行看右边

当父类引用f指向其子类的对象的时候，通过f无法访问专属于子类对象的成员。

为什么这样不可以？LZ有没有想过，因为f是FatherClass，所以编译器只知道f拥有FatherClass.class的信息，FatherClass.class以外的信息，编译器不知道，而子类的对象成员是在SonClass.class里，也就是说在FatherClass.class以外，所以f无法访问子类的对象成员

假如子类中有对父类方法的重写，那么根据多态机制，通过f访问这个方法的时候实际访问的是子类中重写的方法。

为什么这样可以？上面说了，f只能访问FatherClass.class的信息（注意这里指的是编译期编译器只知道f是FatherClass类型，不知道f具体指向什么对象，运行期才知道指向什么对象），而子类重写的方法，父类中也存在，即SonClass.class重写的方法，FatherClass.class里也有（如果SonClass.class里有但是FatherClass.class里没有的方法，f也不能直接调

用），所以f可以访问，但是调用的时候（注意这里指的是运行期），f实际指向的是SonClass对象，所以调用的是SonClass对象的方法。

问题是如果子类重写的方法中访问了专属于子类的成员变量，这时候通过父类引用f还可以调用那个被重写的方法吗？

可以，要分清编译期和运行期，编译期是编译器检查语法和类型，运行期是解析器解析伪代码为机器指令而执行，编译期编译器会检查f的访问范围，也就是f的访问不超过FatherClass.class的信息就不会出错，运行期解析器会解析方法的代码指令，因为f指向子类对象，所以会解析子类重写的方法代码指令，而子类对象的内存空间是包含子类的成员变量的空间的，所以也不存在子类成员变量没有分配内存的问题，所以可以调用。

LZ要分清楚，为什么会生成FatherClass.class和SonClass.class两个文件，既然是生成两个文件，那当然是那个文件被使用，就可以访问那个文件的信息。编译期编译器只知道f是FatherClass类型（至于f=什么，那是运行期，因为不运行=就不会执行），所以会检查f是否在FatherClass.class的范围，而运行期，f指向的是SonClass对象，也就是内存的对象是SonClass.class的信息，所以执行的是SonClass.class的代码指令。

多态的三个条件：继承，重写，父类引用指向子类对象。 七楼说的很好，我总结了下：

多态有两种一是：编译时的多态，编译时的多态一般表现为方法的重载，一个类中存在多个相同名字的方法，但方法的参数不用（方法的数据类型等），在编译时，根据方法传递过来的实参进行重载。

二是：运行时的多态，也叫做多态绑定。子类重写父类的方法后。把子类的引用传递给父类对象，然后通过父类的对象去调用子类覆盖的方法。最后执行的结果是，哪个类的对象传递给父类，就调用哪个类的方法。

对于多态，可以总结它为：

一、使用父类类型的引用指向子类的对象； 二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。 多态的3个必要条件：

1.继承 2.重写 3.父类引用指向子类对象。

4.0--抽象类abstract：

当一个类被声明为abstract时，这个类被称为抽象类。所谓的抽象类就是没有实例对象的类。

java中定义抽象类是出于相同考虑。抽象类是他的所有子类的公共属性的集合，所以抽象类的一大优点就是充分利用公共属性来提高开发和维护程序的效率。 抽象方法

作为修饰符，abstract声明了一种没有具体对象的，出于组织概念的层次关系需要而存在的抽象类；作为类方法修饰符，abstract则声明了一种仅有方法头，而没有具体的方法体和操作实现的抽象方法。 如：

abstract boolen goVacation(int days);

可见，abstract方法只有方法头得声明，而用一个分号来代替方法体得定义；至于方法体得具体实现，那是由当前类的不同子类在他们各自的类定义中完成的。

5.0--final 和finally

局部变量：：

在java语法里，方法定义里的形参以及方法体中的变量都是局部变量，不能使用访问权限修饰符public,private和protected。把方法里的所有访问权限修饰符private删除或换成final即可。

1、final类

final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。 final方法不能被子类的方法覆盖，但可以被继承。

2、final方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 使用final方法的原因有二：

第一、把方法锁定，防止任何继承类修改它的意义和实现。

第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3、final变量（常量）

用final修饰的成员变量表示常量，只能被赋值一次，赋值后值无法改变！ final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 另外，final变量定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

4、final参数

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。 注：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 final不能用于修饰构造方法。 示例：

public void f1(final int i){ } //i是final类型的,值不允许改变的.

6.0--正则表达式：

本文来源：https://www.bwwdw.com/article/bke3.html