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

时间:2023-02-11 14:45:52

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里