Java内置的包装类_java 自带类

最新推荐文章于 2024-07-30 14:53:52 发布

2401_84002482

最新推荐文章于 2024-07-30 14:53:52 发布

阅读量632

点赞数 12

分类专栏：程序员文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/2401_84002482/article/details/138227720

版权

程序员专栏收录该内容

195 篇文章 1 订阅

订阅专栏

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 值返回

最后

腾讯T3大牛总结的500页MySQL实战笔记意外爆火，P8看了直呼内行

当注册的密码并非只由数字或字母组成时，提示“密码只能由数字或字母组成！”，如下所示。

------------用户注册--------------
用户名：
admin
密码：
admin!
年龄：
25
密码只能由数字或字母组成！
注册失败！

如果注册的用户名、密码和年龄都通过验证，则输出“注册成功！”，如下所示。

------------用户注册--------------
用户名：
admin
密码：
admin
年龄：
123
注册成功！

Java 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)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84002482

关注

12
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
Java内置的包装类_java 自带类

当注册的密码并非只由数字或字母组成时，提示“密码只能由数字或字母组成！”，如下所示。------------用户注册--------------用户名：admin密码：admin!年龄：25密码只能由数字或字母组成！注册失败！如果注册的用户名、密码和年龄都通过验证，则输出“注册成功！”，如下所示。------------用户注册--------------用户名：admin密码：admin年龄：123注册成功！
复制链接

扫一扫