培训第一课，Java。

课程目标
熟练掌握Java语言，学会用Java编写代码
掌握面向对象在编程中的应用
熟练掌握异常的处理机制
熟练运用Java完成开发任务
熟练使用开发工具编写，调试和运行程序

第一讲认识Java

Java的主要特点

简单：语法与C和C++类似
面向对象：类、对象；封装、继承、多态
健壮：异常处理、垃圾回收、无指针
与平台无关：通过二进制字节码(.class)和Java虚拟机(JVM)实现

Java安装与配置

官网下载JDK(Java开发工具包)，包含开发环境和运行环境，然后按照安装提示一步步进行。

环境变量

配置位置：右击“我的电脑”->“属性”项 -> “高级系统设置” ->“环境变量”

环境变量名	变量值
JAVA_HOME	安装的JDK的位置
CLASSPATH	Java工具库的位置
Path	Java编译工具位置

测试配置

打开命令提示行，输入java --version或者javac --version，按回车键，若能正常显示JDK的版本信息，就表明JDK已经安装和配置完成。

Java开发过程

Java开发的基本规则

Java源文件必须以”.java”为扩展名。源文件的基本组成部分是类(class)，class 关键字后面的即类名，如本例中的HelloWorld类。
一个源文件中最多只能有一个public类，其他类的个数不限。如果源文件包含一个public类，则必须以类名命名源文件。
Java应用程序的执行入口是main()方法，它有固定的书写格式。
Java严格区分大小写。

每条Java语句由分号结束。

1
2
3

public static void main(String [] args){  
    //main方法主体
}

第二讲 Java语言概述

Java语言基本元素

1. 标识符

标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。
定义规则
以英文大小写字母、下划线“_”、或“$”开始的一个字符序列。
数字不能作为标识符的第1个字符。
标识符不能是Java的关键词。
标识符大小写敏感且长度没有限制。

2. 关键字

关键字是程序里事先定义的，有特别意义的标识符，有时又叫保留字，不能当作一般的标识符使用。

abstract	continue	goto	null	switch
assert	default	if	package	synchronized
boolean	do	implements	private	this
break	double	import	protected	throw
byte	else	instanceof	public	throws
case	extends	int	return	transient
catch	final	interface	short	try
char	finally	long	static	void
class	float	native	strictfp	volatile
const	for	new	super	while

3. 变量

是指在程序的运行过程中随时可以发生变化的量，是程序中数据的临时存放场所。定义变量的语法规则为：
变量数据类型变量名 [ = 变量初值] ;
若要同时声明多个相同数据类型的变量，可以分别声明它们，也可以把它们都写在同一个语句中，每个变量之间以逗号分开，如下面的写法：
变量数据类型变量名1[ = 变量初值1] ，变量名2 [ = 变量初值2]，变量名3 [ = 变量初值3];

4. 常量

指程序里持续不变的值，在整个程序运行过程中它是不可改变的。例如整数常量、字符串常量。
Java中用关键字final来声明常量，并且必须声明它所预保存的数据类型。

5. 数据类型

graph LR
  A[数据类型] --> B[基本类型]
  A --> C[引用类型]
  B --> D[数值型]
  B --> E[字符型]
  B --> F[布尔型]
  C --> G[类]
  C --> H[接口]
  C --> I[数组]
  D --> J[整数类型]
  D --> K[浮点类型]

boolean（逻辑型）只有两种取值true or false，占用一个字节。
byte(字节类型) 一个byte 8位，占用1个字节（-128~127）
short(短整型) 一个short 16位，占用2个字节（-32768~32767）
int(整型)一个int 32位，占用4个字节（-2147483648~2147483647）
long(长整型) 一个long 64位占用8个字节（-2^63~2^63-1）
char(字符型) 一个char16位，占用2个字节，用于表示字符。
float（单精度浮点型）一个float 32位，占用4个字节（-3.4E38 ~3.4E38）
double(双精度浮点型) 一个double 64位，占用8个字节（-1.7E308 ~1.7E308）

整数类型（byte、short、int默认、long）
1、Java各整数类型有固定的表数范围和字段长度，其不受操作系统的影响，以保证Java程序的可移植性。
2、Java语言的整形常量默认为int型，声明long型后面需加上l或者L，否则会出错。
浮点数类型（float、double默认）
1、与整数类型相似，Java浮点数类型有固定的表数范围和字段长度，不受平台影响。
2、Java浮点型常量默认为double型，如要声明一个常量为float型，则需在数字后面加f或F，否则出错。
字符类型（char）
char类型的值通常用单引号(‘和’)括起来。
例如：'a'、'中'、'\n'、'\u03A6'
布尔类型（boolean）
boolean类型适于逻辑运算且只有两个值：true 和 false

自动类型转换（隐式类型转换）
有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后进行计算。
boolean类型不可以转换为其他的数据类型。
整型、字符型、浮点型的数据在混合运算中相互转换，转换时遵守以下原则：
隐式转换
byte、short、char之间不会相互转换，他们三者在计算时首先会转换为int类型。得到的计算结果为int类型。

强制类型转换（显式类型转换）
容量大的数据类型转换为容量小的数据类型时，需要使用强制类型转换，其格式如下：

1 2	int b = 1; byte a = (byte)b;

在强制类型转换过程中，源类型的值可能大于目标类型，因此可能造成精度降低或溢出，使用时需注意。

浮点数
当两个整数相除时，小数点以后的数字会被截断，使得运算的结果保持为整数。想要得到运算的结果为浮点数，就必须将两个整数中的其中一个（或是两个）强制转换类型为浮点数
只要在变量前面加上欲转换的数据类型，运行时就会自动将此行语句里的变量做类型转换的处理，但这并不影响原先所定义的数据类型。

6.运算符

程序是由许多语句组成的，而语句的基本单位是表达式与运算符。
每个语句结束时，必须以分号“ ;”做结尾。
表达式是由操作数与运算符所组成：操作数可以是常量、变量也可以是方法，而运算符可以是数学运算符、逻辑运算符、地址运算符等。以下面的表达式（ z+100）为例，“ z”与“ 100”都是操作数，而“ +”就是运算符。

按操作数的数目分：
一元运算符：++ --
二元运算符：+ - < > =
三元运算符：?:
按功能分：
算术运算符：+，-，*，/，%，++，--
关系运算符：>，>=，<，<=，==，!=
逻辑运算符：!，&&，||
赋值运算符：=，+=，-=，*=，/=
条件运算符：?:
运算符的优先次序
1) ()
2) ++ , -- , !
3) * , / , %
4) + , -
5) > , < , >= , <=
6) == , !=
7) &
8) |
9) &&
10) ||
11) ?:
12) = , += ，-=

自加(++)、自减(–)运算符
++(–)在前时先运算再取值
++(–)在后时先取值再运算

int i=0;
int j=i++ + ++i;
int k=--i + i--;
System.out.println(“j=” + j + ”,k=” + k);

结果为j=2,k=2

7.代码注释

// 注释一行
/* 注释多行 */
/** 文档注释 */

其中，用文档注释（/**……*/）的注释内容会被解释成程序的正式文档，并能包含进如 javadoc之类的工具生成的文档里，用以说明该程序的层次结构及其方法

控制语句

顺序结构

程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾。

graph TD
A(开始) --> B[语句1]
B --> C[语句n]
C --> D(结束)

选择结构

根据条件的成立与否，再决定要执行哪些语句的结构。

graph TD
A(开始) --> B{判断条件}
B -->|True| C[语句1]
B -->|False| D[语句2]
C --> E[语句3]
D --> E
E --> F(结束)

代码大体如下：

if (判断条件) {
  语句 1 ；
  语句 2 ；
  …
  语句 n ；
}

or

if (判断条件){
  语句主体 1 ；
}
else{
  语句主体 2；	
}

or

if (条件判断 1){
  语句主体 1;
}	
else if (条件判断 2){
  语句主体 2;
}
… // 多个 else if()语句
else{
  语句主体 3;
}

or

switch (表达式){
  case 选择值 1:
    语句主体 1;
    break;
  case 选择值 2:
    语句主体 2;
    break;
    …….
  case 选择值 n:
    语句主体 n;
    break;
  default:
    语句主体;
}

switch表达式的返回值类型必须是int、byte、char、short中的一种。
case子句中的值value必须是常量，而且所有case子句中的值应是不同的。
default子句是可选的。
break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。

循环结构

根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。

graph TD
A(开始) --> B{判断条件}
B -->|True| C[语句1]
B -->|False| D[语句2]
C --> B[语句3]
D --> E(结束)

代码大体如下：

for (赋值初值; 判断条件; 赋值增减量){
  语句 1;
  ….
  语句 n;
}

or

while (判断条件){
  语句 1;
  语句 2;
  …
  语句 n;
}

or

do{
  语句 1;
  语句 2;
  ….
  语句 n;
} while (判断条件)

当循环语句中又出现循环语句时，就称为嵌套循环。如嵌套 for 循环、嵌套 while循环等，当然读者也可以使用混合嵌套循环，也就是循环中又有其他不同种类的循环。

关键词

break
离开当前层的循环主体，继续执行循环外的语句
continue
跳出本次循环，回到循环起点，继续执行下一次循环
return
从被调函数返回到主调函数继续执行

程序结构

包

命名
程序中使用package语句来声明包。
package 包名;
规则：
- package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。
- 包名可以是一个合法的标识符，也可以是若干个标识符加“.“分割而成。
- 如果一个类有包名，那么存储文件的目录中必须包含有相应的结构。
包语句
程序如果使用了包语句，例如：
package com.dareway.codec;
那么存储文件的目录中必须包含有如下的结构：
…\com\dareway\codec

如果在源程序中用到了除java.lang这个包以外的类，并且引用的类与源程序不在同一个包中，那么无论是系统的类还是自己定义的包中的类，都必须用import语句标识，以通知编译器在编译时找到相应的类文件。

类

命名：
Java 程序是由类（class）所组成。

1
2
3

public class HelloWorld {   // 类声明
	…
}

规则：
在完整的 Java 程序里，至少需要有一个类。
public修饰的类所在的原始程序的文件名不能随意命名，必须和 public 类名称一样。
在一个独立的原始程序里，只能有一个 public 类，可以有许多非public 类。

大括号、段、主体

左大括号“ {”为主体开始的标记，至右大括号“ }”结束。
类和方法的主体要通过大括号进行标记。
每个命令语句结束时，必须以分号“ ;”做结尾。
当某个命令的语句不只一行时，必须以一对大括号“ {}”将这些语句包括起来，形成一个程序段（segment）或是块（block）。
在使用选择结构或是循环结构时，需要使用大括号将分支语句或是循环主体包括起来。

方法

[访问控制符] [修饰符] 返回值类型 方法名称（类型 参数 1，类型 参数 2， …）
{
	程序语句 ；
	return 表达式；
}

如果不需要传递参数到方法中，只需要将方法名称后面的()写出，不必填入任何内容。
如果方法没有返回值，则 return 语句可以省略，并且返回值类型应该为void

main方法
main()方法为程序的主方法，在一个Java应用程序中有且只能有一个 main()方法，它是程序运行的开端，有固定的格式，如下所示：

public static void main(String args[]) // 主程序入口   
{	
  …
}

一维数组

声明数组

格式
- 类型名[] 数组名;
- 类型名数组名[];
示例
- int[] a，b；等价于 int a[],b[]；
- int a[]，b；此处的b不是数组类型
- float[] a = new float[10]；
- float a[10]; 格式非法

创建数组

格式：
- 数组名 = new 类型名[长度]；
举例
- a = new int[20]；
- float[] f = new float[100]；

数组初始化

格式：
- 数组类型数组名[] = {元素1，元素2，…}
- 数组类型数组名[] = new 数据类型[]{元素1，元素2，…}
示例：
- int a[] = {1,2,3,4,5};
- int[] b = new int[] { 1, 2, 3, 4, 5 };

数组访问

格式：
- 数组名[下标值]
- 数组的下标值从0开始计
- 每个数组都有一个属性length指明数组长度，即元素个数，格式：数组名.length

示例：

int[] a = new int[]{1,2,3,4,5};
for(int i=0; i<a.length; i++){
	a[i]=a[i]+1;
	System.out.print(a[i]+", ");
}

多维数组

声明数组

格式
- 数组类型数组名[][]
- 数组类型[][] 数组名;
- 数组类型[] 数组名[];
示例
- int a[][];
- int[][] b;
- int[] c[];
特性
- Java中没有真正的多维数组，只有数组的数组。
- Java中多维数组不一定是规则矩阵形式。

创建数组

格式：
- 数组名 = new 数据元素类型[行数] [列数] ;
- 数组名 = new 数据元素类型[行数] [] ;
举例
- int a[][] = new int[3][4];
- int[][] b = new int[3][];
- int[] c[] = newint[][4]; 非法，必须声明行的个数

数组初始化

格式：
- 数组类型数组名[][] = { {元素11，元素12，…} , {元素21，元素22，… } }
- 数组类型数组名[][] = new 数据类型[][] { {元素11，元素12，…} , {元素21，… } }
示例：
- int a[][] = { {1,2,3}, {4,5}, {7} };
- int b[][] = new int[][]{ {1,2,3}, {4,5}, {7} };

第三讲面向对象基础

面向对象——实例

面向对象的编程思想力图使在计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能地一致。
类（class）和对象（object）就是面向对象方法的核心概念。
类是对某一类事物的描述，它们具有相同的属性和行为，是抽象的、概念上的定义。
对象是实际存在的该类事物的个体，因而也称实例（Instance）。

面向对象的特征

封装

将相关的数据以及对数据的操作结合在一起，保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法。
其有两层含义：

相关的数据及其操作结合在一起，形成一个不可分割的独立单位，即对象。
信息隐蔽，把不需要让外界知道的信息隐藏起来，或只允许使用对象的功能，而尽可能隐蔽对象的内部细节。

继承

首先拥有反映事物一般特性的类，然后在其基础上派生出反映特殊事物的类。被继承的类称为父类或超类，而经继承产生的类称为子类或派生类。根据继承机制，派生类继承了超类的所有成员，并相应地增加了自己的一些新的成员。
面向对象程序设计中的继承机制，大大增强了程序代码的可复用性，提高了软件的开发效率，降低了程序产生错误的可能性，也为程序的修改扩充提供了便利。

多态

多态是允许程序中出现重名现象。多态具体表现为：

方法重载
在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。
同一个类中的多个方法有相同的方法名，不同的参数列表（参数个数不同或者对应位置上的参数类型不同）。
只有返回类型不同不是重载。
成员覆盖
子类与父类允许具有相同的变量名称，数据类型相同，具有相同的方法名称，但完成的功能不同。
若子类中的属性与父类的某一属性同名，则称该属性被覆盖。
在子类中可以通过 super.属性名的方式调用父类中被子类覆盖的属性。
若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数列表，我们说该方法被覆盖。
在子类中可以通过 super.方法(参数列表)的方式调用父类中被子类覆盖的方法。

类

定义

Java 的每一个程序都是由类构成的，函数必须是属于某个类的。在使用类之前，必须先定义它，然后才可利用所定义的类来声明变量，并创建对象。

[类修饰符] class 类名{
    数据类型 属性 ；
    …. 
    数据类型 方法名称（参数 1，参数 2…） {
        程序语句 ；
    }
}

格式

成员变量定义格式：
[修饰符] 类型属性名=[默认值];

成员方法定义格式：

[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…) 
{ 
    方法体 
}

规则：
- 类的修饰符一般为public，也可以没有修饰符。
- 类的成员包含：成员变量（属性）、成员方法（方法）。
- 通过“.”调用其属性和方法

构造方法

class 类名称
{
    访问权限 类名称（类型1 参数1，类型2 参数2，…）
    {
      程序语句 ；
      … // 构造方法没有返回值
    }
}

规则

构造方法名称必须和类名称一致。
构造方法没有返回值。
一个类可有多个构造方法（重载）。
构造方法不能被子类继承。
每个类至少需要一个构造方法，若某个类一个构造方法都未提供，系统将自动提供一个什么也不做（即无参且方法体为空）的默认构造方法。
只要某个类定义了任何一个构造方法，系统不再提供默认构造方法。
不能在构造方法中用return返回一个值。
构造方法只能被new运算符自动调用。

注意：构造方法不含返回值的概念不同于“void”，是指方法名之前不加返回值类型的修饰词；如果在定义构造方法时加上了“void”，这个方法就不再被自动调用了。

访问修饰符

public（公共）
可以在其他任何位置访问，一般用来修饰类、方法和构造器
protected（保护）
修饰的内容可以被同一个包的其他类访问，也可以被不同包中的子类访问，一般用来修饰只开放
给子类使用的属性、方法和构造方法
无访问控制符（默认）
修饰的内容可以被同一个包中的类访问，一般用于修饰一个包内部的功能类
private
修饰的内容是私有的，限制最大，只能在本类中访问，而不能被类外部的任何类访问，一般用来
修饰类的属性或只在本类内部使用的方法

关键字

static

静态变量
用static 关键字声明的成员变量称为“ 静态成员变量”，或者称“ 类变量“，而没有用static声明的成员变量称为“ 实例成员变量”。
访问修饰符 static 数据类型变量名;static只能修饰类的成员变量，不能修饰局部变量。
静态（类）成员变量是它所属类所有对象共享的，不管该类创建了一个对象，还是多个对象，甚至一个对象都没有创建，只要类装载时静态成员变量就已经存在，并且只具有一个静态数据值，因此，它是属于整个类而不是属于某个具体对象。
实例成员变量只有在创建一个对象时才生成该对象的实例成员变量，且不同的对象具有不同的实例成员变量值，即各对象间的实例成员变量值是互相独立的。
静态（类）变量可以通过类名直接访问，也可以通过对象名调用。
静态方法
static关键字修饰的方法为“静态方法”，又叫“类方法”。
访问修饰符 static 返回值类型方法名（参数列表）{……}
静态（类）方法无需实例化就可以调用，可以直接使用类名调用，也可以通过对象名调用。
静态（类）方法不能访问实例变量，只能访问静态（类）变量或静态（类）方法。

this

当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。

this(参数列表)：调用其他构造函数。
this.属性名：调用本对象的属性
this.方法名：调用本对象的方法
this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this

规则

通过this调用另一个构造方法，用法是this(参数列表)。
使用this（参数列表）语句调用其他构造方法时必须放在当前构造方法的第一行。
函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式。在没有同名的情况下，可以直接用成员变量的名字，也可以用this .成员变量名。
在方法中，需要引用该方法所属类的当前对象时候，直接用this。

extends

继承通过关键字extends实现

class 父类 // 定义父类
{
	…
}
class 子类 extends 父类 
// 用 extends 关键字实现类的继承
{
	…
}

super

如果在子类中想要调用父类的属性或方法，可以使用super关键字，super是用来指向当前对象的父对象的引用

super(参数列表)：调用父类的构造函数。
super.属性名：调用子类继承的父类属性
super.方法名：调用子类继承的父类方法

规则

通过super调用父类的构造方法，用法是super (参数列表)。
使用super（参数列表）语句调用父类构造方法时必须放在子类构造方法的第一行。
子类的成员变量和父类成员变量同名的情况下，父类成员变量被屏蔽，此时要访问父类成员变量则需要用“super.成员变量名”的方式来引用父类成员变量。在没有同名的情况下，可以直接用成员变量的名字，也可以用super.成员变量名。
子类对象在实例化时会默认先去调用父类中的构造方法，之后再调用本类中的相应构造方法。
即使没有在子类构造方法中明确使用super（参数列表）调用父类构造方法，系统也会在子类构造方法的第一行隐含一句“super（）；”语句。当明确使用了super（参数列表）调用父类构造方法时，就不会再隐含“super（）；”语句了。

final

在 Java 中声明类、属性和方法时，可使用关键字 final 来修饰。

final 标记的类不能被继承。
final 标记的方法不能被子类复写。
final 标记的变量（成员变量或局部变量）即为常量，只能赋值一次。

abstract

抽象方法

使用关键字abstract修饰的方法叫做抽象方法
abstract 返回值的数据类型方法名称（参数…）；
抽象方法只需声明，而不需实现，不需要写{}

抽象类

使用关键字abstract修饰的类叫做抽象类

abstract class 类名称 // 定义抽象类
{
	声明数据成员;
	abstract 返回值的数据类型 方法名称(参数…);//抽象方法
	访问权限 返回值的数据类型 方法名称(参数…)
	{  //正常方法
    … 
	}
}

抽象类和抽象方法都必须用 abstract 关键字来修饰。
抽象类不能被实例化，也就是不能用 new 关键字去产生对象。
抽象方法只需声明，而不需实现。
抽象类中可以没有抽象方法，但是含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

interface

接口interface的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有以下两点不同：

接口里的数据成员必须初始化，且数据成员均为常量。
接口里的方法必须全部声明为 abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。

interface 接口名称 
{
  final 数据类型 成员名称 = 常量; // 数据成员必须赋初值
  abstract 返回值的数据类型 方法名称(参数…);
  // 抽象方法，注意在抽象方法里，没有定义方法主体，不写｛｝
}

implements

利用接口打造新的类的过程，称之为接口的实现implements

class 类名称 implements 接口 A,接口 B {
  // 可以同时实现多个接口，用逗号隔开
  …
}

子类可以在继承一个父类的同时实现接口

class 子类 extends 父类 implements 接口 A,接口 B // 继承父类，同时实现接口
{
……
}

extends必须放在implements前面。
抽象类和接口都是无法直接实例化的，但可以通过子类对其进行实例化

对象

创建对象

语法格式
类名对象名 = new 构造器
示例
Employee zhang = new Employee()

对象名实际是指向对象的一个引用，而引用和它所指的对象是两个不同的实体。

访问对象

语法格式
- 访问属性：对象名称.属性名；
- 访问方法：对象名称.方法名()；
示例:
- Employee p=new Employee();
- p.name; 访问对象p的name属性
- p.sayHello();调用对象p的sayHello方法

比较对象

==
比较的是两个操作数的值是否相等，当操作数是对象时比较的是两个变量在堆中存储的地址是否相同
equals()
比较的是两个对象的内容是否相同。

对象回收

对象名 = null；
通过将对象名指向null可以断开引用与对象之间的联系，当没有任何引用变量指向某个对象时，这个对象就成为无用对象。
Java虚拟机会自动地检测出那些不再使用的对象并自动地释放它们所占用的内存空间，这一功能是由Java虚拟机中的一个称为垃圾收集器（Garbage Collector ）的程序模块来完成的。

第四讲常用类库介绍

String类

String类作为字符串的标准格式，是Java中最常用的字符串操作类。String 类对象的内容一旦被初始化就不能再改变。通常用来操作内容固定的字符串。

创建

String str1 = "Hello,dareway!";
 // 静态赋值，在常量池创建
String str2 = new String("Hello,dareway!");
// 动态赋值，在堆区创建

字符串连接

1 2	String str3 = "I am " + name + "!"; String str4 = str1 + str3;

查看字符串长度

1	str.length();

字符串比较

s1.equals(s2) //如果s1等于s2，返回true，否则为false。
s1.equalsIgnoreCase(s2) //忽略大小写,如果s1等于s2，返回true，否则为false。
s1.compareTo(s2) //如果s1<s2，返回小于0；如果s1=s2，返回0；如果s1>s2，返回大于0。
s1.compareToIgnoreCase (s2) //忽略大小写,如果s1<s2，返回小于0；如果s1=s2，返回0；如果s1>s2，返回大于0。

查找字符或子串

indexOf(); lastIndexOf();
返回值int型，找不到返回-1

String s1 = "Hello,dareway!";
String s2  = "da";		
System.out.println(s1. indexOf ('e'));	
//返回s1中字符e在字符串中第一次出现的位置。
System.out.println(s1. indexOf (s2));	
//返回s2在s1中第一次出现的位置。
System.out.println(s1. lastIndexOf (‘e’));	
//返回字符e在s1中最后一次出现的位置。
System.out.println(s1. lastIndexOf (s2));		
//返回s1中字符char在字符串中最后一次出现的位置。

提取字符或子串

charAt();提取单个字符
substring();提取子串

String s1 = "Hello,dareway!";
System.out.println(s1.charAt(5));	
//返回s1中第6个字符。其中，index是下标号，从0开始。
System.out.println(s1.substring(6));	
//截取s1中下标从6开始的所有字符。
System.out.println(s1.substring(6,10));	
//截取s1中下标从6到10的所有字符，不包含10 。

过滤首尾空格

trim()

1 2	String s1 = " Hello,dareway! "; System.out.println(s1.trim()); // 输出Hello,dareway

大小写转换

toLowerCase();转换小写
toUpperCase();转换大写

1 2	System.out.println(s1.toLowerCase());//小写 System.out.println(s1.toUpperCase());//大写

StringBuffer类

StringBuffer对象可以方便地在缓冲区内被修改，如增加、替换字符或子串，适合于处理可变字符串。当完成缓冲字符串数据操作后，可以通过调用其方法StringBuffer.toString( )或String构造器把它们有效地转换回标准字符串格式。

创建

1 2	StringBuffer strbuf= new StringBuffer(); StringBuffer strbuf= new StringBuffer(“abc”);

常用方法

append(String str);//在字符串末尾添加内容
toString();//转换为不变字符串
length();//获取字符串的长度:
setLength(int len);//设置字符串缓冲区的大小
insert(int offset, String str),在offset位置插入字符串。
delete(int start,int end)//删除指定字符串中的字符
substring(int start) //返回从start下标开始以后的字符串
substring(int start,int end) //返回从start到 end-1字符串

包装类

Java 对数据既提供基本数据的简单类型，也提供了相应的包装类。基本数据类型和相应包装类的对应关系如下：

基本数据类型	包装类
boolean	Boolean
byte	Byte
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double

基本数据
包装类对象 = new 包装类(基本数据/String);
包装类对象 = 包装类.valueOf(基本数据/String);
Character类只能根据基本数据得到包装类对象

得到基本数据
包装类对象.xxxValue(); 转换成相应类型
包装类.parseXxx(String); 转换成原始类型
得到字符串
String s1 = int c.toString();
String s2 = Integer.toString(10);
比较
obj1.equals(obj2);相同或者不同包装类对象比较
obj1.compareTo(obj2);同一包装类对象比较

ArrayList

创建方法

ArrayList表示大小可变的数组，可以动态的增加和减少元素。
创建对象的方法如下：

1
2
3

ArrayList list1 = new ArrayList();
ArrayList<String> list2 = new ArrayList<String>();
ArrayList<Integer> list3 = new ArrayList<Integer>();

常用方法

add(element) //添加一个元素到当前列表的末尾
addAll(Collection)//添加一组元素到当前列表的末尾
remove(int) //移除指定位置的元素
size() //查看列表长度
get(int) //获取指定下标的元素
set(int , element) //设置指定下标的元素
contains(Object) //查找某个对象在不在列表之中
toArray()//把ArrayList的元素复制到一个新的数组中

HashMap

创建方法

基于哈希表的 Map 接口的实现。通过“键-值”对（key-value）访问，并允许使用 null 值和 null 键。创建对象的方法如下：

1	HashMap<String,String>map = new HashMap<String,String>();

常用方法

put(key,value) //添加一组键值对到map中
get(key)//获取key对应的value
isEmpty () //是否为空
containsKey(key) //查找某个对象在不在map之中
size() //获取map元素数量
keySet() //获取所有key列表
values() //获取所有values列表

第五讲断点调试

断点调试

设置断点
单步运行

应用场景分析

查看控制台报错
分析控制台报错
断点跟踪

第六讲 Java异常处理

异常

运行期间出现的错误，而不是编译时的语法错误。

打开一个不存在的文件。
网络连接中断。
操作数组越界等。
…

抛出(throw)异常

在Java程序执行过程中如果出现异常事件，
系统会发出异常报告，
这时系统将生成一个异常类对象，
异常类对象封装了异常事件的信息并将其提交给Java运行时系统，
运行时系统寻找相应的代码来处理这一异常,
这一过程称为抛出(throw)异常。

捕获(catch)异常

当Java运行时系统得到一个异常对象时，
它将会沿着方法的调用栈逐层回溯，
寻找处理这一异常的代码。
找到能够处理这种类型的异常的方法后，
运行时系统把当前异常对象交给这个方法进行处理，
这一过程称为捕获(catch)异常。

继承关系

Java通过面向对象的方法来处理程序异常
不同异常有不同的分类
但所有的异常类都直接或间接地继承于java.lang.Throwable类。
当Java程序出现意外时，会实例化一个从Throwable类继承的对象。

异常继承关系

Error类

错误Error类指的是系统错误或运行环境出现的错误，这些错误一般是很严重的错误，即使捕捉到也无法处理，由Java虚拟机生成并抛出，包括系统崩溃、虚拟机错误等，在Java程序中不做处理。

Error名称	产生原因
Out Of Memory Error	内存不足
Stack Overflow Error	堆栈溢出
Unkonw Error	未知错误

Exception类

异常Exception类则是指一些可以被捕获且可能恢复的异常情况，是一般程序中可预知的问题。对于异常又可分为两类：

运行时异常

Java虚拟机在运行时生成的例外，由系统检测, 用户可不做处理，系统将它们交给缺省的异常处理程序。

非检查性异常	说明
Runtime Exception	java.lang包中多数异常的基类
Arithmetic Exception	算数错误，如除以0
IIIlegal Argumen Exception	方法收到非法参数
Arraylndex Out Of Bounds Exception	数组下标出界
Null Pointer Exception	试图访问null对象引用

非运行时异常

一般程序中可预知的问题，其产生的例外可能会带来意想不到的结果，因此Java编译器要求Java程序必须捕获或声明所有的非运行时异常。

检查性异常	说明
Clsss Not Found Exception	无法找到想要创建对象的类文件
IOException	I/O异常的根类
File Not Found Exception	不能找到文件
EOFException	文件结束
IIIlegal Argumen Exception	对类的访问被拒绝
No Such Method Exception	请求的方法不存在
Interrupted Exception	线程中断

异常处理

try{
  //接受监视的程序块,在此区域内发生的异常,由catch中指定的程序处理
}catch(MyException e){
  //处理异常
}catch(Exception e){
  //处理异常
}
…
}finally{
  //最终处理（可选）
}

try…catch语句

try{…}选定捕获异常的范围；每个try代码块可以伴随一个或多个catch语句。
catch语句只需要一个形式参数指明它所能够捕获的异常类型，这个类必须是Throwable的子类。
在catch块中是对异常对象进行处理的代码。
捕获异常的顺序和catch语句的顺序有关，一旦捕获到一个异常，剩下的catch语句就不再进行匹配。由于所有的子类实例都可以使用父类接收，因此在安排catch语句的顺序时，首先应该捕获最特殊的异常（范围小），然后再逐渐一般化（范围大）。也就是一般先安排子类，再安排父类。

finally语句

finally语句放在try …catch语句后。
fianlly语句中的代码块不管异常是否被捕获总是要执行。
通常在finally语句中可以进行资源的清除操作，如：关闭打开文件、删除临时文件。
对应finally代码中的语句，即使try代码块和catch代码块中使用了return语句退出当前方法或break跳出某个循环，相关的finally代码块也会执行。
当try或catch代码块中执行了System.exit(0)时，finally代码块中的内容不被执行

不要在finally中试图return一个值，这样可能会导致一些意想不到的逻辑错误，finally仅用来释放资源的！

throws语句

如果一个方法中的语句执行时可能生成某种异常，
但是并不能确定如何处理，
则可以在程序所在的函数声明后，
使用throws关键字回避异常，
通知潜在调用者，如果发生了异常，必须由调用者处理。

[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…)  throws 异常类
 { 
    方法体 
}

规则：
位置：函数参数列表的后面。
throws关键字后面，可以跟多个异常，中间用逗号分割
throws关键字抛出的异常，由调用该函数的函数处理

throw语句

可以在程序中抛出明确的异常，使用 throw 这个关键字。
throw 异常类实例对象;

规则：
throw语句用在方法体内,表示抛出异常,由方法体内的语句处理。
throw语句不能单独使用，要么和try.. catch…一起使用，要么和throws一起使用。
throw语句的操作数一定是Throwable类类型或Throwable子类类型的一个对象。

第一讲 认识Java

Java的主要特点

Java安装与配置

环境变量

测试配置

Java开发过程

Java开发的基本规则

第二讲 Java语言概述

Java语言基本元素

1. 标识符

2. 关键字

3. 变量

4. 常量

5. 数据类型

6.运算符

7.代码注释

控制语句

顺序结构

选择结构

循环结构

关键词

程序结构

包

类

大括号、段、主体

方法

一维数组

声明数组

创建数组

数组初始化

数组访问

多维数组

声明数组

创建数组

数组初始化

第三讲 面向对象基础

面向对象——实例

面向对象的特征

封装

继承

多态

类

定义

格式

构造方法

访问修饰符

关键字

static

this

extends

super

final

abstract

抽象方法

抽象类

interface

implements

对象

创建对象

访问对象

比较对象

对象回收

第四讲 常用类库介绍

String类

创建

字符串连接

查看字符串长度

字符串比较

查找字符或子串

提取字符或子串

过滤首尾空格

大小写转换

StringBuffer类

创建

常用方法

包装类

ArrayList

创建方法

常用方法

HashMap

第一讲认识Java

第三讲面向对象基础

第四讲常用类库介绍

第五讲断点调试