java 特点 面向对象，跨平台
java的环境 运行环境【JRE】[java runtime environ]： 启动虚拟机运行java的代码 开发环境【JDK】[java development kit]： 给开发者提供了一些操作java程序的工具 java环境的关系： JRE=JVM（java虚拟机）+java核心类库 JDK=JRE+开发工具
环境问题： java虚拟机？JVM 是一台虚拟的计算机 用来管理解析执行我们写的java程序 ---转化成操作系统识别的指令 ---操作系统才根据指令让硬件运行 java程序跟操作系统没关系--跟java虚拟机有关系 跨平台的特性表现 java代码 windows版本jvm window linux版本jvm linux Mac 版本jvm Mac 需要在不同的操作系统上面安装支持的jdk或者jre
JDK的目录结构
bin目录---工具
jre目录---运行环境
lib目录---开发用到的类库【虚拟机库】
src.zip和javaxf-src.zip--所有类库资源的源代码
使用JDK的工具：
虽然是可执行文件，不能直接打开使用，
当我们点击打开的时候--弹出黑色窗体--告诉你它的使用方式--使用命令行
windows的命令行环境--dos系统--【windows+r】
输入工具--执行--【第一次安装jdk--直接运行开发工具的时候】
输入java---报错【不是内部或者外部命令】
原因：dos是windows操作系统的另外一种表现形式
jdk的工具属于外来软件应用---不属于我们的操作系统--操作系统无法识别
解决方法：
让操作系统认识jdk工具---告诉操作系统工具在哪里
告诉操作系统路径方式：
地址dos中直接切换到对应目录下---造成一个问题只能在bin目录下使用
通过windows暴露出来的属性【path】将路径添加到操作系统自动识别目录
如何配置操作系统的属性【环境变量】
配置方式有三种【分别应用不同的环境】
第一种：临时配置【不想在电脑上留下痕迹】
windows在dos提供了命令：
path---查看操作系统默认识别的工具路径
set path=新路径；%path% 添加路径
例如 set path=C:\Program Files\Java\jdk1.8.0_341\bin;%path%
第二种：暴力配置：直接配置到系统环境中
选中【我的电脑】【高级系统设置】等
添加jdk的路径
千万不要删除已存在的路径内容
按下home键--将光标定位到最前面
将你的jdk路径粘贴到这个位置，添加一个英文分好隔开
一路【确定】--重新打开命令行窗体--测试环境【java工具命令】
第三种：标准配置：行业规范
解决【暴力配置】存在的问题
问题：我们想换版本的时候，暴力配置方式
需要我们去path路径中找到原来的删除，添加新路径
解决：
能不能将路径单独配置，然后引入path中，系统允许%自定义变量%
配置方式：【到千万不要删除前面都一样】
1）系统变量里面创建一个新的变量【点击创建按钮】
变量名：java_home
变量值：路径中可变部分
例如：【C:\Program Files\Java\jdk1.8.0_341】\bin
2） 将JAVA_HOME 变量引入到path路径下
变量名：path
变量值：%JAVA_HOME%\bin;path原来的路径
注意事项：
1path 中新配置的环境变量一定放在最前面
2.千万别删除
3，JDK的安装类似于解压---所有我们可以第一次安装之后将安装目录放在u盘中
到电脑上直接
开发工具和开发环境：
在开发环境满足的情况下，就要进行程序开发---学习开发工具
jdk提供的开发工具：
javac：java程序的编译工具
java：java程序字节码运行工具
javadoc：java程序生成帮助文档的工具
jar：java项目打包成jar包发布以后的启动执行工具
基本用法注意：
直接输入命令 ---显示他的帮助信息
命令- help 查看帮助信息
命令-version 查看JDK的版本
编写代码的工具：
文本工具----【记事本】
可视化智能编程（IDE）【不建议javase基础使用】可以一键运行程序，自动监测排版程序
eclipse【解压和安装--】---myeclipse【安装版本】
vscode【安装版本】
idea---收费
netbeas--oracle提供
使用记事本编写代码如何执行--使用dos命令---掌握一些常用的dos命令
1）help：查看dos中支持的命令列表
2）dir：查看当前目录下所有的内容【文件和文件夹】
3）cd系列命令：用于切换目录
cd+文件名： 进入当前目录下对应的文件夹
cd+文件夹绝对路径：进入到对应路径的目录
cd+文件夹1/文件夹2：进入多级目录
cd..：返回
cd/:返回当前磁盘的根目录
4）mkdir/md 文件夹名字：创建文件夹
5）盘符：---切换磁盘
6）清屏：cls
7）删除文件夹：rd 文件夹名
8）del 文件名：删除文件
del+文件夹名：删除文件夹下所有的文件
9）exit：关闭当前窗体
10）使用记事本创建和打开文件
notepad + 文件名.扩展名
如果文件存在就打开，不存在就创建一个新的。
特殊命令：
ipconfig 查看网络情况
ping：攻击命令--黑客入门命令
ping ip/域名 字节大小
netstat -nlp 查看端口占用情况
编写Java的第一个程序---打印helloword
1）java文件的要求
java程序的文件拓展名.java
2）java文件的命名要求和程序类名一致，并且构成文件名的每一个
单词首字母大写
3）创建java文件 HelloWord.java
4）编写java代码
java代码基础语法结构--类
语法：【固定写法】
public class 类名{
}
5）程序要想执行，需要有一个起点----入口函数--主函数
语法：【固定写法】
public static void main（string[]args）{
执行业务代码
}
6）业务代码---输出语句--打印信息
System.out.println(内容)；
7）编译java程序
原因：我们所写的java代码 我们认识但是java虚拟机不认识【只认识 0和1】
所以我们需要使用工具将我们java文件编程【0和1组成的字节码文件】
命令语法格式： javac java文件名.java
此命令会令我们的.java文件翻译成class文件
.class文件就是我们的字节码文件
8）执行字节码文件
使用命令：java 字节码文件名/类名
执行程序--得到结果
五.java第一个程序分析，编码规范，出现问题
1.分析java程序编写过程
1）执行过程
A 创建一个java文件
【扩展名.java】【文件名是英文并且构成名字的每一行单词首字母大写】
B 编写程序
程序规范
最外层：编写一个类
public class 文件名{
业务代码
}
代码运行入口：主函数
public static void main （String[]args）{
}
输出语句：
System.out.println();
注意：
以上代码为java固定格式
所有的java代码都在英文环境下编写
根据我们学习的java语法--逐渐丰富业务代码
C：编写源程序代码jvm不能加载运行，
所以需要使用javac命令，将源代码【.java】编译成【.class】
语法：javac 文件名.java
D:得到的字节码文件【.class】 能够被jvm识别
---使用java命令加载字节码文件直接运行程序
语法:java 类名/字节码文件名
E：程序运行输出结果
总结：
java源文件【HelloWorld.java】--【javac命令变编译】
---java字节码文件【HelloWorld.class】---【java命令执行】--结果
2.编码习惯/编码规范
A:java代码严格区分大写小
B:固定代码不能乱改--照抄
C:所有的java代码都是在英文环境
D:各种括号需要成对出现---
E:层级关系分明，内部代码相对外部代码前面要有空格缩进【2-4空格】
F:在我没有让使用图形化工具之前--统一用notepad
3.问题：
A：编码问题--乱码问题
乱码的原因：
我们认识的【小王】------联系两者中介（字节）------电脑【0,1】
欧洲规范【iso8859-1】【一个中文---6字节】
定义标准【UTF-8】【一个中文---3个字节】
中文规范【GBK/GB312】【一个中文---2字节】
例如：
记事本写东西存储---【小王】---【UTF-8】---字节[AAABBB]
dos加载运行的时候---【GBK】---[AA][AB][BB]
解决办法：
之前统一编码--UTF-8
假如已经编码不统一了：
首先使用源编码工具正常打开
再次选中所有的内容--复制
到新编码工具内--粘贴--保存
B：报错问题
javac 去编译代码，如果没有报错--代码合理 没有语法错误
如果报错，会指出错误位置
C:JAVA编译和运行过程错误探索
字节码文件名就是类名
类名必须和文件名一致
可以不一致【定义类的时候前面的public去掉】
--当我们一个文件夹下面有多个java文件，我们全部编译了--无法知道
哪个【.class】所对应的【.java文件】
java语法知识【三个部分】
1基础语法【语言共性 八大语言基础】
关键字 标识符 注释 变量与常量 运算符 流程语句 数组 函数
2.核心语法---面向对象思想--程序编写的规则
面向对象的概念
类的构成
对象创建使用
关键字 static final this super
权限修饰符
包的定义--类的分类
类与类之间 关系
面向对象三大特征
抽象
接口--架构概念--面向接口编程
3. 案件AV高级技术 常用APL
常用类
异常机制
集合框架
IO流
多线程
网络通行
图形界面
反射和注释
java的基础语法【语言共性】
1.关键字
概念：语言开发者提供的具有特殊含义的单词或者字母
关键字所有的字母都是小写
使用:我们只要遵循它的要求语法使用就行，不要有非分之想
2.标识符
含义： 开发者自定义的已名称所用的单词或者字母
构成：26个英文字母大小写，数字，_和$
约束：
不能是关键字
不能以数字开头
严格控制大小写
使用的位置
类名：构成类名的每一个首字母大写
变量名：构成变量名的每一个单词都小写
函数/方法名：第一个单词全部小写其他单词首字母大写
常量名：全部大写
java基础语法知识
1.关键字
2.标识符
3.注释：
1）方便识别和梳理
2）注释的概念
注释说明代码块或者代码语句
3）有哪些注释
//注释内容 单行注释
/*注释内容*/ 多行注释
/**注释内容*/ 文档注释
4）//单行注释
作用：用于解释说明每一行代码语句
使用要求：每一行业务代码都需要加单行注释
5）/* 注释内容*/ 调试代码
6）/**文档注释*/ 文档注释【java特有】
帮助开发者将代码业务生产帮助文档提供被人使用
文档注释的位置：
java文件开头
类的定义上面
接口定义上面
方法/函数上面
常量上面
文档注释的内容
/**
* 需求：当前类或者接口或者方法干什么
* 分析：细化需求业务
* @author 程序编写人的姓名
* @date 编写的时间
* @version v.1.0.1
* 问题汇总：所有遇到问题以及解决方案写出来
文档注释的功能：
替代多行注释
将此类生成帮助文档--给别人使用
命令：javadoc java文件名.java【-d 生成内容存放置】
7）注释的特点
A：注释说明代码功能
B：良好的注释习惯有助于养成编程的感觉【代码是用来翻译我的想法】
C：注释不会参与编译--jvm最后运行的就是纯代码
D：文档注释或者生成类的帮助文档---高级技术中提供很专业的API
4.变量与常量 【数据的暂存和复用】
1）为什么需要
希望同一个数据能在不同的地方重复使用--程序中多个地方公用一个数据
需要一个地方暂时存放数据---有需要的时候就去获取---【内存】+【硬盘】
【内存存储】---临时性---
【硬盘存储】---持久性---
我们此时的数据共享是临时的--需要在内存中划分空间--
---java语言中--称数据存储空间
2）数据存储分类
固定值存储--常量
可变数据存储--变量
3）变量的概念：
内存中的一块固定临时存储空间
想在程序中使用空间--需要进行标识---
存储数据的类型-----变量类型---用于指定存储空间的大小和存储数据类型
存储数据空间的命名----变量名---用于获取数据
4）定义变量语法
A:变量的声明
语法： 变量类型 变量名
例如：int a;// 声明了一个整数变量
B:变量赋值
语法：变量名=新值;
C:变量声明+初始化赋值
语法：变量类型 变量名=初始值;
例如 int b=10;
5）变量类型的定义
基本类型【八个】
整数：
byte short
int long
小数：
float double
布尔：
boolean
字符：
char
引用数据类型【java核心业务类型】
类
接口【特殊类】
数组--
6）定义变量 演示变量定义和使用
定义整数变量--重复使用
7）变量定义及其使用的原理
8）变量类型为什么有八种
原因：Java的数据类型不仅仅指定了存储数据的类型，还限定了存储数据的大小
整数：byte 1字节 127--- -128 2
short 2字节
int 4字节
long 8字节
小数：
float 4字节
double 8字节
boolean 1字节固定值true或false
9）探索java变量类型中特点
所有数据类型是java中定义，不受操作系统的影响
数据类型的使用注意事项
问题1：
byte a=24
byte a1=a+1;//会出现【不兼容的类型;从int转换到byte可能会损失】
问题出现的原因：
A:运算的数据平等性【重点】
B:默认类型 所有整数字面量【参与变量运算】的时候默认为int类型
C:数据类型的转换
一种：强制转换/显示转化 显示标出
变量=（类型）运算表达式
一种：自动转换/隐式转换/类型提升 默认的 涉及到
byte-->short-->int-->long-->float-->double
char
10)默认类型：
当参与变量运算的时候对应字面量/常量数据类型--默认为默认类型
整数：默认类型 int
小数：默认类型double
11）类型转换 【很重要】
A:自动类型转化
按照图示从小到大
备注：char类型的变量值转换为int以及以上的类型运算的时候，char会以其ASCII码值
B:强制类型转化
byte<--short<--int<--long<--float<--double
需要人为干预：
运算表达式前面加上（类型）
备注：强制的时候是如何溢出数据的呢？
int 和byte演示
结论：如果值在取值范围内
如果值超过范围----当前的值减去当前需要存储数据的类型所能存储的数据个数
2023 4.26
/** 需求：变量的演示 分析： 输出语句： @author 黄庆 @date 20230426 9:03 @version v.1.0.1 问题汇总：
/ public class VarData{ /* 需求：主函数 程序入口 @author 黄庆 @param args @return void */
public static void main(String[]args){
/*//定义整数变量
int sex;
//赋值
sex=18;
//重新赋值
sex=180;
//打印信息
System.out.println("王福奇今年是"+sex+",依然是一朵花");
//重新赋值
sex=18;
//打印信息
System.out.println("王之言明年是"+sex);
System.out.println("苏阿鑫后年是"+sex);*/
//探索java变量类型的特点
//先看整数
/* byte a=24;
short s=12;
int i=100;
double d=200;
//使用
a=(byte)(a+1);
s=s+1;
i=i+1;
d=d+1;*/
//默认类型的探索
/*byte a=12;
int i=100;
long l=300;
//运算*/
常量---字面量
概念：表示的是具体的 数据值
常量分类：
整数常量：所有的整数，例如：1 100 102
小数常量：所有的小数，例如：12.2 133.33
布尔常量：true和false
字符常量：所有的用单引号括起来的单个字符 例如 ‘1’‘A’
字符串常量： 所有用双引号引起来的多个字符 例如 "" "AS"
空值常量：值是null 【很重】
为了常量数据共享重复使用--java提供了定义常量的方式
【public static】 final 类型 常量名=常量值
5.运算符【】
概念：就是一种符号，用于数据的运算 赋值 比较等等
运算符的分类
1）算数运算符
概念：用于进行数据运算
使用规范：
A：基本操作
+ - * / % 二元运算符【两个数据进行运算】
++ -- 一元运算符【单个数据进行运算】
B:特殊用法【重点】
++或者--; 位置不同运算逻辑不同
在数据前面先运算在使用
在数据后面，先使用再运算
+：如果+两边都是整数或者小数 或者字符 加法运算
如果+两边有字符串出现 拼接符合
2）赋值运算符
用于给变量或者常量值存储空间里面放值
列举：
= += -= *= /=
3）比较运算符
概念：数据之间的关系运算，是否满足运算条件
主要由于流程控制语句
主要的运算符：
> < <= >= == !=
用法总结：
属于二元运算符，两个数据参与运算
语法规则：数据1 运算符 数据2
例如：100>200 122==100 a>100 【正确写法】
比较运算符的结果是一个Boolean值：true或false
4）逻辑运算符
概念：用于连接多比较运算，解决比较运算符的问题
比较运算符只能进行单个条件比较，多个条件比较
使用逻辑运算符来进行连接
运算符：
| || & && !
解释运算符：
| 和|| ：或者，多个条件只要有满足条件的【true】
最后结果就是满足【true】
&和&&：并且，多个条件必须都满足【true】
最后结果就满足【true】
！ : 非，比较运算结果是true，前面加！ 结果就是false
用于转化比较条件结果
探索：
|和||的联系与区别
联系：都可以作为逻辑运算符---或
区别：
A：|不仅可以作为逻辑运算符 或
还可以作为位运算符 或
||只能作为逻辑运算符--或
B:运算过程不同
||只要前面条件结果出现了true后，后面的条件表达式不再运算
| 无论前面条件是否满足，后面的条件表达式依然会执行
&和&&的联系与区别
5）位运算符【java中比较特殊的运算符】
概念：关注计算机是如何进行数据运算的
按照计算机识别的语法来进行数据的运算【0和1】
位运算符：
| & ^ >> <<
运算规则：按照计算机中二进制
|：按位置或运算 对应位置只要有1 结果就是1
&：按位置与运算 对应位置必须都是1结果才是1
^:异或运算 两个数二进制对应位置只要不一样，结果是1否则为0
数据>>移动的位数 右移动，会把数据转化成二进制按照移动位置右边删除对应位
左边用0补齐字节长度
【重点】 ^特殊用法 加密解密传输数据 两个变量高效交换数据
A：加密和解密
原来数据
65 67 69 72 75
加密完的数据
77 72 72 68 74
6）三元运算符
语法：条件表达式 值1：值2
当条件表达表达式满足 返回值1结果
当条件表达表达式不满足 返回2结果
有点类似if-else语法
此运算符是有返回结果的;
7）流程控制语句【与javascri一模一样】
条件语句：if
A：语法
if（条件表达式）{
满足条件执行语句
}
B：语句
if（条件表达式）{
}else{
}
C：语句
if（条件表达式）{
}else if{
}
......
else{
}
D:语句
if（条件表达式）{
执行语句1;
if（条件语句2）{
执行语句2
}
}
含义：
条件表达式1的运算结果为true的时候执行【执行语句1】
并且执行条件表达式2运算
【执行语句2】执行的要求是：
条件表达式1的运算结果是true并且 条件表达式2的运算结果也是true；
2）循环语句
A：语法1 for
for（初始条件计数器；判断条件表达式；计数器改变）{
执行循环语句
}
B: while
C:循环do-while
三种循环之间的关系和特点
for循环是对while循环的简化 所以正常循环选择for
while适合做无限循环或者特殊用法【例如数据库结果集迭代】
for(;;){}或者for(;true;){}--无限循环
while(true){}.....无限循环--更加简便
do while无论条件是否满足至少执行一次
C:选择语句 switch
语法：
switch（参数值）{
case值1：
参数值等于1执行语句;
break;
case值2：
参数值等于值2执行语句
break;
default:
以上都没有满足条件的执行语句
}
注意：
A：没有break的时候，当有case条件满足，下面的语句都执行
B:【参数值支持】的类型 byte short int char 枚举 string【JDK1.7】
4）两个关键字
break：结束距离他最近的外层循环
continue：结束本次循环,继续下一次循环
数组
1）出现原因？
前面计数无法解决的问题---有多个数据需要存储共享--数组
2）含义
一些类相同类型的数据的集合
3）定义语法
数据类型[] 数组名=new 数据类型[长度];//定义一个固定长度的空数组
数据类型[] 数组名={数据1，数据2....};定义一个存储了多个数据数组
数据类型[] 数组名=new 数据类型[]{数据1，数据2，数据3.....}
也支持
数据类型 数组名[]=new 数据类型[长度];//定义一个固定长度的空数组
数据类型 数组名[]={数据1，数据2....};定义一个存储了多个数据数组
数据类型 数组名[]=new 数据类型[]{数据1，数据2，数据3.....}
4)数组的使用
存值：
数组名[下标]=值
取值：
数组名[下标]
5）数组的特征总结;
A 数组定义要么给定长度，要么给定值
B 直接打印数组名的时候直接输出数组地址--引用类型
C 定义数组的时候给定长度，会在内存中分配连续多个对应类型的内存
空间
6）数组中常出现的问题
A 数组定义的时候一旦长度确定--此数组存储的数据个数就固定了
不能改变，如果在使用数组的时候调用的下标不在范围内，报出
问题【ArrayIndexOutOfBoundsException】
B：数组定义的时候一旦初始化值，值的个数就是数组的长度，也是在执
行的时候分配至数据的空间块
C：数组长度--固定不可变
D：数组在定义的时候--数组存储的数据类型就固定了
数组的特征：
数组符号--[]
下标索引--多个数组存入一个变量，用于一系列连续的空间
获取某一个数据，需要使用空间编号【下标索引，特点
最小从零开始】
获取数组中所有的数据
找规律---下标从0--len-1 连续整数--循环for
还有一种遍历方式foreach增强for循环--用于遍历引用类型对象
--数组就是引用类型--【集合】
数组本身就是引用类型--Java中塑造一个工具类Array
快速帮助我们处理数组中的一些业务【定义了很多的方法和属性】
排序：sort()
获取长度：length
对于java代码来说，当你定义数组的时候他就将你的数组转化成array
我们定义的数组可以使用array类中所有功能
使用方法：
数组名.方法或属性
7）数组的分类
根据数组存储值的方式
一维数组：定义一个常见数组，定义一个数组里面存储的是基本数据
多维数组：
包括 【二维数组---常见】 三维数组 四维数组......
例如二维数组：一维数组里面存储的数据都是一个一维数组
定义语法
数据类型[][] 数组名=new 数组类型[长度][长度]；
数据类型[][] 数组名={{数据1，数据2}，{数据1，数据2}，{数据3，数据3}}
取值
数组名[第一层数组的下标][第二层数组的下标]
赋值;
数组名[第一层数组的下标][第二层数组的下标]=值
总结
作用:临时存储数据
原因：因为可以将多个同类型的数据存储一个数组变量
一维数组：存储多个数据
二维数组：存储多行多列数据 平面数据
三维数组：存储立体数据
函数:
出现的原因：简化业务逻辑--进行业务代码拆分--形成小的功能代码块--进行功能复用
函数的概念：封装了特定功能的代码块---有名字
定义语法：
【权限修饰符】 【高级修饰符】 返回值类型 函数名（参数类型 参数名,参数类型2 参数名2.....）{
功能代码块;
【return 返回值】;
}
解释：
权限修饰符--访问权限范围【目前用public】
高级修饰符：定义函数的特殊使用方式 final static【目前使用static】
返回值类型：函数执行完成需要返回给使用者的数据类型 一般搭配return使用
函数名：标识符--
参数：告诉调用者，使用函数需要传入的数据
功能代码块：执行业务的代码
return 返回值：就是需要返回的数据
使用：
同一类中函数之间可以相互调用
【变量类型 变量名=】函数名（参数值）
总结：
参数的说明：
定义函数的给定参数（类型 参数名）
形参：形式参数
此处的参数就是告诉函数调用者使用函数的时候需要传入的值类型，个数和
顺序
实参：调用的时候传入的参数
根据要求传入实实在在的数据，根据函数的定义的时候参数要求传入数据
java的编程方式---面向对象的编程思想
java面向对象的第一个特征，抽象---不具体的东西具体化过程
所有java代码都是由类构成，做成java代码最小的文件单元：类文件
java类的定义以及构成
定义语法：
权限修饰符 【高级修饰符】 class 类名{
类体【需要描述的内】
}
备注：
权限修饰符：外部类---默认使用public
内部类---可以是其他的修饰符
高级修饰符: 控制类使用方式
final abstract----【java关键字】
class 类特殊标示--固定写法
类名：标识符 需要开发者自定义【构成类名的每一个单词首字母大写】
类体：解释一类事物的描述信息构成
属性---描述事物的状态信息
方法--就是函数，用于描述事物的行为
构成方法---通过类构建对象，使用
块---用于类加载之前处理的信息引导信息
内部类--内部再次定义一个类用于完善描述一个嵌套信息
类型内部构成信息--属性
属性--特殊变量---对变量进行类约束 存储事物状态数据
定义语法：
【权限修饰符】 【高级修饰符】 属性类型 属性名【=初始值】；
解释：
权限修饰符：定义访问范围权限【四大权限修饰符】--暂时使用public
高级修饰符：用于约束属性的特定用法
final static
属性类型：变量类型【基本类型+引用类型】
属性名：变量名【定义规范：全部小写】
初始值：想给属性一个固定的初始值
备注：在类中可以定义属性(变量)---全局变量----整个类中都可以使用
与全局变量对应的---局部变量--定义函数【方法】或者代码块中--只有有限的范围有用
10. 类内部构成信息---方法(函数）
方法--基本语法中的函数（封装功能被调用）----描述一类个体【对象的】行为功能---
语法：
权限修饰符 【高级修饰符】 返回值类型 方法名（参数列表）{
方法体[执行功能];
【return 返回值;】
}
解释：
权限修饰符：方法的适用范围---目前public
高级修饰符：定义函数的特殊用法
final static synchronized
返回值类型：用于声明方法执行完毕以后需要返回给方法调用者的数据类型
搭配return 返回数据；语句来使用
方法名：标识符【语法规则：构成名字的每一个单词全部小写，第二个开始每一个单词首字母大写】
参数列表：形式参数，声明参数的类型，用于告诉调用者，你如果想要调用方法执行功能
必须传入对应的数据给我
实际参数：方法被调用的时候根据形参类型实实在在传入的数据
方法体：
需要方法被调用的时候执行的业务功能代码块
return 数据：返回给调用者的数据 如果返回值类型是void 此语句可以省略
方法定义案例：
吃饭的功能
说话的功能
类内部构成信息--构造方法【构造函数】
java中提供了一个特殊的方法--来帮助我们通过类构造我们想要的对象--进行业务处理
----面向对象
语法：
权限修饰符 类名（【参数列表】）{
函数体；
}
解释：
权限修饰符：使用范围---，目前使用public
类名：构造方法的名字就是当前类的名字
参数列表：方法参数类似
方法体：用来在创建对象的时候想要做的事情
如何调用构造函数，创建当前类的对象
使用关键字 new
语法：类名 对象名=new类名();
如何使用类的信息
对象名.属性名【=值】;
对象名.方法名（参数）;
类的基本构成-块【代码块】
含义：类中一个独立的代码功能块
作用--初始化信息
语法：
【关键字】{
业务代码块;
}
解释：
关键：static sychronsized
业务代码块：执行一些功能：输出信息，判断，循环等
总结：调用：自动调用执行，在调用构造方法创建对象之前
类的基本构成-内部类【熟悉】
出现的原因：连接类与类之间建立关系
出现的原因：
含义：类的里面还创建一个类
语法：
public class 外部类类名{
【权限修饰符】【高级修饰符】class 内部类类名{
内部类的内容
}
}
总结：
内部类的调用语法：
外部类类名.内部类类名 内部类对象名=外部类对象.new 内部类构造方法（）;
OuterClass.InnerClass inclass=outclass.new InnerClass();
外部类调用内部类的信息：
实例化内部类的对象 调用信息
内部类调用外部类信息
全局信息直接使用
类的构成的总结
组成元素的重点
属性 方法---功能作用重点【必须掌握】
构造方法---类的使用-创建对象【必须掌握】
块----------初始化信息【了解】
内部类-------------减少拆分，类的关系【了解】
类的使用：
类的创建是不用写主函数的，给别人调用，别人想要用必须实例化类的对象
使用对象去调用类的信息
语法:
类名 对象名=new 构造方法();
使用类的信息：
对象名.属性【=值】
对象名.方法（）;
java中核心关键字--this
this叫做本类对象，用于在当前类中自己调用自己的元素，此对象固定写法--自动创建
同一个类中相互调用信息--使用this 属性或者this.方法---this可以省略
this创建的时间：
是你在创建此类的一个对象的时候，就会自动的将你当前创建的对象放在this中一份
把你当前创建的对象的地址给this 所以你在当前这个对象中就可以自己调用自己
特殊用法：
1.当前参数赋值之后，属性和参数的名字相同的时候，我们可以使用this
此时this不能省略【掌握】
2 构造方法的相互调用--可以使用this--【了解】
对创建的类进行划分---包的概念
包的概念：
包的本质上就是电脑中的物理文件夹，只不过在Java中给了特殊的编写规范
包的关键字：package import
包的创建：
选择src--右击
包的命名规范：【两种方式】
第一种：公司域名命名法【涉及版权】
语法：
公司域名反写.项目名.模块名
例如
www.lexed.com---edumanage
包的命名：com.lexed.edumanage.test
第二种：四级命名法
语法：
用途.公司名.项目名.模块名
解释：
用途：org--政府
edu--学校
cn --国际
com--商用
package关键字：放在文件的最前面--用于表面当前类在那个包下
语法 package 完整包名
备注：在使用工具的时候--自动添加--不要手动写
import关键字:放在类前面package后面 用于告诉当前类，使用的其他类在什么位置
语法：
import 包名.类名;
目的：告诉当前类使用其他的类的位置
多个类之间相互关联--类与类之间关系
常见的类与类之间的四种关系
1 没关系
2 关联关系
一种类中有另一个类的对象
3 依赖关系
一个类中方法的执行必须传入另一个类的对象
4 继承关系
探索四种关系的特征：
1 没有关系
是一个独立的类 使用的时候只能类中提供的习性和功能
一般用处：工具类--固定功能
2 关联关系【最重要】
一个类的对象是另一个类的属性
使用者----获取对象---A类----有一个对象属性---->B类
3）依赖关系【最重要】
一个类的方法的执行需要另一个类的对象调用信息
4）继承关系
子类继承父类关键字：extends
语法：
public clas 子类extends 父类{
}
权限修饰符
含义：权限修饰符是用来控制类资源访问范围
权限修饰符关键字：public protected【受保护的】 默认【缺省】 private【私有的】
项目中权限范围：
本质----自己访问自己的资源
同一个包下不同的类---跨类
不同的包下类---不同文件夹下类相互资源访问
继承关系----子类获取父类
权限范围：
本类中--自己调用自己--public/protected/默认/private 都可调用
同一个包中不同的类---相互调用---public/protected/默认 可以
不同的包下面类相互访问---public 可以
继承关系资源访问：
同一个包 public/protected/默认 可以
不同的包 public/protected 可以
权限大小：
public>protected>默认>private
高级修饰符：
高级修饰符定义资源的作用类型
static【静态的】 final【最终的】 abstract【抽象的】 sychronsized【同步锁】
不同修饰符的作用：
1)static 静态的【共享的意思】
作用的资源：
属性 方法 内部类 块
A：修饰属性 静态属性--共享信息--卖票的例子
总结：静态属性不属于某一个该类的对象私有 属于大家共享
所以静态资源与对象没有关系--与类有关系
可以不创建对象使用类直接调用
语法：类名.属性【=值】;
静态属性可以使用对象调用
语法：对象名.属性【=值】
会出现警告--不推荐使用
B：修饰方法 静态方法--对象共享
可以使用类名直接调用
可以使用对象调用【不推荐，警告】
工具类中工具方法 非必要不用
C：修改块 静态块
当前类被加载的时候最先调用执行，并且只执行一次 跟类有关系，跟对象没有关系
与普通块区别
普通块需要创建对象的时候才调用，跟对象有关系
内部类 获取对象
类名.内部类名 对象=new 类名.内部类名（）;
final 最终的--断子绝孙
被final修饰的内容都是最终形态
修饰资源：
属性 方法 类
探索应用：
A：修饰属性的时好--常量--一旦赋值不可改变
一般情况下定义常量可以使用static和final一起修饰
B：final修饰方法--一般在继承里面才有
表示此方法无法被子类重写【继承和方法详解】
C：final修饰的类不可以被继承
面向对象的特征【四大特征】
1）抽象---不具体的内容具体化【很多时候讲特征会排出】
代码数据表述生活中的感官实物信息化
2）封装
属性的封装：属性私有化，提供公共公开的方法以便获取的修改属性的值
为什么需要这么做？
因为原先没有封装的时候，属性中存在问题
属性问题：我们属性暴露出来--只要创建对象就可以直接操作属性的值
业务中这种问题是不允许的---不给直接访问属性---
但是--我现在既需要掩藏属性，也需要能给属性赋值!!!
可以使用方法进行属性赋值
----方法中我们可以判断传入数据是否合法--以判断是否赋值
问题：如果我们使用统一的方法给属性赋值--没有自由性
可以单独给每一个属性提供对应的方法来进行赋值
为了明确那个方法属性那个属性--方法命名的时候 set属性名首字母大写()定义
属性对应赋值的方法
问题：如果我们想回去属性值--此时我们也可以使用方法--返回值概念
为了便于识别，获取属性值得方法定义
3） 继承：
子类继承父类，直接获取父类除了私有以外的所有的属性，方法，构造方法
为什么使用继承？
当下业务代码出现问题--解决问题
A：多个类中代码重复--可以将重复的代码提取放到一个类中--继承回来
继承的第一个功能--简化代码--代码复用
探索继承：
A.子类中时如何获取父类信息？
子类和父类是两个类，所以子类想要获取父类的信息--必须获取父类对象
但是我们在子类并没有创建父类对象可以直接获取除父类私有以外的所有信息
此外 省略了一个关键字：super
super是什么？
super表示在子类中的一个父类对象，当发生继承的时候，就会在子类中
自动创建一个父类对象存入super
也可以调用父类构造函数
写在子类构造函数前面 super（）;
方法的重载：【overload】 在一个类中允许多个同名方法存在，方法的参数不同
方法参数有哪些不同点：
个数不同
类型不同
顺序不同【类型不同基础上】
遇到一个问题：父类中编写的方法无法满足子类的需要的时候，我就需要在子类中写自己方法--自己的功能
父类方法同名方法不会被调用
调用顺序：子类如果没有与父类同名方法--默认直接调用父类继承过来
如果子类有了父类同名方法--直接调用子类自己的方法，屏蔽父类同名方法
这种行为叫：方法重写【override】
重写的特点：发生在继承关系中父类与子类之间
要求：方法的定义相同【名字，参数，返回值相同】 方法内容不同
备注：子类重写父类方法的时候会在方法上面加上@override
继承关系探索：
一个父类可以有几个子类：可以有多个子类；
一个子类可以有几个父类：一个类只能继承一个父类-单继承【一个孩子只能有一个亲爹】
专业用词：
父类到子类：扩展或者派生
子类到父类：继承
属性的一般说法:
成员属性
成员变量
方法：
函数 行为 功能
抽象的 abstract
为什么定义抽象的--原因是子类继承父类的时候有一些方法只需要告诉子类如何定义【定义规范】
不需要编写方法内容
把这种没有内容的方法称为抽象方法；
拥有·抽象方法的类--必须是抽象类
抽象类：
抽象类的作用
抽象类不能创建对象使用【不能实例化】
抽象类是专门用于作为父类被继承的
定义语法：
public abstract class 类名{
属性
抽象方法
普通方法
块
内部类
构造方法
}
抽象方法：
语法：
权限修饰符 abstract 返回值类型 方法名（参数列表）;
作用：
用于在父类中定义规范，让子类照着规范执行 实现自己的功能--必须实现--统一子类规范
抽象类和抽象方法的关系：
抽象类中：可以写抽象方法也可以没有
抽象方法：存在抽象方法的类必须是抽象类
面向对象：
1 联系抽象类+继承关系
2 问题：继承关系中一个子类只能有一个父类，业务扩展局限了！
编写一个业务类--该类很多的业务在；另外一个类中编写了---可以使用继承
使用过程一些其他的业务--出现另外的类上---？如何处理
这个时候我们需要进行分类处理。
如果是基本信息或者功能业务方法获取--直接往上继承
可以将所有继承关系的类--串成一条继承关系线
【前提：抽象类和普通类】
如果只是想要扩展功能：需要再给对应业务添加一些功能规范--接口
3 接口：
接口概念：接口是特殊的抽象类，是用于定义业务规范，接口里面是能有 常量，抽象方法，本地方法
接口关键字：interface implement
接口虽然是特殊的抽象类--命名规范有要求---i或者inf开头
接口没有构造方法--不能创建对象--只能被子类获取使用
接口内容：
public 修饰的常量 高级修饰符符合--省略不写
接口使用：
接口需要被子类使用implements关键字实现
子类必须重写接口方法
探索关系：
一个类可以实现多个接口，多个接口使用逗号隔开
类与类之间---extends--单继承--一个子类只能继承一个父类
类与接口之间--implements--多实现--一个类可以实现多个接口
接口与接口之间--extends--多继承--一个接口可以继承多个其他接口
面向对象的特征--多态
Java中的表现;发生在继承或者实现关系中
用父类变量存储子类对象，使用的时候只要定义父类对象
关键字判断兑现的原始属性
对象
生活到Java的映射---抽象
java中重要的两个元素：
类<----->对象
想要处理业务--创建对象调用信息
类的构成：
属性----特殊变量-----存储信息
方法--函数----执行功能
静态和非静态的调用关系
非静态的资源可以直接调用--非静态资源
静态资源可以直接调用---静态资源
非静态资源可以直接调用---静态资源
静态资源不可以调用---非静态资源
原因：静态资源--跟类有关系--类对于共享的--不属于某一个对象
静态资源使用类名调用，不建议使用对象调用
因此静态方法中没有this对象--不支持this对象
常用API ---核心---学习API文档的使用
1.用于java开发者常用的一些功能写--给你直接用--java提供的常用功能
为了方便你学习，java提供了一套说明书
官方：API document
2.学习API文档的使用
对应的包的概念
目录---通过包--找到对应的类
索引--输出类名【类名的一部分】--搜索我们需要的类
文档内容解析:
横线上面
当前类属于的包
当前是类【class】还是接口【interface】
继承关系
横线下面：
该类的定义完全语法结构
3.常用的工具类
1）object
包：java.lang
含义：所有类层次结构的根类 所有的对象都拥有这个类的方法
当类没有发生继承的时候，自动添加 extends object
一些方法：
clone（）可以根据当前对象复制一个对象出来
equals（对象）比较两个对象是不是一样（是不是指向同一地址）
hashcode()返回值对象的哈希码值
getClass()反射的时候 用来获取信息
toString（）对象转化成字符串
wait+notify 线程处理【等待+唤醒】
2）Scanner
包：java.util
含义：
方法--用法：
3）字符串
字符串的判断：
equals判断字符串是不是相等 之前判定两个值得相等==
==和equals的区别与联系
==可以用于比较两个基本类型数据是不是相等
也可以用于判断两个对象是不是相等--对象变量存储的地址
equals 用于比较两个对象
object类里面的equals方法比较的还是两个对象的地址
使用== 比较
String重写了object的equals方法
先比较地址，如果地址相等返回true
如果地址不相等 再去比较具体的值
字符串值修改的方法--Stringbuffer StringBuilder
字符串内容进行增删改查
Stringbuffer 线程安全
StringBuilder 速度快 线程不安全
4）包装类
在java中把所有的基本类型--都编写了一个类与之对应
基本类型：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
integer类如何对应int
主要是对int值进行处理 该类包含一些属性和方法来处理整数
给了一些静态属性：获取最大值和最小值 原始类型等
给了构造方法
一个整数
一个字符串转化成整数
给了一些静态和非静态方法
备注：包装类和基本类型之间可以进行自动的拆箱和装箱
将基本类型赋值类包装类型--装箱
将包装类型赋值给基本类型--拆箱
基本运算的时候两者可以和包装类相互交替使用
拆箱装箱的原理：
装箱--当我们把一个int整数给integer对象时候，默认调用valueoff（int）将数据
传入交给对象
包装类：
总结：基本类型和包装类混合运算，包装类自动拆箱 按照基本类型运算规则
Integer来说，放我们给Integer复制的时候其调用valueof方法进行装箱
当前值是-128到127之前时，直接从integer给定的常量池中获取
如果超出范围，直接new integer（整数）创建一个新对象
5）数学处理类和随机数类
数学类：math 包：java.lang final修饰
使用：没有提供构造方法 无法创建对象
所有的属性和方法都是static修饰符 直接可以【类名.】 去使用
随机数类：
Random 取随机数
提供构造方法 普通方法
6）日期类
类：Date 包：java.util 备注
含义:表示时间的瞬间 当前时间
使用：构造方法
获取当前时间 过去毫秒值
格式转化类：DateFormat 包:java.text abstract类
我们只能用他的子类 SimapleDateFormat
显示日期的格式
字符串转化日期
日历类：Calendar 包：java.util abstract类
获取日历的对象
子类直接new
获取时间
对象.getTime();
获取每一个字符段
get（）
修改内一个日期
set（）
常量不是直接获取日期字段，而是用于作为日期段的标识
7）大数据类
java提供大数据类用于进行超大数据运算
提供了两个类 Number子类
BigDecimal大小数的运算 Biginteger整数运算
8）数组 do msgbox loop .vbs
java代码中发生问题探索？
Error：写错代码，内存溢出等等，很严重。必须纠正为正确代码，程序才能运行
了解就行；
Exception:异常--程序执行的时候有可能会发生问题
一般是数据和语法错误：除数为零，数据类型不符合等等
他是我们可以在使用过程中编写一些算法避免
4.提供了帮助我们简化处理异常的方法
Error:只能修改代码，没法处理
Exception:可以处理 程序执行过程中偶然出现，检测到他的出现，然后去做事情避免【重点】
Java中如何处理;
提供了一套处理业务代码块
1）try{
可能出现异常的代码块
}
2）catch（出现的异常对象）{
出现异常的解决方法
3）}finally{
不管出不出现异常，我都要补一些补救的事情
}
try{} :主要的功能就是将可能出现的异常代码块圈起来进行监测
catch （异常类类型 对象名）{}：当try监测到异常发生的时候。虚拟机就会创建对应异常类
对象，交给catch根据类型捕获，将异常对象作为参数自动传入，我们可以获取异常原来的信息
调用异常对象的方法，进行业务处理
自定义catch块中，自定义业务功能
没有发生异常--代码执行过程：
直接按照代码顺序执行，不执行catch块
异常发生之后--代码怎么执行
当try块中检测到异常发生--catch直接捕获异常--执行catch块内容【异常处理】---继续
向下执行代码
finally{}:放在异常处理组合最后面，不管发不发生异常，都会执行，关闭之前开启的流数据通道
try catch finally的组合
1 一个try -- 一个或多个catch
备注:
A:当try检测到一个异常发生，try中的代码块执行到此结束，直接跳转到对应的catch块执行
执行完程序往下继续走
B:可以添加一个Exception 对象块，用于检测所有的异常对象
必须放在最后的catch中，不能放在前面
C: catch块的执行先后顺序的：从上往下
异常类对象范围
父类>子类
2 一个try -- 一个或多个catch---一个finally块
没有异常正常执行业务，有异常就捕获
最终用finally进行通道关闭
3 一个try -- 一个finally块
不管有没有异常都不处理，一定要关闭通道，主要目的释放资源
5.自定义异常
开发者可以将自己的想法创建为异常类，作为异常进行处理
如何自定义异常：
创建一个自己的类---继承一个java异常类中的任何一个类
两个关键字;
throw : 抛出异常，产生异常，指定这个位置有异常发生
语法：throw new构造方法();
throws :
与上面搭配使用， 当你抛出异常，将你抛出的异常在对应的方法上面声明，告诉调用者
这里有异常需要处理
语法：
方法的参数括号与方法体括号之间添加 throws类
说明：throw抛出的异常，我们在调用的时候可以处理，也可以继续抛
异常总结：
学习异常类的目的：不是拿它来编写代码，而是要看得懂出现代码的问题，以及可以解决别人抛出的异常
解释：
A 异常的创建，抛出-----设计层面--架构师或者项目经理
普通程序：
知道如何解决别人抛出的异常【重点】
知道常见的异常对应发生的原因【重中之重】{必会技能--调试代码--找错}
常见的异常问题--以及对应出现原因
ArithmeticException：出现数学中异常的运算条件是，例如除数为零
IndexOutOfBoundsException 下标越界
ClassCastException 对象类型转化问题 例如 object a=123； string s=（string）a
NullPointerException 空指针异常【60%以上】 对象没有new 就调
ClassNotFoundException 没有找到类，反射机制，使用第三方框架
集合框架：
为什么要集合框架？
开发项目最核心：
数据--代码核心--数据存储
当下存储方式转变：
直接使用--->共享--->变量
大量数据存储---->数组
数组的问题：
基本类型操作数据方式
固定长度
同一类型
集合框架解决以上问题。
集合框架【内涵架构理解】
1)java提供的几个API
提供了三个接口：
Collection Map lterable
一个类
Collections
2）对应的接口和类
Collection接口：
集合层次的根接口
用于存储【对象】
一些后代存储允许重复，一些后代存储不允许重复，一些后代存储有序，一些后代存储无序
使用：Collection是接口无法直接使用，使用其子接口list接口和set接口
list接口：
实现了集合中有序，可重复，可为空的特征
其提供了很多子类--通过不同的方式实现
Vector Arraylist LinkedList
list接口的子类--Vector
实现增长的对象数组
实现对象的存储 移除 搜索
底层是数组，实现数据存储
是线程安全 同步
list接口的子类---Arraylist
大小可变的数组
功能上等同vector
Arraylist用于替代vector
list接口的子类--LinkedList
使用双向链表的方式实现列表
使用：存储 获取 删除 插入
list集合中的问题探索：
1 遍历集合中的数据
1）常规的for循环
2）使用实现迭代器接口功能 iterable
每个集合中都有一个方法 iterator（）
迭代器中有方法用于获取数据
3）增强for循环 foreach
语法：
for（元素类型 临时变量）
2.数据类型的问题：
没有指定数据类型的时候：
可以向集合中存储任意数据
为什么？
因为默认存储的数据类型是object
集合中存储了多种类型数据的时候，在使用时，无法辨别存储到集合中对应的
数据类型，所以当具体使用的时候，就没办法从object转化成对应类型，就会带来很严重的问题
解决问题：
使用一种技术处理对象存储数据类型的问题：泛型
泛型概念：参数化，模糊类型；具体类型让使用者自己定义
泛型对应的类型必须是类
备注：后期使用的时候要求使用泛型方式--指定类型
3）set集合
1）概念： 不包含重复元素，包含一个null值
2）子类：HashSet和TreeSet
3)HashSet子类
不重复，无序，HashMap实现，不同步
哈希表进行数据存储
去重的方式：去掉前面，保留后面
4）TreeSet子类
不重复 自动排序 不同步的
TreeMap实现
5）set集合总结
是使用map集合实现，他出现的原因也是Map
主要功能：
存储数据
无法单独取出数据，只能遍历数据，因为无法排定对应数据的位置
可以删除数据
可获取大小
附加功能：
去重 排序 【自然顺序】
4）Map集合
1）Map集合概念：
将键映射值的对象，键是不可以重复的，一个键只能映射一个值
允许为空
值允许重复
是一个接口 用于存储键和值
2）子接口
HashMap TreeMap
Hashtable和LinkedHashMap自己探索
3）HashMap
哈希表的实现方式
键值对的存储
允许key和value都为null
无序
4）map集合遍历--转化成set集合--通过set集合去遍历
5）TreeMap--多一个排序【对key进行自然顺序排序】
总结：Map的应用--学习第三方框架中【大量出现】
5. Collections 类
查缺补漏:
工具类
6.问题探索：
数据存储--到目前【集合+变量】---但是电脑一关数据就没了
原因：到目前为止所有数据都是存储在内存中--临时存储空间
我们希望数据可以永久的存储---存储到硬盘或者网络中
数据在硬盘上如何存储？存储的形式是什么？--文件的形式存储在
所以：需要将我们程序中获取的数据存储到硬盘文件中
文件中获取数据
最终我们要向将数据持久化存储到文件中，关注两个概念
文件
数据存入文件和从文件取出数据
java提供了API来解决问题：
文件---File类--处理文件
文件存取数据---IO流--输入输出流
1 包：java.io
2.含义：
主要用于代码中处理物理文件和文件夹
3.用法：
对文件和文件夹的增删改查
4.路径
相对路径：
从当前位置出发 例如："zhangsan/xs.txt"
绝对路径：
给定从磁盘开始的完整路径：例如"C:/zhangsan/xs.txt"
路径表示：
c:/zs/tx.txt
c:\\zs\\tx.txt
java常用API--io流
1.出现的原因：
需要有一个东西将数据写入文件，或者将文件中的数据获取使用
2.解释IO流
中文：全程 input output Stream---输入输出流
为什么有输入输出流？
参照物：内存
输入：
其他存储介质数据到内存--输入流
内存到其他存储介质数据--输出流
存储介质
硬盘 u盘 光盘 网盘 网络
3.java给我们提供了哪些类
输入输出
输入流：inputStream和Reader
输出流：outputStream和Writer
数据类类型
字节流【按字节处理数据】：inputStream outputStream
处理：图片 声音 视频等
字符流【按照字符进行数据处理】：Reader Writer
处理：文本
包装流：【缓冲流】Buffered+对应的流
转换流：inputStreamReader outputStreamWriter
打印流：PrintWirter
4：字节流的输入和输出
输入：inputStream 抽象类
所有字节输入流的父类
学习目标：
键盘输入流
FileinputStream 文件输入流
文件资源的读取，主要读取图片等原始字节文件
用法：
普通类 给定构造方法 没有静态方法 创建对象调用方法
1.创建对象
2.定义缓冲数组--指定每次读取多少字节 不指定 每次读取一个字节
输出流 outputStream 抽象类
含义：将数据一字节的方式发生发送出去
子类：FileoutputStream
将内容写入文件
5.字符流的输入输出
用于文本的数据处理
输入流：Reader 读取字符 抽象 子类：FileReader
FileReader类 读取文件数据
输出流:
Writer:写出字符流 抽象类 子类：FileWriter
FlieWriter：文本的写出
6.包装流-缓冲流
建立缓冲去，以便于提高续写速度
类： BufferedWriter BufferedReader
总结：
加了缓冲区之后除了 BufferedReader类，其他的操作没有变化
7.转化流
InputStreamReader outputStreamReader
字节流转化成字符流，进行高效方便操作
8.对象流--序列化
序列化：格式化--按照一定格式规范进行存储，需要统一标识
存储的对象对应的类必须实现实例化接口---java.io.Serializable
提供了两个类
ObjectinputStream ObjectoutputStream
完成任务：讲将一个自己创建的对象存入文件
将一个集合对象存储文件
9.总结：
重点：对象流和文件流
后面使用流处理文件资源的时候，记得使用包装流打包
10.文件存储数据
虽然解决了持久化存储数据的问题，但是读取数据很不方便，筛选数据麻烦
文件存储不安全
后期也会有技术解决--第三方好事之徒--开发一款软件--数据库软件
数据处理存储方便
常用API---properties属性类
1.原因：
有些简单的固定配置信息-需要文件存储--提供了一个工具
主要是用来处理properties配置文件
2. properties 普通的类
Hashtable的子类 遵循Map集合规范
常用API：多线程
1.为什么学习多线程？
当前面的代码执行过程中，遇到阻碍--停顿执行--后面的代码也必须等着
解决想法：排成多队，一起执行----Java提供的技术---多线程
2.并行和并发的概念
并行：指两个或者多个事情在同一时刻一起运行【同时】
并发：指两个或多个事情在同一时间段内交替运行
执行顺序：A执行完，B才执行，等B执行完C才执行.....
3.线程和进程概念
进程：计算机系统中的一个独立应用程序就是一个进程。当前优化程序执行【一个应用程序可能
包含多个进程】，计算机对于每一个进程分配相应的资源【CPU+内存】
线程：负责进程执行过程，是进程一个执行单元，一个进程可以包含多个线程，
至少包含一个线程，主线程，基础线程 多个线程共享进程资源
4.如何就那些线程调度和资源分配
进程获取操作系统分配资源--一个进程一份资源
一个进程中可以有多个线程--多个线程共享进程资源
进程就会把资源使用时间划分成时间片
获取时间片的方式：（线程调度的方式）
1. 平均分配调度
按照线程个数，平均分配资源使用时间
2.抢夺调度
给每一个线程设置优先级，优先级高的获取资源概率高一些，如果优先级一样
就随机分配对应的线程
5.Java提供的API
java中提供了一个类表示线程：Thread
java.lang包 线程：程序中可执行的线程，java程序中允许并发运行对个线程
创建一个线程
编写一个类，继承thread类，重写Thread的run方法---run方法下就是线程执行业务资源
使用：创建线程对象，使用start（）启动
提供了一个接口创建线程：Runnable
实现了runnable，不能说明当前的资源是一个线程，他只是遵循线程协议，表示
当前资源可以被线程加载
创建线程的方式：创建一个类，实现runnable接口，重写run方法
备注：java中本身就存在至少两个线程main主线程+垃圾回收线程
线程启动：是线程对象调用start方法，不是run方法，run方法是线程自己调用
6.探索线程中的那些事情
1)start方法和run方法
run方法，属于runnable接口，thread类重写了run方法 thread才有线程可以加在执行的资源
因为线程自动调用执行run方法
start方法，用于线程启动，thread线程类才拥有，使数组将每一个创建的线程进行存储
2）继承thread和实现runnable接口哪一个好？
Thread
优势：继承thread直接将业务功能类变成线程，直接进行线程相关操作
劣势：一旦发生继承，不能再进行扩展继承其他类，继承发生后，就只一个线程类，不太方便使用其他功能
Runnable：
优势：
发生实现关系，线程资源和线程执行分开，资源类可以做出了线程以外的其他事情
发生实现，强制重写run方法 很强的提示性
发生实现，还可以继承其他的类，扩展功能
可以多个线程公用一个资源对象
缺点：
需要创建线程thread对象进行加入线程使用
总结：推荐大家使用实现runnable接口的方式创建线程
3）探索runnable接口和thread类
runnable
提供了一个run方法，用于被线程调用，线程调用资源的协定
Thread
属性常量
MAX_PRIORITY 最大优先级表示10
MIN_PRIORITY 最小优先级表示1
NORM_PRIORITY 默认优先级表示5
构造方法
Thread（）创建默认名字的线程对象构造方法 Thread-索引 发生继承
Thread（String name）创建一个指定线程名字的线程对象 发生继承
Thread（Runnable target）创建一个加载对应资源对象的线程 实现Runnable
Thread（Runnable target，String name）创建一个传入资源对象和线程名字的线程对象
实现Runnable
方法：
get方法---获取信息
set方法---设置信息
is开头方法--可以判断线程是否在状态
线程停止：
interrupt 中断当前线程 并不会停止线程，会抛出异常
static sleep 线程进入休眠等待
join 让主线停止，等待子线程运行完成
object 继承过来--线程之间通信
wait 等待
notify 唤醒
static currentTread
通过多窗口售票功能模拟，多线程确实提高了效率---带来问题
问题：
多个线程使用共享的资源的时候，存在抢夺【资源+时间片】的状态
导致信息冲突问题
使用
线程同步的方法三种：
1.同步块
synchronized （钥匙对象）{
同步资源
}
钥匙对象：要求一定是多个线程公用一个对象【多个线程中间只存在一个】
2.同步方法：
权限修饰符 sychronsized 返回值类型 方法名（参数）{
线程执行资源
}
钥匙对象：this 当前类的对象【多线程拥有同一个】
3.lock对象：上锁
创建对象
//获取lock对象
‘’ Lock lock=new ReentrantLock();
lock(对象）.lock（）上锁
lock（对象）.unlock 开锁
4.线程通信
线程之间可以建立联系，相互通信关联
例子：生产者和消费者
生产者负责生产产品，消费者负责消费产品
例子：包子的例子
包子类
包子店类线程
顾客类线程
两个线程之间和相互通信---
广播方式通信
API多线程总结
1.概念
并行
并发
顺序执行
进程
线程
线程和调度
资源分配原则
2.创建方式
3.Thread方法
常用的API-java网络编程
1. 为什么使用网络通信？
多台设备之间数据共享--使用相应的技术进行数据传输--网络传输
2.java提供了API
inetAddress:java.net 主要是ip地址相关处理
网络通信的API
UPD--广播传输
TCP--严格的网络数据传输
API：
socket socketsever
