Java基础总结之各个模块重要知识点

一：对象模块。

一.初始化

1.对this.super,构造函数，构造代码块，静态代码块总结。

this：代表当前对象，也就是所在函数所属对象的引用。

this对象后面加.调用的是对象的成员变量和方法。（this.say()）;

this对象后面加()，调用的是本类中对应参数的构造函数。

super：代表父类，也就是当前类的父类。

使用方式与this类似。

构造函数：用于当对对象初始化时调用的特殊函数，只在执行一次。

在构造函数中使用this或者super，必须定义在构造函数的第一行。如果没有用到，那么构造函数的第一句会默认的加上super（）;

构造代码块：是给所有的对象进行初始化，也就是，所有的对象都会调用的一个代码块，只要对象一建，就会调用这个代码块，用于给不同对象的共性初始化，优先于构造函数执行。

格式：{

代码。。。。。。

}

静态代码块：一个用static关键字标示的一个代码块区域，定义在类中。可以完成类的初始化，静态代码块会随着类的加载而执行一次（new多个对象也是只执行一次）。如果和主函数在同一个类中，优先于主函数执行。

格式：static{

代码。。。。。

}

三种初始化的执行顺序: 静态代码块--->构造代码块------>构造函数。

二.继承(extends)：

1.重写和重载

重写：覆盖父类已有的方法，子父类方法必须一模一样。(包括返回值，子类复写父类方法时访问权限必须比父类大或者同级。方法要么都静态，要么都不静态)。

重载：只在本类中的多个方法，只看同名函数的参数列表。

子类初始化时，先初始化父类的方法和变量，在初始化自己的。

三.接口(implements)

1.实现

接口可以被多实现，类继承只能单继承。

接口与接口之间存在着继承关系，接口可以多继承接口。

四.多态

体现：父类或者接口的引用指向自己的子类对象。（注意：在使用多态时，要访问子类的方法，要求父类中必须对该方法进行了声明或者定义）。

多态在子父类中的成员上的体现的特点：

成员变量：

编译时期：参考的引用类型变量所属的类中是否有调用的成员。（编译时期不产生对象，只检查语法错误）。

运行时期：也是参考引用类型变量所属的类中是否有调用的成员。

简单总结：成员变量——编译运行都看 = 左边。

非静态成员函数：

编译时期：参考引用类型变量所属的类中是否有调用的方法。

运行时期：参考的是对象所属的类中是否有调用的方法。

原因：因为在子父类的非晶态成员函数中有一个特性：重写（覆盖）。

简单总结：成员函数——编译看 = 左边，  运行看 = 右边。 

静态函数：

编译时期：参考引用类型变量所属的类中是否有调用的方法。

运行时期：参考的是引用类型所属的类中是否有调用的方法。

原因：因为是静态方法，所以是不属于对象的，而是属于该方法所在的类。

简单总结：成员函数——编译运行看 = 左边，

五：内部类。

特点：内部类可以直接访问外部类中的成员，而外部类想要访问内部类，必须要建立内部类的对象。

-------------------------------------------------------------------------------------------------------------------------------

class Outer{

int num = 4;

class Inner {

void show(){

System.out.println("inner show run" + num);

}

}

public void method(){

Inner in = new Inner();//创建内部类的对象

in.show();//调用内部类的方法

}

-------------------------------------------------------------------------------------------------------------------------------

当内部类定义在外部类的成员变量位置。可以使用一些成员修饰符进行修饰默认,private,static.

1.默认修饰符。

直接访问内部类格式：外部类名.内部类名 变量名 =  new 外部类对象.内部类对象；

Outer.Inner in = new Quter.new Inner();

上面这种方式比较少见，因为内部类本来就是为了封装，想要获取内部类对象通常都是通过外部类的方法来获取，这样可以对内部类对象进行控制。

2.private修饰符。

通常内部类被封装，都会被私有化。

3.静态修饰符。

如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。

注意：如果内部类中定义了静态成员，那么该内部类必须是静态的。
     当外部类的静态方法访问内部类时，内部类也必须是静态的。

外部其他类中，直接访问static内部类的非静态成员：New Outer.Inner().show();

外部其他类中，直接访问static内部类的静态成员：Outer.Inner.show();

一般内部类经过编译后文件名为：“外部类名$内部类名.class”;

当内部类被定义在局部位置上时。

1.不可以被成员修饰符修饰（例如：static，static是修饰成员的）

2.可以访问外部类中成员，因为还持有外部类中的引用，（外部内.this）,但不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

匿名内部类：

意义：没有名字的内部类，是内部类的简化形式，一般内部类只用一次的话就可以用这种形式。匿名内部类其实就是一个匿名子类对象，想要定义匿名内部类：需要前提，内部类必须实现一个接口或者继承一个类。

匿名内部类的格式：new 父类名&接口名（）{定义子类成员或者覆盖父类方法}.方法

case：

new Object(){

void show(){

System.out.prinlt("show run");

}

} .show();

六：异常。

1.使用throws来在方法上标识（声明），方法可能会出现异常，当调用者检查到有标识时有必须要进行处理，要么接着抛，要么try。否则会出现编译失败

声明格式：throws 异常类，异常类。。。。。并不是所有的异常都需要声明，RuntimeException（运行时异常）类及其子类可以不用声明。

2.捕获异常try{}catch(){}块来捕捉时，要注意有多个catch时，如果有父类的Exception语句块，一定要放在下面.

3.throw用于抛出异常对象。

异常，在子父类进行覆盖时，有以下特点：

1.当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常，要么就抛出父类异常或者该异常的子类，不能抛出其他异常。如果父类没有抛出异常，那么子类只能try不能throws.

2.如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类异常的子集。

3.如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类方法就不需要throws进行声明。

注意：throw下面不能写语句，因为执行不到（会出现编译错误，和return,break后面不能写代码类似），但是注意如果是分支结构，也就是说if语句内写是可以的。

七：多线程。

1.相关概念。

进程：正在进行中的程序，就是一个应用程序运行时的内存分配空间

线程：进程中一个程序的执行控制单元，一条执行路径。

进程负责的是应用程序的空间的标示，线程负责的是应用程序的执行顺序。

cpu随机性原理：因为cpu的快速切换造成，那个线程获取到了CPU的执行权，那个线程就执行。

2.线程的几种状态：

被创建：start()。

运行：具备执行资格，同时具备执行权。

冻结：sleep（time）,wait()-----notify()唤醒，线程冻结（沉睡），释放了执行权，同时释放了执行资格。

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权。

消亡：stop();

3.两种线程的创建方式

第一种方式：继承Thread,由子类复写run方法。

步骤：1.定义类继承Thread类。

2.目的是复写run方法，将要让线程运行的代码都存储到run方法中。

3.通过创建Thread类的子类对象，创建线程对象。

4.调用线程的start方法，开启线程，并执行run方法。

第二种方式：实现一个Runable接口。

步骤：1.定义类实现Runnable接口。

2.覆盖接口中的run方法。（用于封装线程要运行的代码&#