java基础
01 前言
第一个Java程序 HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
//String args[] 与 String[] args 都可以执行
//推荐使用 String[] args可以避免歧义和误读
命令行执行
$ javac HelloWorld.java //将java源文件编译为class字节码文件
//出现一个HelloWorld.class的文件
$ java HelloWorld //java文件中的类名
Hello World
特性
- 简单：语法与C语言和C++语言很接近 不使用指针 而是引用 提供自动废料收集
- 面向对象：提供类、接口和继承等面向对象的特性
- 分布式：
- 健壮：
- 安全：
- 体系结构中立：
- 可移植：
- 解释型：
- 高性能：运行速度随着JIT(Just-In-Time）编译器技术的发展越来越接近于C++。
- 多线程：
- 动态的：
开发工具
- Linux 系统、Mac OS 系统、Windows 95/98/2000/XP，WIN 7/8系统。
- Java JDK 7、8……
- Notepad 编辑器或者其他编辑器。
- IDE：Eclipse
基本语法特点
- 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的
- 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass
- 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写
- 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）
- 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行
标识符：类名、变量名以及方法名都被称为标识符
- 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
- 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
- 关键字不能用作标识符
- 标识符是大小写敏感的
- 合法标识符举例：age、$salary、_value、__1_value
- 非法标识符举例：123abc、-salary
修饰符：修饰类中方法和属性 主要有两类修饰符
- 访问控制修饰符 : default, public , protected, private
- 非访问控制修饰符 : final, abstract, static, synchronized
变量
- 局部变量
- 类变量（静态变量）
- 成员变量（非静态变量）
数组：储存在堆上的对象
枚举：枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug
// eg:限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String[] args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
}
}
关键字：不能用于常量、变量、和任何标识符的名称
访问控制
| 关键词 | 含义 |
|---|---|
| private | 私有的 |
| protected | 受保护的 |
| public | 公共的 |
| default | 默认 |
类、方法和变量修饰符
| 关键词 | 含义 |
|---|---|
| abstract | 声明抽象 |
| class | 类 |
| extends | 扩充,继承 |
| final | 最终值,不可改变的 |
| implements | 实现（接口） |
| interface | 接口 |
| native | 本地，原生方法（非 Java 实现） |
| new | 新,创建 |
| static | 静态 |
| strictfp | 严格,精准 |
| synchronized | 线程,同步 |
| transient | 短暂 |
| volatile | 易失 |
程序控制语句
| 关键词 | 含义 |
|---|---|
| break | 跳出循环 |
| case | 定义一个值以供 switch 选择 |
| continue | 继续 |
| default | 默认 |
| do | 运行 |
| else | 否则 |
| for | 循环 |
| if | 如果 |
| instanceof | 实例 |
| return | 返回 |
| switch | 根据值选择执行 |
| while | 循环 |
错误处理
| 关键词 | 含义 |
|---|---|
| assert | 断言表达式是否为真 |
| catch | 捕捉异常 |
| finally | 有没有异常都执行 |
| throw | 抛出一个异常对象 |
| throws | 声明一个异常可能被抛出 |
| try | 捕获异常 |
包相关
| 关键词 | 含义 |
|---|---|
| import | 引入 |
| package | 包 |
基本类型
| 关键词 | 含义 |
|---|---|
| boolean | 布尔型 |
| byte | 字节型 |
| char | 字符型 |
| double | 双精度浮点 |
| float | 单精度浮点 |
| int | 整型 |
| long | 长整型 |
| short | 短整型 |
变量引用
| 关键词 | 含义 |
|---|---|
| super | 父类,超类 |
| this | 本类 |
| void | 无返回值 |
保留关键字
| 关键词 | 含义 |
|---|---|
| goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 |
| null | 空 |
注释：单行 多行
eg // /* */
public class HelloWorld {
/* 这是第一个Java程序
*它将打印Hello World
* 这是一个多行注释的示例
*/
public static void main(String[] args){
// 这是单行注释的示例
/* 这个也是单行注释的示例 */
System.out.println("Hello World");
}
}
空行：空白行或者有注释的行，Java 编译器都会忽略掉。
继承：被继承的类称为超类（super class），派生类称为子类（subclass）
接口
在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类
02 对象和类
面向对象的语言： 多态 继承 封装 抽象 类 对象 实例 方法 重载
- 对象：对象是类的一个实例 有状态和行为 软件对象的状态就是属性，行为通过方法体现 ;一条狗是一个对象 它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等
- 类：类是一个模板，它描述一类对象的行为和状态
一个类可以包含以下类型变量：
- 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都>* 是在方法中，方法结束后，变量就会自动销毁。
- 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型
03 基本数据类型
- 变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间
- 内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据
Java 的两大数据类型:
- 内置数据类型：
八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型- byte
- short
- int
- long
- float
- double
- boolean
- char
类型默认值
| 关键词 | 含义 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | ‘u0000’ |
| String (or any object) | null |
| boolean | false |
引用数据类型
- 对象、数组都是引用数据类型。
- 所有引用类型的默认值都是null。
- 一个引用变量可以用来引用任何与之兼容的类型。
- 例子：Site site = new Site(“Runoob”)。
常量：在程序中不能被修改
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：
final double PI = 3.1415927;
##自动类型转换
自动类型转换
强制类型转换
隐含强制类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级 byte,short,char—> int —> long—> float —> double
数据类型转换必须满足如下规则：
- 不能对boolean类型进行类型转换。
- 不能把对象类型转换成不相关类的对象。
- 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
- 转换过程中可能导致溢出或损失精度
变量类型
##类变量：独立于方法之外的变量，用 static 修饰。
##实例变量：独立于方法之外的变量，不过没有 static 修饰。
##局部变量：类的方法中的变量。
修饰符
##访问修饰符
#default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
#private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
#public : 对所有类可见。使用对象：类、接口、变量、方法
#protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
##非访问修饰符
#static 修饰符，用来修饰类方法和类变量
// 静态变量
// 静态方法
#final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的
// final变量
// final方法
// final类
#abstract 修饰符，用来创建抽象类和抽象方法
// 抽象方法
// 抽象类
#synchronized 修饰符
#transient 修饰符
#volatile 修饰符，主要用于线程的编程
运算符
算术运算符
| 符号 | 名称 | 含义 | 例子 |
|---|---|---|---|
| + | 加法 | 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 | 左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法 | 相乘操作符两侧的值 | A * B等于200 |
| / | 除法 | 左操作数除以右操作数 | B / A等于2 |
| ％ | 取余 | 左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增 | 操作数的值增加1 | B++ 或 ++B 等于 21（区别详见下文） |
| – | 自减 | 操作数的值减少1 | B-- 或 --B 等于 19（区别详见下文） |
自增自减运算符
自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
- 前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算
- 后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算
关系运算符
| 符号 | 含义 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真 |
位运算符
| 符号 | 含义 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| 如果相对应位都是 0，则结果为 0，否则为 1 | （A | |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
逻辑运算符
| 符号 | 含义 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 ！ | （A && B）为真 |
短路逻辑运算符
当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了
赋值运算符
| 符号 | 含义 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| = | 按位或赋值操作符 | C |
其他运算符
条件运算符（?:）
instanceof 运算符
Java运算符优先级
循环结构
##while 循环
基本结构
while( 布尔表达式 ) {
//循环内容
}
实例
public class Test {
public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n"); // 换行
}
}
}
##do…while 循环
#基本结构/*
do {
//代码语句
}while(布尔表达式);
*/
#实例/*
public class Test {
public static void main(String args[]){
int x = 10;
do{
System.out.print("value of x : " + x );
x++;
System.out.print("\n"); // 换行
}while( x < 20 );
}
}
##for 循环
#基本结构/*
for(初始化; 布尔表达式; 更新) {
//代码语句
}
*/
#实例/*
public class Test {
public static void main(String args[]) {
for(int x = 10; x < 20; x = x+1) {
System.out.print("value of x : " + x );
System.out.print("\n"); // 换行
}
}
}
#运行结果
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
##break 关键字
##continue 关键字
#实例
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}
#输出
10
20
40
50
条件语句
#if…else
#基本结构
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
#实例/*
public class Test {
public static void main(String args[]){
int x = 30;
if( x < 20 ){
System.out.print("这是 if 语句");
}else{
System.out.print("这是 else 语句");
}
}
}
#if…else if…else 语句
#嵌套的 if…else 语句
#基本结构/*
*/
switch case
// switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
#基本结构/*
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
#switch case 语句有如下规则：
// switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
// switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
// case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
// 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
// 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
// switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
Number & Math 类
Character 类
String 类
##创建字符串
##字符串长度
##连接字符串
##创建格式化字符串
##String 方法
StringBuffer
数组
##声明数组变量
##创建数组
##处理数组
##For-Each循环
##数组作为函数的参数
##数组作为函数的返回值
##多维数组
#多维数组的动态初始化（以二维数组为例）
#多维数组的引用（以二维数组为例）
##Arrays 类
// java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
// 给数组赋值：通过 fill 方法。
// 对数组排序：通过 sort 方法,按升序。
// 比较数组：通过 equals 方法比较数组中元素值是否相等。
// 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
#public static int binarySearch(Object[] a, Object key)
// 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
#public static boolean equals(long[] a, long[] a2)
// 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
#public static void fill(int[] a, int val)
// 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
#public static void sort(Object[] a)
// 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
日期时间
// java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
#boolean after(Date date)
// 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
#boolean before(Date date)
// 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
#Object clone( )
// 返回此对象的副本。
#int compareTo(Date date)
// 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
#int compareTo(Object obj)
// 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
#boolean equals(Object date)
// 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
#long getTime( )
// 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
#int hashCode( )
// 返回此对象的哈希码值。
#void setTime(long time)
// 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
#String toString( )
// 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。
##获取当前日期时间
##日期比较
##使用 SimpleDateFormat 格式化日期
##日期和时间的格式化编码
##使用printf格式化日期
##解析字符串为时间
##Java 休眠(sleep)
##测量时间
##Calendar类
#创建一个代表系统当前日期的Calendar对象
#创建一个指定日期的Calendar对象
#Calendar类对象字段类型
#Calendar类对象信息的设置
// Set设置
// Add设置
#Calendar类对象信息的获得
##GregorianCalendar类
| 正则 | 匹配 |
|---|---|
| #GregorianCalendar() | 在具有默认语言环境的默认时区内使用当前时间构造一个默认的 GregorianCalendar |
| #GregorianCalendar(int year, int month, int date) | 在具有默认语言环境的默认时区内构造一个带有给定日期设置的 GregorianCalendar |
| #GregorianCalendar(int year, int month, int date, int hour, int minute) | 为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的 GregorianCalendar |
| #GregorianCalendar(int year, int month, int date, int hour, int minute, int second) | 为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的 GregorianCalendar |
| #GregorianCalendar(Locale aLocale) | 在具有给定语言环境的默认时区内构造一个基于当前时间的 GregorianCalendar |
| #GregorianCalendar(TimeZone zone) | 在具有默认语言环境的给定时区内构造一个基于当前时间的 GregorianCalendar |
| #GregorianCalendar(TimeZone zone, Locale aLocale) | 在具有给定语言环境的给定时区内构造一个基于当前时间的 GregorianCalendar |
正则表达式
- 正则表达式定义了字符串的模式。
- 正则表达式可以用来搜索、编辑或处理文本。
- 正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。
- Java 正则表达式和 Perl 的是最为相似的。
java.util.regex 包主要包括以下三个类
- Pattern 类：
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。- Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。- PatternSyntaxException：
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
| 正则 | 匹配 |
|---|---|
| \ | 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n"匹配字符"n”。"\n"匹配换行符。序列"\\“匹配”\"，"\(“匹配”("。 |
| ^ | 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。 |
| $ | 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。 |
| * | 零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。 |
| + | 一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。 |
| ? | 零次或一次匹配前面的字符或子表达式。例如，"do(es)?“匹配"do"或"does"中的"do”。? 等效于 {0,1}。 |
| {n} | n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。 |
| {n,} | n 是非负整数。至少匹配 n 次。例如，"o{2,}“不匹配"Bob"中的"o”，而匹配"foooood"中的所有 o。"o{1,}“等效于"o+”。"o{0,}“等效于"o*”。 |
| {n,m} | m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。‘o{0,1}’ 等效于 ‘o?’。注意：您不能将空格插入逗号和数字之间。 |
| ? | 此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?“只匹配单个"o”，而"o+“匹配所有"o”。 |
| . | 配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。 |
| (pattern) | 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"(“或者”)"。 |
| (?:pattern) | 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 ( |
| (?=pattern) | 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95 |
| (?!pattern) | 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95 |
| x | y |
| [xyz] | 字符集。匹配包含的任一字符。例如，"[abc]“匹配"plain"中的"a”。 |
| [^xyz] | 反向字符集。匹配未包含的任何字符。例如，"[^abc]“匹配"plain"中"p”，“l”，“i”，“n”。 |
| [a-z] | 字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。 |
| [^a-z] | 向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。 |
| \b | 匹配一个字边界，即字与空格间的位置。例如，“er\b"匹配"never"中的"er”，但不匹配"verb"中的"er"。 |
| \B | 非字边界匹配。“er\B"匹配"verb"中的"er”，但不匹配"never"中的"er"。 |
| \cx | 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。 |
| \d | 数字字符匹配。等效于 [0-9]。 |
| \D | 非数字字符匹配。等效于 [^0-9]。 |
| \f | 换页符匹配。等效于 \x0c 和 \cL。 |
| \n | 换行符匹配。等效于 \x0a 和 \cJ。 |
| \r | 匹配一个回车符。等效于 \x0d 和 \cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。 |
| \S | 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。 |
| \t | 制表符匹配。与 \x09 和 \cI 等效。 |
| \v | 垂直制表符匹配。与 \x0b 和 \cK 等效。 |
| \w | 匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。 |
| \W | 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。 |
| \xn | 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。 |
| \num | 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。 |
| \n | 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。 |
| \nm | 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。 如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。 |
| \nml | 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。 |
| \un | 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。 |
方法
System.out.println()
##方法定义/*
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
*/
- 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行>* 所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 方法体：方法体包含具体的语句，定义该方法的功能。
##方法调用
##void 关键字
##通过值传递参数
##方法的重载
##变量作用域
##命令行参数的使用
##构造方法
##可变参数
##finalize() 方法
Stream、File、IO
Scanner 类
异常处理
Exception 类的层次
异常方法
| 异常方法 | 返回值 |
|---|---|
| #public String getMessage() | 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 |
| #public Throwable getCause() | 返回一个Throwable 对象代表异常原因。 |
| #public String toString() | 使用getMessage()的结果返回类的串级名字。 |
| #public void printStackTrace() | 打印toString()结果和栈层次到System.err，即错误输出流。 |
| #public StackTraceElement [] getStackTrace() | 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。 |
| #public Throwable fillInStackTrace() | 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。 |
捕获异常
#基本语法/*
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
*/
多重捕获块
throws/throw 关键字
finally关键字
#基本语法/*
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
*/
声明自定义异常
通用异常
- JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
- 程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。