JAVA基础篇
一、初识Java编程
1、Java开发环境
JDK Java开发工具
JVM Java虚拟机
JRE Java运行环境
2、实现第一个hello world
public class Hello{
public static void main(String[] args){
System.out.println(“hello man!”);
}
}
执行代码:
(1) 在命令窗体输入: javac 文件名.java
(2) 输入:java 文件名
注意:
(1) 类名和文件名要保持一致;
(2) Java源代码中的所有标点符号使用英文输入法状态输入;
(3) Java源代码是区分大小写;
(4) 类名默认都使用大写;
3、Java运行原理
4、变量的声明
声明语法:
数据类型 变量名 ;
赋值:
变量名 = 值;
示例:
public class Hello{
public static void main(String[] args){
//声明整数类型的a,在内存中创建这个变量
int a;
double b;
double c;
//给变量赋值
a = 1;
b = 2;
System.out.println(a/b);
}
}
5、标识符
(1) 标识符是用于类名、变量名、方法名、对象名、数组名等的命名;
(2) 可以使用英文、数字、下划线_、$符号;
(3) 不能以数字开头;
(4) 不能使用Java关键字或保留字;
(5) 区分大小写;
6、注意事项
(1)当声明的类使用public关键字修饰时,源文件名必须和类名保持一致;
(2)一个.java源文件中可以声明多个类,但是只能有一个public修饰的类,文件名要和public修饰的类名保持一致;
(3)类中可以继续声明类,称为内部类;
6、eclipse的使用
6.1 默认界面效果
6.2 创建项目
(1)在包资源管理器中点右键,选择:
(2)在src目录上右键,新建package,包的命名规范:
域名的倒置,例如:www.baidu.com 包名 com.baidu.www
(3)在当前包下,新建Class
(4)修改字体
7、注释
7.1 单行注释
语法:
//这一行是注释
7.2 多行注释
/*
* 多行注释
* 多行注释
*/
7.3 文档注释
/**
* 这是一个测试的类
* @author
*/
练习
声明两个变量,例如:
int a,b;
a = 1;
b = 2;
把变量a和变量b的值交换。
答案:
int a,b,c;
a = 1;
b = 2;
c = a;
a = b;
b = c;
System.out.println(“a=”+a);//+ 是拼接的意思
System.out.println(“b=”+b);
二、Java的基本数据类型
Java的基本数据类型有4类8种,
类型分别为:整数型、浮点型、字符型、布尔型;
其中整数型有4种,字节型byte、短整型short、整数型int、长整型long;
浮点型有2种:单精度float、双精度double;
字符型char;
布尔型boolean
1、整数型
整数型取值范围:
System.out.println(“字节类型byte取值范围:”);
System.out.println(Byte.SIZE+“位”);
System.out.println(“byte最大:”+Byte.MAX_VALUE);
System.out.println(“byte最小:”+Byte.MIN_VALUE);
System.out.println(“短整型short取值范围:”);
System.out.println(Short.SIZE+“位”);
System.out.println(“Short最大:”+Short.MAX_VALUE);
System.out.println(“Short最小:”+Short.MIN_VALUE);
System.out.println(“整数型int取值范围:”);
System.out.println(Integer.SIZE+“位”);
System.out.println(“int最大:”+Integer.MAX_VALUE);
System.out.println(“int最小:”+Integer.MIN_VALUE);
System.out.println(“长整型long取值范围:”);
System.out.println(Long.SIZE+“位”);
System.out.println(“long最大:”+Long.MAX_VALUE);
System.out.println(“long最小:”+Long.MIN_VALUE);
2、浮点型
整数型取值范围:
System.out.println(“单精度浮点型float取值范围:”);
System.out.println(Float.SIZE+“位”);
System.out.println(“float最大:”+Float.MAX_VALUE);
System.out.println(“float最小:”+Float.MIN_VALUE);
System.out.println(“双精度浮点型double取值范围:”);
System.out.println(Double.SIZE+“位”);
System.out.println(“double最大:”+Double.MAX_VALUE);
System.out.println(“double最小:”+Double.MIN_VALUE);
3、字符型
char类型是一个单一的16位Unicode字符,在Java底层是以整数型进行运算;
最大值:char d = ‘\uffff’;
最小值:char c = ‘\u0000’;
4、布尔型
boolean表示逻辑运算的结果,值为true或false
boolean a = true;//真
boolean b = false;//假
5、数据类型转换
5.1 自动类型转换
int a = 1;
long b = a;//小类型转大类型,自动类型转换
5.2、强制类型转换
int a = 127;
byte b =(byte) a;//大类型转小类型,需要强制类型转换
练习
把123.456789,使用当前所学的知识,计算四舍五入保留2位小数的结果。
答案:
double d = 123.456789;//保留2位小数
System.out.println((int) (d*100+0.5)/100.0);
三、运算符
1、算术运算符
重点掌握:取模(%)、自增自减(++a,a++)
示例代码:
int a = 1;
a++;// 自身增加1 , a = a; a=a+1
++a;// 自身增加1, a = a+1 ; a = a
System.out.println(a++); // 在打印的时候,执行的是a = a,所以打印的结果为1 ,打印结束后 a = a+1;
System.out.println(a);
System.out.println(++a); // 在打印的时候同时执行了 a = a + 1,所以结果为2,打印结束后又执行了 a=a;
System.out.println(a);
2、关系运算符(条件运算)
3、赋值运算
4、逻辑运算符
5、位运算
代码示例:
// boolean a = 1>2; // false
// boolean b = 1==1;// true
//
// System.out.println(a & b);//短路与
// System.out.println(a | b);//短路或
// int a = 3;// 转为二进制:11
// int b = 2;// 转为二进制:10
char a = ‘a’;// 97 --> 1100001
char b = ‘b’;// 98 --> 1100010
// 1100000 --> 96
// 1100011 --> 99
// 0000011 --> 3
System.out.println(a & b);// & 表示对应位都为1,结果为1,否则为0
System.out.println(a | b);// | 表示对应位都为0,结果为0,否则为1
System.out.println(a ^ b);// ^ 表示对应位相同,结果为0,否则为1
异或(^)作为逻辑运算符时,符号两边相同时返回false,两边不同时返回true;
6、条件运算符
语法:
变量类型 变量名 = 条件 ? A : B ;
解读:
声明一个变量,当条件为true时,当前变量的值为A,当条件为false时,当前变量的值为B;
代码示例:
int a = false ? 1 : 0;
System.out.println(a);
int week = 6;
String s = (week>=1 && week<=5) ? “去上课”:“去LOL”;
System.out.println(s);
四、流程控制
1、分支语句
1.1 if-else-if
语法:
if(条件){
当条件为true时,执行大括号内的代码
}else if(条件){
}
补充:
//实例化扫描仪对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入第一个值:”);
int a = sc.nextInt();
System.out.println(“请输入第二个值:”);
int b = sc.nextInt();
System.out.println(“求和结果:”+(a+b));
// String s = sc.next();
// System.out.println(s);
// double d = sc.nextDouble();
1.2 switch语句
概念:
switch 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。
语法:
switch( 变量 ){
case 值1:
break;
case 值2:
break;
default:
}
当程序执行到break关键字时,跳出当前的switch语句;
注意事项:
- switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串类型了,同时 case 标签必须为字符串常量或字面量。
- switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
- case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
- 当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
- 当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
- switch 语句可以包含一个 default 分支,该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
2、循环语句
2.1 while循环
语法:
while(条件){
当条件为true时,执行循环体内的代码;
}
备注:
满足循环的三个条件:初始化变量、关系运算、迭代
2.2 do-while循环
语法:
do{
}while(条件);
备注:与while循环的区别是,当条件为false时,也会被执行一次。
2.3 for循环
语法:
for(int i = 0 ; i < 10 ; i++){
}
2.4 嵌套for循环
2.4.1 打印直角三角形
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j <= i ; j++){
System.out.print("* ");
}
System.out.println();
}
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j <=(10-i) ; j++){
System.out.print("* ");
}
System.out.println();
}
2.4.2 打印乘法口诀
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j <=i ; j++){
System.out.print(j+“×”+i+"="+(i*j)+"\t");
}
System.out.println();
}
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j <=(10-i) ; j++){
System.out.print(i+“×”+j+"="+(i*j)+"\t");
}
System.out.println();
}
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j < i ; j++){
System.out.print("\t");
}
for(int j = i ; j < 10 ; j++){
System.out.print(i+“×”+j+"="+(i*j)+"\t");
}
System.out.println();
}
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j < 10-i ; j++){
System.out.print("\t");
}
for(int j = 1 ; j <=i ; j++){
System.out.print(j+“×”+i+"="+(i*j)+"\t");
}
System.out.println();
}
2.5 循环控制
2.5.1 break语句
break 可以用于所有的循环语句或者 switch 语句中,用来跳出整个语句块。
break 跳出该关键字所在的循环,并且继续执行该循环下面的语句。
2.5.2 continue语句
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中,continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。
2.6 标签的使用
语法:
标签名 :
使用:
break 标签名; 或
continue 标签名;
示例:
a: for (int i = 1; i <= 10; i++) {
System.out.println(“i=”+i);
b: for (int j = 1; j <= 10; j++) {
if(j==5){
// continue a;
break a;
}
System.out.println(“j=”+j);
}
}
注意:
标签名的语法规则要遵循标识符的语法要求;
break 标签名 : 跳出该标签名后面的循环;
continue 标签名: 跳过该标签名的本次循环,继续进行下次迭代;
补充(随机数)
生成随机数(2位)
Random ran = new Random();
int i = ran.nextInt(90)+10; // 随机的结果为 [0,90)+10 = [10,99]
System.out.println(i);
五、数组
1、数组的声明
(1)语法:
类型[] 数组名 = new 类型[长度];
示例:
int[] array = new int[10];
(2)语法:
类型[] 数组名 = {值,值,……};
示例:
int[] array2 = {1,2,3,4,5,6,7,8,9,10};
(3)语法:
类型[] 数组名 = new 类型[]{值,值……};
示例:
int[] array3 = new int[]{1,2,3,4,5,6,7,8};
数组通过下标来赋值和取值,例如:
array[0] = 1;
System.out.println(array[0]);
下标的范围是从0开始,到数组的长度-1;
2、数组的遍历
示例:
int[] array = {10,12,32,45,57,68,79,80,90,100,200,300};
//数组的遍历
for(int i = 0 ; i < array.length ; i++){
System.out.println(array[i]);
}
增强for循环:
语法:
for(数组类型 变量名 : 数组名){
System.out.println(变量名);
}
示例:
int[] a = {1,2,3,4,5,6};
//增强for循环
for(int i : a){
System.out.println(i);
}
3、数组排序
3.1 冒泡排序
从后往前依次确定元素,相邻的两个元素比较,互换位置;
int[] a = {3,7,9,1,5};
for(int i = 1 ; i < a.length ; i++){
for(int j = 0 ; j < a.length - i; j++){
if(a[j] < a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
3.2 选择排序
从前往后确定元素,让未确定的第一个数依次和后面的比较,互换位置;
int[] a = { 3, 7, 9, 1, 5 };
for (int i = 0; i < a.length - 1; i++) {
for (int j = i + 1; j < a.length ; j++) {
if (a[i] < a[j]) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
4、二维数组
示例:
int[] a = {1,2,3,4,5,20};
int[] b = {6,7,8,9,10};
int[] c = {11,12,13,14,15,16,17,18};
//二维数组
int[][] array = {a,b,c};
//遍历array
for(int i = 0 ; i < array.length ; i++){
for(int j = 0 ; j < array[i].length; j++){
System.out.print(array[i][j]+" ");
}
System.out.println();
}
六、方法
1、方法的声明
语法:
[访问修饰符] [static] 返回值类型 方法名(参数列表){
要执行的代码
}
示例:
//自定义方法
public static void print(){
System.out.println(“hello”);
}
1.1 static关键字
用法:
- 当使用static关键字修饰方法时,该方法称为静态方法,即类的方法;
- 如果没有使用static关键字修饰,该方法为普通方法(实例方法),即对象的方法;
- 静态方法中,只能直接调用静态方法;
- 实例方法中,可以直接调用静态方法,也可以直接调用实例方法;
- 静态方法中如果要调用实例方法,必须先实例化对象,使用对象名调用;
补充:
实例化对象语法:
类名 对象名 = new 类名();
1.2 void关键字
- 当方法没有任何返回值时,方法声明语句中使用void关键字;
- 当方法有返回值时,返回值是什么数据类型,就声明为什么类型;
1.3 参数
语法:
- 在方法名后面的括号中声明;
- 参数的个数为大于等于0;
- 写法:方法名(类型 变量名,类型 变量名,……){}
- 参数是当前方法的局部变量,是一种特殊的局部变量;
- 参数的赋值过程,是在调用该方法时完成的;
- 当有多个参数,调用该方法时,依次按照括号中的顺序为参数赋值;
- 参数的类型可以为Java的任何数据类型;
2、使用方法的好处
(1)提高代码的复用性,减少代码量;
(2)把某个功能封装到一个方法中,便于协作开发;
(3)便于代码集中管理;
(4)提现了面向对象的思想;
3、方法重载
概念:重载(overloading) 是在一个类里面,方法名字相同,而参数不同。与返回值类型、访问修饰符无关。
规则:
(1) 参数的类型不同;
(2) 参数个数不同;
(3) 参数的顺序不同;
七、面向对象
万物皆对象
描述一个物质都可以通过两方面说明:数据模型(属性)、行为模型(行为)。
在Java编程中,我们使用成员变量表示数据模型,用成员方法表示行为模型。
使用类表示某些具有相同属性和行为的事物。
以动物为例:
1、构造方法
语法:
[访问修饰符] 类名(){
}
注意:
当类中没有显式的构造方法,实例化该类的对象时,程序会自动创建一个公开的无参构造方法;
如果类中有显示的构造方法,程序就不会创建无参构造;
构造方法,一般是用于为成员属性赋初始化值;
2、变量
2.1 局部变量
- 声明在构造方法、静态方法、实例方法、代码块中的变量,都是局部变量;
- 不能使用static和访问修饰符修饰;
- 可以使用final修饰,即为常量,不必在声明语句中赋值;
- 当执行局部变量所在的方法或代码块时,才有机会被创建,在方法或代码块执行结束后被自 动销毁;
- 局部变量在内存的栈区分配;
- 局部变量在使用之前必须要先赋值;
- 声明在所有方法体和代码块之外,并且没有使用static修饰的变量,叫做实例变量;
- 可以使用访问修饰符和final修饰;
- 使用final修饰时,一定要赋值;
- 实例变量是在对象被创建时创建,对象被销毁时销毁;
- 作用域范围在整个类中;
- 声明在所有方法体和代码块之外,并且使用static修饰的变量;
- 可以使用访问修饰符修饰;
- 一般配合final使用,即public static fianl,标识符使用大写;
- 类变量被分配在静态存储区,是被所有该类的对象共享数据;
- 类变量是在程序开始时被创建,程序结束时销毁;
2.2 实例变量
2.3 类的变量
3、访问修饰符
访问修饰符是用来控制其他类对该类的类、实例变量、构造方法、实例方法的访问权限。Java的访问权限有4种:
public 公开的
protected 受保护的
默认的,没有任何关键字来表示
private 私有的
修饰符 | public | protected | 默认的 | private |
---|---|---|---|---|
当前类 | √ | √ | √ | √ |
同包的类 | √ | √ | √ | × |
同包的子类 | √ | √ | √ | × |
异包 | √ | × | × | × |
异包的子类 | √ | × | × | × |
4、this关键字
this指当前对象,用法:
- 当局部变量名和实例变量名同名时,使用this.变量名来表示实例变量;
- this()表示当前类的构造方法,只能在构造方法中使用该写法,并且是写在构造方法内的第一行。
5、封装
私有的属性,公开的方法。
封装的步骤:
声明私有(private)的属性;
声明公开(public)的geter和seter方法;
6、继承
Java中的继承是单继承,可以实现多层继承,继承的关键字extends
语法:
public class Son extends Father{
}
规则:
- 子类继承父类非私有的所有属性和方法,不能继承父类的构造方法;
- 实例化子类对象的步骤:先执行父类的构造方法,再执行子类的构造方法;
重写定义:
- 子类重新声明从父类继承来的方法,称为方法重写;
- 方法重写时,方法的声明部分要和父类保持一致(返回值类型,方法名,参数);
- 重写方法的访问权限要大于等于父类中方法的访问权限;
- 子类重写父类方法,子类对象调用的是子类中重写后的方法;
- 使用static修饰的方法不能被重写,但是可以被子类重写声明;
- 不同包的子类可以重写父类中protected修饰的方法,但是不能以继承的形式,用子类对象直接调用父类的该方法;
Final关键字:
- 当final修饰类时,当前类不能被继承;
- 当final修饰方法时,该方法不能被重写;
- 当final修饰变量时,变量的值不能被修改,即为常量;
7、多态
实现的必要条件:
- 继承
- 重写
- 父类引用指向子类对象
instanceof关键字:
语法:
if (对象名 instanceof 类名) {
类型转换代码;
}
实例:
Animal cat = new Cat();
if (cat instanceof Cat) {//返回结果为boolean类型
Cat c = (Cat) cat;
c.eat();
}else{
System.out.println(“类型不匹配”);
}
8、抽象类
抽象类语法:
public abstract class Demo {
}
抽象方法语法:
public abstract void abc();
规则:
含有抽象方法的类,一定是抽象类;
- 抽象类中可以声明成员变量、常量、成员方法、抽象方法,抽象类中不一定要有抽象方法;
- 抽象类不能被实例化;
- 抽象类可以被继承;
- 可以通过两种方式获得抽象类对象:父类引用指向子类对象、匿名内部类;
- 子类必须重写抽象父类的所有抽象方法,或者是把子类也定义为抽象类;
- 如果一个类继承的抽象父类还有上级抽象父类,那么子类中需要要重写所有抽象父类的所有抽象方法;
- 抽象类也可以继承非抽象类,同时继承了父类的所有非私有的属性和方法;
9、接口
语法:
public interface ITest {
}
规则:
- 接口使用interface关键字修饰;
- 接口是一个完全抽象的抽象类;
- 接口中没有构造方法;
- 接口不能被实例化对象;
- 接口中可以声明静态常量、抽象方法、静态方法;
- 接口中不能声明实例方法,声明抽象方法时,不能使用static关键字修饰;
- 声明接口语句中,默认含有abstract关键字,抽象方法中也默认含有abstract关键字;
- 接口可以被实现,使用implements关键字,一个类实现一个接口,必须重写该接口中所有的抽象方法;
- 一个类可以实现多个接口,每个接口名用英文的逗号隔开,该类中必须重写所有已实现接口中的抽象方法;
- 接口可以继承接口,接口与接口间是多继承关系,接口不能继承类;
10、内部类
10.1 成员内部类
成员内部类声明在类中,方法体、代码块之外。和成员变量、成员方法在同一级别。
语法:
public class Out {
//成员内部类
public class Inner{
}
}
实例化成员内部类:
//先实例化外部类
Out o = new Out();
//使用外部类对象,再实例化内部
Out.Inner inner = o.new Inner();
实例:
public class Out {
//成员变量
public int a = 1;
//成员内部类
public class Inner{
public int a = 2;
//内部类的成员方法
public void print(){
//执行内部类中的实例变量a
System.out.println(a);
//执行外部类的实例变量a
System.out.println(Out.this.a);
}
}
}
10.2 静态内部类
声明的位置参考成员内部类。
语法:
public class Out {
//静态内部类
public static class Inner{
}
}
实例化静态内部的对象:
Out.Inner inner = new Out.Inner();
实例:
public class Out {
public static int a = 1;
public int b = 3;
//静态内部类
public static class Inner{
public static int a = 2;
public static void print(){
//执行静态内部的静态变量
System.out.println(a);
//执行外部类的静态变量
System.out.println(Out.a);
//执行外部类的实例变量
Out o = new Out();
System.out.println(o.b);
}
}
}
10.3 局部内部类
声明在方法体或代码块内,作用域范围在方法体或代码块内。
语法:
public class Out {
public void method(){
//局部内部类
class Inner{
//局部内部类的成员方法
public void print(){
System.out.println(“局部内部类”);
}
}
//实例化局部内部类
Inner inner = new Inner();
inner.print();
}
}
执行局部内部类的方法:
Test类:
public static void main(String[] args) {
Out o = new Out();
o.method();
}
10.4 匿名内部类
- 声明位置同局部内部类一样,前提条件:必须继承一个类或实现一个接口,匿名内部类的声明和实例化对象是同时进行的;
- 一般使用于获得抽象类或接口对象;
语法:
父类名/接口名 对象名 = new 父类名/接口名(){
//匿名内部类成员
};
实例:
父类
public class Father {
}
匿名内部类:
public class Out {
public void method(){
//匿名内部类对象
Father f = new Father(){
};
}
}
八、Java常用类库
1、Object类
Object类是所有类直接或间接父类。
方法:
toString():以字符串形式返回对象的文本信息;
hashCode():返回该对象的哈希值;
getClass():返回对象的类类型;
equals(Object obj):比较两个对象是否相等
2、包装类
2.1 装箱与拆箱
实例:
byte b = 1;//基本数据类型
System.out.println(b+1);
Byte b2 = new Byte(b);//包装类的对象
System.out.println(b2);
Byte b3 = b;//自动装箱,把基本数据类型转为对象
System.out.println(b3+5);
byte b4 = new Byte(b);//自动拆箱,把对象转为基本数据类型
System.out.println(b4+7);
2.2 Number类的常用方法
- 构造方法;
- valueOf();
- toString();
2.3 Character 常用方法
- valueOf();
- toString();
- isDigit():判断是否为数字
- isLetter():判断是否为字母
- isUpperCase():判断是否为大写字母
- isLowerCase():判断是否为小写字母
- isWhitespace():判断是否为空格
- toUpperCase():转为大写字母
- toLowerCase():转为小写字母
3、字符串操作
3.1 String类
String字符串的值不可更改。
常用方法:
- charAt(int i):返回指定索引处的字符;
- length():返回字符串的长度;
- contains(CharSequence c):判断字符串中是否包含指定的字符序列;
- startsWith(String s):判断字符串是否以指定的前缀开始;
- endsWith(String s):判断字符串是否以指定的后缀结束;
- indexOf(char c):返回指定字符在字符串中第一次出现的索引;
- lastIndexOf(char c):返回指定字符在字符串中最后一次出现的索引;
- isEmpty():当且仅当字符串长度为0时,返回true;
- replace(char old,char new):把字符串中的old字符替换为new字符,然后返回一个新字符串;
- split(String s):根据指定的规则拆分字符串,返回字符串数组;
- subString(int begin,int end):按照指定的索引截取字符串,从begin(包含)开始,到end(不包含)结束;
- toLowerCase():把字符串的英文字母全部转为小写;
- toUpperCase():把字符串的英文字母全部转为大写;
- trim():清除字符串前后的空白字符;
- valueOf():把指定类型的数据转为字符串类型;
- toCharArray():把字符串转为字符数组;
3.2 可变字符序列
StringBuffer和StringBuilder都是可变的字符序列,唯一的区别:StringBuffer是线程安全的,StringBuilder是线程不安全;
常用方法:
- append():追加;
- toString():把所有追加的内容以String类型返回;
4、System类
常用方法:
currentTimeMillis():获得当前时间戳,以毫秒为单位
exit(0):正常终止JVM
5、时间日期操作
5.1 时区操作(了解)
实例:
/*
* 获取可用时区ID的方法
*/
//获得时区对象的方法
// TimeZone t = TimeZone.getDefault();
//获取可用的所有ID
String[] ids = TimeZone.getAvailableIDs();
for (String id : ids) {
//获得每次遍历ID的时区对象
TimeZone tz = TimeZone.getTimeZone(id);
System.out.println(id+"------>"+tz.getDisplayName());
}
//根据时区ID获得时区对象
TimeZone tz = TimeZone.getTimeZone(“Africa/Abidjan”);
//设置时区
TimeZone.setDefault(tz);
//根据时间戳获得指定日期对象
long time = 0;
Date d = new Date(time);
System.out.println(d);
5.2 Date类
构造方法:
- Date():创建日期对象;
- Date(long t):根据时间戳创建日期对象;
常用方法:
- after(Date d):当前日期对象是否在指定日期之后;
- before(Date d):当前日期对象是否在指定日期之前;
- getTime():获得当前的时间戳;
- setTime(long t):设置时间对象的具体时间为指定的时间戳;
5.3 Calendar类
实例:
//获得日历对象
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);//获得年份
System.out.println(year);
int month = c.get(Calendar.MONTH);//获得月份
System.out.println(month+1);
int day = c.get(Calendar.DAY_OF_MONTH);//获得月份中的日期
System.out.println(day);
int week = c.get(Calendar.DAY_OF_WEEK);//星期几
System.out.println(week-1);
// int s = c.get(Calendar.HOUR);//12小时制的时
int s = c.get(Calendar.HOUR_OF_DAY);//24小时制的时
System.out.println(s);
int f = c.get(Calendar.MINUTE);//小时的分钟数
System.out.println(f);
int m = c.get(Calendar.SECOND);//秒
System.out.println(m);
int hm = c.get(Calendar.MILLISECOND);//毫秒
System.out.println(hm);
常用方法:
- add(int field,int value):计算时间日期的偏移量;
- getTime():获得Date类型的日期对象;
- getTimeInMillis():获得时间戳;
- get(int field):获得时间数据;
- set(int field,int value):设置具体的时间;
- set(year,month,day,hour,minute,second):通过参数直接设置具体时间;
- setTime(Date d):把Date类型转为Calendar类型;
Calendar的子类GregorianCalendar,是格里高利日历,常用的方法:
- isLeapYear(int year):判断指定年份是否为闰年,是闰年返回true;
5.4 日期格式化
1.格式化日期
实例:
// Date d = new Date(0);
SimpleDateFormat sdf = new SimpleDateFormat(“y年M月dd日 HH:mm:ss”);
System.out.println(sdf.format(new Date()));
2.解析日期
实例:
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个日期:”);
String str = sc.next();
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy/MM/dd”);
//把字符串类型的日期解析为Date对象
Date d = sdf.parse(str);
System.out.println(d);
注意解析的模式是否正确,防止抛出解析异常
6、Math类
Math类是数学相关的操作工具类
7、Random类
获取伪随机数的类
8、Scanner类
获得用户在控制台输入的内容
9、Desktop类
使用Java程序执行本机的应用程序
执行浏览器实例:
// URI uri = new URI(“http://www.baidu.com”);
//获得本机对象
// Desktop d = Desktop.getDesktop();
// d.browse(uri);
//简化
Desktop.getDesktop().browse(new URI(“http://www.taobao.com”));
执行本地应用程序实例:
//执行本地应用程序
Desktop.getDesktop().open(new File(“F:/a.txt”));
10、正则表达式
正则符号:
含义
符号
数字
[0-9] \d
字母
[a-zA-Z]
空白字符
[ \n\t\r\f\x0B]
表示非
[^规则]
任意字符(换行除外)
. (点)
正则开始
^
正则结束
$
正则数量:
符号
含义
n≥1 1到多个
n≥0 0到多个
?
0≤ n ≤1 0或1个
{n}
n个
{n,}
n ≤ n到多个
{n,m}
n≤ num ≤m n到m个
正则逻辑:
含义
符号
分组
()
或
|
且
什么都不写
实例:
验证手机号:
//手机号是11位数字,前3位是136/130开头,后8位是随机数字
String str = “13033338880”;
//规则
String gz = “^(([1][3][6])|([1][3][0]))([0-9]{8})$”;
boolean rel = str.matches(gz);
if(rel){
System.out.println(“ok”);
}else{
System.err.println(“no”);
}
邮箱验证:
//邮箱 zhangsan_.abc@qq.com为例,前缀:字母、数字、下划线、点、减号,@,qq/126/139/sina,com/http://com.cn/org/cn
String str = “adf123@qq.cn”;
//规则
String gz = “^([0-9a-zA-Z_.-]{3,18})”
+ “[@]”
+ “(([q]{2})|([1][2][6])|([1][3][9])|([s][i][n][a]))[.]”
+ “(([c][o][m])|([c][n])|([c][o][m][.][c][n]))$”;
boolean rel = str.matches(gz);
if(rel){
System.out.println(“ok”);
}else{
System.err.println(“no”);
类
8、Scanner类
获得用户在控制台输入的内容
9、Desktop类
使用Java程序执行本机的应用程序
执行浏览器实例:
// URI uri = new URI(“http://www.baidu.com”);
//获得本机对象
// Desktop d = Desktop.getDesktop();
// d.browse(uri);
//简化
Desktop.getDesktop().browse(new URI(“http://www.taobao.com”));
执行本地应用程序实例:
//执行本地应用程序
Desktop.getDesktop().open(new File(“F:/a.txt”));
10、正则表达式
正则符号:
含义
符号
数字
[0-9] \d
字母
[a-zA-Z]
空白字符
[ \n\t\r\f\x0B]
表示非
[^规则]
任意字符(换行除外)
. (点)
正则开始
^
正则结束
$
正则数量:
符号
含义
n≥1 1到多个
n≥0 0到多个
?
0≤ n ≤1 0或1个
{n}
n个
{n,}
n ≤ n到多个
{n,m}
n≤ num ≤m n到m个
正则逻辑:
含义
符号
分组
()
或
|
且
什么都不写
实例:
验证手机号:
//手机号是11位数字,前3位是136/130开头,后8位是随机数字
String str = “13033338880”;
//规则
String gz = “^(([1][3][6])|([1][3][0]))([0-9]{8})$”;
boolean rel = str.matches(gz);
if(rel){
System.out.println(“ok”);
}else{
System.err.println(“no”);
}
邮箱验证:
//邮箱 zhangsan_.abc@qq.com为例,前缀:字母、数字、下划线、点、减号,@,qq/126/139/sina,com/http://com.cn/org/cn
String str = “adf123@qq.cn”;
//规则
String gz = “^([0-9a-zA-Z_.-]{3,18})”
+ “[@]”
+ “(([q]{2})|([1][2][6])|([1][3][9])|([s][i][n][a]))[.]”
+ “(([c][o][m])|([c][n])|([c][o][m][.][c][n]))$”;
boolean rel = str.matches(gz);
if(rel){
System.out.println(“ok”);
}else{
System.err.println(“no”);
}