public class Demo {
public static void main(String[] args) {
String str1 = "30";
String str2 = "30.3";
// 将字符串变为int型
int x = Integer.parseInt(str1);
// 将字符串变为float型
float f = Float.parseFloat(str2);
System.out.println("x = " + x + ";f = " + f);
}
}
运行结果:
x = 30;f = 30.3
3) 将整数转换为字符串
Integer 类有一个静态的 toString() 方法,可以将整数转换为字符串。例如:
public class Demo {
public static void main(String[] args) {
int m = 500;
String s = Integer.toString(m);
System.out.println("s = " + s);
}
}
运行结果:
s = 500
Java Object类详解
Object 是 Java 类库中的一个特殊类,也是所有类的父类。也就是说,Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后,如果没有指定继承的父类,那么默认父类就是 Object 类。因此,以下两个类表示的含义是一样的。
public class MyClass{…}
等价于
public class MyClass extends Object {…}
由于 Java 所有的类都是 Object 类的子类,所以任何 Java 对象都可以调用 Object 类的方法。常见的方法如表 1 所示。
方法 | 说明 |
---|---|
Object clone() | 创建与该对象的类相同的新对象 |
boolean equals(Object) | 比较两对象是否相等 |
void finalize() | 当垃圾回收器确定不存在对该对象的更多引用时,对象垃圾回收器调用该方法 |
Class getClass() | 返回一个对象运行时的实例类 |
int hashCode() | 返回该对象的散列码值 |
void notify() | 激活等待在该对象的监视器上的一个线程 |
void notifyAll() | 激活等待在该对象的监视器上的全部线程 |
String toString() | 返回该对象的字符串表示 |
void wait() | 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待 |
其中,toString()、equals() 方法和 getClass() 方法在 Java 程序中比较常用。
toString() 方法
toString() 方法返回该对象的字符串,当程序输出一个对象或者把某个对象和字符串进行连接运算时,系统会自动调用该对象的 toString() 方法返回该对象的字符串表示。
Object 类的 toString() 方法返回“运行时类名@十六进制哈希码”格式的字符串,但很多类都重写了 Object 类的 toString() 方法,用于返回可以表述该对象信息的字符串。
哈希码(hashCode),每个 Java 对象都有哈希码属性,哈希码可以用来标识对象,提高对象在集合操作中的执行效率。
先看以下代码:
// 定义Demo类,实际上继承Object类
class Demo {
}
public class ObjectDemo01 {
public static void main(String[] args) {
Demo d = new Demo(); // 实例化Demo对象
System.out.println("不加toString()输出:" + d);
System.out.println("加上toString()输出:" + d.toString());
}
}
输出结果为:
不加toString()输出:Demo@15db9742
加上toString()输出:Demo@15db9742
以上的程序是随机输出了一些地址信息,从程序的运行结果可以清楚的发现,加和不加 toString() 的最终输出结果是一样的,也就是说对象输出时一定会调用 Object 类中的 toString() 方法打印内容。所以利用此特性就可以通过 toString() 取得一些对象的信息,如下面代码。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "姓名:" + this.name + ":年龄" + this.age;
}
public static void main(String[] args) {
Person per = new Person("C语言中文网", 30);// 实例化Person对象
System.out.println("对象信息:" + per);// 打印对象调用toString()方法
}
}
输出结果为:
对象信息:姓名:C语言中文网:年龄30
程序中的 Person 类中重写了 Object 类中的 toString() 方法,这样直接输出对象时调用的是被子类重写过的 toString() 方法。
equals() 方法
在前面学习字符串比较时,曾经介绍过两种比较方法,分别是==
运算符和 equals() 方法,==
运算符是比较两个引用变量是否指向同一个实例,equals() 方法是比较两个对象的内容是否相等,通常字符串的比较只是关心内容是否相等。
其使用格式如下:
boolean result = obj.equals(Object o);
其中,obj 表示要进行比较的一个对象,o 表示另一个对象。
例 1
编写一个 Java 程序,实现用户登录的验证功能。要求用户从键盘输入登录用户名和密码,当用户输入的用户名等于 admin 并且密码也等于 admin 时,则表示该用户为合法用户,提示登录成功,否则提示用户名或者密码错误信息。
在这里使用 equals() 方法将用户输入的字符串与保存 admin 的字符串对象进行比较,具体的代码如下:
import java.util.Scanner;
public class Test01 {
// 验证用户名和密码
public static boolean validateLogin(String uname, String upwd) {
boolean con = false;
if (uname.equals("admin") && upwd.equals("admin")) { // 比较两个 String 对象
con = true;
} else {
con = false;
}
return con;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("------欢迎使用大数据管理平台------");
System.out.println("用户名:");
String username = input.next(); // 获取用户输入的用户名
System.out.println("密码:");
String pwd = input.next(); // 获取用户输入的密码
boolean con = validateLogin(username, pwd);
if (con) {
System.out.println("登录成功!");
} else {
System.out.println("用户名或密码有误!");
}
}
}
上述代码在 validateLogin() 方法中又使用 equals() 方法将两个 String 类型的对象进行了比较,当 uname 对象与保存 admin 的 String 对象相同时,uname.equals(“admin”) 为 true;与此相同,当 upwd 对象与保存 admin 的 String 对象相同时,upwd.equals(“admin”) 为 true。当用户输入的用户名和密码都为 admin 时,表示该用户为合法用户,提示登录成功信息,否则提示用户名或密码有误的错误信息。
该程序的运行结果下所示:
------欢迎使用大数据管理平台------
用户名:
adinm
密码:
admin
用户名或密码有误!
------欢迎使用大数据管理平台------
用户名:
admin
密码:
admin
登录成功!
getClass() 方法
getClass() 方法返回对象所属的类,是一个 Class 对象。通过 Class 对象可以获取该类的各种信息,包括类名、父类以及它所实现接口的名字等。
例 2
编写一个实例,演示如何对 String 类型调用 getClass() 方法,然后输出其父类及实现的接口信息。具体实现代码如下:
public class Test02 {
public static void printClassInfo(Object obj) {
// 获取类名
System.out.println("类名:" + obj.getClass().getName());
// 获取父类名
System.out.println("父类:" + obj.getClass().getSuperclass().getName());
System.out.println("实现的接口有:");
// 获取实现的接口并输出
for (int i = 0; i < obj.getClass().getInterfaces().length; i++) {
System.out.println(obj.getClass().getInterfaces()[i]);
}
}
public static void main(String[] args) {
String strObj = new String();
printClassInfo(strObj);
}
}
该程序的运行结果如下:
类名:java.lang.String
父类:java.lang.Object
实现的接口有:
interface java.io.Serializable
interface java.lang.Comparable
interface java.lang.CharSequence
接收任意引用类型的对象
既然 Object 类是所有对象的父类,则所有的对象都可以向 Object 进行转换,在这其中也包含了数组和接口类型,即一切的引用数据类型都可以使用 Object 进行接收。
interface A {
public String getInfo();
}
class B implements A {
public String getInfo() {
return "Hello World!!!";
}
}
public class ObjectDemo04 {
public static void main(String[] args) {
// 为接口实例化
A a = new B();
// 对象向上转型
Object obj = a;
// 对象向下转型
A x = (A) obj;
System.out.println(x.getInfo());
}
}
输出结果为:
Hello World!!!
通过以上代码可以发现,虽然接口不能继承一个类,但是依然是 Object 类的子类,因为接口本身是引用数据类型,所以可以进行向上转型操作。
同理,也可以使用 Object 接收一个数组,因为数组本身也是引用数据类型。
public class ObjectDemo05 {
public static void main(String[] args) {
int temp[] = { 1, 3, 5, 7, 9 };
// 使用object接收数组
Object obj = temp;
// 传递数组引用
print(obj);
}
public static void print(Object o) {
// 判断对象的类型
if (o instanceof int[]) {
// 向下转型
int x[] = (int[]) o;
// 循环输出
for (int i = 0; i < x.length; i++) {
System.out.print(x[i] + "\t");
}
}
}
}
输出结果为:
1 3 5 7 9
以上程序使用 Object 接收一个整型数组,因为数组本身属于引用数据类型,所以可以使用 Object 接收数组内容,在输出时通过 instanceof 判断类型是否是一个整型数组,然后进行输出操作。
提示:因为 Object 类可以接收任意的引用数据类型,所以在很多的类库设计上都采用 Object 作为方法的参数,这样操作起来会比较方便。
Java Integer类详解
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类对象包含一个 int 类型的字段。此外,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法。
Integer 类的构造方法
Integer 类中的构造方法有以下两个:
- Integer(int value):构造一个新分配的 Integer 对象,它表示指定的 int 值。
- Integer(String s):构造一个新分配的 Integer 对象,它表示 String 参数所指示的 int 值。
例如,以下代码分别使用以上两个构造方法来获取 Integer 对象:
Integer integer1 = new Integer(100); // 以 int 型变量作为参数创建 Integer 对象
Integer integer2 = new Integer("100"); // 以 String 型变量作为参数创建 Integer 对象
Integer 类的常用方法
在 Integer 类内部包含一些和 int 类型操作有关的方法,表 1 列出了这些常用的方法。
方法 | 返回值 | 功能 |
---|---|---|
byteValue() | byte | 以 byte 类型返回该 Integer 的值 |
shortValue() | short | 以 short 类型返回该 Integer 的值 |
intValue() | int | 以 int 类型返回该 Integer 的值 |
toString() | String | 返回一个表示该 Integer 值的 String 对象 |
equals(Object obj) | boolean | 比较此对象与指定对象是否相等 |
compareTo(Integer anotherlnteger) | int | 在数字上比较两个 Integer 对象,如相等,则返回 0; 如调用对象的数值小于 anotherlnteger 的数值,则返回负值; 如调用对象的数值大于 anotherlnteger 的数值,则返回正值 |
valueOf(String s) | Integer | 返回保存指定的 String 值的 Integer 对象 |
parseInt(String s) | int | 将数字字符串转换为 int 数值 |
在实际的编程过程中,经常将字符串转换为 int 类型的数值,或者将 int 类型的数值转换为对应的字符串。以下代码演示如何实现这两种功能:
String str = "456";
int num = Integer.parseInt(str); // 将字符串转换为int类型的数值
int i = 789;
String s = Integer.toString(i); // 将int类型的数值转换为字符串
注意:在实现将字符串转换为 int 类型数值的过程中,如果字符串中包含非数值类型的字符,则程序执行将出现异常。
例 1
编写一个程序,在程序中创建一个 String 类型变量,然后将它转换为二进制、八进制、十进制和十六进制输出。
public class Test03 {
public static void main(String[] args) {
int num = 40;
String str = Integer.toString(num); // 将数字转换成字符串
String str1 = Integer.toBinaryString(num); // 将数字转换成二进制
String str2 = Integer.toHexString(num); // 将数字转换成八进制
String str3 = Integer.toOctalString(num); // 将数字转换成十六进制
System.out.println(str + "的二进制数是:" + str1);
System.out.println(str + "的八进制数是:" + str3);
System.out.println(str + "的十进制数是:" + str);
System.out.println(str + "的十六进制数是:" + str2);
}
}
运行后的输出结果如下:
40的二进制数是:101000
40的八进制数是:50
40的十进制数是:40
40的十六进制数是:28
Integer 类的常量
Integer 类包含以下 4 个常量。
- MAX_VALUE:值为 231-1 的常量,它表示 int 类型能够表示的最大值。
- MIN_VALUE:值为 -231 的常量,它表示 int 类型能够表示的最小值。
- SIZE:用来以二进制补码形式表示 int 值的比特位数。
- TYPE:表示基本类型 int 的 Class 实例。
下面的代码演示了 Integer 类中常量的使用。
int max_value = Integer.MAX_VALUE; // 获取 int 类型可取的最大值
int min_value = Integer.MIN_VALUE; // 获取 int 类型可取的最小值
int size = Integer.SIZE; // 获取 int 类型的二进制位
Class c = Integer.TYPE; // 获取基本类型 int 的 Class 实例
Java Float类
Float 类在对象中包装了一个基本类型 float 的值。Float 类对象包含一个 float 类型的字段。此外,该类提供了多个方法,能在 float 类型与 String 类型之间互相转换,同时还提供了处理 float 类型时比较常用的常量和方法。
Float 类的构造方法
Float 类中的构造方法有以下 3 个。
- Float(double value):构造一个新分配的 Float 对象,它表示转换为 float 类型的参数。
- Float(float value):构造一个新分配的 Float 对象,它表示基本的 float 参数。
- Float(String s):构造一个新分配的 Float 对象,它表示 String 参数所指示的 float 值。
例如,以下代码分别使用以上 3 个构造方法获取 Float 对象:
Float float1 = new Float(3.14145); // 以 double 类型的变量作为参数创建 Float 对象
Float float2 = new Float(6.5); // 以 float 类型的变量作为参数创建 Float 对象
Float float3 = new Float("3.1415"); // 以 String 类型的变量作为参数创建 Float 对象
在 Float 类内部包含了一些和 float 操作有关的方法,见表 1。
方法 | 返回值 | 功能 |
---|---|---|
byteValue() | byte | 以 byte 类型返回该 Float 的值 |
doubleValue() | double | 以 double 类型返回该 Float 的值 |
floatValue() | float | 以 float 类型返回该 Float 的值 |
intValue() | int | 以 int 类型返回该 Float 的值(强制转换为 int 类型) |
longValue() | long | 以 long 类型返回该 Float 的值(强制转换为 long 类型) |
shortValue() | short | 以 short 类型返回该 Float 的值(强制转换为 short 类型) |
isNaN() | boolean | 如果此 Float 值是一个非数字值,则返回 true,否则返回 false |
isNaN(float v) | boolean | 如果指定的参数是一个非数字值,则返回 true,否则返回 false |
toString() | String | 返回一个表示该 Float 值的 String 对象 |
valueOf(String s) | Float | 返回保存指定的 String 值的 Float 对象 |
parseFloat(String s) | float | 将数字字符串转换为 float 数值 |
例如,将字符串 456.7 转换为 float 类型的数值,或者将 float 类型的数值 123.4 转换为对应的字符串,以下代码演示如何实现这两种功能:
String str = "456.7";
float num = Float.parseFloat(str); // 将字符串转换为 float 类型的数值
float f = 123.4f;
String s = Float.toString(f); // 将 float 类型的数值转换为字符串
注意:在实现将字符串转换为 float 类型数值的过程中,如果字符串中包含非数值类型的字符,则程序执行将出现异常。
Float 类的常用常量
在 Float 类中包含了很多常量,其中较为常用的常量如下。
- MAX_VALUE:值为 1.4E38 的常量,它表示 float 类型能够表示的最大值。
- MIN_VALUE:值为 3.4E-45 的常量,它表示 float 类型能够表示的最小值。
- MAX_EXPONENT:有限 float 变量可能具有的最大指数。
- MIN_EXPONENT:标准化 float 变量可能具有的最小指数。
- MIN_NORMAL:保存 float 类型数值的最小标准值的常量,即 2-126。
- NaN:保存 float 类型的非数字值的常量。
- SIZE:用来以二进制补码形式表示 float 值的比特位数。
- TYPE:表示基本类型 float 的 Class 实例。
下面的代码演示了 Float 类中常量的使用。
float max_value = Float.MAX_VALUE; // 获取 float 类型可取的最大值
float min_value = Float.MIN_VALUE; // 获取 float 类型可取的最小值
float min_normal = Float.MIN_NORMAL; // 获取 float 类型可取的最小标准值
float size = Float.SIZE; // 获取 float 类型的二进制位
Java Double类
Double 类在对象中包装了一个基本类型 double 的值。Double 类对象包含一个 double 类型的字段。此外,该类还提供了多个方法,可以将 double 类型与 String 类型相互转换,同时 还提供了处理 double 类型时比较常用的常量和方法。
Double 类的构造方法
Double 类中的构造方法有如下两个。
- Double(double value):构造一个新分配的 Double 对象,它表示转换为 double 类型的参数。
- Double(String s):构造一个新分配的 Double 对象,它表示 String 参数所指示的 double 值。
例如,以下代码分别使用以上两个构造方法获取 Double 对象:
Double double1 = new Double(5.456); // 以 double 类型的变量作为参数创建 Double 对象
Double double2 = new Double("5.456"); // 以 String 类型的变量作为参数创建 Double 对象
Double 类的常用方法
在 Double 类内部包含一些和 double 操作有关的方法,见表 1。
方法 | 返回值 | 功能 |
---|---|---|
byteValue() | byte | 以 byte 类型返回该 Double 的值 |
doubleValue() | double | 以 double 类型返回该 Double 的值 |
fioatValue() | float | 以 float 类型返回该 Double 的值 |
intValue() | int | 以 int 类型返回该 Double 的值(强制转换为 int 类型) |
longValue() | long | 以 long 类型返回该 Double 的值(强制转换为 long 类型) |
shortValue() | short | 以 short 类型返回该 Double 的值(强制转换为 short 类型) |
isNaN() | boolean | 如果此 Double 值是一个非数字值,则返回 true,否则返回 false |
isNaN(double v) | boolean | 如果指定的参数是一个非数字值,则返回 true,否则返回 false |
toString() | String | 返回一个表示该 Double 值的 String 对象 |
valueOf(String s) | Double | 返回保存指定的 String 值的 Double 对象 |
parseDouble(String s) | double | 将数字字符串转换为 Double 数值 |
例如,将字符串 56.7809 转换为 double 类型的数值,或者将 double 类型的数值 56.7809 转换为对应的字符串,以下代码演示如何实现这两种功能:
String str = "56.7809";
double num = Double.parseDouble(str); // 将字符串转换为 double 类型的数值
double d = 56.7809;
String s = Double.toString(d); // 将double类型的数值转换为字符串
在将字符串转换为 double 类型的数值的过程中,如果字符串中包含非数值类型的字符,则程序执行将出现异常。
Double 类的常用常量
在 Double 类中包含了很多常量,其中较为常用的常量如下。
- MAX_VALUE:值为 1.8E308 的常量,它表示 double 类型的最大正有限值的常量。
- MIN_VALUE:值为 4.9E-324 的常量,它表示 double 类型数据能够保持的最小正非零值的常量。
- NaN:保存 double 类型的非数字值的常量。
- NEGATIVE_INFINITY:保持 double 类型的负无穷大的常量。
- POSITIVE_INFINITY:保持 double 类型的正无穷大的常量。
- SIZE:用秦以二进制补码形式表示 double 值的比特位数。
- TYPE:表示基本类型 double 的 Class 实例。
Java Number类
Number 是一个抽象类,也是一个超类(即父类)。Number 类属于 java.lang 包,所有的包装类(如 Double、Float、Byte、Short、Integer 以及 Long)都是抽象类 Number 的子类。
Number 类定义了一些抽象方法,以各种不同数字格式返回对象的值。如 xxxValue() 方法,它将 Number 对象转换为 xxx 数据类型的值并返回。这些方法如下表所示:
方法 | 说明 |
---|---|
byte byteValue(); | 返回 byte 类型的值 |
double doubleValue(); | 返回 double 类型的值 |
float floatValue(); | 返回 float 类型的值 |
int intValue(); | 返回 int 类型的值 |
long longValue(); | 返回 long 类型的值 |
short shortValue(); | 返回 short 类型的值 |
抽象类不能直接实例化,而是必须实例化其具体的子类。如下代码演示了 Number 类的使用:
Number num = new Double(12.5);
System.out.println("返回 double 类型的值:" + num.doubleValue());
System.out.println("返回 int 类型的值:" + num.intValue());
System.out.println("返回 float 类型的值:" + num.floatValue());
执行上述代码,输出结果如下:
返回 double 类型的值:12.5
返回 int 类型的值:12
返回 float 类型的值:12.5
Java Character类
Character 类是字符数据类型 char 的包装类。Character 类的对象包含类型为 char 的单个字段,这样能把基本数据类型当对象来处理,其常用方法如表 1 所示。
方法 | 描述 |
---|---|
void Character(char value) | 构造一个新分配的 Character 对象,用以表示指定的 char 值 |
char charValue() | 返回此 Character 对象的值,此对象表示基本 char 值 |
int compareTo(Character anotherCharacter) | 根据数字比较两个 Character 对象 |
boolean equals(Character anotherCharacter) | 将此对象与指定对象比较,当且仅当参数不是 null,而 是一个与此对象 包含相同 char 值的 Character 对象时, 结果才是 true |
boolean isDigit(char ch) | 确定指定字符是否为数字,如果通过 Character. getType(ch) 提供的字 符的常规类别类型为 DECIMAL_DIGIT_NUMBER,则字符为数字 |
boolean isLetter(int codePoint) | 确定指定字符(Unicode 代码点)是否为字母 |
boolean isLetterOrDigit(int codePoint) | 确定指定字符(Unicode 代码点)是否为字母或数字 |
boolean isLowerCase(char ch) | 确定指定字符是否为小写字母 |
boolean isUpperCase(char ch) | 确定指定字符是否为大写字母 |
char toLowerCase(char ch) | 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写 |
char toUpperCase(char ch) | 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写 |
可以从 char 值中创建一个 Character 对象。例如,下列语句为字符 S 创建了一个 Character 对象。
Character character = new Character('S');
CompareTo() 方法将这个字符与其他字符比较,并且返回一个整型数组,这个值是两个字符比较后的标准代码差值。当且仅当两个字符相同时,equals() 方法的返回值才为 true。如下面的代码:
Character character = new Character('A');
int result1 = character.compareTo(new Character('V'));
System.out.println(result1); // 输出:0
int result2 = character.compareTo(new Character('B'));
System.out.println(resuit2); // 输出:-1
int result3 = character.compareTo(new Character('1'));
System.out.println(result3); // 输出:-2
例 1
在注册会员时,需要验证用户输入的用户名、密码、性别、年龄和邮箱地址等信息是否符合标准,如果符合标准方可进行注册。那么,下面就使用 Character 类中的一些静态方法来完成这个程序,具体的实现步骤如下。
1)创建 Register 类,在该类中创建 validateUser() 方法,对用户输入的用户名、密码和年龄进行验证,代码如下:
public class Register {
public static boolean validateUser(String uname,String upwd,String age) {
boolean conUname = false; // 用户名是否符合要求
boolean conPwd = false; // 密码是否符合要求
boolean conAge = false; // 年龄是否符合要求
boolean con = false; // 验证是否通过
if (uname.length() > 0) {
for (int i = 0;i < uname.length();i++) {
// 验证用户名是否全部为字母,不能含有空格
if (Character.isLetter(uname.charAt(i))) {
conUname = true;
} else {
conUname = false;
System.out.println("用户名只能由字母组成,且不能含有空格!");
break;
}
}
} else {
System.out.println("用户名不能为空!");
}
if (upwd.length() > 0) {
for (int j=0;j<upwd.length();j++) {
// 验证密码是否由数字和字母组成,不能含有空格
if (Character.isLetterOrDigit(upwd.charAt(j))) {
conPwd = true;
} else {
conPwd = false;
System.out.println("密码只能由数字或字母组成!");
break;
}
}
} else {
System.out.println("密码不能为空!");
}
if (age.length() > 0) {
for (int k = 0;k < age.length();k++) {
// 验证年龄是否由数字组成
if (Character.isDigit(age.charAt(k))) {
conAge = true;
} else {
conAge = false;
System.out.println("年龄输入有误!");
break;
}
}
} else {
System.out.println("年龄必须输入!");
}
if (conUname && conPwd && conAge) {
con = true;
} else {
con = false;
}
return con;
}
}
在 validateUser() 方法中,使用 for 循环遍历用户输入的用户名、密码和年龄,对其每个字符进行验证,判断其是否符合要求。在验证的过程中,分别使用了 Character 类的 isLetter() 方法、isLetterOrDigit() 方法和 isDigit() 方法。
2)编写测试类 Test04,调用 Register 类中的 validateUser() 方法,对用户输入的数据进行验证,并输出验证结果,代码如下:
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("------------用户注册--------------");
System.out.println("用户名:");
String username = input.next();
System.out.println("密码:");
String pwd = input.next();
System.out.println("年龄:");
String age = input.next();
boolean con = Register.validateUser(username,pwd,age);
if (con) {
System.out.println("注册成功!");
} else {
System.out.println("注册失败!");
}
}
}
在 main() 方法中,通过调用 Register 类的 validateUser() 方法,获取一个 boolean 类型的变量,即表明是否验证通过。当变量值为 true 时,表示验证通过,输出注册成功的提示信息;否则表示验证未通过,输出注册失败的提示信息。
运行该程序,当注册的用户名并非全部由字母组成时,提示“用户名只能由字母组成, 且不能含有空格!”信息,如下所示。
------------用户注册--------------
用户名:
tg_xiake
密码:
xiake
年龄:
123
用户名只能由字母组成,且不能含有空格!
注册失败!
当注册的年龄并非只有数字组成时,则提示“年龄输入有误!”,如下所示。
------------用户注册--------------
用户名:
admin
密码:
admin
年龄:
123a
年龄输入有误!
注册失败!
当注册的密码并非只由数字或字母组成时,提示“密码只能由数字或字母组成!”,如下所示。
------------用户注册--------------
用户名:
admin
密码:
admin!
年龄:
25
密码只能由数字或字母组成!
注册失败!
如果注册的用户名、密码和年龄都通过验证,则输出“注册成功!”,如下所示。
------------用户注册--------------
用户名:
admin
密码:
admin
年龄:
123
注册成功!
Java Boolean类
Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类的对象只包含一个类型为 boolean 的字段。此外,此类还为 boolean 和 String 的相互转换提供了很多方法,并提供了处理 boolean 时非常有用的其他一些常用方法。
Boolean 类的构造方法
Boolean 类有以下两种构造形式:
Boolean(boolean boolValue);Boolean(String boolString);
其中 boolValue 必须是 true 或 false(不区分大小写),boolString 包含字符串 true(不区分大小写),那么新的 Boolean 对象将包含 true;否则将包含 false。
Boolean 类的常用方法
在 Boolean 类内部包含了一些和 Boolean 操作有关的方法,见表 1。
方法 | 返回值 | 功能 |
---|---|---|
booleanValue() | boolean | 将 Boolean 对象的值以对应的 boolean 值返回 |
最后
当注册的密码并非只由数字或字母组成时,提示“密码只能由数字或字母组成!”,如下所示。
------------用户注册--------------
用户名:
admin
密码:
admin!
年龄:
25
密码只能由数字或字母组成!
注册失败!
如果注册的用户名、密码和年龄都通过验证,则输出“注册成功!”,如下所示。
------------用户注册--------------
用户名:
admin
密码:
admin
年龄:
123
注册成功!
Java Boolean类
Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类的对象只包含一个类型为 boolean 的字段。此外,此类还为 boolean 和 String 的相互转换提供了很多方法,并提供了处理 boolean 时非常有用的其他一些常用方法。
Boolean 类的构造方法
Boolean 类有以下两种构造形式:
Boolean(boolean boolValue);Boolean(String boolString);
其中 boolValue 必须是 true 或 false(不区分大小写),boolString 包含字符串 true(不区分大小写),那么新的 Boolean 对象将包含 true;否则将包含 false。
Boolean 类的常用方法
在 Boolean 类内部包含了一些和 Boolean 操作有关的方法,见表 1。
方法 | 返回值 | 功能 |
---|---|---|
booleanValue() | boolean | 将 Boolean 对象的值以对应的 boolean 值返回 |
最后
[外链图片转存中…(img-A5eoLwyT-1714129552521)]
[外链图片转存中…(img-jDhQiKbt-1714129552522)]