文章目录
- 第一章 基础入门
- 第二章 基本数据类型与数组
- 标识符 有效字符序列/名字 程序中自己定义的内容。如类、方法、变量的名字。
- 关键字 程序中java已经定义好的单词
- 常见的八种基本数据类型
- 变量的声明
- 每种数据的取值范围
- 数据类型转换
- 强制转换 取值范围大的转成取值范围小的
- 基本数据类型数据的取值范围
- 输入输出 大题 格式化 交互
- 数组 7 内层的引用模型 （所有）
- 第三章 运算符、表达式与语句
- 第四章 类与对象
- 类是体现封装的一种数据类型，类所声明的变量称作对象，对象/变量负责存放引用。分配给对象的变量称作实体。构造方法在类创建对象时使用。
- 成员变量与局部变量
- 实例变量与类变量的区别
- 实例方法与类方法
- 方法中的参数传值（综合）
- 构造方法
- 创建对象
- 方法重载 同一个类
- Super与this关键字
- 第五章 类与继承
- 第六章 接口与实现
- 第九章 组件及事件处理
- 第十章 输入输出流 5-8概念题 5综合题
- 第十一章 数据库
- 第十二章 多线程机制 5 基本概念 选择、填空、判断
第一章 基础入门
Java自带的javap反编译一个类
编译三个步骤
1.用文本编辑器编写源文件（.java）
2.使用javac（编译器javac.exe）编译源文件得到字节码文件（.class）//只存放一个类的字节码
3.使用解释器（java.exe）解释执行字节码文件，运行程序//解释器执行的类名必须是主类的名字，不包括拓展名
下列哪个是JDK提供的编译器？B
A.java.exe B.javac.exe C.javap.exe D.javaw.exe
java命令后必须是主类的名字，不包括拓展名。
如果Java应用程序主类的名字是Bird,编译之后，应当怎样运行程序？
java Bird
如果有一个类是public类，那么源文件的名字必须与这个类的名字完全相同。如果源文件没有public类，则源文件与某个类的名字相同就可以了。
下列哪个是Java应用程序主类中正确的main方法？D
A.public void main(String args[])
B.static void main(String args[])
C.public static void Main(String args[])
D.public static void main(String args[])//args[]是main方法的一个参数，是一个字符串类型的数组
第二章 基本数据类型与数组
标识符 有效字符序列/名字 程序中自己定义的内容。如类、方法、变量的名字。
下列哪项字符序列可以作为标识符？C
A.true B.default c._int D.good-class//含有“-”是非法的。
false不是标识符，虽然false不是关键字，但它是Boolean类型的取值之一，有特定的意义。
标识符字符区分大小写 Hello hello不同
标识符由字母，下划线、美元符号和数字组成，长度不受限制；
第一个字符不能是数字；
标识符不能是关键字；
标识符不能是true,false,和null；
标识符 ：
命名规则：（硬性要求）
- 可包含
26个英文字母、0-9数字、美元符号和下划线- 不能以数字开头
- 不能是关键字
命名规范（软性建议）- 类名规范：
大驼峰式首字母大写，后面每个单词首字母大写- 方法名规范：
小驼峰式首字母小写，后面每个单词首字母大写- 变量名规范：全部小写
关键字 程序中java已经定义好的单词
true 和 false 都不是关键字。
有特定用途或被赋予意义的一些单词（50个不可把关键字作为标识符来用的）
什么叫关键字？true 和 false 是否是关键字？请说出6个关键字。
Java语言中已经被赋予特定意义的一些单词，不可以把关键字作为名字来用。
其他的关键字举例：class (类) implements（实现接口） interface(接口类) enum （枚举）extends（继承）abstract(抽象类或抽象方法)
常见的八种基本数据类型
- 基本数据类型：整数(byte short int long)、浮点数(float double)、字符(char)、布尔(boolean)
四类八种基本数据类型：
一个字节就是1byte，8bit
- 注意事项
1 字符串不是基本类型，而是引用类型
2 浮点型可能只是一个近似值，并非精确的值
3 数据范围与字节数不一定相关，float数据范围比long更加广泛，但是float是4byte,long是8byte
| 数据类型 | 关键字 | 内存占用 |
|---|---|---|
| 字节型 | byte | 1 byte |
| 短整型 | short | 2 byte |
| 整型 | int | 4 byte |
| 长整型 | long | 8 byte |
| 单精度浮点数 | float | 4 byte |
| 双精度浮点数 | double | 8 byte |
| 字符型 | char | 2 byte |
| 布尔类型 | boolean | 1 byte |
float 型常量和double型常量在表示上有什么区别？
float常量必须用F或f为后缀。double常量用D或d为后缀。但double常量允许省略后缀。
- 引用数据类型：类、数组、接口、字符串、lambda
数据类型 变量名 = 数据值；
变量名称在同一个大括号范围内不可相同
定义的变量中，不赋值不能使用
long类型：建议数据后加L表示
float类型：建议数据后加F表示
java没有无符号的byte、short、int和long
变量的声明
下列哪三项是正确的float变量的声明？ADF
A.float foo=-1;
B. float foo=1.0//double float foo=(double)1.0f
C. float foo=42e1;
D.float foo=2.02f
E.float foo=3.03d;
F.float foo=0x0123;//16进制可以
B的1.0为double型变量，赋值给float变量需要强制类型转换：float foo=(double)1.0或者是加后缀f。C也是同理。而E的3.03d本身就是不存在的写法。F是16进制写法是可以的。
以下哪两项是正确的char 型变量声明？ BE
A.char ch=”R”; //双引号的原因
B.char ch =’\’;//\是转义字符如果要使用的话必须是双,所以这两个\其实在保存的时候就等于一个
C.char ch =’ABCD’; //其次char是存放单个字符的
D.char ch = “ABCD”; //双引号的原因，只能单引号
E.char ch =’\ucafe’;
F.char ch =’\u10100’;//是\u开头代表是Unicode,而Unicode的范围是从0000~FFFF所以F错了E是对的;
BF 首先给char字符变量赋值要用单引号，其次只能接受一个字符，双引号为String字符串类型，F为Unicode码的正确表示方法
Java
public class E{
public static void main(String args[]){
int x=8;
byte b =127; //【代码1】
b=x; //【代码2】int4转换成byte1需要强制转换
x=12L; //【代码3】long8 int4
long y=8.0; //【代码4】不能把浮点型变量赋值给整型变量
float z=6.89; //【代码5】需要有后缀f 否则认为是double型
}
}
每种数据的取值范围
下列哪一项是正确的？ B
A. char 型字符在Unicode 表中的位置范围是0-32767。
B. char 型字符在Unicode 表中的位置范围是0-65535。
C.char 型字符在Unicode 表中的位置范围是0-65536。
D.char 型字符在Unicode 表中的位置范围是-32768~32767。
char是两个字节的，在c语言中是-32768~32767，Unicode表是从0开始到65535，要注意在Java中是没有unsigned类型的。
数据类型转换
参与计算的数据，必须要保持数据类型一致，若数据类型不一致将发生类型的转换。
自动转换 取值范围小的类型自动提升为取值范围大的类型
转换规则
范围小的类型向范围大的类型提升，byte、short、char运算时直接提升为int
byte1、short2、char2–>int4–>long8–>float4–>double8
int i=1;
byte b=2;//两数相加，运算结果变量的类型是int型。byte=1byte,int=4byte
public class TypeCast {
//TypeCast类型转换
public static void main(String[] args){
int i = 1;
byte b= 2;
//byte x = b + i;//报错
//int类型和byte类型运算，结果是int型
int j= b + i;
System.out.println(j);
//byte类型占内存一个字节，和int类型运算时会提升为int类型，自动补充三个字节，结果为int型
//同理，当一个int类型和一个double类型的变量运算时,int类型会自动提升为double类型
//int类型4个字节，double类型有8个字节
int m = 1;
double d = 2.5;
double n = m + d;
System.out.println(n);
}
}
强制转换 取值范围大的转成取值范围小的
自动转换是java执行的，而强制转化需要自己动手
转换格式：数据类型 变量名 =（数据类型）被转数据值；
int i = 1.5;//错误，double内存8个字节，int内存4个字节
//double类型强制转成int类型，直接去掉小数点
int i =(int)1.5;//注意要写()
public static void main(String[] args){
//强制转换
//short类型，内存占2个字节
short s = 1;
/* s和1做运算时,1为int型，s会被提升为int类型，结果赋值时会编译错误
short内存占2个字节，int类型占4个字节
必须将int强制转换成short才能完成赋值
强制转换只能将取值范围类型大的转换成取值范围小的*/
//s = s + 1;编译失败
s =(short)(s+1);
System.out.println(s);//s=2
}
}
注意事项：
- 浮点转换成整数，直接取消小数点，可能会造成数据精度损失
- int强制转成short砍掉两个字节，可能会造成数据丢失，会出现不确定的结果
public class E{
public static void main(String args[]){
for(int i=20302;i<=20302;i++){
System.out.println((char)i);//输出的是(char)20302的值，输出的实际上是Unicode表中第20302个字符，运行结果为“低”
}
}
}
注意System.out.print()和System.out.println()的区别。
public class OutputData{
public static void main(String args[]){
int x=234,y=432;
System.out.println(x+"<"+(2*x));//234<468
System.out.print("我输出结果后不回车");
System.out.println("我输出结果后自动回车到下一行");//我输出结果后不回车我输出结果后自动回车到下一行
System.out.println("x+y="+(x+y));//x+y=666
}
}
基本数据类型数据的取值范围
类型转换：
boolean类型与其他基本类型不能进行类型的转换（既不能进行自动类型的提升，也不能强制类型转换）， 否则，将编译出错。
byte型不能自动类型提升到char，char和short直接也不会发生自动类型提升（因为负数的问题），同时，byte当然可以直接提升到short型。
两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
输入输出 大题 格式化 交互
数组 7 内层的引用模型 （所有）
对于int a[] = new int [3];下列哪个叙述是错误的？B
A. A.length的值是3
B.a[1]的值是1
C.a[0]的值是0
D. a[a.length-1]的值等于a[2]的值
Java里声明数组的语法和C是有一些区别的，C里我们可以直接声明int a[10];而在Java里我们需要先声明数组int a[]，再用new关键字给数组分配元素a=new int[3]，这是因为数组是引用类型的，数组名就是首个元素的地址也就是引用（对象）创建数组后默认元素的值都为0。可以使用数组名.length返回数组的长度。
public class E{
public static void main(String args[]){
System.out.println("byte取值范围"+Byte.MIN_VALUE+"至"+Byte.MAX_VALUE);
System.out.println("short取值范围"+Short.MIN_VALUE+"至"+Short.MAX_VALUE);
System.out.println("int取值范围"+Integer.MIN_VALUE+"至"+Integer.MAX_VALUE);
System.out.println("long取值范围"+Long.MIN_VALUE+"至"+Long.MAX_VALUE);
System.out.println("float取值范围"+Float.MIN_VALUE+"至"+Float.MAX_VALUE);
System.out.println("double取值范围"+Double.MIN_VALUE+"至"+Double.MAX_VALUE);
}
}
public class E {
public static void main(String args[]) {
long[] a = { 1, 2, 3, 4 };
long[] b = { 100, 200, 300, 400, 500 };
b = a;
System.out.println("数组b的长度:" + b.length); //【代码1】4
System.out.println("b[0]=" + b[0]); //【代码2】1
}
}
数组属于引用型变量，因此两个相同类型的数组如果具有相同的引用，他们就有完全相同的元素。因此当执行b = a时候，系统会释放最初分配给b的元素后，b和a指向相同的内存地址（引用相同）所以b的长度就是a的长度为4，b[0]=a[0]=1
public class E {
public static void main(String args[]) {
int[] a = { 10, 20, 30, 40 }, b[] = { { 1, 2 }, { 4, 5, 6, 7 } };
b[0] = a;
b[0][1] = b[1][3];
System.out.println(b[0][3]); //【代码1】40
System.out.println(a[1]); //【代码2】7
}
}
第三章 运算符、表达式与语句
运算符的区别，； 表达式
while语句中的条件表达式，关系运算符的运算结果boolean类型
if语句中的条件表达式的值不能是int型，只能为boolean
switch语句中不是必须有dafault选项
在while语句的循环体中，执行break语句的效果是，结束while语句的执行。
可以用for语句代替while语句的作用
增强型for循环介绍
增强型for循环，又叫foreach循环，最多的应用在于循环遍历数组元素
Java
int [] arr = {1,2,3,4,5};
for(int n:arr) //定义了一个局部变量n按顺序获取数组arr中每一个元素
System.out.println(n);
2.选择题
1.下列哪个叙述是正确的？
A. 5.0/2+10的结果是double型数据
B. (int)5.8+1.0的结果是int型数据
C. ‘苹’+’果’的结果是char型数据
D.(short)10+’a’的结果是short型数据
2.用下列哪个代码替换程序标注的【代码】会导致编译错误？
A. m–>0
B. m++>0
c. m=0
D. m>100&&true
Java
public class E {
public static void main(String args[]) {
int m=10,n=0;
while([代码]){
n++;
}
}
}
Type mismatch: cannot convert from int to boolean
3.假设有“int x=1;”，以下哪个代码导致“可能损失精度，找到int需要char”这样的编译错误？
A. short t = 12+’a’;
B. char c = ‘a’+1;
C. char m = ‘a’+x;
D. byte n = ‘a’+1;
下列哪个叙述是正确的？B
A. Java应用程序由若干个类所构成，这些类必须在一个源文件中。
B. Java应用程序由若干个类所构成，这些类可以在一个源文件中，也可以分布在若干个源文件中，其中必须有一个源文件含有主类。
C. Java源文件必须含有主类。
D. Java源文件如果含有主类，主类必须是public类。
一个java程序/工程由若干类构成，这些类可以在一个源文件中，也可以分布在若干源文件中。从主类的main方法开始执行。
怎样获取一维数组的长度，怎样获取二维数组中一维数组的个数？**
一维数组名.length 二维数组名.length
（5）下列程序中哪些【代码】是错误的？
Java
public class E{
public static void main(String args[]){
int x=8;
byte b =127; //【代码1】
b=x; //【代码2】
x=12L; //【代码3】
long y=8.0; //【代码4】
float z=6.89; //【代码5】
}
}
（6）对于int a[] = new int [3];下列哪个叙述是错误的？B
A. A.length的值是3
B.a[1]的值是1
C.a[0]的值是0
D. a[a.length-1]的值等于a[2]的值
在Java里我们需要先声明数组int a[]，再用new关键字给数组分配元素a=new int[3]，这是因为数组是引用类型的，数组名就是首个元素的地址也就是引用（对象）创建数组后默认元素的值都为0。可以使用数组名.length返回数组的长度。
关键字
关键字 ：程序中java已经定义好的单词。
标识符
标识符 ：程序中自己定义的内容。如类、方法、变量的名字。
命名规则：（硬性要求）
- 可包含
26个英文字母、0-9数字、美元符号和下划线- 不能以数字开头
- 不能是关键字
命名规范（软性建议）- 类名规范：
大驼峰式首字母大写，后面每个单词首字母大写- 方法名规范：
小驼峰式首字母小写，后面每个单词首字母大写- 变量名规范：全部小写
定义出所有类型的常量
常量：java程序中固定不变的数据
| 类型 | 含义 | 数据 |
|---|---|---|
| 整数常量 | 所有整数 | 0，-9,567 |
| 小数常量 | 所有小数 | 0.0,-0.1,2.55 |
| 字符常量 | 单引号，只能写一个字符，必须有内容 | ’ ',‘a’,‘好’ |
| 字符串常量 | 双引号，可以写多个字符，也可以不写 | “A”,“Hello”,"" |
| 布尔常量 | 只有两个值 | ture,false |
| 空常量 | 只有一个值 | null |
8种基本数据类型分类
- 基本数据类型：整数(byte short int long)、浮点数(float double)、字符(char)、布尔(boolean)
四类八种基本数据类型：
一个字节就是1byte，8bit
- 注意事项
1 字符串不是基本类型，而是引用类型
2 浮点型可能只是一个近似值，并非精确的值
3 数据范围与字节数不一定相关，float数据范围比long更加广泛，但是float是4byte,long是8byte
| 数据类型 | 关键字 | 内存占用 |
|---|---|---|
| 字节型 | byte | 1 byte |
| 短整型 | short | 2 byte |
| 整型 | int | 4 byte |
| 长整型 | long | 8 byte |
| 单精度浮点数 | float | 4 byte |
| 双精度浮点数 | double | 8 byte |
| 字符型 | char | 2 byte |
| 布尔类型 | boolean | 1 byte |
- 引用数据类型：类、数组、接口、字符串、lambda
变量的定义
数据类型 变量名 = 数据值；
变量名称在同一个大括号范围内不可相同
定义的变量中，不赋值不能使用
long类型：建议数据后加L表示
float类型：建议数据后加F表示
数据类型的转换
java程序中参与计算的数据，必须要保持数据类型一致，若数据类型不一致将发生类型的转换。
[1] 数据类型的自动转换
int i=1;
byte b=2;//两数相加，运算结果变量的类型是int型。byte=1byte,int=4byte
自动转换就是将取值范围小的类型自动提升为取值范围大的类型
public class TypeCast {
//TypeCast类型转换
public static void main(String[] args){
int i = 1;
byte b= 2;
//byte x = b + i;//报错
//int类型和byte类型运算，结果是int型
int j= b + i;
System.out.println(j);
//byte类型占内存一个字节，和int类型运算时会提升为int类型，自动补充三个字节，结果为int型
//同理，当一个int类型和一个double类型的变量运算时,int类型会自动提升为double类型
//int类型4个字节，double类型有8个字节
int m = 1;
double d = 2.5;
double n = m + d;
System.out.println(n);
}
}
转换规则
范围小的类型向范围大的类型提升，byte、short、char运算时直接提升为int
byte1、short2、char2–>int4–>long8–>float4–>double8
各数据类型字节数表格
[2] 数据类型的强制转换
强制转换：将取值范围大的类型强制转换成取值范围小的类型，自动转换是java执行的，而强制转化需要自己动手
转换格式：数据类型 变量名 =（数据类型）被转数据值；
int i = 1.5;//错误，double内存8个字节，int内存4个字节
//double类型强制转成int类型，直接去掉小数点
int i =(int)1.5;//注意要写()
public static void main(String[] args){
//强制转换
//short类型，内存占2个字节
short s = 1;
/* s和1做运算时,1为int型，s会被提升为int类型，结果赋值时会编译错误
short内存占2个字节，int类型占4个字节
必须将int强制转换成short才能完成赋值
强制转换只能将取值范围类型大的转换成取值范围小的*/
//s = s + 1;编译失败
s =(short)(s+1);
System.out.println(s);//s=2
}
}
注意事项：
- 浮点转换成整数，直接取消小数点，可能会造成数据精度损失
- int强制转成short砍掉两个字节，可能会造成数据丢失，会出现不确定的结果
ASCII编码表
-
编码表：将人类文字和一个十进制数进行对应组成的表格。为了让计算机识别人类文字。
-
american standard code for information interchange 美国标准信息交换码：
将所有英文字母，数字，符号和十进制进行对应
| 字符 | 数值 |
|---|---|
| 0 | 48 |
| 9 | 57 |
| A | 65 |
| Z | 90 |
| a | 97 |
| z | 122 |
int和char类型运算原理
- char类型和int类型计算过程中,char类型先查询编码表得到常数，再求和。char内存2个字节，int类型4个字节，char类型提升为int型。
运算符
算数运算符
| + | 加,字符串连接运算 |
|---|---|
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取模，两数相除取余 |
| ++、– | 自增自减 |
- 整数使用以上运算符不会得到小数
- ·
++自增1，`–``自减 - ++i，i++在独立运算中没有没有区别；在混合运算中，
++i先自加，再运算。i++,先运算，再自加。
public class OperationalCharacter {
public static void main(String[] args){
//++a
int a =1;
int b = ++a;
System.out.println(a);//2
System.out.println(b);//2
//a++
int n = 1;
int m = n++;
System.out.println(n);//2
System.out.println(m);//1
}
}
+号在遇上字符串的时候表示拼接- “a”+“b”=“ab”
-
System.out.println(“5+5=”+5+5);//55
赋值运算符
就是将符号右边的值赋给左边的变量
先做运算，再赋值变量
| = | 等于号 |
|---|---|
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等 |
int s =5;
s+=5;//s先自加5再赋值变量
System.out.println(s);//10
比较运算符
| == | 两边数值相等，true |
|---|---|
| < | 左小右，true |
| > | 左大右，true |
| <= | 左小等右，true |
| >= | 左大等右，true |
| != | 两边数值不相等,true |
比较运算符是两个数据间进行比较，运算结果都是布尔值true或false
//比较运算符
System.out.println(1==1);//true
System.out.println(1<2);//true
System.out.println(3>4);//false
System.out.println(3<=4);//true
System.out.println(3>=4);//false
System.out.println(3!=4);//true
逻辑运算符
| &&短路与 | 两边是true,true;一边false,结果为false;短路特点：符号左边是false，右边不再运算 |
|---|---|
||短路或 |
两边都是false,false;一边是ture，ture;短路特点：符号左边是ture，右边不再运算 |
| !取反 | ！true,→false;!false→true |
- 逻辑运算符：用来连接两个布尔类型的运算符，运算结果是布尔值true或false.
System.out.println(true&true);//true
System.out.println(true&false);//false
System.out.println(false&true);//false，右边不计算
System.out.println(false||false);//false
System.out.println(false||true);//true
System.out.println(true||false);//true,右边不计
System.out.println(!false);//true
三元运算符的格式和计算结果
数据类型 变量名 =布尔类型表达式？结果1：结果2
true赋值结果1；false赋值结果2
int y =(1==2?100:200);
System.out.println(y);//200
int x =(3<=4?500:600);
System.out.println(x);//500
方法的概念
方法：将一个功能抽取出来。代码单独定义在一个大括号内，形成一个单独的功能。需要这个功能时，再进行调用。
修饰符 返回值类型 方法名（参数列表）{
代码...
return;
}
目前固定写法
- 修饰符：
public static - 返回值类型：
void - 方法名：自定义，满足标识符规范，用来调用方法
- return:方法结束。返回值为void时，return可以不写
public static void methodName(){
System.out.println("我是一个方法")
}
方法调用
- 在主方法中写需要调用的方法名即可。
- 方法定义注意事项：方法不能定义在另一个方法里；方法必须定义在一类中方法外
- class为类，类中，main方法外可定义方法
public class Invoke {
//方法调用练习
public static void main(String[] args){
//定义调用的方法
method();
operator();
}
//定义方法，被main方法调用
public static void method(){
System.out.println("lambor定义的方法，需要被main调用运行");
}
//定义方法，方法定义三元运算符
public static void operator(){
int i = 0;//operator运算
i = (1==2 ? 100:200);
System.out.println(i);
int j = 0;
j = (3<=4? 500:600);
System.out.println(j);
}
}
第四章 类与对象
类是一种数据类型，用类来声明的变量，称为对象。用类声明对象后，必须创建对象。类是创建对象的模板，没有类就没有对象。
类是体现封装的一种数据类型，类所声明的变量称作对象，对象/变量负责存放引用。分配给对象的变量称作实体。构造方法在类创建对象时使用。
成员变量与局部变量
int m=0，sum=10；//成员变量在整个类中有效
int getSum(int n){//参数变量n是局部变量，方法的参数在整个方法内有效
//局部变量只在方法内有效，且与声明的位置有关。
int sum = 0;//声明局部变量sum
for(int i=1;i<=n;i++){
sum= sum+i;//i只在循环语句中有效。方法内的局部变量从声明它的位置之后开始有效。
}
return sum;
}
如果局部变量的名字与成员变量的名字相同，那么成员变量被隐藏。该成员变量在这个方法内暂时失效。如果想要调用被隐藏的成员变量，使用关键字this。
calss B{
int x = 100, y = 200;
public void setX(int x){
x = x;//等号右边的是传递参数为-100，左边的x也是指这个参数，参数的值赋给本身，没有任何意义 100
}
public void setY(int y){
this.y=y;//this调用被隐藏的成员变量 200=-200
}
public int getXYSum(){
return x+y;
}
}
public class A{
public static void main(String args[]){
B b = new B();
b.setX(-100);
b.setY(-200);
System.out.println("sum="+b.getXYSum());//-100
}
}
实例变量与类变量的区别
成员变量分为实例变量和类变量。实例变量与相关对象有关，类变量与类相关联。
一个类通过使用new运算符可以创建多个不同的对象，不同的对象的实例变量将被分配不同的内存空间。所有对象的类变量都分配给相同的一处内存，类创建的所有对象共享类变量。
实例方法与类方法
实例方法中不仅可以操作实例变量也可以操作类变量。
只有类创建对象后，类中的实例方法才分配入口地址。
实例方法的入口地址被所有对象共享，当所有的地址不存在时，方法的入口地址才被取消。
实例方法可以操作类变量static，类方法不可以操作实例变量
实例方法可以操作类变量，因为类总是先于实例存在。而类创建对象才有实例。
类方法不可以操作实例变量，类不知道被创建多少实例，哪些实例还存在，实例方法没有加载进内存，必须以new的方式加载。实例成员变量也是，因为没有加载进内存。
类的实例方法不能用类名直接访问，需要new加载进来。类方法可用类名直接访问。
在new的时候才被分配内存空间。类的字节码加载到内存时，类变量一定分配了内存空间。
方法中的参数传值（综合）
方法的参数属于局部变量，对象调用方法时，参数被分配内存空间，并要求调用者向参数传值。方法被调用时，参数变量必须有具体的值。
参数得到的值类似于复印件。是指定值的拷贝。当参数为引用类型（数组、对象、接口）时，传递的是变量中的引用，而非实体。
基本数据类型参数的传值，只能传比该参数级别低的参数。向该参数传递的值的级别不可以高于该参数的级别。
int型参数不可传递float值，可向double型参数传递float
引用型数据的传值：数组 对象 接口。
一个类声明的两个对象具有相同的引用，二者就有完全相同的变量。
构造方法
构造方法的名字必须和它所在类的名字完全相同，且没有类型。
有类型的是非构造方法/方法（void，int），不是构造方法。构造方法没有类型。
构造函数用于创建类的实例对象,构造函数名应与类名相同,返回类型不一定为void.
一个类中可以拥有不同的构造方法，但是参数必须不同（参数个数，对应某个参数的类型）
如果类中没有编写构造方法，会有默认的无参构造方法,且方法体中没有语句。
对于下列Hello类，哪个叙述是正确的？ D
A. Hello类有两个构造方法。 //只有一个，构造方法名与类名相同，且没有类型
B. Hello类的int Hello()方法是错误的方法。
C. Hello类没有构造方法。//有一个
D. Hello无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）//方法需要有类型
class Hello{
Hello (int m){
}
int Hello(){
return 20;
}
hello(){
}
}
创建对象
两步：对象的声明和为对象分配变量 ，分配给对象的变量叫做对象的实体
对象的声明：类名 对象名；为对象分配变量并获得一个引用/创建对象：new运算符和类的构造方法。
//example.java
class People{
float weight,height;
String head,ear;
void speak(String s){
System.out.printIn(s);
}
}
public class example{
public static void main(String args[]){
People lambor;//声明对象 类名 对象名
//lambor的内存中还没有任何数据，此时为一个空对象。空对象不能使用，必须为对象分配实体。
lambor = new People();//为对象分配变量（new 和默认的构造方法）
//第一步，为People类的成员变量weight,height,head,ear分配内存空间，然后执行构造方法的语句。
//第二步，分配内存后计算一个引用的值。该值包含成员变量内存位置及相关重要信息。引用值赋给lambor，则成员变量的内存单元将由lambor操作管理。为属于lambor的实体
}
}
People lambor//声明对象，空对象=new people()//new和默认的构造方法为对象创建分配变量，给类的成员变量分配内存空间（形成实体），然后执行构造方法中的语句。分配内存后再计算一个引用值赋给lambor，成员变量的内存单元将由lambor操作
对象的内存模型
一个类使用new运算符可以创建多个不同对象。new运算符只能和类的构造方法进行运算，运算的最后结果是一个十六进制的数。这个数称作对象的引用。new People()的值是一个引用。计算出引用后，对象才产生。
堆中的实体，栈中的引用
对象的引用存在栈中，对象的实体（分配给对象的变量）存在堆中。
对象具有相同的引用，则有完全相同的变量
将对象p2的引用赋给对象p1，则两者拥有完全相同的变量/实体，若p1对象拥有的实体不再被任何对象所拥有。则释放实体所占内存。
垃圾收集 内存泄漏
java运行的垃圾收集发现堆中分配的实体不再被栈中任何对象引用时，就会释放该实体在堆中所占内存。因此java中很少出现内存泄露。即由于程序忘记释放内存所导致的内存溢出。
class Fish{
int weight = 1;
}
class Lake{
Fish fish;
void setFish(Fish s){
fish = s;
}
void foodFish(int m){
fish.weight=fish.weight + m;
}
}
public class E{
public static void main(String args[]){
Fish redFish = new Fish();//redFish为Fish实例，具有Fish类的属性
System.out.println(redFish.weight);//1
Lake lake = new Lake();//lake为Lake的实例
lake.setFish(redFish);//传递的redFish对象，将redFish对象赋值给Lake中的fish对象，两者具有相同的引用，从而具有完全相同的变量
lake.foodFish(120);
System.out.println(redFish.weight);//121
System.out.prihtln(lake.fish.weight);//121
}
}
方法重载 同一个类
两种多态：重载和重写
功能多态性：可以向功能传递不同的消息，以便对象根据相应的消息产生相应的行为。对象的行为通过类中的方法体现，行为的多态性就是重载。
方法重载：一个类中可以拥有具有相同名字的多个方法，但是方法的参数必须不同。构造方法也是可以重载的
参数不同：参数的个数不同/参数个数相同，但对应的参数类型不同
类只能用public 修饰或者默认（友好），不能用protected和private修饰类
下列哪些类声明是错误的？CD
A. class A
B. public class A
C. protected class A
D. private class A
Super与this关键字
super：用来引用当前对象的父类
this:指向自己的引用，调用当前方法的对象
class A{
int x;
static int y;
void f(){
this.x=100;//实例成员变量在实例方法中出现时，默认this.成员变量 this为f的当前对象。为当前对象变量的x被赋予100
A.y=200;//static成员变量在实例方法中出现时，默认类名.成员变量
//this表示当前对象
//当实例成员变量和局部变量名字相同时，不可以省略 this. 类名.
}
}
第五章 类与继承
abstract class A{
abstract float getFloat(); //A友好型
void f() //B
{ }
}
public class B extends A{
private float m = 1.0f; //C
private float getFloat () //D 私有 编译错误
{
return m;
}
}
//方法重写要求重写的方法的访问权限大于等于被重写的方法
子类重写父类的方法，参数必须一致。而返回值可以是其返回值的子类
class A{
public A Hello(A a) {
return a;
}
}
class B extends A{
}
class C extends A{
@Override
public A Hello(A a) {
return new B();
}
}
子类的继承
所有类都是继承于java.lang.Object，当一个类没有extends关键字，则默认继承object类。
每个类（除了Object类）有且仅有一个父类
子类继承父类的成员变量和方法就像它们在子类中直接被定义了一样。可以被子类自己定义的任何实例方法调用。
在同一个包里：子类自然继承了父类非private属性、方法。访问权限保持不变。
在不同包中的继承性：friendly和private不会被继承。protected可以被子孙类继承。
对象.属性/方法 protected：
对于子类自己声明的protected成员变量和方法，Other类（创建object对象）和D类 在同一个包中，则可以访问。
对于从父类继承的，则需追溯到祖先类，只要Other类与祖先类在同一个包中，则可以访问protected方法。
子类可以调用继承方法操作未被子类继承却被分配了内存空间的变量
当子类用构造方法创建一个子类对象时，不仅子类的成员变量被分配了内存空间，父类的成员变量也被分配了空间。但只将子类继承的部分成员变量作为分配给子类对象的变量。看似浪费了内存空间（父类没被继承的成员变量），但实际上，子类还有一部分方法是从父类继承的，这部分方法可以操作未继承的变量
重写的目的
子类一旦隐藏了继承的成员变量，那么子类创建的对象就不再拥有该变量，该变量将归关键字super拥有。同样子类一旦重写了继承的方法，则覆盖（隐藏）了继承的方法,子类创建地对象不能调用被覆盖/隐藏的方法，方法的调用应由super调用。
- super调用被隐藏方法时，该方法中出现的成员变量是子类隐藏的成员变量或继承的成员变量
- 子类不继承父类的构造方法，子类在其构造方法需要使用super来调用父类的构造方法。如果在子类的构造方法，没有明显地写出super关键字来调用父类某个构造方法，则默认为
super()
重写方法既可以操作继承的成员变量、调用继承的方法，也可以操作子类新声明的成员变量、调用新定义的其他方法，但是无法操作被子类隐藏的成员变量和方法。
子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。
对象的上转型对象
把子类创建的对象引用放到一个父类的对象中。这个上转型对象在调用方法时就可能具有多种形态。不同对象的上转型对象调用同一方法可能产生不同行为。
上转型对象不能操作子类新增的方法和成员变量，可以将对象的上转型对象再强制转换到一个子类对象。
上转型对象可以操作子类继承的成员变量和隐藏的成员变量，也可以使用子类继承或重写的方法。
继承与多态
不同的子类在重写父类的方法时可能产生不同的行为
把子类创建对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，这个上转型对象在调用这个方法时就可能具有多种形态
abstract类和abstract方法
抽象类可以有抽象方法，也可以有普通方法，也可以没有抽象方法。
抽象类的子类如果是抽象类，则可以继承也可以重写父类的抽象方法。如果是非抽象类，则重写需要去掉抽象类的修饰
第六章 接口与实现
接口
定义接口：接口声明和接口体
接口体中只有常量（必须指定初值）和抽象方法以及默认方法和静态方法，不能声明变量和定义非抽象方法（普通方法）
接口体中包含常量的声明(public、final、static可以省略)和抽象方法(public、abstract可以省略)两部分。
接口体中的所有常量和抽象方法的访问权限一定都是public
接口也是重要的引用类型
接口的语法规则
- 只有default方法及static方法可以添加方法体
- 实现接口的类如果不能实现所有接口中待重写的方法，则必须设置为抽象类
- 接口可以实现多继承，即一个子接口可以同时继承多个父接口
- 一个类可以继承自一个父类，同时实现多个接口
- 当一个类同时实现多接口，且其中同时具有相同方法时，实现类需要重写该方法，否则会编译报错
如果一个类声明实现一个接口，但是没有重写接口中的所有方法。这个类必须是抽象类。抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法。
接口回调
把实现某一接口的类所创建的对象的引用，赋给该接口声明的接口变量中。则该接口变量可以调用被类实现的接口中的方法。
interface A{
double f(double x,double y);
}
class B implements A{
public double f(double x,double y){
return x*y;//实现了A接口，并重写A中的方法
}
int g(int a,int b){
return a+b;
}
}
public class E{
public static void main(String args[]){
A a = new B();//接口回调。把实现某一类接口的类所创建的对象的引用，赋给接口声明的接口变量中。则该接口变量就可以调用被类实现的接口中的方法。
System.out.println(a.f(3,5));//【代码1】 15.0
B b = (B)a;
System.out.println(b.g(3,5));//【代码2】 8
}
}
interface Com{
int add(int a,int b);
}
abstract class A{
abstract int add(int a,int b);
}
class B extends A implements Com{
public int add(int a,int b){
return a+b;
}
}
public class E{
public static void main(String args[]){
B b = new B()
Com com = b;
System.out.println(com.add(12,6));//【代码1】 18
A a = b;//子类的引用赋值给父类对象，则a也可以调用子类重写父类的方法
System.out.println(a.add(10,5));//【代码2】15
}
}
第九章 组件及事件处理
Component子类或间接子类创建的对象——组件
Container子类或间接子类创建的对象——容器（中间容器）
可以向容器添加组件——add()方法将组件添加到容器
removeAll(),remove(Component c)移掉指定的组件
容器本身也是一个组件，故可以容器套容器
javax.swing包中JComponent类是
- java.awt包中Container类的直接子类
- java.awt包中Component类的一个间接子类
JFrame类是一个底层容器，窗口。不允许窗口添加到另一个容器中。JFrame类是Container类的间接子类。当需要一个窗口，用JFrame类创建一个对象。
Java处理事件的模式是：事件源、监视器、处理事件的接口
能够产生事件的对象都可以成为事件源；事件源通过调用相应的方法将某个对象注册为自己的监视器；监视器都是使用接口来实现的，负责处理事件源发生的事件
（1）JFrame类的对象的默认布局是什么布局？
Frame容器的默认布局是BorderLayout布局
（2）一个容器对象是否可以使用add方法添加一个JFrame窗口？
不可以。JFrame窗口是一个底层容器，其他组件必须被添加到底层容器中，以便借助这个底层容器和操作系统进行交互。窗口默认被系统添加到显示器屏幕上，因此不允许将一个窗口添加到另一个容器中。
（3）JTextField可以触发什么事件？
文本框。ActionEvent
AddActionListener（监视器）
（4）JTextArea中的文档对象可以触发什么类型的事件？
文本区。DocumentEvent
（5）MouseListener接口中有几个方法？
5个。分别是在事件源上按下鼠标键。在事件源上释放鼠标键。在事件源上单击鼠标。鼠标进入事件源。鼠标退出事件源。
（6）处理鼠标拖动触发的MouseEvent事件需要使用哪些接口？
MouseMotionListener
（1）下列哪个叙述是不正确的？
A.一个应用程序中最多只有一个窗口。
B.JFrame创建的窗口默认是不可见的。
C.不可以向JFrame窗口中添加JFrame窗口。
D.窗口可以调用setTitle(String s)方法设置窗口的标题。
A
一个应用程序中可以有若干个窗口。窗口默认是不可见的，需要调用setVisible(boolean b)设置窗口的可见性。
（2）下列哪个叙述是不正确的?
A.JButton对象可以使用addActionListener(ActionListener 1)方法将没有实现ActionListener接口的类的实例注册为自己的监视器。
B.对于有监视器的JTextField文本框，如果该文本框处于活动状态（有输入焦点）时，用户即使不输入文本，只要按回车（Enter）键也可以触发ActoinEvent事件。
C.监视KeyEvent事件的监视器必须实现KeyListener接口。
D.监视WindowEvent事件的监视器必须实现WindowListener接口。
A
没有实现ActionListener接口的类的实例不能被注册
（3）下列哪个叙述是不正确的？
A.使用FlowLayout布局的容器最多可以添加5个组件。
B.使用BoderLayout布局的容器被划分为5个区域。
C.Jpanel的默认布局是FlowLayout布局。
D.JDialog的默认布局是BorderLayout布局。
A 流水布局可以添加若干个组件。
常见的组件有哪些（都是JComponent子类）：JTextField(文本框)输入单行文本、JTextArea(文本区)输入多行文本、JButton(按钮)、JLabel(标签)提供提示信息、JCheckBox(复选框)、JRadioButton(单选按钮) 、JComboBox(下拉列表/组合框)、JPasswordField(密码框)
常用的布局有哪些：概念（GUI设计界面用啥布局）
FlowLayout流 从左向右排满
BorderLayout边界 最多添加五个组件（东西南北中）
CardLayout卡片式布局 叠放，最先在上
GridLayout网格
null布局
BoxLayout布局
事件处理模式：
事件源——监视器——处理事件的接口（接口回调）
事件源必须是一个对象，能够发生事件的对象
事件处理的方式：有哪些事件命名方式有哪些
Action(重点) addXXXaction
Item
Mouse
对发生的事件做出反应来实现特定的任务。比如单击确定或取消，程序做出不同的处理。
自身类，只有一个类
package exam.text1;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//自身类 自己实现监听器和窗口
public class Action1 extends JFrame implements ActionListener {
private JButton button1,button2;
private JLabel label1,label2;
private JTextField textField;
public Action1(){
super("事物自身类处理方式");
setBounds(300,300,300,300);
setLayout(new GridLayout(3,2));
label1 = new JLabel("请输入姓名");
this.add(label1);//this被省略
textField = new JTextField(10);
add(textField);
button1 = new JButton("按钮一");
add(button1);
button1.addActionListener(this);
button2 = new JButton("按钮二");
add(button2);
button2.addActionListener(this);
label2 = new JLabel();
add(label2);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
//自身类中只有两个方法和一个主方法
public void actionPerformed(ActionEvent e){
String name = textField.getText();
if(e.getSource()==button1){
if(name.isEmpty())
return;
label2.setText("你好，"+name);
}else if(e.getSource()==button2){
if(name.isEmpty())
return;
label2.setText("欢迎你"+name);
}
}
public static void main(String[] args) {
new Action1();
}
}
外部类 多种事物统一处理
package exam.text2;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Action2 extends JFrame {
JTextField textField;
JLabel label1,label2;
JButton button1,button2;
public Action2(){
super("外部类 统一处理事物");
setBounds(300,300,300,300);
label1 = new JLabel("请输入姓名");
add(label1);
textField = new JTextField(10);
add(textField);
//事物处理方式
button1 = new JButton("按钮一");
add(button1);
BtnEventListner btn= new BtnEventListner(this);
button1.addActionListener(btn);
button2 = new JButton("按钮二");
add(button2);
button2.addActionListener(btn);
label2 = new JLabel();
add(label2);
setLayout(new GridLayout(3,2));
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Action2();
}
}
class BtnEventListner implements ActionListener {
Action2 action;
//构造方法
BtnEventListner(Action2 act) {
action = act;
}
public void actionPerformed(ActionEvent event) {
String name = action.textField.getText();
if (event.getSource() == action.button1) {
if (name.isEmpty())
return;
action.label2.setText("你好," + name);
} else if(event.getSource() == action.button2){
if(name.isEmpty())
return;
action.label2.setText("欢迎你," + name);
}
}
}
外部类 事物分别处理
package exam.text3;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//外部类 事物分别处理
//两个监听类，一个主类
public class Action3 extends JFrame {
public JButton button1,button2;
public JTextField textField;
public JLabel label1,label2;
public Action3(){
super("外部类，事物分别处理");
setLayout(new GridLayout(3,2));
setBounds(300,300,300,300);
label1 = new JLabel("请输入名字");
add(label1);
textField = new JTextField(10);
add(textField);
button1 = new JButton("按钮一");
add(button1);
BtnEventListener1 btn1= new BtnEventListener1(this);
button1.addActionListener(btn1);
button2 = new JButton("按钮二");
add(button2);
BtnEventListener2 btn2= new BtnEventListener2(this);
button2.addActionListener(btn2);
label2 = new JLabel();
add(label2);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new Action3();
}
}
class BtnEventListener1 implements ActionListener {
Action3 action;
BtnEventListener1(Action3 act) {
action = act;
}
public void actionPerformed(ActionEvent event) {
String name = action.textField.getText();
if (name.isEmpty())
return;
action.label2.setText("你好" + name);
}
}
class BtnEventListener2 implements ActionListener {
Action3 action;
BtnEventListener2(Action3 act) {
action = act;
}
public void actionPerformed(ActionEvent event) {
String name = action.textField.getText();
if (name.isEmpty())
return;
action.label2.setText("欢迎你" + name);
}
}
内部类 一个大类 类中类
//内部类
public class Action5 extends JFrame {
private JTextField textField;
private JLabel label1,label2;
private JButton button1,button2;
Action5(){
super("外部类，事物分别处理");
setLayout(new GridLayout(3,2));
setBounds(300,300,300,300);
label1 = new JLabel("请输入名字");
add(label1);
textField = new JTextField(10);
add(textField);
button1 = new JButton("按钮一");
add(button1);
BtnEventListener btn = new BtnEventListener();
button1.addActionListener(btn);
button2 = new JButton("按钮二");
add(button2);
button2.addActionListener(btn);
label2 = new JLabel();
add(label2);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new Action5();
}
//内部类
public class BtnEventListener implements ActionListener{
public void actionPerformed(ActionEvent event){
String name = textField.getText();
if(event.getSource()==button1){
if(name.isEmpty())
return;
label2.setText("你好，"+name);
}else if(event.getSource()==button2){
if(name.isEmpty())
return;
label2.setText("欢迎你"+name);
}
}
}
}
内部匿名类
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//匿名内部类
public class Action4 extends JFrame{
private JTextField textField;
private JLabel label1,label2;
private JButton button1,button2;
Action4(){
super("外部类，事物分别处理");
setLayout(new GridLayout(3,2));
setBounds(300,300,300,300);
label1 = new JLabel("请输入名字");
add(label1);
textField = new JTextField(10);
add(textField);
button1 = new JButton("按钮一");
add(button1);
button1.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String name = textField.getText();
if (name.isEmpty())
return;
label2.setText("你好"+name);
}
}
);
button2 = new JButton("按钮二");
add(button2);
button2.addActionListener(
new ActionListener(){
@Override
public void actionPerformed(ActionEvent e){
String name = textField.getText();
if (name.isEmpty())
return;
label2.setText("欢迎你"+name);
}
}
);
label2 = new JLabel();
add(label2);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new Action4();
}
}
第十章 输入输出流 5-8概念题 5综合题
字节输入/字符输入的综合题 挖空/结果
输入流称为源，输出流称为目的地
输入流读取数据的方法，四个基本步骤：
设定输入流的源//给出流的文件，目的地/源 路径方式/file方式
创建指向源的输入流
让输入流读取源中的数据
关闭输入流
文件到达末尾的标志：返回一个值 read（） 达到文件末尾，则返回-1
文件输入流：文件读取
FileInput类是InputStream类的子类，以字节为单位读取文件。创建指定文件的输入流。
FileInputStream(String name);//给定文件名name创建FileInputStream流
FileInputStream(File file);//构造方法使用File对象FileInputStream流.参数name和file指定的文件称作输入流的源
文件到达末尾的标志：返回一个值 read（） 达到文件末尾，则返回-1
输入流的目的时提供读取源中数据的通道。字节输入流read方法以字节为单位读取源中的数据。
写入的文件不存在的处理方法：
当创建输入流时，可能会产生异常。输入流/输出流指向的文件可能不存在，I/O错误，使用IOException（IO异常）对象来代表这个出错信号。程序必须在try-catch语句中try块部分创建输入流/输出流，在catch部分检测并处理这个异常。
File f = new File("destin.txt")；//指定输入流/输出流的目的地
try{
FileInputStream in = new FileInputStream("destin.txt");//创建指向源的输入流
FileOutputStream out = new FileOutputStream(f/"destin.txt");//创建指向目的地的输出流
}catch(IOException e){
System.out.printIn("File read error:"+e)；
System.out.printIn("Filewrite:"+e)；
}
为什么有随机流：读写操作 建立一个流，既可以读文件，也可以写文件。不属于IO流，支持对文件的读取和写入随机访问。
RandomAccessFile类创建的流称作随机流。它既不是InputStream的子类也不是OutputStream的子类。但是RandomAccessFile类创建的流的指向即可以作为流的源也可以作为流的目的地。
随机流的特点：
1.他的父类是Object
2.不区分是输出流和输入流，并要指定文件的访问方式
3.随机流可以移动操作文件的指针，以便随机访问文件中的某个位置的数据
4.可以以二进制的方式对数据进行存储
输入流的指向称为源，程序通过输入流读取源中数据。输出流的指向称为它的目的地，程序通过输出流到达目的地
虽然I/O流经常与磁盘文件存取有关，但是源和目的地也可以是键盘、内存或显示器窗口
read()方法读入源中的数据
wirte()方法把数据写入目的地
I/O流库提供大量流类，所有的输入流都是抽象类InputStream（字节输入流）或抽象类Reader(字符输入流)的子类。
所有输出流都是抽象类OutputStream（字节输出流）或抽象类Writer(字符输出流)的子类
File类的对象主要用来获取文件本身的一些信息，不涉及对文件的读写操作
文件字节输入流读取数据的方法，四个基本步骤：
设定输入流的源
创建指向源的输入流
让输入流读取源中的数据
关闭输入流
文件字节输出流4个基本步骤：
设定输出流的目的地
创建指向目的地的输出流
让输出流把数据写入目的地
关闭输出流
第十一章 数据库
数据库SQL语句编写
--查询
select * from tablename;
--新增
insert into tablename(属性1,属性2) values(value1,value2);
--删除，只能删行
delete from tablename （where）;
--修改
update tablename set 属性1=value1,属性2=value2 （where）;
并发、事务、存储过程
查询的结果集：
查询ResultSet对象中的数据时，不可以关闭和数据库的连接。否则结果集对象的数据立马消失，必须保持与数据库的连接
预处理语句：
使用PreparedStatement对象（命令封装在预处理对象中，事先将SQL解释为数据库底层内部命令，然后数据库再去执行）可以提高操作数据库的效率
好处：减轻数据库内部SQL语句解释器的负担
事物的基本概念：
事物是由一组SQL语句组成。事物处理指的是事物中的SQL语句要么全部执行要么一个都不执行。
事物处理步骤：
- setAutoCommit()方法关闭自动提交模式
- commit()方法处理事物 全部生效
- rollback()处理事物失败 其中一条语句未生效，则使事物恢复到commint()执行前的状态
第十二章 多线程机制 5 基本概念 选择、填空、判断
web系统难点：高并发（多线程）、安全
线程和进程的关系：一个进程可以有多个线程
线程是比进程更小的执行单位，一个进程在执行过程中，可以产生多个线程，形成多条执行线索。在同一进程内运行的并发任务称之为线程。
进程和程序间的关系：进程是程序的一次动态执行过程。程序（代码，静态的）调到CPU运行变成进程。进程内综合runnable()/thread()接口创建一个线程，就变成两个线程。因为一个程序开始运行的话，一定有一个主线程，主线程执行main方法。即如果中途运行时调用创建线程语句则会创建一个线程，不调用语句只会有一个线程。
程序静态的，进程是动态的（在CPU中执行的动态运行程序）。同一段代码可以有N个进程。每个进程有没有多个线程则是看它是否创建线程。创建了一个，则有两个线程。
程序新建后，不调用start方法是没有机会获得CPU资源的
线程的同步：资源竞争。如果两个线程需要调用同一个同步方法，那么一个线程调用该同步方法时，另一个线程必须等待。
几个线程都需要调用同一个同步方法（用synchronized修饰的方法）。一个线程在使用同步方法时，可能根据问题的需要，使用wait()方法暂时让出CPU的使用权，以便其他线程使用这个同步方法。其他线程在使用这个同步方法时如果不需要等待，那么它用完这个同步方法的同时，应当执行notifyAll()方法通知所有由于使用这个同步方法而处于等待的线程结束等待。
线程的几种状态：新建-就绪-运行-阻塞-死亡
新建：Thread类及其子类的对象声明并被创建时
进程在初始化线程：start开始新建-就绪（区别阻塞-就绪）start();run();
就绪-运行：操作系统控制，随机性
外设备操作时间长：阻塞 网络数据来了 阻塞-就绪 sleep(int millsecond);wait();
死亡：释放实体
在Java中，我们有2个方式创建线程：
- 通过直接继承thread类，然后覆盖run()方法。
- 构建一个实现Runnable接口的类, 然后创建一个thread类对象并传递Runnable对象作为构造参数
可以看到，这两种创建线程的方式都需要新建一个Thread对象，可以说一个Thread对象代表一个线程实例
``
