1 第一阶段 java入门

1.1 java快速入门及第一个程序

1.1.1 java的特性和优势

• 跨平台性、可移植性
• 安全性
• 面向对象
• 简单耐性
• 高性能- 分布式
• 多线程

1.1.2 java应用程序的运行机制

计算机高级语言的类型主要有编译型和解释型两种，而java是两种类型的结合。

graph TDA[源文件.java]-->B[java编译器]B[java编译器javac]--> C[字节码文件.class]C[字节码文件.class]-->D[类转载器]D[类装载器]-->F[字节码校验器]F[字节码校验器]-->G[解释器]H[解释器java]-->I[系统平台]

1.1.3 JVM、JRE和JDK

• JVM(Java Virtual Machine)即java虚拟机，用于执行bytecode字节码。他定义了指令集，寄存器集，结构栈，垃圾收集堆，jvm中的内存区域。JVM负责将java字节码解释运行，边解释边运行。这就是java比c运行慢的原因。有各种操作系统的虚拟机，所以java是跨平台使用的。
• JRE(Java Rintime Environment)包含：java虚拟机，库函数，运行java程序所需的文件。
• JDK(Java Developmen Kit)包含：JRE，增加编译器和调试器等用于程序开发的文件。

1.1.4 jdk的安装

1.1.5 第一个JAVA程序

• 找报错，哪行报错看哪行
• 程序员需要有调错能力，调错和写代码一样重要

1.1.6 第一个JAVA程序错误总结

-解决的错误越多，成长的越快
-千万不要逃避错误，不要把错误直接丢给老师、同学

1.1.7 任何方法的代码都要以{开始以}结尾

• main方法是程序的入口，它有固定的格式
• 一个源文件可以包含多个类class
• 一个语句以“；”结束，可以跨多行。

1.1.8 常用的DOS命令

命令	作用
cd <目录路径>	进入某个目录
cd…	进入父目录
dir	查看本目录下的文件和子目录列表
cls	清除屏幕命令
上下键	查找敲过的命令
Tab键	自动补齐命令

1.1.9 常用的java开发工具

1.1.9.1 记事本类- Notepad+± UltraEdit

• EditPlus

1.1.9.2 集成开发环境(IDE)

• eclipse
• intellij IDE
• NetBeans

1.1.10 零基础开发桌球游戏小项目

1.2 变量、数据类型和运算符

1.2.1 注释

程序代码中说明性的文字，用来提高程序的可读性。

• 单行注解：用“//”开头，在“//”后面的单行内容为注解
• 多行注解，以“/”开头以“/”结尾。可以再行内注解不影响运行
• 文本注解。以/*开头，以/结尾。通常放在一个文件的前面

1.2.2 标识符规则

标识符是用来给变量、类、方法以及包命名的，就是命名规范。

• 表示符必须以字母、下划线_、美元符号$开头
• java标识符大小写敏感，长度无限制
• 标识符不可以是java的关键字

1.2.2.1 表示符使用的规划

• 表示类名的标识符：没单词的首字母必须大写，如GoodMan
• 表示方法和变量的标识符：第一个单词小写，从第一个单词起首字母大学，成为“驼峰原则”

1.2.3 变量的本质

变量的本质就是一个“可操作的存储空间”，空间位置是确定的，但是里面放什么值不确定。我们可通过变量名来访问“对应的存储空间”，从未错这个“存储空间”的值。

• 一行声明一个变量
• 变量必须声明以后才能使用

1.2.4 变量的分类

1.2.4.1 局部变量

• 局部变量是方法或语句块内部定义的变量。生命的周期从生命位置开始到方法或语句块执行完毕为止。
  如public void kill（）{
  int a;
  a=2;
  }
• 局部变量必须初始化才能使用

1.2.4.2 成员变量

• 也称实例变量，方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。
• 成员变量如果未被初始化，则自动初始化，按下表自动初始化。

数据类型	初始值
int	0
double	0.0
char	‘\u0000’
boolean	false

1.2.4.3 静态变量

• 使用static 定义，如static int size;
• 从属于类
• 生命周期伴随着类始终，是所有变量里生命周期最长的

1.2.5 符号常量

在java中，主要使用关键字final来定义一个常量。常量一旦被初始化后不能再更改其值。

• 声明格式
  final type varname = value;

1.2.5.1 常量命名规则

全部大写，多个单词用下划线连接，如：BIG_EYE

1.2.6 基本数据类型

• 数值型：byte、short、int、long、float、double
• 字符型：char
• 布尔型：boolean

类型	大小
byte	1字节
short	2字节
int	4字节
long	8字节
float	4字节
double	8字节
char	2字节
布尔型	1位

1.2.7 整型变量和整型常量

1.2.7.1 当给一个整型变量赋一个整型常量时，主要前面的进制符号，如：

• int a = 15;标识赋值十进制的15给a
• int a = 015 则表示赋值8进制的一个数给a，换为十进制为：13
• int a = 0x15 则表示赋值一个十六进制的数给a，化为十进制为：21
• int a = ob110则表示赋值a一个二进制数，实际上是十进制的7
• char型在做算式运算时也算整型

1.2.7.2 长整型常量的声明

java 中，整型默认为int型，所以在声明Long型时，如该long型被赋予的值在int范围内，可以通过编译，但超出此范围时，无法通过编译。所以在声明长整型时，要在常量后面加L或l,为了和数字1区别，建议使用L

1.2.8 浮点型数据类型

• 浮点型数据类型分为两种：单精度浮点类型float，双精度浮点类型（数据位数比单精度多一倍）。
• 之所以叫精度浮点，是因为，两个数之间的小数是无限的，不能具体表现出来，所以有精度的说法

1.2.8.1 浮点型数据的表示方法

• 十进制类型：如3.1415926
• 科学计数法：314E-2、456E2 (E2表示10的2次方，E-2表示10的-2次方)

1.2.8.2 浮点型数据的赋值

• 浮点型默认型是double
• 当要给float型赋值时，需要在后面加f或者F，例如 float a = 3.14f
• 因为是3.14f是不准确的，所以3.14f≠3.14

1.2.8.3 在金融计算方面，如果涉及浮点型数据的计算，推荐使用 BigDecimal

1.2.9 算术运算符

1.2.9.1 整数运算

• 如果两个操作数（运算符号两边的数）为long，结果也为long
• 没有long时，结果全为int
• char型数据本质是整型，在做运算时系统按字符相对应的unicode做计算

1.2.9.2 浮点运算

• 如果两个操作数有一个为double，则结果为double
• 只有两个操作数为float的情况，结果才为float

1.2.9.3 取模运算

• 其操作数可以为浮点数，一般使用整数，结果是“余数”，余数符号和左边操作数相同，如：7%-3=1

1.2.10 关系运算符

关系运算符来进行的运算结果为布尔值，即true或者false

1.2.11 逻辑运算符

1.2.11.1 逻辑运算符展示

逻辑	符号	说明
逻辑与	&	两个操作数为true结果才为true
逻辑或	|	只有两个操作数为true结果才为true
逻辑非	！	操作数为true，则结果为false，反之
短路与	&&	只要有一个为false，则直接返回false
短路或	||	只要有一个为true，则直接返回true
逻辑异或	^	两个操作数相同为false，不同为true

注：逻辑或与短路或的区别：逻辑或在系统做判断时，要判断两个操作数，而短路或只需判断一个操作数。这样提高的效率。短路与同理。

1.2.12 位运算符

• 位运算符&，如整型的4&3即为00000100&00000011作逐位与运算
• 位运算符 | ，二进制形式下作逐位或运算
• << 表示左移符号，左移1表示乘2，例如3<<1即是3*2.左移2则为3乘2再乘2
• >> 右移符号，表示除2取商一次，例如4>>1表示4/2,而4>>2表示4/2/2

1.2.13 字符串连接符“+”

当＋好两边有一个操作数为字符串时，输出的结果会将两个操作数连接起来，如int a=3;String b=“4”,则system.out.println(a+b);输出为34

1.2.14 条件运算符（三元运算符）

• 式子x？y：z
  -其中x为布尔型表达式，y和z为一般语句，可以为值
  -在运行时，先计算x的值，如为true，则返回y，否则返回z

1.2.15 自动类型转化

graph LRbyte-->shortshort-->intchar-->intint-->longlong-.->floatint-.->floatint-->doublelong-.->doublefloat-->double

注：虚线表示有精度损失，实线表示无精度损失

1.2.16 强制类型转换

• 精度会损失，如double a = 3.14,(int)a就为3

1.2.17 基本类型常见错误

• 操作较大的数值时，注意是否溢出，尤其是整数时，溢出时结果会是一个负数
• 尽量不要用小写L
• 为了避免溢出，在一个可能溢出的算式里将任意一个值强转为long型（在这个值后面加L）赋值给一个long型变量即可，例如：long a=200L*1000000000;

1.3 流程控制语句和方法

1.3.1 if但选择结构

• double d = Math.random()表示返回一个[0,1)之间的随机数,这里是0到1之间的小数
• Math.random（）+1。这个表示(0,1]
• 如果需要[0，y）之间的数，则用y*Math.random()
• 如果需要(0，y]之间的数，则用y*Math.random()+1

1.3.2 if-else双选择结构

if-else双选择结构使逻辑变得严密，日常生活中，else后面的内容都很重要

• x的二次方表达为：Math.pow(x,2)

1.3.3 swith多选择结构

一般swith只用来做多值的判断

• 结构

switch(表达式）{ //表达式计算的结果一般为整数，不能为string型

case 值1;语句序列1;[break];//可选,执行break则switch结束case 值2;序列语句2;[break];...case n;序列语句n;[break];[default];默认语句;

}

1.3.4 循环结构

循环结构分两大类，一类是当型，一类是直到型

• 循环是结果，而不是过程
• 当型

当布尔表达式条件为true时，反复执行某语句，只有当布尔表达式为false时才停止循环，比如while与for循环

• 直到型

这种类型比较少用。先执行某语句，再判断布尔表达式，如果为true，再执行某语句，如此反复，直到表达式为false时才停止循环。比如do-while循环。

1.3.4.1 while循环

while（表达式）{        循环体}

1.3.4.2 for循环-使用最多的循环

• 结构

for（1.初始化语句;1.表达式;2.步进迭代语句）{        循环体}

• for后面的括号中，语句1和2可以不写，但分号必须写
• 先执行循环体再执行迭代语句
• 表达式不写则默认为true

1.3.4.3 do-while循环

do{    循环体    }while（表达式）

1.3.5 break与continue语句

• break在循环语句中一旦运行，则整个循环结束
• 当循环体运行到continue时，跳过循环体中continue后面的语句，不执行。continue的本质是终止本次循环

1.3.6 带标签的break和continue语句

在break和continue后面跟上一个标签名，就会在执行break或continue语句后跳转到标签所指的语句去并且break或者continue它。

• 格式：

<标签名：>被订上标签的语句......break <标签名>;/continue <标签名>;- 例子labelA:for(){    for(){        continue labelA; //执行到该语句时，直接终止内循环，跳转到被订标签的外循环并且continue一次外循环    }}

1.3.7 方法的定义、语句块

1.3.7.1 语句块

语句块由两个花括号{}括起来的一块语句。因为没有名字，所以不能反复调用。

1.3.7.2 方法

• 方法相当于带了名字的语句块，可以反复调用
• 一般方法需要对象来调用，形式为：对象名.方法名;
• 方法定义在类里面
• 形参和实参的数据类型必须匹配
• 实参与形参的数据传递是值传递（拷贝一份数据给形参），不是传递数据的地址
• 方法中的return会终止方法并返回return后指定的值
• 静态方法由static修饰，和类一同加载，不需要对象就可以直接调用

1.3.8 方法的重载-@Overload

1.3.8.1 雷区

重载的方法，实际是完全不同的独立的方法，只是名称相同而已

1.3.8.2 构成方法重载的条件

• 不同的含义：形参类型，形参个数，形参顺序不同
• 只有返回值的类型不同不构成方法的重载

1.3.9 递归（方法自己调用自己）

1.3.9.1 递归头

递归头即用来说明什么时候停止调用自身的代码

1.3.9.2 递归体

用来说明什么时候自身调用自身

1.3.9.3 递归的耗时

递归相比其他算法特别耗时

• 耗时计算

long d1 = System.TimeMills() //表示1970年1月1日到目前为值的毫秒数

此处运行一次递归算法；

long d2 = System.TimeMills() //表示1970年1月1日到目前为值的毫秒数

然后输出d2-d1就为耗时了

以上方法可用来计算某段代码运行的时间差，很灵活

1.4 面向对象初步

1.4.1 类和对象

1.4.1.1类

• 类是对象的模板
• 类中可以含有属性（成员变量）
• 类中可以含有方法

1.4.1.2 对象

对象就是实例，是某个类的具体列子

• 实例化一个类得到一个对象时，本质上是将这个新的“类的副本”即新的对象的地址赋值给对象

<类名> a =new <默认构造方法>实际是a=对象的地址

1.4.2 JVM内存分析详解-栈-堆-方法区-栈帧-程序执行的内存变化过程

1.4.2.1 栈

• 栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧（存储局部变量，操作数，方法出口等）
• jvm为每个线程创建一个栈，用于存放该线程执行方法的信息（实参，局部变量的等）
• 栈属于线程私有，不能实现线程间的共享
• 栈的存储特性是“先进后出，后进先出”
• 栈是由系统自动分配，速度快，栈是一个连续的内存空间

1.4.2.2 堆

• 堆用于存储创建好的对象和数组（数组也是对象）
• JVM只有一个堆，被所有线程共享
• 堆是一个不连续的内存空间，分配灵活，速度慢
• 等号右边有变量运算时，会在堆中开辟新的空间（有地址）
• 等号右边有new时，会在堆中开辟新的空间（有地址）

1.4.2.3 方法区（静态区）

• 方法区的常量有自己的地址
• JVM只有一个方法区，被所有线程共享
• 方法区实际上也是堆，只是用于储存类、常量相关的信息
• 用来存放程序中永远不变或唯一的值（类信息【class对象】、静态变量、字符串常量等）
• 以下为一个程序执行时映射在jvm内存的示意图

1.4.3 一个典型类和UML图入门

• new一个对象的时候实质上是在调用这个类的构造方法
• 直接打印一个对象会得到它的地址

1.4.4 构造方法

构造方法也称构造器，用于对象的初始化

• 构造方法虽然有返回值，但是不能定义返回值类型（返回值类型肯定是本类），不能在构造器里使用return返回某个值
• 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数
• 构造器的方法名必须与类名一致（大小写都要对应）
• 构造方法只能被new调用或者被另一个构造方法调用
• • 在构造方法中，第一句永远是super();super();会调用父类构造方法。写与不写它就在那里

1.4.5 垃圾回收机制（garbage collection）

垃圾回收机制保证可以将“无用的对象”进行回收，无用的对象指的是没有任何变量引用该对象，java的回收期通过相关算法发现无用对象，并进行清除和整理

• 对象空间的释放：讲对象赋值null即可，垃圾回收期将负责回收所有“不可达”对象内存空间

1.4.5.1 垃圾回收过程

任何一种垃圾回收算法丢要做两件基本事情

• 1.发现无用的对象
• 2.回收无用对象占用的内存的空间

1.4.5.2 垃圾回收相关算法

• 1.引用计数器法：
  堆中每个对象都有一个引用计数器，被引用一次，计数加一，被引用变量值变为null，则计数减一，知道计数为0，则表示变为无用对象，优点是算法简单，缺点是“循环引用的无用对象”无法被识别
• 2.引用可达法：
  程序把所有的引用关系看作一张图，从一个节点GC ROOT开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，当所有的引用节点寻找完毕以后，剩余的节点则被认为是没有被引用到的节点，即无用的节点

1.4.6 通用的分代垃圾回收机制

JVM将堆内存划分为Eden、Survivor、Tenured/Old空间。

• 年轻代Eden：
  所有新生成的对象首先都是放在Eden区，年轻代的目标就是尽可能快速的手机掉那些生命周期周期短的对象。对应的是Minor GC,每次Minor GC都会清理年轻代区域的内存，算法采用效率较高的复制算法
• 年老代Old：
  在年轻代中历经了N（默认15）次垃圾回收后，任然存活的对象，就会被放到老年代中。年老代对象越来越多，我们就需要启动Major GC（清理年老代）ll GC，来一次大扫除，全面清理年轻代区和年老代区域
• 持久代Survivor：用于存放静态文件，如java类、方法等，持久代对垃圾回收机制没有显著影响

1.4.7 this 的本质-对象创建的4个步骤

this的本质就是“创建好的对象的地址”！由于构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表“当前对象”。this相当于方法中的形参。

1.4.7.1 创建一个对象分为如下四步

• 1.分配对象空间，并将对象成员变量初始化为0或null
• 2.执行属性值的显式初始化
• 3.执行构造方法
• 4.返回对象的地址给相关的变式

1.4.7.2 this的两种使用方法

• 1.用来强调区分成员变量和局部变量，如：

TestThis(int a,int b){ //这是一个构造方法    this.a=a;    this.b=b;}

• 2.用来调用构造器

TestThis(int a,int b,int c){     //这也是一个构造方法    this(a,b);//构造器的调用必须为第一句    this.c=c;}

• 3.this不能用于static方法中

1.4.8 static关键字-静态变量和静态方法

• 在类中，用static声明的成员变量为静态成员变量，也称类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效

• static修饰的成员变量从属于类。普通变量和方法从属于对象：静态方法可以调用静态变量和静态方法，但不能调用非静态的成员变量和方法

1.4.9 参数的传值机制

java中，方法中的所有参数都是“值传递”，也就是传递参数的副本，也就是说，我们得到的是“原参数的复印件”，而不是原件，因此，不会影响到原件。

• 基本数据类型参数的传值：
  传递的是值的副本，副本改变不会影响原件
• 引用类型参数的传值（对象的传递）：
  传递的是值的副本，但是引用类型值的是“对象的地址”，因此，副本和原参数都是指向了同一个“地址”，改变“副本指向地址对象的值”，也就意味着原参数只想对象的值也发生了改变

1.4.10 静态初始化块

构造方法是用于对象的初始化。类也需要初始化，为类初始化的语句块叫做静态初始化块。

• 静态初始化语句块用static修饰
• 在静态初始化块中不能直接访问非static成员

1.4.10.1 静态初始化块的执行顺序

• 上溯到Object类，先执行Object类的静态初始化块，直到当前的类的静态初始化块执行完为止
• 构造方法执行顺序和上述一样

1.4.11 java包的机制

开发中，我们会遇到大量同名的类，通过包我们很容易解决类重名的问题，也可以实现对类的有效管理。包对于类，相当于文件夹对于文件的作用。

1.4.11.1 package的命名机制

• 1.通常是类的第一句非注释语句
• 2.包名：域名倒着写即可，再加上模块名，便于内部管理类
• 3.com.gao和com.gao.kan，这两个包没有包含关系，是两个完全独立的包，只是逻辑上看起来后者是前者的一部分
• 4.举例

com.baidu.test;cn.sxt.gao.viem;

1.4.11.2 jdk中主要的包

包名	说明
java.lang	包含一些Java语言的核心类，如String、Math、Integer、System和Thread,提供常用功能
java.awt	包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)
java.applet	包含applet运行所需的一些类
java.net	包含执行与网络相关的操作的类
java.io	包含能提供多种输入/输出功能的类
java.util	包含一些实用工具类,如定义系统特性、使用与日期日历相关的函数

1.4.12 import详解和静态导入详解

当需要使用到其它包里面类时，就需要导入包

1.4.12.1 导入方法一

精确导入，如

cn.sxt.oo.User user= new cn.sxt.oo.User

这段代码表示调用cn.sxt.oo包下的User类

1.4.12.2 导入方法二

直接在类上方包名下方使用import导入

• 单个类导入，如：import cn.sxt.oo.User;
• 包下所有类导入，如：import cn.sxt.oo.*;

1.4.12.3 注意事项

当导入的多个包中含有重名的类，而这个类又被使用到的时候，以最精确导入的类为准

1.4.12.4 静态导入

静态导入作用是用于导入指定类的静态属性，这样我们可以直接使用静态属性。

• 单个属性导入，如：
  import static java.lang.Math.PI; 表示导入Math类下的PI
• 多个属性导入，如：import static java.lang.Math.*;表示导入Math类下的所有静态属性

1.4.13 面向对象的三大特征之继承extends

面向对象的三大特征是继承、封装、多态
从英文字面意思来讲，extends的意思是“拓展”，子类是父类的拓展。

• 子类继承父类的一切东西
• 并不是所有父类的东西子类都可以用
• java中只有单继承，一个子只有一个父
• 父类又被称作超类、基类、派生类等
• 类没有多继承，接口有
• 如果定义一个类时，没有调用extends，则它的父类为java.lang.Object
• 可以使用ctrl+t来查看当前类的继承关系
• <对象A>instanceof<类B>用来判断对象A是否是B或B的子类的实例，返回True or false

1.4.14 继承-方法的重写Override

子类通过重写父类的方法，可以用自身的行为替换父类的行为

• 方法重写要求方法名、形参必须一致
• 重写方法的返回值类型和声明异常类型，子类要小于等于父类
• 重写方法的访问权限，子类大于等于父类
• 重写的方法并不影响父类的方法

1.4.15 继承-Object类的用法-重写toString方法

Object是所有java类的根基类，也就意味着所有的java对象都有用Object类的属性和方法

1.4.15.1 toString方法的重写

当我们直接打印一个对象时，实质上是在调用toString 方法，调用toString 方法默认可以返回对象的hashcode

• toString方法的重写

@Overridepublic String toString(){//此处填写重写代码    }

1.4.16 ==和equals方法

1.4.16.1 ==

“==”用来判断是否相同，如果是基本类型则表示判断值是否相等，如果是引用类型则表示判断地址是否相等，即判断是不是同一个对象

1.4.16.2 equals方法

equals方法定义在Object类中，哟呵你过来定义“对象内容是否相等”的逻辑

• 我们经常重写equals方法根据比较某些属性来返回想要的结果（true/false）

1.4.17 继承-super父类对象引用-继承树追溯问题

当子类重写了父类的方法，但又要调用到父类原本的方法时，使用super.<父类方法名>来调用

• super相当于一个父类的对象
• 在构造方法中，第一句永远是super();super();会调用父类构造方法。写与不写它就在那里

1.4.18 面向对象的三大特征之封装

1.4.18.1 高内聚低耦合

封装的含义就是“高内聚低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外界干涉；低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用

1.4.18.2 封装的优点

• 提高代码的安全性
• 提高代码的复用性
• 高内聚：封装细节，便于修改内部代码，提高可维护性
• 低耦合：简化外部调用，边用调用者使用，便于扩展和协作

1.4.18.3 使用访问控制符来实现代码的封装

• 访问控制符的权限

修饰符	同一个类	同一个包中	子类	项目中的所有类
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

注：在没写修饰符的情况下默认为default

1.4.18.4 封装的使用细节

• 一般方法public即可
• 碰到类的属性(成员变量)，一般使用private访问权限
• 然后提供相应的set与get方法来访问相关属性，这些方法通常是pubic修饰的
• boolean类型的get方法是is开头，如
• boolean 方法中的retrun语句不能终结整个方法

public boolean isbeautiful(){ //填充代码}

1.4.19 面向对象的三大特征之多态

多态指的是同一个方法的调用，由于调用对象的不同可能会有不同的行为。在现实生活中，同一份方法，不同的人去具体实现也会大有不同。

1.4.19.1 多态的要点

• 1.多态是方法的多态，与属性无关
• 2.多态的存在要有三个必要条件：继承、方法的重写、父类引用指向子类对象
• 3.父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了
• 4.接口引用指向实现类对象，也出现多态

1.4.20 对象的转型

1.4.20.1 向上的转型

父类引用子类对象，我们称这个过程为向上转型，属于自动类型转换。子类对象自动转换为父类的对象。

1.4.20.2 向下的转型

强制转型一个父类的对象为子类的对象，方法是
<子类> <子类对象> =（<子类>） <父类对象>；
例如：
Dog d2 = (Dog) d;

1.4.21 final修饰变量、方法和类

1.4.21.1 修饰变量

当final用来修饰变量时，就意味这个这个变量变成了常量，因为它不可被重新赋值

1.4.21.2 修饰方法

final用来修饰方法时，该方法不可被子类重写，但是可以被重载！

1.4.21.3 修饰类

final用来修饰类时，该类不可被继承，比如Math、String等

1.5 数组初步

1.5.1 数组的使用_内存状态

1.5.1.1 数组

• 数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
• 数组变量属于引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。
• 数组元素的下标从0开始

1.5.1.2 数组的三个特点

• 长度是确定的。数组一旦被创建，它的大小不可以改变
• 其元素必须是相同类型，不予许出现混合类型
• 数组类型可以使任何数据类型，包括基本类型和引用类型（如对象）

1.5.2 数组的三种初始化方法

1.5.2.1 静态初始化

直接赋值，举例：int [] a={1,2,3,4,5,6}、User[] b={new User(1001,“gaoqi”),new User(1002,“gaoxiaoqi”)};

1.5.2.2 动态初始化

使用循环给数组进行动态赋值

1.5.2.3 默认初始化

当一个数组只给了长度时，默认给元素进行赋值，赋值规则和成员变量默认赋值一样。
举例：int a=int[10];然后它就挨个儿给这个数组赋值0

1.5.3 数组的遍历_for-each循环

增强for循环for-each循环是专门用于读取数组或集合中的所有元素，即相对数组进行遍历

• 只能读取数组元素的值，不能修改元素的值
• for-each的写法

    for(<数据类型> 变量名 ： 数组名){        System.out.println(变量名);    }

1.6 打飞机项目

1.6.1 窗口绘制

• 设置窗口居中

this.setLocationRelativeTo(null);

• 设置窗口不可最大化

        this.setResizable(false);

• this.setVisible(true)这个语句要放到后面才可以
• paint方法是自动调用的，其中的g变量相当于一支画笔
• paint方法中画笔颜色的使用（字体使用同理）

        Color c =g.getColor();//得到当前颜色:默认的黑色g.setColor(Color.RED);//设置为红色g.setColor(c);//还原为黑色

• 设置窗口关闭按钮

//关闭窗口代码this.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent e) {System.exit(0);}});

1.6.2 线程实现动画-paint方法与repaint方法

• 构建根类思想
• 重写paint方法只有在类是继承JFrame类或是继承Frame类
• paint方法只有在有窗口的情况下才会被调用
• repaint方法不是循环！不是循环！不是循环！在paint方法中改变的值（即使调用paint方法外面的其他方法来改变的值），再次调用repaint也会被重置！
• 使用sleep语句来控制线程休眠

Thread.sleep(40);//40表示每40ms执行一次

• 在线程类里添加run()方法和while循环，然后再某个地方调用它才能运行起来

public void run() {while (true) {repaint();// 重复调用绘画方法try {Thread.sleep(40);// 40表示40ms，1s/40ms=25帧（此时人眼捕获为动画）} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

///调用线程new <线程类名>().start();

1.6.3 键盘控制原理

• 通过键盘监听类实现键盘控制

//键盘监听class KeyMonitor extends KeyAdapter{@Overridepublic void keyPressed(KeyEvent e) { //如果有另一个KeyEvent e,会和这个冲突，需要改一个，如改成fSystem.out.println(e.getKeyCode());}@Overridepublic void keyReleased(KeyEvent e) {// TODO Auto-generated method stubsuper.keyReleased(e);}}

• 然后在launch中调用

addkeyListener(new KeyMonitor()); //这是键盘监听，还有鼠标监听的没写

• 强烈建议在某个类中生成具体动作的方法，通过接受来自键盘监听的数据。不要在窗口类中写移动方法

void drawSelf(Graphics g) {System.out.println("x:"+x+"\ty:"+y);g.fillRect(x, y, width, height);if (left) { //通过判断left来控制物体移动x-=speed;}}// 键盘控制方法void move(KeyEvent e) {switch (e.getKeyCode()) {case KeyEvent.VK_LEFT:left=true; //标记left为truebreak;default:System.out.println("按了其它键");break;}}

1.6.7 使用数组生成多个对象

• 第一步，定义一个需要生成对象的类的数组，这里用shell类举例：

Shell[] shells =new Shell[Constant.SHELL_NUMBER];

• 第二步，使用for循环生成对象：

//代码放在生成窗口的方法中for(int i=0;i<shells.length;i++) {shells[i]=new Shell();//利用数组循环生成Shell对象}

1.6.8 解决闪屏问题：双缓冲技术

//在类中插入此段代码即可private Image offScreenImage = null;public void update(Graphics g) {    if(offScreenImage == null)        offScreenImage = this.createImage(500,500);//这是游戏窗口的宽度和高度    Graphics gOff = offScreenImage.getGraphics();    paint(gOff);    g.drawImage(offScreenImage, 0, 0, null);}//本段代码需要窗口继承的是Frame类而不是JFrame类

1.6.9 矩形碰撞

• 在物体根类返回一个矩形

//返回物体所在的矩形，便于后续的碰撞检测public Rectangle getRect() {return new Rectangle((int)x,(int)y,width,height);}

• 在画（paint方法）的时候判断是否碰撞

//这里为炮弹对象shell[i]与飞机对象的碰撞判断crush1 = shells[i].getRect().intersects(plane.getRect());if (crush1) {System.out.println("撞上了"+i);plane.live=false;}

1.6.10 图片轮播类

用于轮播某组图片

public class Explode {double x, y;//图片的初始位置static Image[] imgs = new Image[16]; //16表示16张图片static {for (int i = 0; i < 16; i++) {imgs[i] = GameUtil.getImage("images/e" + (i + 1) + ".gif");//图片名为e0.gif-e15.gifimgs[i].getWidth(null);}}int count;public void draw(Graphics g) {if (count <= 15) {g.drawImage(imgs[count], (int) x, (int) y, null);count++;}}public Explode(double x, double y) {this.x = x;this.y = y;}}

1.6.11 计时功能的实现

在游戏开始时新建一个时间，结束时再新建一个，两者相减就得到了生存时间。开始时间写在窗口内。

• 开始时间

long start = System.currentTimeMillis();

• 结束时间

long end = System.currentTimeMillis();

• 累计时间

System.out.println(end-start);

1.6.12 窗口的销毁

• 销毁代码

<窗口类对象>.dispose();