JavaSE笔记
2021-08-28 22:34:55 0 举报AI智能生成
JavaSE笔记
作者其他创作
大纲/内容
条件语句
if...else语句
if...else if...else 语句
嵌套的 if…else 语句
Java Number & Math 类
Math类
示例
类方法
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类
Character类
Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值
Character 类在对象中包装一个基本类型 char 的值
在某些情况下，Java编译器会自动创建一个Character对象。
例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
示例
转义序列
转义序列 描述
\t 在文中该处插入一个tab键
\b 在文中该处插入一个后退键
\n 在文中该处换行
\r 在文中该处插入回车
\f 在文中该处插入换页符
\' 在文中该处插入单引号
\" 在文中该处插入双引号
\\ 在文中该处插入反斜杠
\t 在文中该处插入一个tab键
\b 在文中该处插入一个后退键
\n 在文中该处换行
\r 在文中该处插入回车
\f 在文中该处插入换页符
\' 在文中该处插入单引号
\" 在文中该处插入双引号
\\ 在文中该处插入反斜杠
方法
序号 方法与描述
1 isLetter()
是否是一个字母
2 isDigit()
是否是一个数字字符
3 isWhitespace()
是否是一个空白字符
4 isUpperCase()
是否是大写字母
5 isLowerCase()
是否是小写字母
6 toUpperCase()
指定字母的大写形式
7 toLowerCase()
指定字母的小写形式
8 toString()
返回字符的字符串形式，字符串的长度仅为1
1 isLetter()
是否是一个字母
2 isDigit()
是否是一个数字字符
3 isWhitespace()
是否是一个空白字符
4 isUpperCase()
是否是大写字母
5 isLowerCase()
是否是小写字母
6 toUpperCase()
指定字母的大写形式
7 toLowerCase()
指定字母的小写形式
8 toString()
返回字符的字符串形式，字符串的长度仅为1
String类
创建字符串
示例
字符串长度
示例
连接字符串
示例
创建格式化字符串
示例
方法
StringBuffer和StringBuilder类
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
示例
然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
示例
方法
数组
声明数组变量
dataType[] arrayRefVar; // 首选的方法
dataType arrayRefVar[]; // 效果相同，但不是首选方法
dataType arrayRefVar[]; // 效果相同，但不是首选方法
创建数组
arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。
示例
数组作为函数的参数
示例
数组作为函数的返回值
示例
多维数组
Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
具有以下功能：
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
方法
正则表达式
正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。
正则表达式可以用来搜索、编辑或处理文本。
示例
捕获组
start 和 end 方法
matches 和 lookingAt 方法
replaceFirst 和 replaceAll 方法
appendReplacement 和 appendTail 方法
Java方法
方法调用
通过值传递参数
方法的重载
变量作用域
命令行参数的使用
构造方法
可变参数
finalize() 方法
Java 流(Stream)、文件(File)和IO
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
从控制台读取多字符输入
示例
从控制台读取字符串
示例
控制台输出
示例
IO流
字符流
Reader
BufferedReader
InputStreamReader
FileReader
StringReader
PipedReader
CharArrayReader
FilterReader
PushbackReader
Writer
BufferedWriter
OutputStreamWriter
FileWriter
PrinterWriter
StringWriter
PipedWriter
CharArrayWriter
FilterWriter
字节流
InputStream
FileInputStream
public void close() throws IOException{}
关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
protected void finalize()throws IOException {}
这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
public int read(int r)throws IOException{}
这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。
这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。
public int read(byte[] r) throws IOException{}
这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。
这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。
public int available() throws IOException{}
返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。
返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。
FilterInputStream
BufferedInputStream
DataInputStream
public final int read(byte[] r, int off, int len)throws IOException
从所包含的输入流中将 len 个字节读入一个字节数组中。如果len为-1，则返回已读字节数。
从所包含的输入流中将 len 个字节读入一个字节数组中。如果len为-1，则返回已读字节数。
Public final int read(byte [] b)throws IOException
从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
public final Boolean readBooolean()throws IOException,
public final byte readByte()throws IOException,
public final short readShort()throws IOException
public final Int readInt()throws IOException
从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
public final byte readByte()throws IOException,
public final short readShort()throws IOException
public final Int readInt()throws IOException
从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
public String readLine() throws IOException
从输入流中读取下一文本行。
从输入流中读取下一文本行。
PushbackInputStream
ObjectInputStream
PipedInputStream
SequenceInputStream
StringBufferInputStream
ByteArrayInputStream
public int read()
从此输入流中读取下一个数据字节。
从此输入流中读取下一个数据字节。
public int read(byte[] r, int off, int len)
将最多 len 个数据字节从此输入流读入字节数组。
将最多 len 个数据字节从此输入流读入字节数组。
public int available()
返回可不发生阻塞地从此输入流读取的字节数。
返回可不发生阻塞地从此输入流读取的字节数。
public void mark(int read)
设置流中的当前标记位置。
设置流中的当前标记位置。
public long skip(long n)
从此输入流中跳过 n 个输入字节。
从此输入流中跳过 n 个输入字节。
OutputStream
FileOutputStream
public void close() throws IOException{}
关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
protected void finalize()throws IOException {}
这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
public void write(int w)throws IOException{}
这个方法把指定的字节写到输出流中。
这个方法把指定的字节写到输出流中。
public void write(byte[] w)
把指定数组中w.length长度的字节写到OutputStream中。
把指定数组中w.length长度的字节写到OutputStream中。
FilterOutputStream
BufferedOutputStream
DataOutputStream
PrintStream
ObjectOutputStream
PipedOutputStream
ByteArrayOutputStream
public void reset()
将此字节数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。
将此字节数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。
public byte[] toByteArray()
创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。
创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。
public String toString()
将缓冲区的内容转换为字符串，根据平台的默认字符编码将字节转换成字符。
将缓冲区的内容转换为字符串，根据平台的默认字符编码将字节转换成字符。
public void write(int w)
将指定的字节写入此字节数组输出流。
将指定的字节写入此字节数组输出流。
public void write(byte []b, int off, int len)
将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
public void writeTo(OutputStream outSt)
将此字节数组输出流的全部内容写入到指定的输出流参数中。
将此字节数组输出流的全部内容写入到指定的输出流参数中。
File类
Java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。
File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。
File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。
示例
基础语法
概念
对象
对象是类的一个实例，有状态和行为
类
类是一个模版，它描述一类对象的行为和状态
方法
方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的
实例变量
每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定
基本语法
大小写敏感
类名
对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写
方法名
所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写
源文件名
源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口
所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
注意事项
所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
修饰符
访问控制修饰符
default
(即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
public
对所有类可见。使用对象：类、接口、变量、方法
protected
对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
private
在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
非访问控制修饰符
static
静态变量
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据
final
final 变量
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法
父类中的 final 方法可以被子类继承，但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
声明 final 方法的主要目的是防止该方法的内容被修改。
final 类
final 类不能被继承，没有类能够继承 final 类的任何特性。
abstract
抽象类
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
实例
抽象方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。
实例
synchronized
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
transient
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
实例
volatile
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。
一个 volatile 对象引用可能是 null。
实例
Java变量
局部变量
类变量（静态变量）
成员变量（非静态变量）
Java数组
数组是存储在堆上的对象，可以保存对歌同类型变量
Java枚举
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 ;
}
}
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 ;
}
}
Java关键字
保留字不能用于常量、变量、和任何标识符
Java空行
空白行或者有注释的行，Java编译器都会忽略掉
继承
在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
接口
在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
对象和类
基础概念
分装
继承
多态
抽象
类
变量
局部变量
类的方法中的变量
成员变量
独立于方法之外的变量，不过没有static修饰
类变量
独立于方法之外的变量，用static修饰
对象
对象是类的一个实例，有状态和行为
实例
方法
重载
构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
public class Puppy{
public Puppy(){
}
public Puppy(String name){
// 这个构造器仅有一个参数：name
}
}
public Puppy(){
}
public Puppy(String name){
// 这个构造器仅有一个参数：name
}
}
创建对象
对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。
创建对象的步骤
声明
声明一个对象，包括对象名称和对象类型。
实例化
使用关键字 new 来创建一个对象。
初始化
使用 new 创建对象时，会调用构造方法初始化对象。
访问实例变量和方法
/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();
public class Puppy{
int puppyAge;
public Puppy(String name){
// 这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public void setAge( int age ){
puppyAge = age;
}
public int getAge( ){
System.out.println("小狗的年龄为 : " + puppyAge );
return puppyAge;
}
public static void main(String[] args){
/* 创建对象 */
Puppy myPuppy = new Puppy( "tommy" );
/* 通过方法来设定age */
myPuppy.setAge( 2 );
/* 调用另一个方法获取age */
myPuppy.getAge( );
/*你也可以像下面这样访问成员变量 */
System.out.println("变量值 : " + myPuppy.puppyAge );
}
}
int puppyAge;
public Puppy(String name){
// 这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public void setAge( int age ){
puppyAge = age;
}
public int getAge( ){
System.out.println("小狗的年龄为 : " + puppyAge );
return puppyAge;
}
public static void main(String[] args){
/* 创建对象 */
Puppy myPuppy = new Puppy( "tommy" );
/* 通过方法来设定age */
myPuppy.setAge( 2 );
/* 调用另一个方法获取age */
myPuppy.getAge( );
/*你也可以像下面这样访问成员变量 */
System.out.println("变量值 : " + myPuppy.puppyAge );
}
}
Java 包
包主要用来对类和接口进行分类。
import 语句
在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
import java.io.*;
示例
循环结构
while 循环
只要布尔表达式为 true，循环就会一直执行下去。
示例
do…while 循环
对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
示例
for循环
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。
示例
Java 增强 for 循环
示例
break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
示例
continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
示例
switch case
示例
日期时间
java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
Date()
第一个构造函数使用当前日期和时间来初始化对象。
Date(long millisec)
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。
方法
获取当前日期时间
示例
日期比较
Java使用以下三种方法来比较两个日期：
使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
使用 SimpleDateFormat 格式化日期
示例
使用printf格式化日期
示例
解析字符串为时间
示例
Java 休眠(sleep)
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。
示例
测量时间
示例
Calendar类
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象
Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Calendar对象
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Calendar类对象字段类型
Calendar类对象信息的设置
Set设置
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12
c1.set(2009, 6, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12
c1.set(Calendar.DATE,10);//把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.YEAR,2008);//把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算
Add设置
Calendar c1 = Calendar.getInstance();
把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);
把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);
Calendar类对象信息的获得
Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);
GregorianCalendar类
Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。
Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。
Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。
示例
基本数据类型
byte
byte 数据类型是8位、有符号的，以二进制补码表示的整数
最小值：-128（-2^7）
最大值：127（2^7-1）
默认值：0
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一
例子：byte a = 100，byte b = -50
short
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）
最大值是 32767（2^15 - 1）
short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一
默认值：0
例子：short s = 1000，short r = -20000
int
int 数据类型是32位、有符号的以二进制补码表示的整数
最小值是 -2,147,483,648（-2^31）
最大值是 2,147,483,647（2^31 - 1）
一般地整型变量默认为 int 类型
默认值是 0
例子：int a = 100000, int b = -200000
long
long 数据类型是 64 位、有符号的以二进制补码表示的整数
最小值是 -9,223,372,036,854,775,808（-2^63）
最大值是 9,223,372,036,854,775,807（2^63 -1）
默认值是 0L
例子： long a = 100000L，Long b = -200000L
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写
float
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数
默认值是 0.0f
浮点数不能用来表示精确的值，如货币
例子：float f1 = 234.5f
double
double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数
浮点数的默认类型为 double 类型
double类型同样不能表示精确的值，如货币
默认值是 0.0d
boolean
boolean数据类型表示一位的信息
只有两个取值：true 和 false
这种类型只作为一种标志来记录 true/false 情况
默认值是 false
例子：boolean one = true
char
char 类型是一个单一的 16 位 Unicode 字符
最小值是 \u0000（十进制等效值为 0）
最大值是 \uffff（即为 65535）
char 数据类型可以储存任何字符
例子：char letter = 'A';
Java运算符
算术运算符
操作符 描述 例子
+ 加法 - 相加运算符两侧的值 A + B 等于 30
- 减法 - 左操作数减去右操作数 A – B 等于 -10
* 乘法 - 相乘操作符两侧的值 A * B等于200
/ 除法 - 左操作数除以右操作数 B / A等于2
％ 取余 - 左操作数除以右操作数的余数 B%A等于0
++ 自增: 操作数的值增加1 B++ 或 ++B 等于 21
-- 自减: 操作数的值减少1 B-- 或 --B 等于 19
+ 加法 - 相加运算符两侧的值 A + B 等于 30
- 减法 - 左操作数减去右操作数 A – B 等于 -10
* 乘法 - 相乘操作符两侧的值 A * B等于200
/ 除法 - 左操作数除以右操作数 B / A等于2
％ 取余 - 左操作数除以右操作数的余数 B%A等于0
++ 自增: 操作数的值增加1 B++ 或 ++B 等于 21
-- 自减: 操作数的值减少1 B-- 或 --B 等于 19
示例
关系运算符
运算符 描述 例子
== 检查如果两个操作数的值是否相等，如果相等则条件为真。 （A == B）为假。
!= 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 （A> B）为假。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 （A <B）为真。
>= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 （A> = B）为假。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 （A <= B）为真。
== 检查如果两个操作数的值是否相等，如果相等则条件为真。 （A == B）为假。
!= 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 （A> B）为假。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 （A <B）为真。
>= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 （A> = B）为假。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 （A <= B）为真。
示例
位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
示例
操作符 描述 例子
＆ 如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
| 如果相对应位都是 0，则结果为 0，否则为 1 （A | B）得到61，即 0011 1101
^ 如果相对应位值相同，则结果为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
＆ 如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
| 如果相对应位都是 0，则结果为 0，否则为 1 （A | B）得到61，即 0011 1101
^ 如果相对应位值相同，则结果为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）为真。
&& 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 （A && B）为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 （A | | B）为真。
！ 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 ！（A && B）为真。
示例
赋值运算符
操作符 描述 例子
= 简单的赋值运算符，将右操作数的值赋给左侧操作数 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 | = 2等价于C = C | 2
= 简单的赋值运算符，将右操作数的值赋给左侧操作数 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 | = 2等价于C = C | 2
示例
其他运算符
条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
实例
instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
示例
Java运算符优先级
Scanner类
java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。
next
nextLine
Java异常处理
异常类型
检查性异常
最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常
运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误
错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
Exception
Java内置异常类
非检查性异常
ArithmeticException
当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException
用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException
试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException
当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException
抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException
抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException
在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException
线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException
指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException
如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException
当应用程序试图在需要对象的地方使用 null 时，抛出该异常
NumberFormatException
当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException
由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException
此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException
当不支持请求的操作时，抛出该异常。
检查性异常类
ClassNotFoundException
应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException
当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
IllegalAccessException
拒绝访问一个类的时候，抛出该异常。
InstantiationException
当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException
一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException
请求的变量不存在
NoSuchMethodException
请求的方法不存在
异常方法
public String getMessage()
返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
public Throwable getCause()
返回一个Throwable 对象代表异常原因。
返回一个Throwable 对象代表异常原因。
public String toString()
使用getMessage()的结果返回类的串级名字。
使用getMessage()的结果返回类的串级名字。
public void printStackTrace()
打印toString()结果和栈层次到System.err，即错误输出流。
打印toString()结果和栈层次到System.err，即错误输出流。
public StackTraceElement [] getStackTrace()
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。
public Throwable fillInStackTrace()
用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。
用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。
捕获异常
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
实例
多重捕获块
实例
throws/throw 关键字
如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
实例
finally关键字
finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
实例
声明自定义异常
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
只继承Exception 类来创建的异常类是检查性异常类。
下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。
一个异常类和其它任何类一样，包含有变量和方法。
下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。
一个异常类和其它任何类一样，包含有变量和方法。
0 条评论
下一页
