总复习{
配置环境变量，安装jdk
1.关键字: 都是小写字母
在java中，具有特殊含义的 单词就是关键字
this, break, class, public, continue,private
byte,short, int ,long ,double, float ,char ,boolean, finally,protected
goto 保留关键字
2. 标识符:
在java中，凡是自己起名字的地方都是标识符;
约束: 1.由26字母，a-z,A-Z,0-9数字 ，_ $ 组成
2.不能以数字开头 ,但是可以包含关键字
3.不能是关键字，但是可以包含关键字
4.不能由空格
5.一般都以驼峰式命名 ， xxxXXXxxx， 都是小写
3.变量:
什么作用?
存储单个数据，在内存中存储在 栈中
必须用 数据类型修饰 ， 在同一个作用域中 ，变量是不可以重复的
一般都是简明知意
4.数据类型:
基本数据类型:
数值型：
整型: byte (-128 - 127), short(-2^15 - 2^15-1), int(-2^31-2^31-1) , long(-2^63-2^63-1)
1 2 4 8
long类型特殊: long 可以加后缀 也可以不加的
因为java中识别整型默认是按int 类型加载，long a = 2342;
在int范围内，就不用加L ， 如果这个值超过int 类型在 long 类型范围内
就必须加 L
浮点型：float(必须加f、F后缀) ，double (默认加载) d
4 8
字符型: char 2
布尔型: boolean 1
1个字节 8位: 0000 0000
以上8个数据类型的默认值是什么?
整型 0 ， 浮点型 0.0 char ' ' boolean false
数据类型转换: 给oop 做铺垫 ，多态 Object Person
自然数据类型转换(隐式转换): 从小到大的转换 byte-->short-->int-->long float --> double
一般都是整型 和 整型转换， 浮点型和 浮点型转换，如果他们转换 会出现精度损失
强制数据类型转换(显示转换): 从大到小的转换 long -->int ---> short ---> byte
char <---> int
ASCII 每个字符 都对应一个 数字，
经典的一道题: 在控制台输入a ，打印出来一个 大写A
引用数据类型:
类class，数组 array，注解@Annotation ,接口interface ， 枚举enum
运算符:
算数运算符: +， - ，* ，/ ，% , ++, -- (一元运算符)
比较运算符: > ,< ,>= ,<=, != , ==
逻辑运算符: && , || , ! , & , | , ^
true && true true
false && true false 左边位false 右边不参与判断，
true && false false
true && false false
true || true true
true || false true
false || true true
false || false false
true ^ true false
true ^ false true
false ^ true true
false ^ false false
!true false
!false true
赋值运算符: = ， +=,-=,/=,%=
三元运算符: boolean类型表达式 ? 结果1 : 结果2 ;
条件语句:
单分支 if(){}
双分支 if(){}else{}
多分支 if(){}else if(){}else if(){}else{}
switch( int,char, String ,enum ){
case 1:
case 2:
case 3:
default:
}
循环:
1.while( boolean类型表达式 ){ 循环体 }
2.do...while(boolean类型表达式);
如果boolean类型表达式结果位false ，do...while要比while多执行一次循环体
3.for
能不能执行 ，什么效果 死循环
for( ; ; ){
}
循环的三要素:
1. 终止条件
2. 初始化值
3. 迭代部分
break: 作用 用来终止循环
for(){
for(){
break; 它只对内层循环有用 ，不会影响外层循环
}
}
continue: 跳过本次循环，执行下一次循环，
java循环结构有几种? 5种 iterator 真对 Set集合
}
数组:
一维数组:
数组初始化:
动态初始化: 数据类型[] 变量名 = new 数据类型[长度];
静态初始化: 数据类型[] 变量名 = {44,4,51,23,11};
数据类型[] 变量名 = new 数据类型[]{5,2,3,412,1,2};
多维数组: 二维数组
动态初始化: 数据类型[][] 变量名 = new 数据类型[3][2]; 3行 2列
3行 指的是一个二维数组中，有几个 一维数组，
2列 每个一个数组中有几个元素
静态初始化: 数据类型[][] 变量名 = { {} , {} , {} };
数组的特点:
1.数组长度一旦确定不能改变
2.数组必须通过下标来获取元素， 从0 开始， 到length- 1结束
3.数组只能存储相同数据类型
4.数组可以存储重复元素
---------------------------------------------------------------------
面向对象: oop (Oriented-Object Programming)
那什么是面向对象编程?
当我们遇到一个问题的时候，先不考虑如何解决问题，先从问题域中
查找对象，在根据对象构建 Java类，在new 对象 ，调用方法 执行
在程序中 这个过程 就是面向对象
学习面向对象的基础:
类 和 对象的关系?
类是 对象的 抽象， 人 ，包含 男人， 女人 所以范畴定义的
对象 是 类的 具体实例
是先有类 还是先有对象?
一定是先有 类 ， 才能根据 class 类 new 对象
java中如何定义一个类啊?
public class Person{
}
类的组成部分? 有 5 个
1.成员属性 ， 也可以用static ，final 修饰
2.成员方法 方法就是类的 功能
3.构造器 创建对象即可 构造方法 是不是方法，是方法，是特殊的方法，无返回值
作用: 1. 给成员属性赋值
2. 规范对象的创建
4.静态块 是用 static 关键字修饰的，全局加载一次，
5.构造块儿 ，实例化几次对象 就 加载几次
访问修饰符:
public 公共的
protected 受保护的
private
static关键字可以修饰什么?
1. 可以修饰 方法
2. 可以修饰 属性
3. 内部类
private static class Node<E> { 静态内部类
面向对象特性:
封装，继承，多态， 抽象:
1.封装: 类本身就是一个封装体 ， 内部类
private 修饰属性 ， 必须提供 共有的 getter ，setter方法
方法也是封装体
让程序编程 安全，外界无法访问，
2.继承: 是用extends关键字
作用就是可以拓展程序，提高程序的延展性，减少代码重复
构造器: 在继承中 构造方法能被继承吗?
是不能被继承的 ，只能被调用
注意: 子类继承父类 必须调用父类的构造器，
默认是去调用 无参数的, 如果没有无参数的，
就一定调用 有参数
java中只支持单继承 (一个类 只能有一个父类)， 但是可以多重继承
3.多态:
多态的前提,必须是继承
同一种事物的不同种表现形态， 减少代码冗余 ，让程序变的更加灵活
public void follow(Pet pet){
}
体现多态的形式有几种?
1. 一个类作为 一个方法的 入参，这个类一定要是一个父类
它可以传入子类的类型
2. 父类 a = new 子类对象(); 父类的 类型 指向了 子类对象
用的最多的: 3. 接口 a = new 实现类();
多态在编写代码时:
1.编译时类型: 是父类类型
2.运行时类型: 子类类型
castDown castUp
向下转型 向上转型
instanceof 关键字 判断 当前变量 是不是 这个 类型的
Animal a = new Dog();
if(a instanceof Dog){
Dog dog = (Dog)a;
dog.调用子类独有的方法 或属性
}
抽象: 体现 抽象类 ， 接口
对于 具体事物的一个 设计
接口 --->抽象类 --->类 ----> 对象
1.抽象类:
是用abstract关键字 ,可以修饰属性， 修饰方法
由抽象方法的类一定是抽象类吗？
一定是
抽象类种 一定有 抽象方法吗?
不一定
抽象类存在的意义是什么?
1.就是用来被继承的 ，不能new 对象
里面可以有具体方法 ， 也可以有抽象方法
抽象方法没有方法体
2.抽象类中有构造器吗?
有，不能new对象 存在的意义是什么?
就是用来被 子类 调用的;
2.接口
接口中的方法都是 抽象方法，接口不能new对象
接口是用来被 类实现的；用implements 关键字
一个类 可以实现多个 接口，
接口和接口之间是继承关系
方法重载:
在同一个类中，方法名相同，参数列表不同(参数个数，参数类型，参数顺序)，与返回值无关
方法的重写:
在继承中， 方法名相同，参数列表相同(参数个数，参数类型，参数顺序)，返回值相同，
========================================================================================
常用类:
包装类:
Byte, Short, Integer, Long , Float,Double, Boolean,Character
Integer：
new Integer(int a);
new Integer(String str);
parseInt(); 字符串转换为 int类型
valueOf(); 把int ，String 转换位Integer对象
toBinaryString(); 二进制的字符串
Object: 是 所有类的 父类
clone(); 返回对象的副本; 它是Java、中创建对象的一种方式
必须实现Cloneable 接口
equals(); 用来比较两个对象是否相等
toString(); 打印对象信息
wait(); 让线程进入 锁池(等待池)
notify(); 唤醒锁池中的一个 线程
notifyAll(); 唤醒锁池中的 所有线程
finalize(); 垃圾回收机制
自己背画完整的线程的生命周期图;
String: 代表字符的序列，是用final修饰的类， 不能有子类，
被称为不可改变类，
构造器:
new String();
new String(byte[] b);
new String("");
new String(byte[] b,字符集名字); 在框架开发中 可能被用到
方法:
charAt(''); substring() , indexOf(); ,lastIndexOf();
split(); replace(); length(), isEmpty(); contains();
trim(); endWiths(); startsWith(); getBytes();
toUpperCase(); toLowerCase(); compareTo(); 可以比较两个字符串的大小
valueOf(); 项目中用到的
常量池: java中创建字符串的方式有两种
String str = "abc"; 放在常量池中
String str = new String("abc"); 放在堆中
常量池在方法区中，方法区在堆中
StringBuffer: 线程安全 , 有synchronized修饰
代表字符串的缓冲区: 默认长度16
缓存区 实际上就是一个 new char[16];
StringBuilder: 线程不安全 没有 synchronized 修饰
同理;
append();
reverse();
toString();
lastIndexOf();
IndexOf();
length(); 有效长度
capacity(); 容量
charAt();
insert();
delete();
toString();
String , StringBuffer, StringBuilder的区别?
String是 不可改变类， 如果 是用 + 加号进行操作就是 拼接作用
频繁的+ ， 就会频繁的开辟空间，
StringBuffer 和 StringBuilder 多是字符串缓冲区;
是用append是拼接作用，不会占用新的空间
Date:
日期类: java.util.Date 当前系统时间
new Date(); 有无参数构造器
|-- java.sql.Date 代表数据库日期
new Date(date.getTime());
将系统时间包装成 数据库时间
Time: 代表时间
Timestamp: 代表日期 + 时间
SimpleDateFormat: 用来格式化 日期时间的
sdf = new SimpleDateFormat("yyyy-MM-dd");
sdf.format(Date date); String
sdf.parse(String str); Date
Scanner:
nextLine(); 按回车截取
next(); 按空格截取
Math:
abs(); max(); , min() , Math.pow(); ,Math.random();
sqrt(); 开方 ，Math.pi();
Random:
nextInt(int bound); 代表边界值 + 1 代表偏量值
-----------------------------------------------------------------
异常Exception:
体系: 后期都是被动处理异常
我们很多地方在后期 都是用框架，技术点，都是封装号的，调用
也有我们需要自己设计的，但是异常一般我们都不用自己区定义
学会处理异常，但是大多数都是声明;
Throwable:
|-- Error: 解决不掉的，开车，发动机坏了
|-- VirtualMachineError:
|-- StackOverflowError: 栈溢出 ---> 方法调用方法了
|-- OutOfMemeryError: 内存泄露 当我们运行的程序没有可用的资源时
|-- Exception: 开车，出现小动物，导致停车了
|-- RuntimeException: 运行时异常
|-- IndexOutOfBoundException
|-- ClassCastException
|-- ClassNotFoundException
|-- NullPointerException
|-- ArthmeticException
|-- IllegalArgumentsException
|-- NumberFormatException
|-- IOException: IO流异常
|-- EOException
|-- FileNotFoundException
java中处理异常的方式:
1.try...catch 捕获一个异常
try{
}catch(AException | BException | CException e){
}
try{
}catch(AException e){
}catch(BException e){
}catch(CException e){
}
try{
}finally{
用于关闭资源
}
finally块儿中 如果 加了return 会出现什么情况?
1.方法的返回值 会 被 覆盖
2.会出现异常丢失
finally块儿一定执行吗? 不一定
1.在try块前出现异常
2.在try块儿中 执行System.exit(0);
2.抛出 throw new Exception(); 创建一个对象
throws 声明异常 一般用于方法上，当前方法声明了一个异常
=====================================================================================
I/O:流
主要功能就是用 流 来传输数据;
流的体系:
按方向划分: 输入流 / 输出流
按类型划分: 字节流 / 字符流
InputStream: 字节输入流 抽象类
available(); 有效的字节数
close(); 关闭
read();
read(byte[] b);
read(byte[] b,int offset,int len);
功能 读取数据
|-- ByteArrayInputStream: 是用来读取byte数组的 输入流
|-- FileInputStream: 文件流 读取指定文件的
在学习FileInputStream的时候 一定要 先学习File类
File代表文件 或 目录：
1.递归遍历指定目录下内容、
2.递归删除指定目录
createNewFile(); 创建文件
exits();判断是否存在
isFile(); 是否是文件
isDirectory(); 判断是否是 文件夹
mkdir(); mkdirs(); 创建一层文件夹， 创建多层文件夹
isHidden();判断是否是隐藏文件
File[] file = listFile();
getName(); ，getAbsolutePath(); 获取绝对路径
getParent(); 获取父目录
lastModified(); 获取最后修改时间
|-- ObjectInputStream: 反序列化 ,对象流 ，专门用来读取对象的
readObject();
序列化 和 反序列化的区别?
什么是序列化?
将内存中的对象 ，通过对象流的形式 写入到 物理文件中的过程就是序列化、
将物理文件中的内容，通过反序列化读取到内存中的过程就是反序列化;
|-- AudioInputStream: 音频输入流
|-- PipedInputStream: 管道输入流
OutputStream: 字节输出流 抽象类
write(int a);
write(byte[] b , int off,int len);
write(byte[] b);
flush();
close();
|-- ByteArrayOutputStream:
|-- FileOutputStream:
|-- ObjectOutputStream: 序列化
|-- AudioOutputStream: 音频输入流
|-- PipedOutputStream: 管道输入流
Reader:
|-- BufferedReader:
String str = readLine();
close();
|-- InputStreamReader:
|-- FileReader:
|-- CharArrayReader:
Writer:
|-- BufferedWriter:
newLine();
write(String str);
flush();
close();
|-- OutputStreamWriter:
|-- FileWriter:
|-- CharArrayWriter:
案例应用时:
new BufferedReader(new InputStreamReader(new FileInputStream(new File())));
readLine();
new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File())));
write(str);
newLine();
close();
nio: Non-blocking I/O 也叫 New-I/O
三大核心:
Buffer:缓冲区 ---->ByteBuffer，IntBuffer,ShortBuffer....
ByteBuffer.allocate(1024);
Channel:通道
Selector: 选择器 监听多个通道 读取数据的
================================================================================
多线程:
1. 迅雷 多个线程 处理多个任务
2. 多个线程共享一个资源 ： 体现了资源的 竞争问题
3. 多个线程 共享多个资源： 死锁
4. 线程通讯： Object类的 wait ，notify， notifyAll
1.sleep方法和 yield方法的区别?
1.sleep方法执行完 会让线程进入 阻塞状态，不释放锁， 有异常，不考虑线程优先级问题
所以会让低优先级的线程机会大点
2.yield 方法执行完毕会让线程进入就绪状态，yield更适合测试场景
考虑线程优先级问题; 没有入参，没有异常;
2.sleep方法和 wait方法的区别?
sleep是Thread类的方法，有异常，有入参，自动释放锁，在时间片用完的时候
静态方法;
wait方法会让线程进入锁池(等待池)，必须通过notify或notifyAll来 唤醒
普通方法 ， 必须放在同步锁中; 有异常， 有入参，Object类的方法
java中实现多线程的方式有几种?
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口： juc 高并发
什么是 守护线程?
守护线程是 服务其他线程的线程，一般都是运行在后台，jvm虚拟机退出后它
还会执行，不受jvm虚拟机的影响，也就是具有自动结束声明周期的能力
GC就是一个守护线程;
守护线程 不确定什么时候 死亡; setDeamon(); isDeamon();
多线程有几种锁机制? 分别是什么? synchronized 和 Lock的区别?
synchronized 和Lock 锁:
1.synchronized锁 是 关键字，自动释放锁 ，偏于jvm虚拟机底层实现
2.Lock锁是方法啊，lock() , 不能自动释放锁，必须程序员手动调用 unlock()方法
释放锁; 一般存在finally块儿中,跟synchronized 更灵活
jdk1.8 对synchronized 不必 lock差 ， lock支持 高并发
什么是线程同步， 什么是 线程异步?
线程同步指的是 线程安全，有synchronized修饰 ，资源不会出现竞争问题，(不会出现数据丢失)
线程异步 是线程不安全的，没有synchronized修饰 ， 会出现资源竞争问题，数据第十
加Lock lock = new ReetrantLock();
完整的线程声明周期图?
======================================================================================
集合框架:
集合框架的作用?
用来存储大量数据 ，数组作用也是用来存储数据的，但是有局限性
数组的长度一旦确定不能改变，数组只允许存储相同数据类型,但是 集合是很灵活的
提供泛型;
Iterable: 父接口 提供了 可以迭代的功能 ，iterator方法 返回一个迭代器
|-- Collection: 单值集合的顶级接口
|-- List: 有序的，可重复的, 允许存储null 值的
|-- ArrayList: 是是用Object[] 对象数组 封装的，
是有下标的，可以通过get(int i);
获取元素; 适用于查询操作，速度快
|-- LinkedList: 双向链表，每一个链表节点都会被封装成
一个Node节点(E e ,Node pre, Node next)
没有下标，对于查询速度慢，添加和 删除速度块儿
一身多值: 当双向链表，栈，单项队列， 双向队列
|-- Vector: 根ArrayList功能一样，只是线程安全的,
是是用 Object[] 对象数组完成; 现在淘汰
|--Stack: 栈结构, 特点 后进先出 LIFO
推箱子，象棋悔棋 , ctrl + z 撤销
|-- Set: 无序的，不可重复，允许存储null值 ， 只能存储一个
HashSet:
底层实现是HashMap ，向HashSet存储数据时就技术
存储自定义对象 时 一定要重写 hashCode 和 equals方法
由于 Set 集合 没有get方法，没有下标可以操作
所以 只可以用 迭代器， 和foreach 遍历输出
TreeSet:
有序的Set集合, 我们在存储Integer，String的时候
都没有问题，但是在存储自定义对象时，TreeSet
必须实现 Comparable接口
或者重写Comparator接口 自定义比较器，自由
还可以是是用 匿名内部类
|-- Queue: 代表的是 单向 队列 结构
|-- Deque:
代表双向队列结构
以上两个接口的实现类 都是LinkedList
|-- Map接口 : 允许存储null 值
|-- HashMap: 哈希表存储
默认空间16
原理:
每当我们向HashMap集合中添加元素时，HashMap
会将当前对象 包装成一个 Node对象，这个Node节点
中 包含四个元素，hash，key ，value ，next
当我们存储数据时，会先根据key值 计算出当亲啊元素的
hash值，那到这个hash值，判断当前内存地址是否有，
如果没有 ，就直接存储，如果有 ，就比较equals
方法，如果equals方法相等，那么说明两个key相等
替换value值，如果equals不相等 就以 链表的形式向下存储，
如果链表的长度大于8 就会变成红黑树
如果树的元素个数小与6 就会切换成链表
jdk1.7完 是用 数组 + 链表
jdk1.8 是素组+ 链表 = 红河树的结构;
entrySet(); Set<Map.Entry<Integer,String>> 集合 键值对儿集合
KeySet() ，返回所有的key的集合
values(); 返回所有value的集合
get(Object key);
让自定义对象 当作 map的 key 没多大意思
|-- TreeMap: 有序的map集合
有序的 map集合 ，key值 不允许 存储null ， value无关
key 值 Integer ，String
value 值 自定义对象
|-- Hashtable :
代表线程安全map集合， 不允许存储null值，key-value都不可以
不支持复合操作
网络编程:
什么网络?
网络时将分散在不同位置上的 网络终端，通过网络介质链接起来
从而达到 数据串树 和 通信的目的;
网络变成的基础只是：
ip: 标识 一台唯一的终端
port: 端口号，用来 匹配程序的， 操作系统上可以准确的对接程序
protocol: 在满足以上两个情况后， 就需要用到同一个语言
来进行通讯
重点我们学习的时协议:
TCP/IP: Transmission Control Protocol 传输控制协议
有链接的， 安全的， 性能慢
Socket: 代表客户端
new Socket(InetAddress.getLocalHost(),8888);
getInputStream();
getOutputStream();
ServerSocket: 代表服务器
ss = new ServerSocket(InetAddress.getLocalHost(),8888);
Socket socket = ss.accept(); 服务器要接收客户端发送的请求
了解TCP/IP三次握手 和 四次挥手
UDP: User DatagramPacket protocol 用户数据库包协议
无连接 ，不安全， 速度快， 丢包
DatagramSocket ：客户端 ， 服务器
send(DatagramPacket p); 发送
receive(DatagramPacket p); 接收
DatagramPacket
getData(); 可以获取包中的数据
Http协议: 无状态 无连接的协议， 网站
https://
整体都是理论;
现有广度 ，才有深度
oop面向对象， 集合 ，常用类 ，异常
=======================================================================================
编写通讯案例：
I/O ,网络编程 ，多线程, 多人聊天
客户端, 服务器
Client Server
模拟案例:
功能聊天， heSay ， mySay
=======================================================================================
jvm内存模型:
运行时数据区: 5
1.虚拟机栈 VM Stack
Java虚拟机栈 是线程私有的，
这里存储类中的方法，
栈帧:
1)存储局部变量表: 方法的局部变量都在这里
存放基本数据类型:byte short int long boolean char float double
引用数据类型的变量名 指针指向堆中的内存地址
2)操作数栈:
3)动态链接:
4)方法出口:
包括了每个方法从调用到执行完毕的过程
每个方法都对应一个栈帧
2.堆 Heap:
存放的都是引用数据类型，是对象的 实例, Class类类型
3.方法区Method Area (应该在堆中的)
常量池都在这里
4.本地方法栈 Native Method Stack
只加载native修饰的方法， native修饰的方法 底层不是java
有可能借用了操作系统的内容;
5.程序计数器: Program Counter Register
类加载过程:
1.加载类
将java类 存放到 jvm迅即的过程 ，类加载过程
javac Person.java ------> .class 字节码文件
jvm会从.class文件中 提取 类的 二进制数据
加载到内存中的方法区 ，并且在堆 创建一个 Class对象 ，用来
封装在方法区中的类的数据结构
类加载的最终产物就是 Class对象
javac Person.java
java Person
类的加载是用类加载器完成的:
1.启动类加载器
2.拓展类加载器
3.系统类加载器
以上类 都是 C lassLoader的子类实例
2.连接:
1)验证: 验证类的内部结构是否正确，与其他类是否协调一致
目的为了方式黑客随意编写class文件入侵，这样程序就会很安全
2)准备: 准备给静态变量分配内存 ，static 类只加载一次，
3)解析: 把符号换成指针 cat.run(); 这个点 . 换成 --->
3.初始化:
给当前静态资源变量 初始值 = 0;
即使 代码中 public static int a = 3;
当我们调用的时候 才会 初始化为 3
类 和 接口 触发 资源 初始化的方式:
1.创建对象时
2.调用静态方法时
3.访问静态变量时
4.通过Class 对象的newInstance()方法
5.初始化一个子类 new Cat(); 你的父类也会被加载
6.执行 java 命令 例如 : java Person
标明 Person类是一个启动类;
java中创建对象的方式有几种?
1.new Person();
2.clone();
3.反序列化
4.newInstance();
1487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
