目录
1.JavaAPI（ApplicationProgramInterface）
1.“+”号连接字符串与StringBuffer的append()方法拼接区别
2.String类、StringBuffer类、StringBuilder类区别
3.javaGUI编程（Graphical User Interface）
4.GUI编程API（Application Program Interface）
3.请说明Collection和Collections的区别？
2.ObjectInputStream、ObjectOutputStream（对象字节输入、输出流）
3.DateInputStream、DataOutputStream
一、Java由来
1、Java语言
1.1、时间：
- 1991 - - Java的前任诞生 - - OAK Sun公司开发团队：詹姆斯.戈斯林 -->绿色计划
- 1994 - - SUN公司要求詹姆斯将OAK语言变更为官方语言
- 1995 - - 爪哇（爪哇岛）语言 -> 1995 Java语言
1.2、结构（JDK）jdk是主要、jre是辅：
- JVM（java虚拟机）组成：类加载器、垃圾回收器（垃圾回收机制）
- API （应用程序接口）为java程序提供工具类
2、Java程序执行流程
二、数据类型
1、Java数据类型
1.1、八大基本数据类型：
1.整数类型：int（正整数、负整数、0）
范围：-2（31）- - 2（31）-1 //（-1减一）因为还有一个0
位数：32位 - -> 4个字节
2.长整数类型：long
特征：当数字的长度超过int的范围后可以使用长整型来存放，但必须添加单位“l”
范围：-2(63)- - 2(63)-1
3.但精度浮点类型：float
特征：数字后小数位数为一位，在使用float类型的时候数据必须添加单位“f”
位数：32位 - - > 4个字节
4.双精度浮点类型：double
位数：64位 - - > 8字节
5.短整型：short（属于淘汰产品）
6.字符类型：char
特征：所有的字符数据都必须添加单引号包含（' 字符 '）
位数：16位 - - > 2个字节
例如：'H''e''l''l''o'（英文2个字节）、'张''三'（中文4个字节）
7.布尔类型：boolean
特征：用于存放真假值得一种类（true、false）
位数：1位 - - >1字节
8.字节类型：byte
位数：8位
特征：用于存放最小单位
1.2、引用数据类型
1.字符串类型：String
特征："Hello World"
2.程序员自定义的类型
3.java中的其他引用类型
2.Java变量
蓝屏：超频，内存影响
栈域：程序员操作区域（程序的入口），例如“物质的名字”
堆域：计算机…，对应栈的实质性东西。
常量域：用于存放所有不可变数据的容器（变量存放在这里面）
静态域：属于程序在运行之前就需要获得的数据都存放在当前容器中，这种方式属
于程序加载时操作的方式
1)变量的定义语法
语法：
a.数据类型 变量名 = 值;
属于在定义变量的时候直接初始化变量的值
b.数据类型 变量名; //先声明后赋值
例：int a;
a = 1;
2)变量的使用
关于变量的赋值方式和变量的声明方式
变量的声明：
如果在一个代码中存在多个相同类型的变量需要实现声明，可以省略变量的数据类型
例如：
int a; int b; - - > int a,b;
int a=1; int b=2; - - >int a=1,b=2;
变量的赋值：
变量的赋值可以先声明，然后可以直接赋值，也可以通过其他变量来实现赋值的操作
3.Java的转译符
在java代码中有些输出内容和编写内容需要不一样的显示效果，就可以通过转译
符实现“\”斜杠。
\n：换行
\t：制表符
疑问：
1.Boolean是大写还是小写
小写（boolean）：基本数据类型
大写（Boolean）：包装类
2.char是不是2个字节
java中的char是Unicode编码占2个字节，16位，一个汉字占2个字节。
3.float转double会不正确
我们使用的是十进制，计算机使用二进制数据表示。浮点数精度7位，doubl类型精度15位。float、double都有精度丢失，但是范围不同。
第03天 - - 运算符、STS工具
一.目标
1.STS工具的使用
2.Java运算符
二.知识点
1.STS工具使用
Java工程(JavaProject)：
在一个工程中可以包含多个java程序
Java程序：
通过java语言实现的执行过程
STS工具的使用：
a.STS工具介绍：
b.STS工具使用
1.创建Java Project工程（STS最低支持JDK1.8）
2.STS工程结构
3.STS创建Java源代码文件
2.Java运算符
1.算数运算符
a.一元运算符
++自增 --自减
现象：
1.如果运算符在变量之前表示先执行自增或自减操作、在输出其内容
2.如果运算符在变量之后表示先输出其内容，在进行自增自减操作
b.二元运算符
+加 -减 *乘 /除 %取余
2.比较运算符
> 大于 != 不等于 >= 大于等于
< 小于 == 等于 <= 小于等于
3.赋值运算符
+= -= *= /= %= =
例如：
a+=5; a=a+5; a=5;
4.逻辑运算符
a、逻辑运算符
& 逻辑与：
运算符前后两者如果结果都为真表达式结果就为真，只要有任意一方为假结果就为假
| 逻辑或：
运算符前后两者中有任意一方为真表达式结果就为真，如果两者都为假结果才为假
! 逻辑非：对结果取反（只能对结果操作）
b、短路运算符（java常用的）
&&（短路与） ||（短路或）
5.多元运算符
语法：
表达式 ? 真的结果 : 假的结果;
疑问：
1.一、二、三元运算符的区别
一元：
只需要一个操作数的运算符。例：++a，b--;
二元：
需要两个操作数的运算符。例：a+b;
三元：
需要三个操作数的运算符。例：a?b:c;
第04天 - - 流程、循环语句（水仙花）
一.目标
1.Java条件控制语句
2.Java条件语句类型
3.Java开发工具使用-Scanner
4.Java开发工具使用-Random随机数
5.Java循环语句
二.知识点
1.Java条件控制语句
概念：通过条件判断来确定执行的java代码部分
2.条件控制语句
a.if类型
1. if..else类型
语法：
If(条件表达式){
条件表达式成立执行的代码部分
}else{
条件表达式不成立执行的代码部分
}
2.多重if..else类型
语法：
if(条件表达式1){
条件表达式1成立执行的代码部分
}else if(条件表达式2){
条件表达式2成立执行的代码部分
}else{
条件表达式不成立执行的代码部分
}
3.嵌套if..else类型
语法：
if(条件表达式){
if(条件表达式){
}else{
}
}
b. switch类型
作用：用于简单或单一性的值得判断
语法：
switch(比较的内容){
case 值1 ：表达式;
break;
case 值2 ：表达式;
break;
//…
default : 默认表达式;
}
3.Java开发工具类使用
a.控制台输入工具 - - Scanner
使用方式：
1. 导入工具类所在的库路径
import java.util.Scanner;
2.定义工具 - - 获得工具使用
Scanner s=new Scanner(System.in);
3.实用工具
String str = s.next(); //获得控制台输入内容
4.案例
猜数字游戏 //2018-01-15-JavaControl - >Demo_Game
5.Java开发工具
随机数工具：
1.导入工具类所在的库路径
import java.util.Random;
2.定义工具- -获得工具使用
Random r = new Random();
3.获得随机数
r.nextInt(); //随机一个int范围的随机数
r.nextInt(index); //随机一个index参数范围的整数
6.Java循环语句
类型：
a.循环
特征：通过有效的循环条件来控制循环的执行
b.死循环
特征：重复不停的执行。（大部分病毒的特性）
循环种类：（三种）
a.while循环（通常使用在死循环）
语法：
while(循环条件){
循环体- -循环执行的代码部分
}
b.do..while循环
语法：
do{
循环体 //先执行循环体在判断循环条件
}while(循环条件);
c.for循环（小于符号效率高于小于等于符号）
特征：简化循环代码的编写
语法：
for(参数1;参数2;参数3){
循环体
}
参数1：计数器 - - int i=0;
参数2：循环条件 - - i<?
参数3：计数 - - i++;
7.案例
循环：
1.一重循环100-999之间的水仙花数（各个位上的数的立方相加等于这个数本身）
//2018-01-15-JavaControl - >Work - >Work1_Flower（老师\三重\Demo_Flower）
2.输出空心菱形
//2018-01-15-JavaControl - >Work - >Work3_Rhombus.java
3.九九乘法表
//2018-01-15-JavaControl - >Work - >Work2_Multiply.java
注意：
1. 字符串内容比较：在java程序中需要对字符串内容进行比较不能使用==,因 为==在
比较字符串的时候是比较的引用地址是否相同，所以需要使用到字符串中提供的方法来判断内容是否相同,字符串.equals(比较的字符串);
2. "".equals(input)和input.equals("")区别：input.equals()要求字符串必须有引用产生才能正确判断否则，就会出现空指针错误。"".equals避免了系统出现空指针错误来判断字符串内容.
疑问：
1.Scanner输入的字符串无法用“==”判断（可用equals()），定义的2个字符串却可以。
半解决：
第05天 - - 数组
一.回顾
作业讲解：
1.单循环方式打印水仙花数
2.9x9乘法表
3.空心菱形(老师) //2018-01-16-JavaArray - >Work_LookBack - >LookBack_Rhombus.java
二.目标
1.了解Java数组
2.掌握Java数组类型
3.掌握Java数组排序
三.知识点
1.Java数组
概念：在程序中一组相同类型数据的表示方式
2.Java数组定义
定义方式：
1.定义
语法：
数据类型[] 数组名 = new 数据类型[长度]; //非配了空间，无值
例如：
int[] a=new int[5];
2.声明
语法：
int[] a; //声明数组
赋值：
a={值};
a=new int[]{值};
a[下标]=值;
下标起始值从0开始
3.Java数组类型
a.一维数组
语法：
数据类型[] 数组名=new 数据类型[长度];
作用：
通过一个数组变量来存放内存中多个相同类型的变量数据
b.一维数组
语法：
数据类型[][] 数组名=new 数据类型[长度1][长度2];
作用：
通过一个数组变量来存放内存中多个相同类型的数组
4.Java数组排序
排序方式：
系统排序（java语言内置提供的排序方式）、普通排序、插入排序、选择排序冒泡排序。
冒泡排序：通过相邻的两个数据进行比较，将大的后移。
int[] a={11,21,3,22,12,44};
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-i-1;j++){
if(a[j]>a[j+1]){
int temp =a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
5.案例
1.冒泡排序
//2018-01-16-JavaArray - >Test.java
2.半成品扫雷
//2018-01-16-JavaControl - >Work - >Work_SweepBomb.java
注意：
1.数组是引用类型，数组的变量的值，是这个数组的地址。
2.地址都是来自堆当中（有new就是引用了堆中的数据）
第07天 - - OOP（东）
一.介绍
1.c面向过程编程
2.c++：面向过程编程+面向对象编程
3.java/c#：面向对象编程（革命、推翻c++面向过程）
二.知识点
1.什么叫软件：
软件有可能是多个程序，某种意义上软件与程序等同。（软件就是现实的虚拟）
2.软件开发：
使用计算机语言将现实中的事物在计算机中虚拟化（写作文：结构就相当于散文、议论文之类）
3.面向过程（不要记标准答案，没有。主要记核心）
所关注的是做一件事情的步骤、过程
例子斗地主：洗牌 发牌 抢地主 出牌 确定输赢
5函数： f1() f2() f3() f4() f5()
4.面向对象
所关注的是做一件事情的人或物
对象：是一个具体的个体
类：是一个抽象的概念，对象共同点的描述
类是对象的抽象---->类描述的是从对象身上找到的共同点（虽然有许多点，但是只找需要的）
类的作用：
1.作为模板，可以根据类得到对象
2.作为一种数据类型
3.调用这个类，根据类创建对象
第08天 - - OOP（斌）
一.目标
1.了解JavaOOP
2.掌握JavaOOP的核心思想特征
3.掌握JavaOOP类和对象的定义
4.掌握类和对象的成员使用-属性
二.知识点
1.JavaOOP
OOP：面向对象编程 - - 思想
现实世界：所有存在的东西都统称为实体，
虚拟世界：所有存在的东西都统称为对象
2.OOP特征
a.封装
b.继承
c.多态
d.抽象
e.接口
3.OOP核心
一切皆对象
4.OOP思想
a.类（class）
作用：
在虚拟世界中java语言通过类来创建虚拟世界中的所有对象，类就是生产对象的工厂，也是程序员设计的东西。
b.对象（Object）
作用：
在虚拟世界中所存在的所有东西都统称为对象，对象就是虚拟世界中完成虚拟化的工具
语法：对象名在栈中，new是指向堆中的地址
类名 对象名（实例名） = new 类名(); //赋一个引用（地址）给他
案例：请说明吃饭需要准备对象有哪些
人、饭、碗、筷、菜、钱……
c.成员
类型：
1.属性
作用：用于在程序中对一个对象进行描述信息保存的一种容器
语法：
数据类型 属性名; //在类中一般不存在直接赋值
操作：
对象名.属性名=值; //为对象的属性赋值
对象名.方法名
练习：请使用OOP思想设计一个扫雷游戏的对象，及对象成员属性
对象：格子对象
属性：坐标、内容、状态
2.方法（下次课讲）
作用：用于在程序中对一个对象进行描述信息保存的一种容器
5.作业
1.请使用OOP思想设计撸啊撸游戏的对象及属性
2………植物大战僵尸的对象及属性
3………坦克大战游戏的……
4………飞机大战……
5………21点……
6………象棋……
注意：
1.要开始养成面向对象的思想
2.java提示：“△”表示属性，“○”表示方法
3.变量、数组、对象，都是容器，还有一个集合。
第09天 - - OOP-方法
一.回顾
a.通过OOP设计坦克大战游戏的对象和属性
对象：
坦克（坐标、方向、图片、状态、血量）
子弹（坐标、方向、图片、状态）
障碍物（坐标、类型、状态、图片）
道具（坐标、图片、类型、状态）
b.飞机大战
c.植物大战僵尸
对象：
植物（类型、图片、坐标、状态、价格、血量、攻击力、技能）
僵尸（类型、图片、坐标、状态、血量、攻击力、技能）
障碍物（坐标、类型、状态、图片）
子弹（坐标、方向、图片、状态、类型）
二.目标
1.掌握对象中方法的类型
2.掌握方法的使用
3.掌握对象的构造
三.知识点
1.对象的成员
a.成员属性（属性就是对象中的成员部分）
作用：在java中为某个对象提供描述信息（类有的东西，对象不一定有）
b.成员方法（方法也是对象中的成员）
作用：在java程序中为对象提供行为能力的一种表现。
语法：
对象名.方法名(参数列表);
属于程序员编写指令的部分。
2.Java特征：封装
在java程序中类、对象、属性、方法的操作都属于封装的现象。
3.Java的对象员之方法
类型：
a.无返回、无参数
语法：
访问修饰符 void 方法名(){
方法体（需要该方法执行的代码）
}
b.无返回、有参数
语法：
访问修饰符 void 方法名(参数列表){
方法体（需要该方法执行的代码）
}
c.有返回、无参数
语法：
访问修饰符 返回值类型 方法名(){
方法体（需要该方法执行的代码）
return 返回值;
}
d.有返回、有参数
语法：
访问修饰符 返回值类型 方法名(参数列表){
方法体（需要该方法执行的代码）
return 返回值;
}
4.对象的构造
产生：
在Java程序中所有的对象是通过类中提供的构造方法来构造出每个对象，在每个类中隐式包含一个构造方法，程序员可以将其改变成显示方式来扩展。
语法：
访问修饰符 类名(参数列表){
对象初始化的时候需要执行的代码部分
}
类名 对象名 = new 类名();
5.方法的作用
a.方法在程序中用于提供对应的功能代码实现
b.方法在类中用于为当前属性进行赋值操作
1.使用普通方法为属性赋值
例如：
public class Teacher{
String name;
int age;
//为属性赋值的构造方法
public Teacher(String n){
name=n;
}
//定义一个为属性赋值的方法
public void setName(String n){
name=n;
}
}
//通过构造方法赋值
Teacher t = new Teacher("xx");
//使用对象赋值
t.name="yy";
//通过普通方法赋值
t.setName("小花");
6.总结
在java语言中OOP思想的开始取决于封装，因对象的创建和类的创建就体现了封装，并且类和对象中的成员也完成了封装的体现，所以虚拟世界的构建离不开对象，并且也由对象而开始。
7.案例
//参数不用考虑人本身。参数不是绝对的，是可变的看你如何用。（有参数、和无参数之间2种情况时，就要选择有参数（考虑周全））
睡觉 无返回、无参数
玩游戏 无返回、有参数
做作业 无返回、有参数
回家 无返回、有参数
泡妞 有返回、有参数
吃鸡 无返回、有参数
起床 无返回、无参数（穿衣服..属于内部操作）
第10天 - - JavaOOP-重载
一.回顾
1.方法
a.自定义方法
作用：在程序中为程序提供功能操作（一个方法一个功能）
类型：
1.无返回、无参数
2.无返回、有参数
3.有返回、无参数
4.有返回、有参数
b.构造方法
作用：用于在java程序中创建对象需要使用的方法
new 类名(); //没有构造方法这个概念。自动执行
语法：
访问修饰符 类名(参数列表){
}
二.目标
1.重载
2.继承
三.知识点
1.方法重载
重载：在程序中，为某个功能提供多种执行的选择过程。
要素：
a.方法名称必须相同。
b.方法的参数列表不同（参数类型不同、参数个数不同、参数顺序不同）
2.方法重载案例
请说明下面哪些方法实现了重载：
public void run(){}
public String run(){}
public int run(int a){}
public void run(String b){}
public void run(String a,int b){}
public String run(int a,String b){}
public void run(String a,String b){}
答案：134567或者234567（判断重载不看返回类型）
3.继承
现实世界：子承父业
虚拟世界：实现类与类之间关系的建立。
4.继承的实现
语法：
public class 类名（子类） extends 类名（父类）{
}
词汇：
儿子（子类、派生类）
父亲（父类、基类、超类）
5.继承的特征
a.单向性特征
在java程序中类与类之间建立关系后，子类可以获得父类非私有化成员（属性方法）而父类不能访问子类的所有成员
b.单一性特征
在java程序中一个类与另一个类继承关系后，子类只能拥有一个父类，但父类可以拥有多个子类
b.传递性特征
在java程序中实现多个类之间关系的建立，将类与类之间联系起来。
问题：
1.在子类对象创建的时候父类对象是否被创建？ 有
子类对象在创建的时候必须先构造出父类对象。在创建子类对象
2.在父类对象创建的时候子类对象是否被创建？ 无
注意：
重载与方法的区别：需不需要适应（要满足多个不同需求）
子类可以访问父类的成员，但是父类不能访问子类的成员
是否要创建子类应考虑该类的功能。
疑问：
类的属性，该类对象到底是不是都有
第12天 - - 访问修饰符、关键字
一.目标
1.java访问修饰符
2.java继承系统包含的关键字使用
3.java对象参数使用
二.知识点
1.访问修饰符（属性private,方法public）
a.共有化访问修饰符 - - public
作用域属于整个应用程序
b.私有化访问修饰符 - - private
将一个类中的成员修饰为只有本类才能访问，其他的都不能访问
c.受保护访问修饰符 - - protected
在java程序中，如果类之间存在父子关系的话，允许外部包中有关系的类访问不同包中的成员
d.缺省访问修饰符
当某个成员被修饰成缺省类型后，表示该成员只能在同包中的类访问到
package - - 包
作用：用于在java程序中实现类的归类操作，等同于文件夹
规范：
com.xxx.包名（每个点就是一个子包）
- - - com：商业化表示名
- - - xxx：公司名称，团队名称，项目名称
包名命名：
bean - - 实体类包
util - - 工具类包
test - - 测试类包
core - - 核心类包
---------（↑现阶段学的，↓以后要学的）
dao
service
servlet
action
2.关键字
a.super
作用：
在程序中为子类访问父类非私有成员和构造方法所提供的访问方式。
使用方式：
1.父类构造方法调用
语法：
super(); //相当于调用父类构造方法
2.父类成员调用
语法：
super.属性 / super.方法
注意方式：
所有子类在使用super关键字访问父类成员的时候必须将super关键字代码写在第一行的位置。
例如：
public Order(){
super();
name = xxxx;
}
b.this
作用：
在子类中访问父类的非私有成员和自身的所有成员，但父类的构造方法不能访问。
this关键字在自身类中可以省略（写出this层次更鲜明）
c.对象参数传递
传值方式：
1.对象
2.构造方法
3.set方法传值
目的：用于在程序中为值实现对象的封装。
4.总结
访问修饰符：用于控制程序访问对象的权限
关键字：this和super都是用于获得成员操作
对象参数：更进一步完成封装的操作
封装：
属于java语言的特征之一，该特征属于OOP思想入门，主要体现在成员的包含和值的存储方面，并且封装属于一种程序实现的现象。
5.预习
多态：
a.引用转型
b.方法重写
第14天 - - 多态
一.目标
1.方法重写
2.引用转型（父读子）
3.多态
二.知识点
1.方法重写
方法重载：
作用：
在程序中为功能提供选择的操作，根据相同的方法选择而获得不同的执行结果。
要素：
1.方法名称必须相同
2.参数列表不同（类型、个数、顺序）
方法重写 - - 方法覆盖
作用：将程序中已存在的功能实现更新。
要素：
1.必须具备继承关系
2.方法结构完全相同
2.引用转型
作用：（可以避免子类可以随意访问父类属性）
通过引用的不同来获得不同的功能结果
例如：
Person 父类
Student 子类
//通过学生实例来保存学生对象
//通过父类的引用指向父类的实例
Person p = new Person();
//父类的引用指向子类的实例
Person p = new Student();
注意：
在完成引用转型的时候，必须具备继承的条件，并且只能父类引用指向子类的实例。
在通过引用转型获得到的对象使用中，该对象中所包含的功能只会有父类的功能，如果子类重写父类的方法后，使用的功能才会是子类中的重写功能
3.多态
在java程序为程序系统扩展功能所拥有的一种现象和思想。
实现方式：
a.静态多态实现
方法重载实现
在方法调用之前，通过人为方式实现选择的操作来得到不同的执行结果
b.动态多态实现
方法重写和引用转型构成动态多态
当java程序中某个方法在调用的时候无法确定执行者是谁，而是通过运行后才能确定执行者，这种现象就属于动态多态。
注意：
封装、继承、多态，只有继承才是实际能看到的，其他两种的内容大多是思想性的东西。
第15天 - - 扫雷
一.目标
1.递归
2.扫雷控制台版
二.知识点
1.递归（开销很大）
递归调用：在程序中用于处理重复执行代码的操作，并且通过自定义方法实现
通俗方式：自己调用自己
2.扫雷（控制台）
分析：
游戏对象：
格子对象（Grid）
属性：内容（content）、状态（status）、坐标（Point）
游戏功能：
添加格子（布局）、输出雷区、布雷、8个方向获取、布雷数、踩雷
工程架构：
1.创建工程结构
bean：实体类（Grid）
core：游戏核心类（Core）
test：测试类（Test）
2.核心功能实现
a.添加格子
通过定义一个格子的数组来完成雷面板的绘制
b.输出雷区
通过循环来获得每个格子对象中的内容，并且显示的内容要根据格子对象的状态来获取
c.布雷
通过雷数来获得循环的次数，并且每次循环的时候要考虑当前格子位置的内容是否已存在雷，如果有雷就继续循环，直到布满10个雷为止。
d.雷数添加
前提必须要考虑如何获得8个方向的格子对象，当得到所有方向后再根据方向位置的格子对象来统计雷数
e.踩雷
该功能和雷数添加功能类似，但踩雷中需要提供辐射效果，所以需要使用递归调用来完成所有空格内容格子的开启。
第16天 - - 复习
一.复习
1.封装
a.类
作用：用于在java程序中创建对象（属于对象工厂）
b.对象
作用：构成虚拟世界的组成部分
c.成员（对象有的东西类肯定有、类有的东西对象也有）
属性：为对象提供描述信息
方法：为对象提供行为能力
2.继承
关键字：extends
关系：父（父类、基类、超类）子（子类、派生类）关系
特性：
1.单向性（只有一个方向、子类可以访问父类非私有成员）
2.单一性（一个子类只能有一个父类，但一个父类可以包含多个子类）
3.传递性（子类可以通过父类，或者父类的父类进行信息传递）
方法重载：
要素：1.必须方法名称相同、参数列表不同（参数个数、类型、顺序）
3.多态
方法重写：（方法覆盖）
要素：.
1.必须继承关系
2.方法结构必须完全相同
引用转型：
父类的引用指向子类的实例
Person 父类 show();
Student 子类 show(); --重写
Person p = new Student();
p.show(); - -运行后获得子类方法（“.”的时候，获得是父类的，运行后是子）
多态类型：
1.静态多态（方法重载）
2.动态多态（方法重写、引用转型）
二.目标
1.抽象
2.接口
三.知识点
1.抽象
概念：没有具体的描述内容
作用：在一个类中提供没有具体行为过程的方法的现象
关键字：abstract
类型：
1.方法的抽象
作用：
在一个类中为某个定义的方法提供声明的操作。
例如：
定义一个方法：
public void eat(){
方法体
}
声明一个方法：（没有方法体的方法（抽象方法））
public void eat();
2.类的抽象
语法：
访问修饰符abstract 返回类型 方法名(参数列表){
}
作用：
一个类中如果出现了抽象方法，那么该类就必须修饰为抽象类，当类被修饰为抽象类后，1.该类不能被实例化2.只能通过引用转型（子类）来获得对象3.规范子类必须有该方法（抽象方法）
实现：
在抽象类对象的的获取中，必须通过子类的实现来获得抽象类的实例。
第17天 - - JavaOOP
一.目标
1.抽象
2.接口
3.异常
二.知识点
1.抽象
1.当一类中出现了抽象方法，那么该类就会被修饰为抽象类2.抽象类中没有实现的抽象方法，可以通过该类的子类来实现抽象方法3.抽象类不能被实例化，可以通过引用转型来获得该类的实例
2.接口
作用：
用于弥补抽象类的不足，1.包含抽象类的实现类不能实现多个抽象类，并且抽象类中会包含抽象方法和非抽象方法，2.同时接口中不会提供属性，只有常量的提供。
关键字：
interface（接口）、implements（实现）
语法：
public interface 接口名{
常量;
抽象方法;
}
实现方式：
1.一个实现类实现多个接口方式
2.一个实现类实现一个接口，但接口继承了多个接口（接口不是类，所以不受extends约束）
引用转型：
1.父类的引用指向子类的实例
2.接口的引用指向实现类的实例
3.常量
属于在接口中出现的一种保存数据的变量，该变量属于一种特殊的变量，1.值是不可变的，2.属于程序加载的时候就直接初始化的，3.在当前应用程序中都可以被访问到
static: 属于程序加载的时候就直接初始化的（自动加载）
语法：
public final static 数据类型 常量名 = 值; //常量名都是全大写
例如：
public final static double PI = 3.1415956;
访问：
接口名.常量
4.抽象类与接口的区别
抽象类：
1.当一类中出现了抽象方法，那么该类就会被修饰为抽象类2.抽象类中没有实现的抽象方法，可以通过该类的子类来实现抽象方法3.抽象类不能被实例化，可以通过引用转型来获得该类的实例
接口：
用于弥补抽象类的不足，1.包含抽象类的实现类不能实现多个抽象类，并且抽象类中会包含抽象方法和非抽象方法，2.同时接口中不会提供属性，只有常量的提供。
5.异常
错误（error）
异常（Exception）（运行时异常）：在执行过程中产生的的错误现象
a.异常处理
1.try..catch..方式
语法：
try{
被监控的代码块
}catch(异常类型){
处理部分
}
2.throws方式
作用：在程序代码中将出现的异常抛给调用者处理，本身不处理
语法：（写在方法的后面）
public void 方法名() throws 异常类型{
}
b.异常创建
关键字：throw （创建异常）
N.扩展
1.吃饭为什么要用筷子
Java面向对象编程可以看成模拟生活，在人都是人类，人类都需要吃饭的基础上，人吃饭可以使用多种方式，使用筷子只是其中一种，根据不同的人吃饭使用的工具也不一样。
吃饭是传承（继承）下来的，慢慢演变（重写、重载），吃饭的方式发生改变。
2.抽象类与接口的区别
相同点：
1.概念上都是抽象的，没有包含足够的信息来描绘一个具体的对象。声明抽象方法时方法不能有方法体。
2.不能直接实例化，实例化需要引用转型，通过抽象类或接口变量（引用）指向子类或实现类的对象，来获得实例
3.子类或实现类如不能实现抽象类或接口的抽象方法，则必须为抽象类或接口
不同点：
抽象类：
1.抽象类使用abstract关键字定义
2.抽象类中变量为普通变量，可以有非abstract方法（既可以做声明也可以做实现）
3.子类只能继承一个抽象类
4.从设计理念来看，抽象类中方法应该为某个类型的本质
接口：
1.接口使用interface关键字定义
2.接口中变量只能为公共的静态的常量，方法必须为public abstract修饰（只能做声明）
3.实现类可以有多个接口
4.从设计理念来看，接口中方法应该为某个类型的扩展功能
第18天 - - API
一.目标
1.了解JavaAPI
2.掌握JavaAPI包
3.掌握JavaAPI - lang包
二.知识点
1.JavaAPI（ApplicationProgramInterface）
java应用程序编程接口 - - java开发工具（20万种） - - 300+种
葵花宝典:JDK API 1.6.0 中文版
2.JavaAPI包
包结构：
java.lang包
|--包装类
|--String类
|--StringBuffer类
|--Object类
|--Class类
|--Math类
java.util包
|--Date类
|--集合类 （*）
java.io包 （*）
|--File类
|--InputStream类/OutputStream类
|--Reader类/Writer类
|--FileReader类/FileWriter类
|--ObjectInputStream类/ObjectOutputStream类
|--DataInputStream类/DataOutputStream类
|--InputStreamReader类/OutputStreamWriter类
|--BufferedInputStream类/BufferedOutputStream类
java.awt包
javax.swing包
--------------------------------------学完以上包，开始项目
java.sql包
java.net包
java.servlet包
3.java.lang包
路径：
JRE System Library -> rt.jar ->java
java是原始包 javax（x是扩展的意思）
.jar结尾（jar包）
如果不能显示源码：（没有导入src包）
第二个选项 -> jdk安装路径 -> 选择src.zip
java语言包：提供语言相关的工具
a.包装类
属于基本类型的包装类型 - - 将8种基本类型包装成对象类型
方法：
构造方法：传入字符串、对应基本数据类型
包装类.parseXXX(字符串); 将字符串转换成XXX基本类型（char类没有）
包装类.valueOf(字符串); 将字符串转换成该包装类对象类型
包装类.toString(); 将当前数据以字符串获得
b.String类
该类型存放的字符串数据属于一种副本类型的数据，数据不能被修改。
方法：
indexOf(字符串);
通过传入的字符串返回字符串所在位置的索引，匹配传的第一个字符
charAt();
通过索引查找位置的字符
lastIndexO()
最后一次出现的位置
valueOf(基本类型)
将基本类型转换成字符串
toUpperCase()
将字符串内容以大写获得
toLowerCase()
将字符串内容以小写获得
trim()
去除字符串前后空格
split(字符串)
通过传入的字符串进行正则匹配，来按照传入的字符串进行截取，将截取的内容以数组保存。
在截取中匹配符号不能使用语言关键字
第19天 - - API-lang包
一.目标
1.String类
2.StringBuffer类
3.StringBuilder类
4.Object类
5.Class类
6.Math类
二.知识点
1.String类
方法：
a.substring(参数1（begin）,参数2（end）); //通过指定范围截取
b.endWith(字符串); //判断当前字符串是否以传入的字符串结尾
c.replace(旧的内容 , 新的内容) //字符串替换
2.StringBuffer类
作用：
通过字符串内容的修改，并且该类所存放的字符串再多线程编程中属于高效率、高安全的一种字符串容器。（牵扯到线程必须和安全挂钩）
方法：（构造方法创建缓冲区，只要有缓冲区，值就是可变的）
a.增 append(字符串); 通过拼接的方式添加字符串内容
b.删 delete();
c.改 replace();
d.查 toString(字符串);
3.StringBuilder类
作用：
用于实现字符串内容的修改，该类所存放字符串在单线程中属于高效率、高安全的一种字符串容器
4.Object类
作用：属于Java语言中的万能容器。
使用：在反射中使用。
5.Class类
作用：
用于存放java语言中的类信息。
例如：
Class c = Person.class;
6.Math类
数学类-存放所有的数学相关的功能
7.预习
常规流程：
lang - util - IO - Swing（GUI（图形界面））
下节课预习Swing
N.扩展
1.“+”号连接字符串与StringBuffer的append()方法拼接区别
字符串拼接所用“+”号，效率是最低的，它需要多个步骤，StringBuffer属于自己在缓冲区通过方法修改，效率高更安全）。
2.String类、StringBuffer类、StringBuilder类区别
相同点：
1.都属于字符串容器
不同点：
String：
1.其值存放于常量池中，属于副本类数据，无法对其进行修改
StringBuffer
1.其值存放于缓冲区中，可以进行修改
2.在多线程编程中属于高安全、高效率的字符串容器
StringBuilder
1.其值存放于缓冲区中，可以进行修改
2.在单线程编程中属于高安全、高效率的字符串容器
第20天 - - static、final与GUI
一.目标
1.static关键字
2.final、finally关键字
3.javaGUI编程
4.java.awt包和javax.swing包
5.JFrame类（窗体类）
6.JPanel类（面板类）
二.知识点
1.static（静态）
作用：
1. 程序启动的时候就为其分配空间，内存地址为静态域
2.只存在一份地址空间，对象共享一个静态变量
类型：
1.属性的修饰（修饰的属性一般都有值）
public static String name="";
2.方法的修饰
public static void play(){
方法体
}
3.块的修饰 - 静态块
static{
方法体
}
使用：
在Java程序中访问static修饰的成员直接通过 类名.成员 来获取
2.final、finally
作用：
用于修饰最终的意思。
final：
用于修饰属性（该属性属于常量）、方法（该方法不能被重写）、类（该类不能被继承）。
finally：
在异常处理中提供不管有没有异常产生都需要执行的部分，就用finally块包含。
语法：
try{
}catch(){
}finally{
一般存放所有开关操作
}
3.javaGUI编程（Graphical User Interface）
GUI：图形用户界面编程
4.GUI编程API（Application Program Interface）
java.awt:界面原始组件
javax.swing:扩展的界面组件
5.JFrame类（窗体类）
作用：
用于Java程序创建可视化窗口。
实现步骤：
1.定义一个类继承窗体类
2.设置窗体的属性
3.设置窗体可见
6.JPanel（面板类）
作用：
用于在窗体上添加组件的部分
实现步骤：
1.定义一个类继承面板类
2.定义方法设置面板
3.在窗体类中添加面板对象
7.布局
类型：
空布局 - - nullLayout
8.组件
输入组件：
文本框（JTextfield）
密码框（JPasswordField）
单选框（JRadioButton）
复选框（JCheckBox）
下拉框（JComboBox）
文本域（JTextArea）
按钮（JButton）
……
输出组件：
标签（JLabel）
N.扩展
1.类在哪儿
类属于一个文件，为什么可以使用class来调用方法属性，是因为虚拟机把他变为了对象
2.为什么类被声明时没有调用静态方法
声明的时候是没有任何开销的，当new时或者执行操作时才会加载（静态方法启动时被加载）
3.背景颜色会超出面板（panel）的大小
有时需要设置JPanel的大小，而JPanel的setSize()方法不管用。
因为设置面板大小在显示窗体之前没有用，以后会解决。
//在设置JPanel大小的时候,要用JPanel.setPreferredSize()这个方法才行.然后再用//borderLayout就可以设置上下左右的宽度了。
4.常量池不是存放常量吗？变量的值不是存放在栈中吗？
变量的声明是在栈中，但是值是在常量池中的。
第21天 - - JavaGUI
一.目标
1.组件
2.事件
二.知识点
1.组件
文本框
标签
按钮
密码框
单选框
复选框
下拉框
文本域
2.事件
概念：
正在发生的一件事情
类型：
a.鼠标事件
b.键盘事件
c.焦点事件
d.窗体事件
……
结构：
1.事件源（event）
2.监听器（接口）
鼠标监听器
键盘监听器
焦点监听器
窗体监听器
……
3.监听器
a.鼠标监听器
MouseListener
b.点击监听器
ActionListener（面板和窗体不能使用，组件才能使用）
c.键盘监听器
KeyListener
N.扩展
1.组件的声明
在javaGUI编程中，所有的组件声明必须以属性方式声明（在类里面声明）因为监听器中如果需要访问外部定义的组件，只能通过属性来获取
2.匿名内部类
在一个方法的参数列表中通过匿名的方式定义一个类的结构，来实现功能的扩展
语法：
public class 类名(){
new 接口名(){
成员
}
}
3.通过标签设置图片
语法：（图片通常存放在img（与src文件夹并列）文件夹中）
JLabel jl = new JLabel();
jl.setIcon(new ImageIcon("图片路径"));
第22天 - - JavaAPI
一.目标
1.java.util包
2.Date类
3.集合类（java最后学的一个容器，也是最大的容器）
二.知识点
1.java.util包（工具）
该包中用于存放Java语言在开发过程中需要使用到的开发工具，在使用中必须导包。
包含的工具：
Scanner
Random
Date
集合（中文，说明里面有多个API）
2.Date类
作用：
用于在java程序中存放时间信息（格式：格林威治格式）的一种对象
概念：
a.计算机有记载的时间开始？
1900年
b.java语言有记载的时间开始？
1970年 - - 毫秒
区别：
int：秒为单位
long：毫秒为单位
3.集合
作用：
用于在Java程序中整理和储存数据操作的一种容器
容器：
变量：
用于存放一种类型的数据（单个）
数组：
用于存放一组相同类型的单个数据，必须定义长度（一组）
对象：
用于存放不同类型的多个数据，不需要制定个数（多个）
集合：
用于存放各种不同类型的多个数据，并且没有个数的限制，同时可以通过方法来操作存放的数据。
分类：（都可以是集合意思）
Collection：（父接口）
|-- List（子接口）
|-- ArrayList（动态数组）
用于对容器数据频繁的读取操作
|-- LinkedList
|-- Vector
|-- Set（子接口）
|-- HashSet
Map：（父接口）
|-- HashMap
N.扩展
1.过时方法
在Java代码中会在中间加条黑线表示
2.集合中对象元素调用属性
如果不指定集合类型，只能通过再次强制转换来获取。加上尖括号“<>”指定类型之后则可以直接调用。
3.for、foreach循环的使用场合不同
for：读取同时又要修改
foreach：只能读取
第23天 - - JavaGUI
一.目标
1.集合
2.List
3.Set
4.Map
二.知识点
1.List
有序可重复
a.ArrayList（动态数组）
用于频繁的查询和修改集合
b.LinkedList（链表集合）
用于频繁的插入和删除集合
c.Vector（线程集合）
用于在多线程中解决同步。
特征：
属于一种动态数组结构的集合，存放在该集合中的数据属于有序数据，并且数据可以实现重复内容（相同数据）。
2.Set集合（这里Set可以理解为集合）
无序不重复
特征：
属于一种散列结构的集合，存放在该集合中的数据属于无序数据，并且数据不能重复。
实现类：
HashSet（散列集合）
3.Map集合
Hash结构（散列），存放Value（值）时会绑定Key（键）。
与文件夹类似，Key就相当于文件名，Value就相当于文件
特征：
属于一种键值对的集合，存放在该集合中的数据必须以键的方式标识，而且键所对应一个值，值可以重复内容，但键不能重复。
实现类：
HashMap
N.扩展
1.Set集合
set集合的数据获取采用了层的结构方式，所以需要使用迭代器来获得层的迭代
2.请说明List、Set、Map区别
相同点：
1.都为集合接口，其实现类用于存放不同类型的多个数据
2. 指定泛型后可以通过方法来操作存放的数据。
不同点：
父类接口不同：
Lis、Set子接口继承Collection父接口，Map属于父接口。
实现类不同：
List下有三个实现类（集合类）ArrayList、LinkedList、Vector。
Set有一个实现类HashSet。
Map下有一个实现类HashMap。
结构不同：
List属于动态数组且数据属性为有序数据，可重复。
Set属于散列数据结构且数据为无序数据，不可重复。
Map属于散列数据结构且数据为无序数据，键不可重复、值可重复。
3.请说明Collection和Collections的区别？
Collection属于集合接口。
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
第24天 - - JavaGUI
一.目标
1.java.io
2.File类
3.流
4.InputStream/OutputStream
|--FileInputStream/FileOutputStream
二.知识点
1.java.io包
io:：input/Output I/O
在计算机中IO操作体现分为：
1.文件操作 //临时文件存放在内存、永久存放在磁盘
2.网络信息传输
2.File类
文件对象：
包含了单个文件和文件夹。
3.流
作用：
用于在Java程序中为应用程序提供对文件内容进行读写操作的一种传输工具。
类型结构：
|-- 字节流：（以java（应用程序）为主）（比较多，较好、更安全）
InputStream：读（读取至java里面来）
OutputStream：写（输出至文件里去）
|-- FileInputStream、FileOutPutStream（文件输入、输出字节流）
|-- ObjectInputStream、ObjectOutputStream（对象输入、输出字节流）
|-- DataInputStream、DataOutputStream（数据输入、输出字节流）
|-- BufferedInputStream、BufferedOutputStream（输入、输出字节缓冲流）
|-- 字符流：
Reader
Writer
|-- FileReader、FileWriter（文件输入、输出字符流）
|-- BufferedRead、BufferedWriter（输入、输出字符缓冲流）
|-- 字节字符流：
InputStreamReader
OutputStreamWriter
4.FileInputStream
文件字节输入流：
将文件的信息通过字节流传递到java应用程序中
N.扩展
1.作业
1.
请使用文件对象读取jdk目录下src文件中的所有java类型的文件，并在控制台打印出java文件名和统计出所有java文件的个数
2.
通过读取出的所有文件，将读取到的第一个java文件，将其内容打印在控制台中
2.各种流的区别（浅析）
介绍：
1.外部设备流入中央处理器属于输入，反之输出。
2.字节流读一个字节返回一个字节。字符流使用了字节流，读多个字节（字符）。
3.字节流可处理所有数据（图片、MP3…），字符流只能处理纯文字（推荐）。
区别：
字节流：
FileInputStream：（基本流）
读取本地文件内容
BufferedInputStream：
给FileInputStream提供一个缓冲区。（减少对数据源的访问，更高效）
DataInputStream：
基于多字节读取，可读取基本数据类型数据。
输出流同理。
字符流：
FileReader：（基本流）
读取字符文件的便捷类。
BufferedReader：
为FileReader提供字符缓冲器，存取数据更有效。
输出流同理
第25天 - - JavaGUI
一.目标
1.流
2.FileOutputStream
3.ObjectInputStream、ObjectOutputStream
4.DateInputStream、DateOutputStream
5.字符流
二.知识点
1.FileOutputStream（文件字节输出流）
将Java程序中的数据以字节的形式写入到文件中，并且文件中所保存的内容和程序中格式相同。
2.ObjectInputStream、ObjectOutputStream（对象字节输入、输出流）
在java程序中将对象数据输入、输出到文件中
java.io.NotSerializableException - - 没有序列化异常
序列化：（要实现Serializable接口（java强制规范））
在实体类中将一个实体类实现有序的传输方式，并且在实现序列化后的对象在保存到文件中时，除类中定义的静态成员都会写入到文件。
3.DateInputStream、DataOutputStream
将数据信息以dat格式写入到dat类型的文件中
4.字符流
Reader（字符输入流）、writer（字符输出流）
FileReader：
在程序中读取文件的数据以字符的方式获得
FileWriter：
在程序中将字符数据写入到文件中
5.缓冲区
作用：
用于在数据传输的时候对数据内容进行临时的管理
类型：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
N.扩展
1.作业
1.
使用GUI编程实想QQ注册的功能，并且QQ用户信息以文件方式保存
2.
使用GUI编程实现QQ登录的功能，需要从保存的文件中获取用户信息登录
2.任务
从以下游戏中选定本次项目周的项目（个人项目）
雷电（飞机大战）
坦克大战
植物大战僵尸
像素鸟
吃豆豆
扫雷
超级玛丽
3.汉字的字节数
起因：
字节流，输出存进文件对象的长度时发现文件大小为3字节
原因：
采用utf-8编码，长度由动态的字节组成有可能为1~6字节
其他：
java中char
为内码，采用utf-16编码格式。为2个字节，极少为4个字节
utf-8
英文为1个字节，汉字一般为3个字节，个别汉字4个字节
第26天 - - JavaAdv
一.目标
1.绘图
2.
二.知识点
1.绘图
案例：
打飞机
分析：
1.打飞机游戏存在的对象
飞机、子弹
2.对象的成员
a.飞机：
属性：状态、坐标、图片、矩阵
b.子弹：
属性：状态、坐标、图片、矩阵
3.游戏核心类：
创建飞机（我方飞机、敌方飞机（随机））对象
线程（飞机的移动、飞机的销毁、子弹的移动、、重绘）
实现：
1.准备素材：
在工程中创建一个img文件夹存放所有素材
2.创建工程架构
包（util、test、bean、frame、core）
工具类（在util工具包中创建（ImageUtil、SoundUtil））
N.扩展
第27天 - - JavaThread
一.目标
1.线程
2.案例实现
二.知识点
1.线程
关键字：
进程：在操作系统中正在运行的应用程序。
线程：在应用程序中存在的每个功能。
2.线程使用
定义：
a、Thread类
b、Runable接口
N.扩展