06天-05-面向对象(帮助文档的制作javadoc)：
java文档生成命令：
javadoc -d filepatn demo.java   -author -version(可选)
一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致
默认构造函数的权限是随着的类的变化而变化的。

06天-06-面向对象(静态代码块)：
静态代码块的特点：随着类的加载而加载，只执行一次，用于给类的初始化。
非静态代码块的特点：随着类的实例建立而分配内存空间初始化。
构造代码块的特点：随着类的实例而初始化，在非静态代码块初始化后。
new对象过程：
1.加载类文件到内存； 2.初始化类的静态变量和函数； 3.分配堆内存地址；
4.在堆内存建立对象的特有属性，并进行默认初始化；  5.对属性显示初始化
6.对对象构造代码块初始化；7.对对象对应的构造函数初始化；
8.将堆内存地址赋给栈内存对象的实例变量。

06天-09-面向对象(单例设计模式)：
设计模式：解决某一类问题最行之有效的方法

07天-01-面向对象(继承-概述)：
继承 extends：1.提高了代码的复用性
2.让类与类之间产生了关系，有了这个关系才有多态的特性
重载：只看同名函数的参数列表
重写：子父类方法要一模一样
继承：子类的所有构造函数，默认都会访问父类中的空参数构造函数
子类实例化过程：
子类每个构造函数的第一行都有一句隐式super()；
当父类没有空参数构造函数时，子类必须手动通过super语句指定访问父类构造函数
当子类的构造函数第一行也可以指定this语句访问本类构造函数间接访问父类构造函数

07天-07-面向对象(final关键字)：
final：最终，作为一个修饰符
1.可以修饰类、函数、变量
2.被final修饰的类不可以被继承，为了避免被继承，被子类覆写功能
3.被final修饰的方法不可以被覆写
4.被final修饰的变量是一个常量只能赋值一次，可以是成员变量或者局部变量
5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量

抽象类的特点：
1.抽象方法一定在抽象类中
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以用new创建对象，因为调用抽象方法没意义
4.抽象类中的方法要被使用，必须由子类覆写所有抽象方法，建立子类对象调用
5.抽象类比一般类多了抽象函数，并且不可以实例化

模板方法设计模式：
在定义功能时，功能的一部分是确定，但是有一部分是不确定，而确定的部分在
使用不确定的部分，那么就将不确定的部分暴露出去，由该类的子类实现

07天-12-面向对象(接口)：
接口定义时特点：
1.接口中常见定义：常量、抽象方法
2.接口中的成员都有固定修饰符，可以省略
常量：public static final 方法：public abstract

接口：是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中
的抽象方法全部覆盖后，子类才可以实例化，否则子类是一个抽象类
接口可以被类多实现，也是对类多继承不支持的转换形式
类与类：继承关系，单继承
接口与接口：继承关系，多继承
类与接口：实现关系，多实现

08天-01-面向对象(多态-概念)：
多态：可以理解为事物存在的多种体现形态
多态的体现：父类的引用可以指向子类的对象，父类的引用可以接收自己子类对象
多态的前提：必须是类与类之间有关系，要么是继承，要么是实现，并存在覆盖
多态的好处：多态的出现大大提高了程序的扩展性
多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员

09天-01-面向对象(内部类访问规则)：
内部类的访问规则：
1.内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用：
格式特点：外部类名.this.变量名
2.外部类要访问内部类，必须建立内部类对象
3.当内部类中定义了静态成员，该内部类必须是static类
当内部类在成员位置时：
内部类访问权限可以是private，但是外部类必须是default或者public
内部类访问修饰符可以是static,并具备static的特性
访问内部类：
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中访问
当外部类中的静态方法访问内部类时，内部类也必须时static的
格式： 外部类名.内部类名 变量名=外部类对象.内部类对象
在外部其他类中，直接访问static内部类的非静态成员
格式： new 外部类名.内部类().非静态成员；
在外部其他类中，直接访问static内部类的静态成员
格式： 外部类.内部类.静态成员；
内部类定义在局部时：
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类的引用
但是不可访问它所在的局部变量，只能访问被final修饰的局部变量

09天-04-面向对象(匿名内部类)：
1.匿名内部类其实就是内部类的简写格式
2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
3.匿名内部类的格式： new 父类或者接口(){定义子类的内容};
4.其实匿名内部类就是一个匿名子类对象
5.匿名内部类中定义的方法最好不要超过3个

09天-05-面向对象(异常)
异常：就是程序在运行时出现不正常情况
异常由来：问题也是现实生活中一个具体的事物，也可以通过java类的形式
进行描述，并封装成对象。其实是java对不正常情况进行描述后对象的体现
对于问题的划分：两种：
一种是严重问题，java通过error类进行描述，一般不编写针对性代码处理
一种是非严重问题，java通过exception类进行描述，使用针对性代码处理
自定义异常：自定义类必须是继承Exception类
继承Exception原因：
异常体系有一个特点，因为异常类和异常对象都被抛出，他们都具备可抛性
这个可抛性是Throwable这个体系中独有的特点。只有这个体系中的类和对象
才可以被throw和throws操作。

在函数上通过throws关键字声明该函数有可能会出现异常，在被调用的地方
try-catch处理或者继续抛出去
method thorws ArithmeticException,ArrayIndexOutofBoundsException

当函数内部出现throw抛出异常，那么必须要给对应的处理动作
1.要么在函数内部try-catc处理
2.要么在函数上声明抛给调用者处理

throw和throws的区别：
throw：使用在函数内，后面跟的是异常对象
throws：使用在函数上，后面跟的异常类，可以跟多个，用逗号隔开

Exception中有一个RuntimeException运行时异常，其子类有如下特点：
如果在函数内抛出该异常，函数上可以不用声明，编译通过
如果在函数上声明了该异常，调用者可以不用进行处理
原因：该类异常是因为不需要让调用者处理。当异常发生时，希望程序停止，
因为在运行时出现了无法继续运行的情况，停止程序对代码进行修正
自定异常时：如果该异常的发生，无法再继续进行运算，
就让自定义异常继承RuntimeException类

对于异常分为两类：
1.编译时被检测的异常
2.编译时不被检测的异常(运行时异常，RuntimeException以及其子类)

finally 里面的语句无论是否有异常都会执行，在return前执行除了System.exit(0);

异常在子父类覆盖中的体现：
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，
只能抛出父类的异常或者该异常的子类
2.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不
能抛异常。如果子类方法发生了异常，必须进行try-catch处理，不能抛出

异常总结：异常是对问题的描述，将问题进行对象的封装。
异常体系：　 Throwable
　　　　　　--Error
　　　　　　--Exception --RuntimeException
异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性，
也就是说可以被throw和throws关键字操作，也只有异常体系具备这个特点。
throw和throws的用法：
throw定义在函数内，用于抛出异常对象；
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
注：当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数
上声明，否则编译失败。RuntimeException除外，可以不用throws或者try。
如果函数声明了异常，调用者需要进行处理，可以throws或者try
异常有两种：
编译时被检测的异常：
该异常被标识，代表这类异常可以被处理。
在编译时，如果没有处理(没有抛也没有try)，编译失败。
运行时异常(编译时不检测)：
该异常的发生，建议不处理，让程序停止，需要对代码进行修正
在编译时，不需要处理，编译器不检查
注意：finally中定义的通常是关闭资源，除了System.exit(0);其他情况都会执行

自定义异常：定义异常类继承Exception或者RuntimeException
1.为了让自定义类具备可抛性；
2.让该类具备操作异常的共性方法，并按java面向对象思想将程序中的异常封装

异常的好处：1.将问题进行封装
2.将正常流程代码和问题处理代码相分离，方便阅读
异常的处理原则：
1.处理方式有两种：try或者throws
2.调用到抛出异常的功能时，抛出几个就处理几个。
3.多个catch，父类的catch放到最下面
4.catch内需要定义正对性的处理方式，不要简单的输出printStackTrace语句，
也不要不写，当捕获到的异常，本功能处理不了时，可以继续在catch中抛出
异常的注意事项：在子类覆盖父类方法时，
1.子类抛出的异常必须是父类的异常的子类或者子集；
2.如果父类或者接口没有异常抛出时，子类覆盖出现异常只能try不能抛出去

this：代表本类对象，哪个对象调用this所在函数，this就代表哪个对象
final： 1.修饰类，变量(成员变量，静态变量，局部变量)，函数
2.修饰的类不可以被继承；     　　　　3.修饰的函数不可以被覆盖
4.修饰的变量是一个常量，只能赋值一次

多态类调用：成员变量看左边，函数看右边实际实例化的是哪个类

注：throw单独存在时，下面不要定义语句，因为执行不到。

包package：包与包之间访问，被访问包中的类以及类中的成员，需要public修饰
不同包中的子类还可以直接访问父类中被protected权限修饰的成员
包与包之间可以使用的权限只有两种：public、protected
　　　　　　　public　　 protected 　　　 default　　　　 private
同一个类中　　 yes　　　　 yes 　　　　　　 yes　　　　 yes
同一个包中 　　yes　　　　 yes 　　　　　　 yes　　　　 no
子类　　　　　 yes 　　　　 yes　　　　　　 no　　　　   no
不同包中　　　 yes　　　　  no　　　　　　   no　　　　   no

java编译：javac -d sourceFolder ClassName.java .或者省略表示当前目录
java运行：java package.ClassName

java打包：jar -cfv packageFilePath.jar packA packB
查看包：jar -tvf packageName >d:\jar.txt 输出详细信息到jar.txt里

Java基础知识_毕向东_Java基础视频教程笔记(5-10)