java基础-note
1.面向对象
子类的构造方法调用父类的构造方法
1.子类的构造方法执行体第一行代码使用了super显示调用父类构造方法
系统将根据super调用里传入的的实参列表，调用父类的构造方法
2.子类的构造方法执行体的第一行代码使用this显示调用本类中重载的方法
系统将根据this调用传入的实参列表，调用本类中另一个构造方法 执行本类中
另一个构造方法 既会调用父类的构造方法
3.子类构造方法执体 既没有this 也没有super 系统会调用super()
父类的无参构造方法
构造方法和普通方法
构造方法只有在当JVM在创建类的实例时，才会执行构造方法
构造方法:构造对象时调用的函数，作用是:可以给对象进行初始化
创建对象都必须通过构造方法初始化
一般函数和构造函数的区别
构造函数在对象创建时，就会调用与与之对应的构造函数，对对象进行初始化
一般函数 对象创建后，需要函数功能才可以调用
构造函数 创建对象时，只会调用一次。
一般函数 对象创建后，可以调用多次
this 代表一个本类对象的引用
super 代表一个父类的空间
Object - toString() 类名@hash值
- equals()判断两个对象是否指向同一块区域 instanceof 判断是否值指定类型的对象
- hashCode() 返回给该对象的哈希值
- getClass()
多态的体现：父类或接口的引用 指向其子类的对象
成员变量和静态变量的区别
1.两个变量的声明周期不同
成员变量随着对象的创建而存在 随着对象的被回收而消失
静态变量随着类的加载而存在，随着类的消失而消失
2.调用方式不同
成员变量只能被对象调用
静态变量可以被类名调用，还可以被对象调用
3.别名不同
成员变量也叫实例变量
静态变量也叫类变量
4.数据存储位置不同
成员变量存储在堆内存的对象中，也叫对象的特有数据
静态变量存错在方法区中 也叫对象的共有数据
static的特点
1.static是一个修饰符，用于修饰成员
2.static 修饰的成员被所有对象所共享
3.static 优先于对象的存在，因为static的成员，随着类的加载而存在
4.static 修饰的成员多了一种调用方式，就是可以直接被类名所调用
5.static 修饰的是共有数据 对象中的存储的是特有数据
使用静态的注意事项
1.静态方法只能访问静态成员 (非静态方法可以访问静态成员，也可以访问静态)
2.静态方法中不可以用this或super关键字
3.主方法是静态的
多态时 成员的特点
1.成员变量
编译时，参考引用类型的变量所属的类中是否有相同的成员变量
有 编译通过，否则 编译失败
运行时，参考引用类型的变量所属的类中是否有相同的成员变量
有 编译通过 否则 编译失败
简单的说，编译和运行看左边
2.成员方法
编译时，参考引用类型的变量所属的类中是否有相同的函数
有 编译通过 否则 编译失败
运行时，参考对象所属的类中是否有调用的函数
有 成功 否则 失败
简单说 编译看左边 运行看右边
3.静态方法
简单说 编译和运行都看左边
其实 对于静态方法 是不需要对象的 直接类名调用即可
静态代码块 构造代码块 构造函数
主函数特殊之处
1.格式是固定的
2.被jvm所识别和调用
public :权限最大
static 不需要对象的，直接用主函数所属类名调用
void 主函数没有具体返回值类型
main 函数名 不是关键字 只是一个jvm识别固定的名字
String () args 这是主函数的参数列表 是一个数组类型的参数
而且元素类型是字符串类型的
继承和多态
1.查看该体系中的顶层类，了解该体系的基本功能 看顶层，用底层
2.创建体系中的最子类对象，完成功能的使用
什么时候使用继承
类与类之间存在所属关系的时候，就定义继承
1，本类的成员和具局部变量同名时，用this区分
2,当子父类中的成员变量同名时 用super区分父类
this:代表一个本类对象的引用
super:代表一个父类空间
当子父类中出现成员函数一模一样的情况，运行子类的函数
这种现象称为覆盖操作
方法的重载
定义:在一个类中可以定义有相同的方法名但参数列表不同(参数类型，参数个数，参数顺序) 方法的
返回值类型可以不同
方法的重写
定义:子类和父类具有相同的名称 返回值类型和形参列表
三同一小一大
同:相同的名词 返回值类型 形参列表
小:子类抛出的异常必须小于或者等于父类抛出的异常
大:子类的方法权限必须是大于父类的权限
静态时多态的表现形式是方法重载 overloading
动态时多态的表现形式是方法重写 overriding
子父类中的构造函数的特点
子类的实例化过程
在子类构造对象时，发现 访问子类构造函数时，父类也运行了
原因是:在子类的构造函数第一行有一个默认的隐士语句 super()
为什么子类实例化的时候要访问父类中的构造函数呢
因为子类继承了父类，获取到了父类中内容(属性)
所以在使用父类内容之前，要先看父类是如何对自己内容进行初始化的
如果父类中没有定义空参数函数，那么子类的构造函数 必须用super明确要调用父类中的哪一个函数
同时 子类构造函数中如果用this调用了本类中构造函数时，
那么super就没有了，因为super和this都只能定义在第一行，只能有一个
但是可以保证的是子类中，肯定会有其他的构造函数去访问父类的构造函数
继承的优点
1.提高了代码的复用性
2.类与类之间的关系
3.为第三方的多态提供了基础
实例变量
1.声明的时候赋值
2.在构造方法的时候初始化
3.普通代码块
类变量
1.声明的时候赋值
2.静态初始化块
单例设计模式
如何保证对象的唯一性
1.不允许其他程序用new 创建类 对象
2.在该类创建一个本类实例
3.对外提供一个方法让其程序可以获取对象
步骤 1私有化该类构造函数
2.通过new在本类中创建一个本类的对象
抽象的特点
1.方法只有声明没有实现，该方法就是抽象方法
需要被abstract修饰，抽象方法必须定义在抽象类中，该类也必须被abstract修饰
2.抽象类不能实例化 为什么
因为调用抽象方法没有意义
3.抽象类必须有其子类覆盖了所有的抽象方法 该子类才可以实例化
否则 该类必须定义为抽象类
1.抽象方法中有构造函数吗
有 用于给子类进行初始化
2.抽象方法可以不定义抽象方法吗
可以 但是很少见 目的就是不让该类创建对象
AWT的适配器 对象就是这个类
3.抽象类关键字不可以和哪些关键字共存
private 不行 子类会覆盖父类
static 不行 会随着类的加载而加载
final 表示只能有一个类
抽象类和普通类的区别
不同1.一般类有足够的信息描述事物
抽象类描述事物的信息不足
2.一般类中不能定义抽象方法，只能定义非抽象方法
抽象类中可以定义抽象方法和非抽象方法
3.一般类可以实例化
抽象类不能被实例化
–接口
当一个抽闲类中的方法都是抽象方法的时候，这时候可以将该抽象类用另一种形式定义和表示 这就是接口
对于接口当中常见的成员 而且这些成员都有固定的修饰符
全局变量 public static final
抽象方法 public abstract
接口中的成员都是公共权限
接口是对外暴露的规则
接口是程序的功能拓展
接口的出现降低的了耦合性
在java中不直接支持多继承
改良之后 称为多实现
一个类可以实现多个接口
接口与接口之间是继承关系 而且接口可以多继承
抽闲类和接口的异同点
相同点和不同点
相同点----
都是不断向上抽取而来的 不能实例化
不同点----
1.抽象类需要被继承，而且只能单继承
接口需要被实现，而且可以多实现
2.抽象类中可以定义抽象方法和非抽象方法
子类继承后，可以直接使用非抽象方法
接口只能定义抽象方法，必须有子类去实现
3.抽象类的继承是is a 关系 在定义该体系的基本内容
接口的实现是like a 关系 在定义体系的额外功能
2.集合类
集合总结
集合的由来
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就可以使用集合容器存储对象
集合的特点
1.用于存储对象的容器
2.集合的长度是可变的
3.集合不可以存储基本数据类型
集合框架
集合容器因为内部的数据结构不同，有多种具体容器 不断的向上抽取就形成了集合框架
collection
set存放的是无序的 不可重复的元素
list存放的是有序的 可以重复的元素
迭代器 Iterator
取出元素的方式 迭代器 该对象必须依赖具体的容器 因为每个容器的数据结构都不同
所以该迭代器对象是在容器内部实现的
在迭代器过程中，不要使用集合操作元素，容易出现异常，可以使用Iterator接口的子接口
ListIterator来完成 在迭代器中对元素进行更多操作 集合和迭代器同时操作有问题
注意，只有list的集合具备该迭代器迭代功能。
Iterator 接口就是对所有的Collection容器进行元素取出的公共接口
set 无序的 不可重复元素
HashSet 特点 不保证元素的加入顺序 根据元素的哈希码进行存放
linkedHaseSet 特点 根据元素的哈希值进行存放 用链表记录元素的添加顺序
TreeSet 特点 自然排序
List 有序的 可重复的元素
ArrayList 特点 内部是数组结构 查询速度快
LinkedList 特点 内部是链表结构 不同步 删除和添加速度快 可以对首部和尾部元素操作
Vector 特点 线程同步其他和ArrayList一样
Stack 特点 先进后出
empty() 查看是否为空
peek() 查看栈顶对象 不删除
pop() 移除栈顶对象 并显示该对象
push() 把项压入栈顶
search() 返回对象在栈中的位置
Map接口 （键值对）
HashMap linkedHashMap TreeMap
java集合和数组的区别
在创建java数组时，必须明确指定的数组的长度 数组一旦创建 其长度就不能改变 为了是程序能方便的存储
检索 和操作数目不固定的一组数据
栈 先进后出
队列 先进先出
3.内部类
内部类访问特点
1.内部类可以直接访问外部类中的成员
2.外部类要访问内部类，必须建立内部类的对象
内部类的使用
分析事物时，发现该事物描述中还有事物，而且这个事物还是访问被描述事物的内容，这时，就是还有的事物
定义成内部类来描述。
为什么内部类能直接访问外部类中成员
那是因为内部类持有了外部类的引用
格式:外部类.this
成员内部类
声明格式: 外部类.内部类 名字 = new 外部类().new 内部类()
如果内部类中定义了静态成员，那么此类就必须为静态类
静态内部类
由于静态内部类比较特殊，它的对象创建并不需要外部类对象
匿名内部类
匿名内部类就是内部类的简写格式.
必须有前提:内部类必须继承或者实现一个接口或者外部类
在object中equals和==比较的都是两个引用是否指向同一个对象，既比较的是地址值是否相等
在子类中重写了object中的equals和==
子类中的equals比较的是两个对象的内容是否相等
==比较的是两个引用是否指向同一个对象
4.异常
异常和错误
语法错误石油编译器发现的
异常是执行过程中发生的错误
异常:就是在运行时期发生的不正常情况。
异常就是java通过面对对象的思想，将问题封装成对象
Throwable是异常和错误的超类
该体系的特点是:子类的后缀名都是其父类名做后缀，阅读性比较强
常见的异常
Exception 异常的根类
RuntimeException – 异常的基类
ArithmeticException 算术异常
IIIegalArgumentException 非法的参数
ArrayIndexOutofBoundsException 数组越界
NullPointerException 空指针
ClassCastException 类型转换异常
ClassNotFoundException 不能加载所需的类
NumberFormatException 数字转换异常
IOException io异常
FileNotFoundExceotion 文件找不到异常
EOFexception 文件结束
InterruptedException 线程中断
异常处理的原则
1.函数内容如果抛出需要被检测异常，那么函数上必须要声明
否则，必须在函数内用try catch 捕捉，否则编译失败
2.如果函数调用到了声明异常的函数，要么try catch 要么throws 否则编译失败
3.什么时候使用catch 什么时候使用throws
功能内容 可以解决的用catch
解决不了的用throws告诉调用者，有调用者来解决
4.一个功能如果抛出多个异常，那么调用时，必须有对应的catch进行针对性处理
内部有几个需要检测的异常 就抛出几个异常 抛出几个 就有几个catch块
异常的注意事项
1.子类在覆盖父类的方法时，父类的方法如果抛出了异常，子类的方法只能抛出父类的异常或该异常的子类
2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集
简单说:子类覆盖父类只能抛出父类的异常或者子类的子集
注意:如果父类的方法没有抛出异常，那么子类覆盖是绝对不能抛出异常
只能 try catch
如果让一个类称为异常类，那么必须继承异常体系，因为只有称为异常体系的子类 才有资格具备可执行性
才能被两个关键字所操作。
throws和throw的区别
1.throws 使用在函数上
throw 使用在函数内
2.throws抛出的是异常类，可以抛出多个，之间用逗号隔开
throw抛出的是异常对象
finally 关闭数据库的时候，可以将关闭数据库的方法发到finally语句块中
try catch finally 组合
1.try catch finally
2.try catch (多个catch)
不使用finally
3.try finally
没有处理，必须声明 异常无法直接catch处理，但是资源必须关闭
不管什么情况finally块总会执行到的
除了虚拟机关闭之后，finally不会执行到
受检异常()
1.编译时被检测异常–受检异常—checked
只要是Exception和其子类，除了RuntimeException 这种问题一旦出现，希望在编译时就可以
检测，让这种问题有对应的处理方式
2编译是不检测异常(运行时异常)—非受检异常—unchecked
就是Exception中的RuntimeException和其子类
直接编译通过，运行时，调用者调用程序强制停止，让调用者对代码进行修正
5.多线程
多线程复习
什么是多线程
进程:正在进行的程序
线程:就是进程中一个负责程序执行的控制单元
一个进程中可以有多执行路径，称之为多线程
一个进程至少有一个线程
开启多个线程是为了同时运行多部分代码
每一个线程都有自己的内容 这个内容可以称之为线程要执行的任务
线程和进程的区别:
同时运行多个任务程序–进程
同一个应用程序有多条执行路径并发执行–多线程
多线程的好处:解决了多部分同时运行的问题
多线程的弊端:线程太多，效率的降低
创建线程目的是为了开启一条执行路径，与执行指定的代码和其他代码实现同时运行，而运行的指定代码就是
执行任务的路径
JVM创建的主线程的任务都定义在了主函数中
自定义的线程它的任务在哪
Thread类用于描述线程 线程是需要任务的 所以Thread类也是对任务的描述
这个任务就是通过Thread类中的run方法来实现的 run()就是封装自定义线程
run()方法中定义的就是线程需要运行的任务代码
开启线程就是为了运行指定代码，所以只有继承Thread类，并复写run方法
JVM启动就会执行多个线程
1.执行mian函数的线程-
2.负责垃圾回收机制的线程
如果创建一个线程
1.创建线程的方式 继承Thread类
步骤 1.定义一个类继承Thread类
2.覆盖Thread类中的方法 run();
3.直接创建Thread的子类对象创建线程
4.调用start方法开启线程并调用线程的任务run方法执行
2.创建线程的第二种方式 实现Runnable接口
步骤 1.定义类实现runnable接口
2.覆盖接口中的run方法 将线程的代码封装到run方法中
3.通过Thread类创建线程对象，并将Runnabel接口中的子类对象作为
Therad类的构造函数 参数进行传递
原因:因为线程的任务都封装在Runnabel接口中的子类run()方法中的 所以要在线程对象创建时，
就要明确要运行的任务。
4.调用线程的start()方法开启线程
实现接口的好处
1.将线程的任务从线程的子类中分离出来，进行单独的封装 按照面向对象的思想将任务封装成了对象
2.避免了java单继承的局限性
Runnabel接口的出现仅仅是将线程的任务进行了对象的封装
start:作用是启动一个新线程会相继调用run方法
run:和普通方法一样 单独调用会在当前线程执行run() 不会启动新线程
停止线程的
1.stop方法
2.run方法结束
怎么控制线程的任务结束
任务中会有循环结构，只要控制循环结构 就可以结束任务
控制循环通常使用标记来实现
cpu的执行资格:可以被cpu处理 在处理的队列排队
cpu的执行权:正在被cpu处理
线程的五种状态
被创建start()
线程运行–具备执行权和执行资格
临时堵塞状态–具备执行资格，但不具备执行权，正在等待执行权
冻结状态----释放执行权的同时，释放执行资格
消亡状态—run方法的结束 线程的任务结束
wait可以指定时间也可以不指定时间
sleep 必须指定时间
在同步时，对cpu的执行权和锁的处理不同
wait 释放执行权 释放锁
sleep 释放执行权 不释放锁
守护线程和用户线程
用户线程 java虚拟机在它所有分守护线程都离开后自动离开
守护线程 守护线程是用来服务用户线程的
setDaemon()
多线程安全问题的产生的原因
1.多个线程在操作共享的数据
2.操作共享数据的线程的代码有多条 当一个线程在执行操作共享数据的多条数据代码过程找中
其他线程参与了运算，就会导致线程的安全问题的发生
同步的好处：解决了线程的安全问题
弊端:相对降低了效率 因为同步外的线程都会判断同步锁
同步的前提是:同步中必须有多个线程并使用同一个锁sybchroized
同步函数的锁是this
同步代码块的锁是任意的(同步代码块对于锁的操作是隐士的)
jdk1.5后将同步和锁封装成了对象
并将操作锁的隐式方式封装成了对象，将隐式动作变成了显示动作
lock接口 出现替代了同步代码块或同步函数 将同步的隐式锁 操作变成了
显示操作 同时更为灵活 可以一个锁加上多组监听器
wait 让线程处于一个冻结状态 被wait的线程会被存储到线程池中
notify 唤醒线程池中一个线程(任意)
notifyAll唤醒线程池中的所有线程
这些方法必须定义在同步中
因为这些方法是用于操作线程状态的方法
必须要明确到底操作的是哪个锁上的线程
if判断只有一次
会导致不该运行的程序运行了 出现了数据错误的情况
while判断标记解决了线程获取执行权后是否运行
notify只能唤醒一个线程 如果本方唤醒本方 没有意义
而while判断标记 notify会导致死锁
nitifyAll解决了本方线程一定唤醒本方线程的问题
6.I/O
io 流
转换流
InputStreamReader 字节流—字符流 解码
OutputStreamWriter 字符流----字节流 编码
流的操作规律
之所以弄清楚这个规律，是因为流对象太多，开发时不知道
要使用哪一个
要弄清楚开发时，使用哪一个就需要明确
1.明确源和目的(汇)
源: InputStream Reader
目的: OutputStream Writer
2.明确数据是否是文本数据
源:是文本格式 Reader
不是的话 InputStream
目的 是 Writer
不是的话 OutputStream
注意:到这里就可以明确要是用哪一个体系
3.明确具体的设备
源设备:
硬盘:File
键盘:System.in
内存:数组(其实就是缓冲区)
网络:Socket流
目的设备
硬盘:File
控制台:System.out
内存:数组(其实就是缓冲区)
网络:Socket流
4.是否需要其他额外功能
1.是否需要高效
是，就是用缓冲区
Buffer
2.是否需要转换
需求1:复制一个文本文件
1.明确源和目的
源:InputStream Reader
目的:OutputStream Writer
2.明确是否是文本文件
源文件是 Reader
不是 InputStream
目的文件是文本文件
Writer
3.明确设备
源设备 硬盘 File
目的设备 硬盘 File
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FilWriter("b.txt");
4.是否需要额外功能
需要高效
Buffer
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt"));
需求2:读取键盘录入信息，并写入到一个文件中
1.明确源和目的
源: InputStream Reader
目的: OutputStream Writer
2.明确是否是文本文件
源文件是文本文件 Reader
目的文件 是文本文件 Writer
3.明确设备
源文件设备
键盘 System.in
目的文件设备
硬盘 File
InputStream in = System.in;
FileWriter fw = new FileWriter("t.txt");
现在需要思考的问题是从键盘上获取的是字节流，
而在文本中输入的是字符流，所以需要将键盘上获取的字节流转换成字符流
4.是否需要额外功能
需要转换
字节流转换字符流
InputStreamReader Isr = new InputStreamReader(new InputStream(System.in));
FileWriter fw = new FileWriter("t.txt");
还需要其他额外功能吗
需要高效
BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in))
BufferedWriter bfw = new BufferedWriter(new FileWriter("t.txt));
需求3:将一个文本文件数据显示在控制台上
1,确定源和目标
源 Inputstream Reader
目的 OutputStream Writer
2.是否是文本文件
源 是文本文件 Reader
目的 是文本文件 Writer
3.明确设备
源设备 硬盘 File
目的 System.out;
FileReader fr = new FileReader("a.txt");
OutputStream out = System.out;
4,是否需要额外功能
注意:现在需要思考一个问题就是从文本中读取之后在控制台上输出来是是需要转换成字符流
字符流转换成字节流
FileReader fr = new FileReader("a.txt");
OutputStreamWriter osw = new OutputStreamWriter(new OutputStrem(System.out));
是否需要高效
需要 使用Buffered
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(new OutputStream(System.out)))
需求4:读取键盘录入数据，显示在控制台上
1.明确源和目的
源 InputStrem Reader
目的 OutputStrem Writer
2.明确是否是文本文件
源 不是文本文件
InputStrem
目的 不是文本文件
3.明确设备
源设备
System.in
目的设备
System.out.
InputStream in = System.in;
OutputStream out = System.out;
4.是否需要额外功能
注意现在需要思考的是，从键盘上获取的文件是字节流，为了操作方便需要将其转换成字符流文件
InputStremReader isr = new InputStreamReader(System.in)
注意现在获取到的是字符流 需要将其转换成字节流
OutputStreamWriter osw = new OutputStreamWriter(System.out);
是否还需要其他功能
需要高效
BufferedReader bfr = new BufferedReader(new InputStremReader(System.in))
BufferedWriter bfw = new BufferedWriter(new OutputStremWriter(System.out));
5.将一个中文字符串按照指定的编码表写入到一个文件中
1.目的 OutputStream Writer
2.是存文本吗 Writer
3.设备 硬盘File
FileWriter fw = new FileWriter("a.txt");
注意：既然需求中已经明确了指定的编码表的动作
那就不可以使用FileWriter 因为FileWriter内部是使用了默认的
本地编码表
只能使用其父类 OutputStreamWriter
OutputStreamWriter 接收一个字节输出流对象
既然是操作文件，那么该对象应该是FileOutputStream
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt").utf-8);
是否需要高效
需要
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(("a.txt"),utf-8)))
gbk utf-8 unicode 编码表
9. 一个对象的实例化过程
一个对象的实例化过程
Person p = new Person();
1.jvm会读取指定的路径下的peron.class文件 并且加载进内存
并会先加载person的父类(如果有直接父类的情况的话，默认为object)
2.在堆内存中开辟空间分配地址
3.并在对象空间中对对象中的属性进行默认初始化
4.调用对应的构造函数初始化
5.在构造函数中，第一行会先调用父类中的构造函数进行初始化
6.父类初始化完毕后，在对子类的属性进行显示初始化
7.在进行子类构造方法的特定初始化
8.初始化完毕后，将地址值赋值给引用变量