corejava知识---【一】

-------------------CoreJava第一阶段---------------------------

day1-------------------------------------------------------
B/S：Browser/Server
C/S：Clinet/Server

第一代编程语言：机器代码、机械码。
第二代编程语言：汇编。
第三代高级编程语言：Java C# C++


一、Java：
1. 95年 Sun MicroSystem
2. 96年 1.0V
3. 98年 1.2v
4. 04年 JavaSE(Java Platform Standard Edition) JavaEE(EnterPrise)
二、特点：
1. 纯面向对象（使用计算机模拟现实世界，解决现实问题。贴近人类思维模式）
2. 简单性（相对C、C++、C#）
3. 跨平台性（操作系统、服务器、数据库）
三、执行机制：
1. 编译执行：源文件 编译成二进制(010111001)，可执行文件。一次编译，多次执行。不可跨平台。
2. 解释执行：源文件 一行一行解释，一行一行执行。不同操作系统具备不同解释器。可以跨平台的。
3. Java先编译 再解释：源文件编译成字节码文件（平台中立文件.class）。再将.class文件进行逐行解释。
四、名词解释：
1. JVM(Java Virtual Machine)：使用软件模拟一个完整的操作系统。
2. JRE(Java Runtime Environment)：Java运行环境，运行Java程序。(JVM+解释器)。
3. JDK(Java Development Kit)：Java开发工具包：JRE+类库+工具包。
五、Java的环境变量：
1. JAVA_HOME: C:\Program Files\Java\jdk1.6.0_21。
2. PATH: ;C:\Program Files\Java\jdk1.6.0_21\bin。
3. CLASSPATH: . 。
六、Windows DOS窗体命令：
1. 更换盘符： d:
2. 查看盘符内容：dir
3. 进入文件夹：cd 文件夹名称
4. 返回上一级目录：cd..
5. 清除：cls
6. 删除文件：del 文件名称
7. 删除文件夹：rd 文件夹名称
8. 新启DOS：start
9. 退出：exit

七、创建源文件、编写类：
1. class 关键字 
2. 类名自定义
3. 主函数：main 入口程序框架。一个类中，只能有一个主函数。
4. 层级间要有缩进。
5. Java对大小写敏感
6. 每句代码的结束要加;

八、程序编译、执行：
1. 编译：javac 源文件名称.java 
2. 运行：java 类名

九、类的阐述：
1. 在同一个源文件中，可以书写多个类。
2. 公开类(public class)的类名要和文件名完全相同。
3. 在同一个源文件中，只能有一个公开类(public class)。

十、package(包)：
1. 管理、区分类的。
2. 声明包 package 包名（全小写）。
3. 语法：package zpark; 必须是源文件的第一行。
4. 带包编译：javac -d . 源文件名称.java。自动生成目录结构。
5. 带包运行：java 全限定名.类名  java zpark.Hello。
6. import 导入包。将外部class文件引入到自身文件中。
7. import java.util.Scanner; 导入公开类。

十一、java中注释：
1. 注释不参与编译。
2. 单行注释： // 单行
3. 多行注释： /* 多行 */
4. 文档注释： /**文档 */   javadoc -d . Hello.java

十二、编码规范：
1. 类名：HelloWorldpasacl帕斯卡  每个单词的首字母大写
2. 包名：全小写
3. 变量、函数：camel驼峰首单词首字母小写 拼接词首字母大写

day2---------------------------------------------------


8bit位 == 1Byte == KB == MB == GB == TB 




一、变量：
1. 概念：一个数据存储空间的表示，它是存储数据的基本单元。

2. 语法：
I. 声明：数据类型 变量名    int money;
II. 赋值：变量名 = 值money = 100;
III.声明并赋值：数据类型 变量名 = 值       int money = 100;
IV. 声明 赋值 使用



二、数据类型：

基本数据类型（原始、简单）：
1.整数：
I. byte1个字节-128 ~ 127-2的7次方到2的7次方-1
II. short2个字节-32768 ~ 32767   
III.int 4个字节 -2147483648 ~ 2147483647 
IV. long8个字节-922京 ~ 922京

2.小数(浮点)：
I. float4个字节1e38
I. double8个字节1e308

3.字符：
I. char2个字节'A' 65 '\u0041'    ascii / unicode 收录的所有字符
II. 转移字符 \t  \n   \\    \' \"

4.布尔：
I. boolean  true  false

对象数据类型：
1.字符串：
I. String“字面值”

三、标示符的规则与规范:
1. 字母、数字、_、$
2. 不能以数字开头。
3. 望文生义


四、类型转换：
1. 自动类型转换：
I. 两种类型相互兼容。
II. 目标类型大于源类型。（目标类型的取值范围包含源类型）。

2. 强制类型转换：
I. 两种类型相互兼容。
II. 目标类型小于源类型。
a. 长度合适，数据完整。 short s = 20byte b = (byte)s;
b. 长度不适，数据截断。 short s = 260byte b = (byte)s;
c. 小数强转整数时，数据截断，失去精度。  double d = 3.5;   int i = (int)d;
d. char和整数，可相互转换，不会失去精度。
e. boolean的取值true/false不可转换。

五、表达式：
1. 概念：使用运算符连接的变量或字面值，并且最终可以得到一个结果。
2. 自动类型提升规则：
I. 两个操作数，有一个为double，其结果提升为double。
II. 没有double时，有一个为float，其结果提升为float。
III.没有float时，有一个为long，结果是long。
IV. 没有long时，一个为int，结果是int。


六、运算符： 
1. 算数运算符：+ - * / % ++ -- 
2. 赋值运算符：= += -= *= /= %=
3. 关系运算符：> < >= <= == !=   boolean类型的结果 true / false
4. 逻辑运算符：
I. && 与（并且）：两个条件同时为true，结果才为true，短路
II. || 或（或者）：两个条件有一个为true，结果为true
III. ! 非（不是）：取反。
5. 三元运算符： 布尔表达式 ? 结果1 : 结果2
6. 位运算符：
I. & (按位求与)：相同为1，不同为0，做逻辑判断时，为非短路
II. | (按位求或)：有一个为1，结果为1
III.^ (异或)：相同为0，不同为1
IV. ~（按位求反）： 正数取反后 -1 ，负数取反后 + 1
V. <<（左移）：X2
VI. >>（右移）：/2
VII.>>>（无符号右移）：右移后，符号位补0

day3-------------------------------------------------------------


一、选择结构：
1. 基本选择结构：
if(布尔表达式){
//代码块
}

2. 多重if选择结构
if(布尔表达式){

}else if(布尔表达式){

}else if(布尔表达式){

}else{

}
相互排斥，当有一个条件满足时，其他均不再执行。

注意：在做区间判断，要遵循升序或降序的排列顺序。

3. 嵌套if选择结构：
当外层条件满足时，再判断内层条件。

4. switch选择结构：
只做等值判断。
int char  ---  String JDK1.7之后可以使用

所有case的取值，不可相同。

当某一条件满足时，并不会自动结束整个选择结构，需增加break。

break ：终止，跳出，结束。

二、局部变量：
从定义起，到直接包含它的结构结束。
必须赋初始值。

三、Scanner扫描仪：
1. 导入包
2. 声明Scanner变量。
3. 使用Scanner中对应的输入方法。
4. 类型不同使用的能力不同：
I. int    input.nextInt();
II. double  input.nextDouble();
III.String  input.next();
IV. charinput.next().charAt(0);

day4-------------------------------------------------------------------


一、循环：
1. 概念：通过某个条件，使一段代码周而复始的执行。

2. 组成：初始部分，循环条件，循环操作，迭代部分（控制循环条件改变的增量）

3. while循环：

while(boolean){
//代码块
}

特性：先判断，再执行。

应用场合：循环次数明确。

例：统计1、2、3、4、5~100是所有数之和。

4. do while循环：

do{

}while(boolean);

特性：先执行，再判断。(无条件执行一次)

应用场合：循环次数不明确。

5. for循环：

for(初始部分;循环条件;迭代部分){
//循环操作
}

特性：先判断，再执行。

应用场合：循环次数明确。

6. 循环流程控制的关键字：

1. break:终止，跳出，结束。既可以跳出switch也可以跳出循环。

2. continue：结束本次，进入下一次。

7. 二重循环：

1. 概念：一个完整的循环结构中，嵌套另一个完整的循环结构；

2. 图形归纳：在打印图形时，外层循环控制行数，内层循环控制列数。

3. 其他：外层控制循环次数，内层控制单次循环操作。

========================== day5 函数 ==========================


思考：目前程序存在的问题？
1、重复代码太多（代码冗余）
2、所有的代码都写在1个main函数中（可读性、可维护性差）
函数：
一、概念
函数：实现特定功能的一段代码。
注意：1）定义位置：类中，其他函数的外面；
 2）1个类中可以有多个函数，函数定义的顺序没有要求。

二、定义【重点】
1、三要素（声明）
[public static] 返回值类型 函数名(形参列表){
// 功能代码、函数体语句
}
2、返回值类型
可以是 8种基本类型、对象类型、void。

如果是8种基本类型、对象类型，代表该函数必须要有返回值，意味着
在函数体语句中必须要有 return xxx; 并且xxx表达式的类型必须和 返回值
类型完全匹配。
如果是void，代表该函数没有返回值，意味着在函数体语句中 可以有
语句 return; 该语句也可以省略。

3、函数名
望文生义，必须是一个有效的标识符
驼峰命名法，如 printSplitChar()
4、形参列表
形(式)参(数)列表语法：(数据类型 变量名,类型 变量名,....)

int a =10;

int b = m1(a);
//double c = a>b?10.5:20.4;

System.out.println(a);
public static int m1(int b){
//返回 b+1;
return b+1;
}
形参变量，相当于函数内部的 局部变量，只在该函数内部有效!!

三、调用【重点】
1、语法：
在某个函数内部进行调用，语法： 函数名(实参列表)
2、实参列表
实(际)参(数)列表，语法，(值1,值2,...)
注意：实参和形参列表的 个数、类型、顺序 必须完全一致。
3、使用返回值
当成 表达式或表达式中的一部分 进行使用。
如，System.out.println(add(2,3));
add(2,3) + 5
4、执行
调用函数时，程序转到 函数定义的位置，先把 实参值传递给对应的
形参变量，运行函数中的功能代码语句；
执行完功能代码，程序自动返回 调用的位置，并且继续执行后面代码。

四、好处
1、减少代码冗余
2、提高可维护性
3、提高可读性
4、提高复用性
5、方便分工合作

五、嵌套
在函数中调用了其他函数。

六、递归【难点】
特殊的函数嵌套形式，函数中调用了自已。
注意：避免 无穷递归调用!!!


========================== day6 数组 ==========================


数组
一、概念
一块连续的内存空间，用于存放 多个 相同类型数据的。
强调：连续、相同类型。

二、定义【重要】
语法：1）
数据类型[] 变量名; //声明
int[] score;//声明
score = new int[5];//开辟内存空间(指定数组长度)

int[] a = new int[3];//声明的同时，开辟内存空间
a[0] = 10;
a[1] = 20;
a[2] = 30;
2）显示初始化
int[] a = {10,20,30,0,3};//声明、开辟空间、赋值
3）int[] a = new int[]{10,20,30};
int[] a = new int[3]{10,20,30};//error

默认值：
给数组开辟内存空间后，数组元素的初始值。
1) 基本类型
数值类型 0
boolean false
char '\u0000'   空字符''
2) 对象类型
默认值 null

三、遍历【重要】
下标： 范围：0 ~ (长度-1)
数组长度：  数组变量名.length  

访问数据元素： 数组变量名[下标]
遍历：把数组中的所有元素，都访问1遍。

四、应用
1、统int数组中所有元素的和
2、把数组元素倒置
10,90,30,20
20,30,90,10
共需要对调的次数： a.length/2
每次需要对调的元素： a[i]  <-->  a[a.length-1-i]


常见问题：
1、int[] a;
a = {10,20,30}; //error，声明和显示初始化必须在同一行写
2、java.lang.ArrayIndexOutOfBoundsException:.......
数组下标越界异常
解决方案：检查数组下标。


五、扩容
1) 先创建新数组，把旧数组元素依次赋值给新数组的对应元素，新数组地址赋给a
2) System.arraycopy(原数组变量名,原数组起始下标,新数组变量名,新数组起始下标,长度);
3) 数组类型 java.util.Arrays.copyOf(原数组变量名, 新长度);


========================== day7 排序 ==========================


一、排序【难点】
1、冒泡排序【重点】
方法：相临的2个数比较大小，大的往后放

原有数组a中的数据：  4  3   9    2 1
下标： a[0] a[1] a[2] a[3] a[4]

冒泡排序的过程：
----------第1轮(4次)-----------
a[0]>a[1] 3 4 921i=0for(int j=0; j<4; j++)
a[1]>a[2] 3 4 921
a[2]>a[3] 3 4 291
a[3]>a[4] 3 4 219//比较1轮后，最大值“沉到最后”
----------第2轮(3次)-----------
a[0]>a[1] 3 4 219i=1for(int j=0; j<3; j++)
a[1]>a[2] 3 2 419
a[2]>a[3] 3 2 149//比较2轮后，第2大的数，确定
----------第3轮(2次)-----------
a[0]>a[1] 2 3 149i=2for(int j=0; j<2; j++)
a[1]>a[2] 2 1 349//比较3轮后，第3大的数，确定
----------第4轮(1次)-----------
i=3 for(int j=0; j<1; j++)
a[0]>a[1] 1 2 349//比较4轮后，第4大的数，确定, 排序完成

结论：n个数排序，比较 n-1 轮，每轮比较 (n-1-i) 次。

n = a.length;
for(int i=0; i<n-1; i++){//比较轮数
for(int j=0; j<n-1-i ; j++){//每轮比较的次数
// 相临2个数，前>后，则交换
if(a[j] > a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}


2、选择排序
方法：固定下标的数 和 其后的元素比较大小，小的往前，大的往后放

原有数组a中的数据：  4  3   9    2 1
下标： a[0] a[1] a[2] a[3] a[4]

选择排序的过程：
----------第1轮-----------
a[0]>a[1] 3 4 921i=0 a[0]>a[j] for(int j=1;j<5; j++)
a[0]>a[2] 3 4 921
a[0]>a[3] 2 4 931
a[0]>a[4] 1 4 932//1轮后，最小的放到最前面
----------第2轮-----------
a[1]>a[2] 1 4 932i=1a[1]>a[j] for(int j=2;j<5; j++)
a[1]>a[3] 1 3 942
a[1]>a[4] 1 2 943//2轮后，第2小的数确定
----------第3轮-----------
a[2]>a[3] 1 2 493i=2a[2]>a[j] for(int j=3;j<5; j++)
a[2]>a[4] 1 2 394//3轮后，第3小的数确定
----------第4轮-----------
i=3 a[3]>a[j] for(int j=4;j<5; j++)
a[3]>a[4] 1 2 349//4轮后，第4小的数确定，排序结束


结论：n个数排序，比较 n-1 轮。

n = a.length;
for(int i=0; i<n-1; i++){
for(int j=i+1; j<n; j++){
if (a[i] > a[j]){
// 交换
}
}
}
3、java.util.Arrays.sort(数组变量名);//底层实现，快速排序



二、二维数组
一维数组的一维数组。
1、定义
int[][] a; //声明
a = new int[4][3];//开辟内存空间,4-高维,3-低维
a[0][1] = 11; //赋值


int[][] a = new int[4][3]; 
2、遍历
双重循环，外循环 控制行，内循环 控制列。
访问数组元素：a[行][列]
3、显示初始化
int[][] a = {{1,2},{3,4},{5,6}};//3行2列
int[][] a = new int[][]{{1,2},{3,4},{5,6}}; //注意[][]中不能有数字
4、不规则数组
int[][] a = new int[4][];
a[0] = new int[2];
a[1] = new int[5];
a[2] = new int[7];
a[3] = new int[3];//不规则的2维数据

//int[][] a = new int[][3];//error，必须指定高维长度

遍历：  a.length //高维长度
a[i].length //低维长度


------------------------ CoreJava第二阶段 ------------------------


========================== day8 OO ==========================


一、编程思想
需求 -->  建立思想  --> 完成任务

面向过程的编程思想：
从过程入手，第1步，第2步，..... 完成任务。
面向对象的编程思想：
从对象入手，借助对象间的相互配合，完成任务。

二、面向对象(Object-Oriented)
1、什么是对象？
对象，一切客观存在的事物，统称为对象。
属性：有什么
方法/行为：干什么

大对象 可以是由小对象 组成的; 
对象的方法，通常会提供给别的对象 使用。
2、面向对象的思想
先把 解决问题 涉及的对象找到， 借助这些对象间方法的相互使用，完成任务。
3、计算机中的对象
内存中的数据
是现实中对象 ， 在计算机中的抽象/逻辑表示。
4、面向对象的特点
1) 各司其职  高内聚、简单性
2) 弱耦合性 低耦合
3) 可重用性
4) 可扩展性
5、类的概念
1) 类 是对象的公共特性的提取
2) 类是对象的模版
3) 类 是 现实对象 在计算中的体现
三、类的组成
1、属性
语法 ： 数据类型 变量名;

****** 实例变量 和 局部变量的区别？****** 
局部变量 实例变量 
定义位置 函数中  类以内，方法外面
默认值 先赋值后使用   有默认值(同数组元素)
使用范围 从定义开始到该代码块结束  至少在本类中可用
命名冲突 相同范围内不允许重名 实例和局部变量重名，在重合范围内局部优先

注意：如果实例变量的声明和赋值分开写，则赋值语句必须写在方法中。
//int m ;
//m = 10;//error,原因 该语句是功能性语句

class Student{


String name;
int age;

public void study(){
int a = 10;
}
public void study(int a){}

/*无参构造方法   */
public Student(){

}
/*有参构造方法   */
public Student(String name , int age){
this.name = name;
this.age  = age;
}


}
class Test{
public static void main(String args[]){

/*声明一个Student类型的引用 名为 stu1*/ 
Student stu1;
/*使用无参构造方法 为stu1赋值*/
stu1 = new Student();
/*为stu1对象的name属性赋值*/
stu1.name = "陈维汉";
/*这个学生的年龄是18岁*/
stu1.age = 18;
//---------有一个Student类型的对象 名字为stu1 
//name属性的值为 陈维汉 
//age属性的值为 18
stu1.name
stu1.age
stu1.study();



/*创建一个Student类型的对象 引用名为 stu2 使用有参构造方法为 stu2赋值*/
Student stu2 = new Student("石致远",48);

//---------有一个Student类型的对象 名字为stu2
//name属性的值为 石致远 
//age属性的值为 48

//两种创建对象 赋值方式不同 目的相同 意义不同


}
}

2、方法（函数）
语法 ：
声明    修饰符 返回值类型 方法名(参数列表){
实现 // 方法体语句
}

重载(OverLoad)
语法要求： 1) 方法名 相同
  2) 参数列表 不同(个数/类型/顺序 任一个不同)
  3) 返回值类型 不要求
注意：1) 在编译时确定要调用的方法，由JVM编译时自动匹配    编译时多态
 2) 参数匹配时，遵循 向上就近匹配原则。
 3) 参数匹配时，避免出现类型 混淆。
好处：对使用者 屏蔽 (因参数列表不同导致的)差异，使得方法的调用更灵活方便。

3、构造方法
是特殊的方法。
语法要求：1) 方法名称 必须和 类名完全一致
 2) 没有返回值类型(不是void，连void都没有) 
 3) 不允许 手工调用，在创建对象时，由JVM自动调用 1 次。
注意：1) 在1个类中如果没定义构造方法，则JVM会自动添加1个 公共无参的 默认构造方法
 2) 在1个类中如果已经定义了构造方法，JVM将不再添加 公共无参的 默认构造方法
 3) 构造方法 可以重载
 4) 构造方法的作用： 通常用于给 属性 赋值。
 
// 创建对象的语法
类名  对象名 = new 类名();
对象名.属性
对象名.方法

作业： 1 2 3 6 7 11 12


========================== day9 OO ==========================


一、创建对象
类 和 对象 的关系：
类 是 对象 的模板；
对象 是 类的实例。

创建对象的语法：
对象类型 变量名 = new 类名(和构造方法的参数对应的实参列表);
Student stu1 = new Student();
Student stu2 = new Student("tom");

stu1,是对象类型的变量，也称为 Student类的一个实例/引用。

操作对象的属性或方法：对象名.属性   
对象名.方法(实参)


创建对象的过程：
1) 分配空间 给所有的实例变量赋 默认值
2) 初始化属性 给所有的实例变量赋 初始值
3) 调用构造方法 通常给实例变量进行 第3次赋值

二、this
代表当前对象，是引用，“我”
使用方法有2种：
1、当前对象的引用
使用在类定义的方法内部，通常用于访问对象的属性或方法
如，this.属性   this.方法(实参)

注意：1) this.可以省略不写，当 实例和局部变量重名时，必须写！！
2) this 不能在 static 修饰的方法中使用，如main方法。
2、调用本类的其他构造方法
在类的构造方法内部，使用 this(构造参数) 调用该类的其他构造方法
注意：this()必须是构造方法中的 第1个有效语句。


三、引用【重难点】
数据类型
基本类型：8个
对象类型：类 接口 数组

变量
基本类型变量：存值 
对象类型变量：存地址(内存首地址)

JAVA中方法的参数传递
基本类型变量： 传值
对象类型变量： 传地址  
形参和实参指向同1个对象；
在方法内部，修改了形参变量的值，说明形参指向了其他对象。


========================== day10 封装 继承 ==========================


一、封装
封装，类也应该有个边界，可以对 其中的数据进行保护和隔绝的作用。
属性私有，提供公共的get/set方法。
数据隐藏
1)属性私有： private 私有 本类中使用
2)提供公共的get/set方法:public  公共所有类都可用


// 获取属性值
public String getPassword(){
return this.password;
}

// 设置属性值
public void setPassword(String p){
this.password = p;
}


访问方法
封装前：
对象名.属性
封装后：
对象名.方法名(实参)
二、继承
//提取三个类 共性 作为父类
class People{
String name;
int age;
boolean sex; 

public People(String name , int age , boolean sex){
this.name = name;
this.age =age;
this.sex = sex;
}
public void  eat(){
System.out.println("一日三餐");
}
}

class Man extends People{

public Man(){
super.sex = true;
}
//xxx  特性
}

class Woman extends People{
public Woman(String name , int age , boolean sex){
super(name , age , sex);
}

// ooo 特性
}

class ChenWH extends People{
//犄角
//蹼
//鱼鳞
//触须

//父类的eat方法 不适用 采用覆盖 
public void eat(){
//if( 犄角 软了){
super.eat();
//}else{
System.out.println("三日一餐");
//}
}
}

class Test{
public static void main(String[] args){
Woman w = new Woman("刘丹妮",18,false);


}
}



1、继承：类和类之间的 "is a" 关系 ，也是 “一般” 到“特殊” 的关系。
一般的类，也称父类、超类、基类；
特殊的类，也称子类、派生类。

思想，多个类具有共性，把共性抽取出来，定义成父类，从而 提高代码的可重用性。

使用，子类可以使用父类的功能, 根据需求，子类中还可以添加自己的新功能，从而 提高代码的可扩展性。

*****特点：单继承（1个类只能有1个直接父类）

语句： 子类名 extends 父类名{}
extends,中文 含义 扩展。


问题：子类可以使用父类的哪些东西？
注意：1) 构造方法 不能被继承
2) 属性和方法 取决于 访问修饰符

2、访问修饰符/访问可见性

private 私有本类不能被继承
(default) 默认 本类+同包 取决于是否在同1个包
protected 受保护 本类+同包+不同包的子类可以继承
public 公开 所有类 可以继承


-------------------------------------------------------------
  本类   同包    不同包的子类    其他
private √
default √ √
protected √ √ √
public √ √ √√
-------------------------------------------------------------


注： 1) 都可以属性、方法、构造方法
2) 可以修饰类的： public default 


3、覆盖 Override 重写
在子类中，根据需求，把从父类继承过来的方法 进行重新实现，就称为覆盖。
语法特点：
1) 方法名、返回值类型、参数列表 必须和父类中的完全相同；
2) 访问修饰符可以相同 或 更宽。
使用：
子类对象.方法名(实参);// 如果子类中有覆盖的方法，则优先调用子类的方法

4、子类对象的创建过程
1) 分配空间（父类+子类）    默认值
2) 递归地 创建父类对象(步骤2-4)
3) 初始化本类属性 初始值
4) 调用本类的构造方法 第3次赋值

举例：
class A
class B extends A
class C extends B

创建子类C的 对象 过程：
1) 分配空间（A+B+C）//步骤1
2) 创建父类B 的对象
2-1) 创建父类A 的对象
2-1-1)创建类A的直接父类对象（没有）
2-1-2)初始化A的属性 m = 5//步骤2
2-1-3)调用A的构造方法//步骤3
2-2) 初始化B的属性 n = 10//步骤4
2-3) 调用B的构造方法 //步骤5
3) 初始化C的属性 k=15//步骤6
4) 调用C 的构造方法 //步骤7
5、super
2种使用方法：
1)super.属性 super.方法(实参)
父类对象，引用
代表要调用父类的属性或方法。
注意： 1) 写在子类的方法中
2) 不能在static修饰的方法中使用。

2)super(实参)【难理解】
写在子类的构造方法中，告诉JVM在创建子类对象时，要调用父类的哪个构造方法。
（调用父类的构造方法）

注意：a) 必须是子类构造中的第1个有效语句
 b) super(实参) 和 this(实参) 不允许同时出现在同1个构造方法中
 c) 如果在构造中第1句不是this(实参)，也不是super(实参)，则JVM会自动添加super();
 d) 如果在构造中第1句是this(实参)或是super(实参)，则JVM不再添加super()




========================== day11 多态【重难点】 ==========================


一、概念
多态，父类引用 指向 子类对象，从而产生的多种形态。

二、语法：
父类类型  引用名 = new  子类类型(实参);
Animal a1 = new Dog();
Animal a2 = new Cat();
父类类型 子类类型
父类引用 子类对象
主观类型 实际类型
三、特点
1) 对象类型 不变(是Dog就是Dog)
2) 编译时，通过父类引用 只能调用 父类类型中声明了的 方法(不能调用子类特有的方法)
3) 运行时，如果子类 覆盖了父类中的方法，通过父类引用调用时，以子类中的方法优先;如果没覆盖，则直接运行父类中的方法。

四、对象类型间的 类型转换
基本类型间的类型转换：
int i = 5;
long l = i;//OK, 大类型 = 小类型，自动类型转换

double d = 3.4;
int m = d;//error, 小类型 = (小类型)大类型，必须通过强制类型转换

boolean bn = false;
int n = bn;//error, 类型不兼容，不允许类型转换

对象类型间的类型转换：
1) 子类对象 赋值给 父类引用 
父类类型(大类型)  = 子类类型 (小类型)//ok
Animal a = new Dog();
Animal a = new Cat();

结论：父类引用 可以直接指向 子类对象。
2) 父类引用 赋值给 子类引用
子类类型(小类型)  = 父类类型(大类型)//

Animal a = new Dog();
Dog d = (Dog)a;//编译OK。运行OK。

Animal a = new Cat();
Dog d = (Dog)a;//编译OK。运行异常

结论：父类引用 必须通过强制类型转换 才可以 赋值给 子类引用。
但是，只能保证编译OK；运行时，可能会出现类型转换异常ClassCastException。

3) 没有继承关系的2个类，不允许 类型转换 
Person p = new Dog();//ERROR

结论：没有继承关系的2个类，不允许 类型转换。

五、 instanceof
语法：引用 instanceof 类名
作用：判断引用指向的对象类型 是不是 和类名对应的类型 相兼容，
如果兼容返回true; 否则 false.
举例：
Animal a = new Dog();
a instanceof Dog//true
a instanceof Animal//true
a instanceof Cat//false
使用场景：把父类引用 赋值给 子类引用时，防止出现类型转换异常ClassCastException，可以使用instanceof先进行判断。

六、多态在实际开发中的应用
1、多态应用在方法参数上
详见 Person类的 feed(Animal a) 方法。
在使用时，可以给形参传的值，包括 该类和其所有子类的对象。
2、多态应用在方法的返回值上
详见 Person类的 Animal getPet(int type) 方法。
在使用时，可以根据形参 创建不同的Animal类或其子类的对象，并且返回。

七、多态的好处
对使用屏蔽各子类间的差异，使得程序的调用更通用、简单。


作业：
多态： 3 4 5 13 14 17 20 21 23 24

======================== day12 三大修饰符【重点】 ========================


访问修饰符：
本类 同包不同包的子类所有
private OK
(default) OK OK
protected OK OK OK
public OK OK OKOK
这4个访问修饰符，都可以修饰 属性、方法、构造方法。
只有(default)、public 可以修饰 类。


一、static  静态
1、属性
static 类型 变量名 = 5;
类变量/静态变量，被该类的所有对象共享，不再单属于某1个对象(和对象无关)。
访问形式： 类名.属性名 
对象名.属性名 （正确，但不建议使用）
2、方法
static 返回值类型 方法名(形参){
//功能代码
}
类方法/静态方法
访问形式： 类名.方法名

注意： 1) static修饰的方法中，只能 直接使用 static 变量。
2) static修饰的方法中，不能用 this 和 super 。
3) static修饰的方法中，只能被 static 方法覆盖, 但是没有多态(详见下1条)
4) 使用引用调用static方法时，执行的是 引用类型 自己的static方法。

3、初始代码块
初始代码块: 在类以内，方法以外，用{}括起来的功能语句段。
用于在创建对象时，和初始化属性一起执行，进行相关初始化工作。


静态初始代码块： 被static修饰的 初始代码块。
在 类加载 时，只被执行1次的代码，用于进行初始化工作。
4、类加载
类加载：在JVM在第1次使用某个类时，在classpath中找到对应的class文件，
把该文件中类的信息(属性名称/属性类型/方法返回值类型.....)读取到内存，并且保存起来的过程。
类加载的时机： 1) 创建对象
2) 访问类的静态变量/方法时
3) 加载子类时，先加载父类
注意：只做对象类型声明时，不进行类加载。

类加载的顺序：
读取 class 文件
根据定义的顺序，依次执行 static 属性、静态初始代码块。

二、final 最终
1、修饰变量
局部变量、实例变量、类变量
常量，只允许赋值 1 次，值不允许改变。
1) 基本类型，值不允许改；
2) 对象类型，地址不允许改。

注意：1) final修饰实例变量时，JVM不再分配默认值。
可以通过 声明或构造方法 赋初值。
如果使用构造方法赋值，则所有的构造方法 必须都赋值。
 2) final修饰类变量时，JVM不再分配默认值。
可以通过 声明或static静态初始代码块中 赋初值。
2、修饰方法
最终方法，不允许 被覆盖。

3、修饰类
最终类，不允许 被继承。

在final修饰的类中，方法 自然都是 final 的。(正确)


三、abstract 抽象
1、修饰方法
抽象方法：1)只有声明，没有实现。
2)抽象方法，必须定义在 抽象类中。
2、修饰类
抽象类：1) 不允许创建对象，可以声明引用。
2) 子类继承抽象类时，必须 实现 父类中的所有抽象方法，除非子类还是抽象的。
3) 抽象类中， 可以有抽象方法，也可以有非抽象方法。

作用：强制 使用 多态。

四、修饰符小结
static、final、abstract 都不能修饰构造方法
static修饰时，是静态，与对象无关；
final修饰时，构造方法不能被继承；
abstract修饰时，不允许构造方法没有实现。

private、static、final、abstract中不能连在一起使用的关键字组合：
private abstract： private的方法不能被继承；
static abstract： static与对象无关,不允许方法没有实现；
final abstract： final的方法不能被覆盖。


========================== day13 接口【重难点】 ==========================


一、概念
接口，相当于 特殊的抽象类。

相同点：
1) 都会生成 class 文件
2) 不允许创建对象
3) 可以声明引用(强制使用多态)
不同点：
1) 接口中的属性，默认都是公开 静态 常量(public static final)
2) 接口中的方法，默认都是公开 抽象的(public abstract)
3) 接口中不能有构造方法，初始代码块{}，静态初始代码块static{}

二、语法
创建接口： interface 接口名 extends 接口名2,接口名3{ }
实现接口： class 类名 implements 接口名1,接口名2{ }
实现类 父接口

注意：1) 1个类实现1个接口，必须实现 该接口中的所有抽象方法，除非该类是抽象的。
2) 实现类中 实现 接口中的抽象方法，访问修饰符 必须是 public 。
3) 强制类型转换时，即使1个类没实现接口，强转成对应的接口类型，仍可以保证编译OK。


三、OO中 关系小结
继承关系： 类和类 单继承
接口和接口 多继承

实现关系： 类和接口 多实现

先继承后实现：
1个类，即可以继承1个父类(单继承)，同时也可以实现N个接口(多实现)。
类名 extends 父类 implements 接口名1,接口名n


四、作用
1、多继承
不破坏原有的继承关系树的简单性，把 主要功能 和 次要功能加以区分。
2、弱耦合性
接口，标准，规范，约束，统一的使用方法。
定义接口后，接口的使用者 和 接口的实现者进行了分离，借助于多态，降低了程序间的耦合性。


接口回调：接口定义以后，先有接口的使用者，后有接口的实现者。




------------------------ CoreJava第三阶段 ------------------------


API的应用


========================== day14 内部类、Object ==========================
一、内部类
定义在 类内部的 一个类。
编译层面的类，编译后会分别生成对应的class，运行时就当成2个类来使用。

分类：
1、成员内部类
相当于 实例变量， 定义在 类以内方法以外。

1) 成员内部类，可以在不破坏封装的前提下，直接访问外部类的私有属性。
2) 创建成员内部类对象：  先创建外部类对象，再使用 外部类对象名.new 语法
Outer o1 = new Outer();
Outer.Inner in = o1.new Inner();
3) 外部类类名.this 语法：代表外部类的当前对象
4) 在成员内部类中，不允许定义 static 的元素。

2、静态内部类
相当于 类变量， 定义在  类以内方法以外，并且被static修饰。

1) 静态内部类中，只能访问 外部类的 静态成员。
2) 创建对象：不用先创建外部类对象
Outer.Inner in = new Outer.Inner();

3、局部内部类
相当于 局部变量，定义在 方法以内。

1) 局部内部类 作用范围 同局部变量。
2) 在局部内部类中，即可以访问外部类的私有属性；也可以访问外部类的局部变量，但是必须使用final修饰。

4、匿名内部类
1) 特殊的 局部内部类；
2) 只需要该类的1个对象；
3) 该类 不需要类名。 
4) 该类 必须继承抽象父类 或 实现父接口。
好处：接口公开，实现类作为匿名内部类加以隐藏，强制 弱耦合。


二、Object类
是JAVA中所有类的父类，位于 类继承关系树的最顶层。
Object o ; 做为参数时，实际可传 所有类的对象； 
做为返回值，可以返回  所有类的对象。


JAVA中的所有类，都可以使用 从 Object 继承过来的方法。
1、finalize()方法：用于在 垃圾回收器，回收垃圾对象时，自动调用的。
垃圾对象，没有引用 指向的对象。
回收时机：
1) 自动回收，JVM的内存耗尽，不能再为新对象开辟空间时；
2) 手动回收，调用System.gc()方法，通知JMV做垃圾回收，GC是空闲则回收垃圾对象；
GC如果繁忙，则暂不回收。
2、getClass()方法： 用于获取 引用 的实际类型
应用，判断2个引用指向的对象实际类型是否一致。
a1.getClass() == a2.getClass()
3、public String toString(), 返回对象的字符串形式。
打印对象，把该对象的字符串形式打印。
4、public boolean equals(Object obj), 用于判断当前对象 和 obj 的内容是否相同。

==: 1) 基本类型，值是否相同
2) 对象类型，地址是否相同(2个引用 是否指向 同1个对象)

作业：除 6 9 10 


========================== day15 包装类、String ==========================


一、包装类
包装类，在JDK中，基本类型 和 对应的包装类类型相互转换。
1) 让Object 统一所有数据
2) 包装类的默认值是null，用在类属性中，可以区分 有效数据和无效数据。

基本类型      包装类类型
int Integer
char Character
float Float
boolean Boolean
.....

基本类型 和 包装类类型 间的相互转换：
int i;
Integer integerNum;
String str;
// int --> Integer
integerNum = new Integer(i);
// String --> Integer
integerNum = new Integer(str);


// int --> String
str = i + "";
// Integer --> String
str = integerNum.toString();

// Integer --> int
i = integerNum.intValue();
// String --> int【重点】
i = Integer.parseInt(str);
注意：String必须是数字字符串，否则会出“数字格式转换异常 NumberFormatException”

自动装箱/拆箱：JDK5.0后，基本类型 和 对应的包装类类型 可以自动转换。


二、String【重点】
1、创建对象
String s = "hello";//1个对象，放在串池，共享
String s = new String("hello");//2个对象，第1个-串池中的"hello"；第2个-new的hello对象
2、方法
详见“String方法介绍.txt”
3、String不变性
所有对String的操作，都是先创建该对象的副本，在副本中修改。
4、可变字符串
StringBuffer: jdk1.0 慢，线程安全
StringBuilder:jdk5.0快，线程不安全


三、BigDecimal
做精确算术运算。java.math.BigDecimal
创建对象
BigDecimal bg = new BigDecimal(String val);
BigDecimal bd1 = new BigDecimal("1.3");
方法
BigDecimal add(BigDecimal augend) //加
BigDecimal subtract(BigDecimal subtrahend) //减
BigDecimal multiply(BigDecimal multiplicand)//乘
BigDecimal divide(BigDecimal divisor, int roundingMode) //除
注意：除法，需要指定4舍5入的模式，常用的 BigDecimal.ROUND_HALF_UP 


四、Calendar
日历，包含年月日时分秒毫秒。java.util.Calendar
用于对日期进行运算。
创建对象
Calendar c = Calendar.getInstance();//当前时间


方法
int get(int field) //根据给定的日期部分，获取日期
void set(int field, int value)  //根据给给定的日期部分，修改成vlaue
set(int year, int month, int date) //根据给定的年月日，设置日期
c1.getTimeInMillis()//获取毫秒数






========================== day16 集合框架-List ==========================


集合：用于 存储  多个数据 的对象。

特点、方法、遍历、实现类


一、Collection 父接口
特点：存储所有Object数据
方法：
boolean add(Object e)   //把对象e 放到当前集合中，成功-true；否则false
boolean addAll(Collection c) //把集合c 放到当前集合中，成功-true；否则false
void clear()  // 删除当前集合中的所有元素
boolean contains(Object o)  // 判断对象o 在当前集合中是否存在，是true；否false
boolean isEmpty()  // 是否是空集合
boolean remove(Object o) // 在当前集合中 删除对象o，成功-true；否则false
int size()  // 获取当前集合元素的个数
Object[] toArray() // 把当前集合 转换成  对象数组
遍历：<见下面实现类>
实现类：没有直接实现类

二、List 接口
特点：有序、有下标、允许重复
方法：继承自Collection父接口的所有方法
void add(int index, Object e)  //把对象e 放到当前集合的 index下标位置
boolean addAll(int index, Collection c)  ////把集合c 放到当前集合的 index下标位置
int indexOf(Object o)  // 获取对象o 在当前集合中的下标位置，不存在-1
Object remove(int index)  //在当前集合中 删除下标为index 的对象，返回被删掉的对象
Object set(int index, Object e)  //替换下标index处的元素 为 对象e(不会增加集合长度)
List subList(int fromIndex, int toIndex) //取子集合，从fromIndex(含)到toIndex(不含)位置
Object get(int index)  //获取下标index处的元素 
遍历：下标遍历、迭代遍历、for-Each遍历(JDK5.0)
for(泛型集合的元素类型 变量名 : 要遍历的集合){
System.out.println(变量名.方法());
}
实现类：
1、ArrayList 【重点】
数组实现 查询快，增删慢
JDK 1.2 快，线程不安全
2、Vector 
数组实现
JDK 1.0 慢，线程安全
3、LinkedList 
链表实现 查询慢，增删快


泛型集合：
类型安全的集合，限制 集合元素的类型必须一致。
List<Student> list = new ArrayList<Student>();//集合元素只能是Student类型

工具类Collections：
reverse(list) //集合元素 倒置
shuffle(list) //随机显示 集合元素 
sort(list) //排序，升序
集合元素的类 必须 实现 java.lang.Comparable 接口。

作业：
List: 2、3、5、13、18


========================== day17 集合框架-Set、Map ==========================


一、Set 接口
特点：无序、无下标、不允许重复
方法： 继承自Collection父接口
遍历：迭代遍历、for-Each遍历
实现类：
1) HashSet
为了保证HashSet中的集合元素内容不重复，在集合对象类中，需要：
a) 覆盖hashCode方法
确保相同的对象，返回相同的int值；
为了提高效率，尽量保证，不同的对象，返回不同的int值。
b) 根据需要，如果第1步的值相同，则执行
覆盖equals方法，确保相同的对象，内容也相同时，拒绝加入集合。
2) TreeSet
实现了 SortedSet接口（是Set的子接口），对集合元素自动排序
集合元素的类 ，必须实现 Comparable接口，并且借助compareTo的返回值是否为0维护集合元素不允许重复。
二、Map 接口
特点：存储 一对 数据（键值对）
键：无序、无下标、不允许重复（唯一）
值：无序、无下标、允许重复
方法：
Object put(Object key, Object value) //存入1个键值对(如果key已存在，则旧值被覆盖)
Object get(Object key) //根据key，获取对应的值
Object remove(Object key) //根据key，删除对应的键值对，返回被删除掉的值
boolean containsKey(Object key) //判断key是否存在
boolean containsValue(Object value) //判断value是否存在
遍历：
值遍历
Collection c = map.values();
键遍历
Set set = map.keySet();
键值对遍历
Set set = map.entrySet();
实现类：
1、HashMap【重点】   key对象 需要覆盖hashCode和equals方法。
JDK1.2  快，线程不安全key和value允许为null。
2、Hashtable
JDK1.0 慢，线程安全key和value不允许为null。
3、Properties
是Hashtable的子类。key和value只能是String，通常用于配置文件的读取。
4、TreeMap
实现了 SortedMap接口（是Map的子接口），可以对键进行自动排序。
key对象 需要实现 Comparable接口。

========================== day18 异常处理 ==========================
一、异常
程序在运行过程时 出现的 特殊情况、例外。
异常处理：异常出现后，会执行预先定义好的一段程序，以尽量减少因异常带来的损失。

二、分类 
Throwable 父类
|- Error 错误，严重底层错误，处理不了的(不归程序员)
|- Exception 异常
|-RuntimeException或子类运行时异常，未检查异常 编译器可以忽略可以不处理
ClassCastException
NullPointorException
IndexOutOfBoundsException
NumberFormatException
|-非RuntimeException或子类非运行时异常，已检查异常 编译器不可以忽略必须处理
IOException
FileNotFoundException
EOFException
SQLException

三、异常发生和传递
1、发生
a) 自动抛出异常
遇到异常，相当于遇到 return语句，导致程序因异常而终止。
b) 手动抛出异常
throw new 异常类();//手动抛出异常
注意，throw 后的顺序执行语句永远都不会执行到，因此不要写。

2、传递
异常发生后的传递，按 函数调用链的 反方向 传递。
异常堆栈信息：
Exception in thread "main" java.lang.RuntimeException
at day18.TestException.m3(TestException.java:23)//异常开始
at day18.TestException.m2(TestException.java:17)
at day18.TestException.m1(TestException.java:12)
at day18.TestException.main(TestException.java:7)

四、异常处理【重点】
1、消极处理(声明异常)
throws用在方法声明后，用于 声明异常 
修饰符 返回值类型 方法名(形参列表) throws 异常类名1,异常类名2{
//功能语句
}
只是把异常进行了传递，没有最终解决异常，只让程序因异常终止。
2、积极处理(捕获处理异常)
try{
// 可能会出异常的代码
}catch(Exception e){//捕获异常，并把捕获到的异常对象，自动传递给e对象
// 异常处理代码
}finally{
// try中的语句不管 有没有出异常，总是会被执行的代码 
// 通常用于释放资源
}

注意：1) catch 只能处理try中可能会出现的已检查异常；
2) 可以有多个catch，但是 父类异常 必须放在后面；
3) finally 中的return 总是会被执行。
小结：
try...catch...
try...catch...catch...
try...catch...finally...
try...catch...catch...finally...
try...finally...//确认finally中的语句总是被执行，和异常处理无关
允许嵌套 try{ try....catch... finally }catch(Exception e){ }

五、自定义异常
继承自Exception及子类，通常继承自RuntimeException及子类。


六、方法覆盖
语法要求：1) 方法三要素 必须完全一致；
2) 修饰符 可以相同或更宽；
3) 子类中的方法 不允许 抛出更多更广的异常。


e.printStackTrace(); //往控制台打印异常堆栈信息
System.out.println(e.getMessage()); //获取异常对象的详细信息(message)

========================== day19 多线程 ==========================


一、概念
进程：在操作系统中，并发执行的1个任务。
线程：在1个进程中，并发执行的1个程序流程。
主线程-main函数

线程的组成元素：
1) CPU （OS分配）
2) 数据  堆空间共享，栈空间独立
堆空间：对象(实例变量)
栈空间：局部变量

3) 功能代码
创建线程对象，有2种方式：
a)继承Thread父类 
覆盖run方法
创建子类对象 Thread t = new MyThread();
调用 start 方法，启动线程 t.start();

b)实现Runnable接口
实现run方法 MyThread2 t2 = new MyThread2();
Thread t = new Thread(t2);
创建目标对象，创建Thread对象
调用 start 方法，启动线程 t.start();

二、线程的状态
详见“线程状态.png”

三、线程同步【重点】
原子操作：不可分开的一段代码，做为一个整体，要执行都执行，要不执行都不执行。
临界资源：多线程并发时，共享的一个对象。
使用场景：多线程并发时，存在共享对象。
线程同步/安全: 多线程并发时，为了保证临界资源的正确性，而不能破坏程序的原子操作。
线程同步的实现有2种： synchronized
1) 同步代码块 
synchronized(临界资源对象){
// 代码(原子操作)
}
当线程对象 获取到 临界资源对象的锁标记时，才可以执行{}中的代码块，并且必须执行完后才释放该对象的锁标记;
如果线程，没有获取到临界资源对象的锁标记，该线程处于等待状态，直到 获取到锁标记为止。


2) 同步方法
synchronized 返回值类型 方法名称(形参列表0){
// 代码
}
相当于 synchronized(this){
// 代码
}

思考：ArrayList 和 Vector 的区别？

四、等待-通知
wait()：必须使用在同步代码块中，当前线程 释放获取到的 锁标记，让该线程处于 等待状态。
notify()/notifyAll()：必须使用在同步代码块中，通知其它线程 再次获取锁标记，但是必须等当前线程 的同步代码块 执行完后。


思考：wait和sleep的区别？


synchronized 和 abstract 组合：
不可以。abstract方法只有声明没有实现，synchronized修饰方法，相当于对当前对象加互斥锁，一旦获取了锁标记，就可以执行对应的代码。
synchronized 和 构造方法 组合：
不可以。synchronized修饰方法，一旦获取到了 当前对象 的锁标记， 就可以执行对应的代码。构造方法执行时，对象还没构造出来。
synchronized 和 static 组合：
可以。对 类对象 加互斥锁。

========================== day20 IO-1 ==========================
持久化：把内存中的数据 往 存储设备中进行永久存储 的过程。
流：在 JVM内存 和 存储设备 传输数据。
分类：
方向：
输入流input/输出流output
数据单位：
字节流/字符流
功能：
节点流：读写数据
过滤流：在节点流基础上添加新功能


一、字节流
可以读写 所有类型的 文件。
InputStream/OutputStream 父类 抽象类
节点流：FileInputStream/FileOutputStream 【重点】
过滤流：DataInputStream/DataOutputStream   读写8种基本类型、String(readUTF/writeUTF)
BufferedInputStream/BufferedOutputStream  缓冲
ObjectInputStream/ObjectOutputStream    读写对象

FileOutputStream：
void write(int b) 
 将指定字节b 写入此文件输出流。 
void write(byte[] b) 
 1次写多个字节，把b数组中的所有内容，写入输出流。
void write(byte[] b, int off, int len) 
 1次写多个字节，把b数组中的部分内容(从off下标开始到长度为len)，写入输出流。


FileInputStream：
int read() 
 从此输入流中读取一个数据字节，返回读到的字节；-1，则代表读到结尾。 
int read(byte[] b) 
 从此输入流中读多个字节，把读到的内容存放b数组，返回实际读到的字节数；-1，结束。 
int read(byte[] b, int off, int len) 
 从此输入流中读多个字节，把读到的内容存放b数组指定部分(从off下标开始到长度为len)，返回实际读到的字节数；-1，结束。 


练习：a.jpg 复制成 b.jpg。


ObjectInputStream/ObjectOutputStream    读写对象
对象序列化：把对象 使用流 进行操作。

所有能被序列化的对象，必须实现 java.io.Serializable 接口。
文件结束的标记：java.io.EOFException
private transient Integer score;//不被序列化的属性

序列化1个对象，其所有的对象属性也要能被序列化才可以；
序列化1个集合，保证集合元素对象 是能被序列化才可以。

作业：
字节流：4 5 6 7 8 9 14 16 18 19 22




========================== day21 IO-2 ==========================


一、字符编码
ISO8859-1   西欧
GB2312 简体中文
GBK
GB18030
BIG5 台湾，繁体中文
UTF-8 变长，1-2-3Byte

字符编码 和 字符解码 方式 如果不一致，可能会导致 乱码问题。


二、字符流
父类： Reader/Writer 抽象类
节点流：FileReader/FileWriter    文件输入/输出
过滤流：BufferedReader/PrintWriter缓冲

【重点】桥转换流：用于把字节流 转成 字符流，设置字符编码集。
【重点】桥转换流： InputStreamReader/OutputStreamWriter  
使用步骤：1) 创建节点流
2) 创建过滤流，设置字符编码集
3) 封装过滤流
4) 读写数据
5) 关闭流


三、File
IO流，用于 操作文件内容 。
File类，用于 操作文件/文件夹 自身(是否存在/创建/改文件名/大小/只读/隐藏)。
File，代表 磁盘中的 一个文件或文件夹。

创建：boolean createNewFile() 
boolean mkdir() 
改名：boolean renameTo(File dest) 
删除：boolean delete()  //文件直接删除；文件夹必须是空文件夹

获取文件大小：long length()  
判断是否存在：boolean exists()  
获取文件(夹)名：String getName()  
获取文件(夹)真实路径及文件名：String getAbsolutePath()  

判断是否是文件夹：boolean isDirectory()  
判断是否是文件：boolean isFile() 
获取文件夹中的所有文件(夹)：File[] listFiles()  





========================== day22 网络编程、反射 ==========================


一、网络编程
IP: 标识网络中的一台主机，逻辑标识。
MAC地址：标识网络中的一台主机，物理地址。
端口号：区分 同一台主机上的 不同进程。
协议：网络中通信 必须遵循的规范。

ISO7层网络模型：
物理层
数据链路层
网络层 IP
传输层 TCP UDP
会话层
表示层
应用层 SMTP POP HTTP FTP TELNET

TCP: 传输控制协议 有连接 有序不乱
UDP：用户数据报协议 无连接 所有数据包一起发送 无序会丢会乱


基于TCP协议的Socket编程：
服务器端server的程序：
// 1 创建serverSocket，绑定商品号
// 2 等待client请求，获取到请求的client
// 3 i/O
// 4 关闭socket
客户器端client的程序：
// 1 创建client，指定要请求的server IP和port
// 2 i/O
// 3 关闭socket

二、反射
类的对象：基于某个类 new 出来的对象，也称实例对象。
类对象：类加载产物。

1、获取类对象(3种方式)
1) 使用类名
Class c = 类名.class;
2) 使用静态方法
// 检查是否已存在，不存在则先类加载
Class c = Class.forName("包名.类名");
3) 使用类的对象
Class c = o.getClass();

2、根据类对象，获取类的对象
Object o = c.newInstance();


三、单例模式（饿汉式、懒汉式）全局唯一

设计模式：经验的总结。

package single;


public class TestSingle {


public static void main(String[] args) {
Student s1 = Student.getInstance();
Student s2 = Student.getInstance();
System.out.println(s1 == s2);
System.out.println();

Student2 s3 = Student2.getInstance();
Student2 s4 = Student2.getInstance();
System.out.println(s3 == s4);
}


}


// 方案1：饿汉式
class Student{
private static final Student instance = new Student();

private Student(){}

public static Student getInstance(){
return instance;
}
}
// 方案2：懒汉式
class Student2{
private static Student2 instance;

private Student2(){}

public static synchronized Student2 getInstance(){
if (instance == null)
instance = new Student2();
return instance;
}
}