面向对象基础的Java作业九

你二舅ya

已于 2023-11-27 16:43:44 修改

阅读量83

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2023-11-26 22:08:23 首次发布

本文链接：https://blog.csdn.net/yang2001106/article/details/134634261

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章详细介绍了Java中字符串操作，包括构造方法、判断、获取、转换、拼接、替换、切割以及System类的使用，还涉及了如何定义和操作BankAccount类，实现存款、取款和余额查询功能。

摘要由CSDN通过智能技术生成

1. 编写 Java 程序，定义Test01类，要求如下：

(1) 在main()方法中分别使用不同的构造方法创建字符串对象。

(2) 将字符串内容输出，根据打印结果观察字符串之间的区别，熟悉不同构造方法的用途。

注：String str1 = "string";

String str2 = new String("string");

1．代码

public class Test01 {
    private String str;

    // 无参构造方法
    public Test01() {
        this.str = "";
    }

    // 带有一个字符串参数的构造方法
    public Test01(String str) {
        this.str = str;
    }

    public static void main(String[] args) {
        // 使用无参构造方法创建字符串对象
        Test01 test011 = new Test01();
        System.out.println("使用无参构造方法创建的字符串对象的内容为：" + test011.str);

        // 使用带有一个字符串参数的构造方法创建字符串对象
        Test01 test012 = new Test01("string");
        System.out.println("使用带有一个字符串参数的构造方法创建的字符串对象的内容为：" + test012.str);
    }
}

2．运行效果：

使用无参构造方法创建的字符串对象的内容为：

使用带有一个字符串参数的构造方法创建的字符串对象的内容为：string

2. 编写 Java 程序，定义Test02类，要求如下：

(1) 在main()方法中，使用String类中的几种常见判断操作方法，依次实现对字符串的判断操作。

(2)将判断结果输出，根据打印结果，熟悉不同判断方法的作用。

1．代码

public class Test02 {
    public static void main(String[] args) {
        // 定义一个字符串变量
        String str = "Hello, World!";

        // 使用equals()方法判断字符串是否相等
        boolean isEqual = str.equals("Hello, World!");
        System.out.println("使用equals()方法判断字符串是否相等：" + isEqual);

        // 使用equalsIgnoreCase()方法判断字符串是否相等，忽略大小写
        boolean isEqualIgnoreCase = str.equalsIgnoreCase("hello, world!");
        System.out.println("使用equalsIgnoreCase()方法判断字符串是否相等，忽略大小写：" + isEqualIgnoreCase);

        // 使用contains()方法判断字符串是否包含指定子串
        boolean isContains = str.contains("World");
        System.out.println("使用contains()方法判断字符串是否包含指定子串：" + isContains);

        // 使用startsWith()方法判断字符串是否以指定子串开头
        boolean isStartsWith = str.startsWith("Hello");
        System.out.println("使用startsWith()方法判断字符串是否以指定子串开头：" + isStartsWith);

        // 使用endsWith()方法判断字符串是否以指定子串结尾
        boolean isEndsWith = str.endsWith("!");
        System.out.println("使用endsWith()方法判断字符串是否以指定子串结尾：" + isEndsWith);
    }
}

2．运行效果：

使用equals()方法判断字符串是否相等：true

使用equalsIgnoreCase()方法判断字符串是否相等，忽略大小写：true

使用contains()方法判断字符串是否包含指定子串：true

使用startsWith()方法判断字符串是否以指定子串开头：true

使用endsWith()方法判断字符串是否以指定子串结尾：true

3. 编写 Java 程序，定义Test03类，要求如下：

(1) 在main()方法中，使用String类中几种常见的获取方法，依次实现对字符串的获取操作。

(2)将获取结果输出，根据打印结果，熟悉不同获取方法的作用。

1．代码

public class Test03 {
    public static void main(String[] args) {
        // 定义一个字符串变量
        String str = "Hello, World!";
        
        // 使用charAt()方法获取指定位置的字符
        char ch1 = str.charAt(4);
        System.out.println("使用charAt()方法获取指定位置的字符：" + ch1);
        
        // 使用length()方法获取字符串长度
        int len = str.length();
        System.out.println("使用length()方法获取字符串长度：" + len);
        
        // 使用substring()方法获取子字符串
        String subStr = str.substring(7, 12);
        System.out.println("使用substring()方法获取子字符串：" + subStr);
        
        // 使用indexOf()方法获取指定字符在字符串中的位置
        int index = str.indexOf("o");
        System.out.println("使用indexOf()方法获取指定字符在字符串中的位置：" + index);
        
        // 使用lastIndexOf()方法获取指定字符在字符串中最后一次出现的位置
        int lastIndex = str.lastIndexOf("o");
        System.out.println("使用lastIndexOf()方法获取指定字符在字符串中最后一次出现的位置：" + lastIndex);
    }
}

2．运行效果：

使用charAt()方法获取指定位置的字符：o

使用length()方法获取字符串长度：13

使用substring()方法获取子字符串：World

使用indexOf()方法获取指定字符在字符串中的位置：4

使用lastIndexOf()方法获取指定字符在字符串中最后一次出现的位置：8

4. 编写 Java 程序，定义Test04类，要求如下：

(1) 在main()方法中，使用String类中的转换和拼接方法，对字符串操作。

(2) 将操作结果输出，根据打印结果，熟悉上述转换和拼接方法的作用。

1．代码

public class Test04 {
    public static void main(String[] args) {
        // 将字符串转换为大写字母
        String str1 = "hello world";
        String upperStr1 = str1.toUpperCase();
        System.out.println("将字符串转换为大写字母：" + upperStr1);

        // 将字符串转换为小写字母
        String lowerStr1 = str1.toLowerCase();
        System.out.println("将字符串转换为小写字母：" + lowerStr1);

        // 将字符串反转
        String reverseStr1 = new StringBuilder(str1).reverse().toString();
        System.out.println("将字符串反转：" + reverseStr1);

        // 将两个字符串拼接成一个字符串
        String str2 = "hello";
        String str3 = "world";
        String concatStr1 = str2 + str3;
        System.out.println("将两个字符串拼接成一个字符串：" + concatStr1);

        // 将一个字符串插入到另一个字符串中
        String insertStr1 = "Java编程语言";
        String str4 = "是一种高级语言";
        String insertStr2 = insertStr1.substring(0, 5) + str4;
        System.out.println("将一个字符串插入到另一个字符串中：" + insertStr2);
    }
}

2．运行效果：

将字符串转换为大写字母：HELLO WORLD

将字符串转换为小写字母：hello world

将字符串反转：dlrow olleh

将两个字符串拼接成一个字符串：helloworld

将一个字符串插入到另一个字符串中：Java编是一种高级语言

5. 编写 Java 程序，定义Test05类，要求如下：

(1) 在main()方法中，使用String类中的替换和切割等方法，对字符串的操作。

(2) 将操作结果输出，根据打印结果，熟悉上述替换和切割方法的作用。

1．代码

public class Test05 {
    public static void main(String[] args) {
        // 定义一个字符串
        String str = "Hello, World!";

        // 使用replace()方法将字符串中的"World"替换为"Java"
        String replacedStr = str.replace("World", "Java");
        System.out.println("使用replace()方法将字符串中的\"World\"替换为\"Java\":" + replacedStr);

        // 使用substring()方法从字符串中截取第7个字符到第12个字符
        String subStr = str.substring(7, 12);
        System.out.println("使用substring()方法从字符串中截取第7个字符到第12个字符：" + subStr);

        // 使用split()方法将字符串按照空格分割成数组
        String[] splitStr = str.split(" ");
        System.out.println("使用split()方法将字符串按照空格分割成数组：");
        for (String s : splitStr) {
            System.out.println(s);
        }
    }
}

2．运行效果：

使用replace()方法将字符串中的"World"替换为"Java":Hello, Java!

使用substring()方法从字符串中截取第7个字符到第12个字符：World

使用split()方法将字符串按照空格分割成数组：

Hello,

World!

6. 编写 Java 程序，定义Test06类，要求如下：

(1) 在main()方法中，使用StringBuffer类中的方法，依次实现字符序列的添加和删除操作。

(2)将添加和删除操作的结果输出，根据打印结果，熟悉各个方法的作用。

1．代码

public class Test06 {
    public static void main(String[] args) {
        // 定义一个StringBuffer对象
        StringBuffer strBuf = new StringBuffer("Hello");

        // 使用append()方法将字符' World'添加到字符串末尾
        strBuf.append(" World");
        System.out.println("使用append()方法将字符' World'添加到字符串末尾：" + strBuf);

        // 使用delete()方法删除字符串中的第4个字符
        strBuf.delete(3, 7);
        System.out.println("使用delete()方法删除字符串中的第4个字符：" + strBuf);

        // 使用insert()方法在字符串中插入字符'!'
        strBuf.insert(5, "!");
        System.out.println("使用insert()方法在字符串中插入字符'!':" + strBuf);

        // 使用reverse()方法将字符串反转
        strBuf.reverse();
        System.out.println("使用reverse()方法将字符串反转：" + strBuf);
    }
}

2．运行效果：

使用append()方法将字符' World'添加到字符串末尾：Hello World

使用delete()方法删除字符串中的第4个字符：Helorld

使用insert()方法在字符串中插入字符'!':Helor!ld

使用reverse()方法将字符串反转：dl!roleH

7. 编写 Java 程序，定义Test07类，要求如下：

(1) 在main()方法中，通过StringBuffer类的替换、截取和反转等方法依次实现对字符序列的操作。

(2) 将替换、截取和反转操作的结果输出，根据打印结果，加深不同方法的理解。

1．代码

public class Test07 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello, World!");

        // 替换操作
        sb.replace(7, 12, "Java");
        System.out.println("替换操作的结果：" + sb);

        // 截取操作
        String substring = sb.substring(7, 12);
        System.out.println("截取操作的结果：" + substring);

        // 反转操作
        sb.reverse();
        System.out.println("反转操作的结果：" + sb);
    }
}

运行效果：

替换操作的结果：Hello, Java!

截取操作的结果：Java!

反转操作的结果：!avaJ ,olleH

8. 编写 Java 程序，定义Test08类，要求如下：

(1) 在main()方法中，通过调用System类的常用方法，依次实现获取系统信息的操作。

(2) 将获取到的系统信息输出，根据打印结果，熟悉System类中常用方法的作用。

1．代码

public class Test08 {
    public static void main(String[] args) {
        // 获取操作系统名称
        String osName = System.getProperty("os.name");
        System.out.println("操作系统名称： " + osName);

        // 获取操作系统版本
        String osVersion = System.getProperty("os.version");
        System.out.println("操作系统版本： " + osVersion);

        // 获取Java运行时环境版本
        String javaVersion = System.getProperty("java.version");
        System.out.println("Java运行时环境版本： " + javaVersion);

        // 获取Java安装目录
        String javaHome = System.getProperty("java.home");
        System.out.println("Java安装目录： " + javaHome);

        // 获取用户的主目录
        String userHome = System.getProperty("user.home");
        System.out.println("用户主目录： " + userHome);

        // 获取用户的当前工作目录
        String userDir = System.getProperty("user.dir");
        System.out.println("用户当前工作目录： " + userDir);
    }
}

2．运行效果：

操作系统名称： Windows 11

操作系统版本： 10.0

Java运行时环境版本： 17.0.8

Java安装目录： D:\JAVA

用户主目录： C:\Users\凡尘

用户当前工作目录： D:\java\java程序文件\tenproject

思考题：编写Java应用程序。定义一个描述银行类，包括成员变量“账号”和“存款余额”，成员方法有“存款”、“取款”和“余额查询”。测试银行类的功能。

注：掌握定义类的语法结构、掌握类的实例化方法、掌握对象属性、方法的调用。

1．代码

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

// 定义银行账户类
class BankAccount {
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public boolean withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            return true; // 取款成功
        } else {
            return false; // 余额不足，取款失败
        }
    }
}

// 定义银行类
public class Bank {
    private static Map<String, BankAccount> accounts = new HashMap<>();
    private static String currentAccount; // 当前登录的账号

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            // 提供登录和注册选项
            System.out.println("欢迎使用银行服务!");
            System.out.println("请选择操作:");
            System.out.println("1.登录");
            System.out.println("2.注册");
            System.out.println("3.退出");

            int choice = scanner.nextInt();
            scanner.nextLine(); // 消耗换行符

            switch (choice) {
                case 1:
                    login(scanner);
                    break;
                case 2:
                    register(scanner);
                    break;
                case 3:
                    System.out.println("感谢使用银行服务，再见！");
                    scanner.close();
                    System.exit(0);
                default:
                    System.out.println("无效的选择");
            }

            // 登录成功后的操作
            if (currentAccount != null) {
                while (true) {
                    System.out.println("当前账户为: " + currentAccount);
                    System.out.println("请选择服务类型:");
                    System.out.println("1.存款");
                    System.out.println("2.取款");
                    System.out.println("3.余额查询");
                    System.out.println("4.退出登录");

                    int serviceChoice = scanner.nextInt();
                    scanner.nextLine(); // 消耗换行符

                    switch (serviceChoice) {
                        case 1:
                            deposit(scanner);
                            break;
                        case 2:
                            withdraw(scanner);
                            break;
                        case 3:
                            checkBalance();
                            break;
                        case 4:
                            currentAccount = null;
                            System.out.println("已退出登录。");
                            break;
                        default:
                            System.out.println("无效的选择");
                    }

                    // 退出登录后返回到主界面
                    if (currentAccount == null) {
                        break;
                    }
                }
            }
        }
    }

    private static void login(Scanner scanner) {
        // 登录逻辑...
        System.out.println("请输入账号:");
        String account = scanner.nextLine();
        System.out.println("请输入密码:");
        String password = scanner.nextLine();

        if (accounts.containsKey(account)) {
            // 简单演示，密码直接和账号相同
            if (password.equals(account)) {
                currentAccount = account;
                System.out.println("登录成功，欢迎回来！");
            } else {
                System.out.println("密码错误，登录失败。");
            }
        } else {
            System.out.println("账号不存在，登录失败。");
        }
    }

    private static void register(Scanner scanner) {
        // 注册逻辑...
        System.out.println("请输入新账号:");
        String newAccount = scanner.nextLine();

        // 检查账号是否已存在
        if (accounts.containsKey(newAccount)) {
            System.out.println("账号已存在，请选择登录或使用其他账号注册。");
        } else {
            System.out.println("请输入密码:");
            String newPassword = scanner.nextLine();

            // 创建新账户并关联
            BankAccount newBankAccount = new BankAccount(generateAccountNumber(), 0.0);
            accounts.put(newAccount, newBankAccount);

            System.out.println("注册成功，请记好您的账号和密码。");
        }
    }

    private static void deposit(Scanner scanner) {
        // 存款逻辑...
        System.out.println("请输入存款数目:");
        double depositAmount = scanner.nextDouble();
        scanner.nextLine(); // 消耗换行符

        BankAccount account = accounts.get(currentAccount);
        account.deposit(depositAmount);

        System.out.println("您的存款数目为: " + depositAmount + "元，账户余额为: " + account.getBalance() + "元");
    }

    private static void withdraw(Scanner scanner) {
        // 取款逻辑...
        System.out.println("请输入取款数目:");
        double withdrawAmount = scanner.nextDouble();
        scanner.nextLine(); // 消耗换行符

        BankAccount account = accounts.get(currentAccount);
        boolean success = account.withdraw(withdrawAmount);

        if (success) {
            System.out.println("取款成功，取款数目为: " + withdrawAmount + "元，账户余额为: " + account.getBalance() + "元");
        } else {
            System.out.println("余额不足，取款失败。");
        }
    }

    private static void checkBalance() {
        // 余额查询逻辑...
        BankAccount account = accounts.get(currentAccount);
        System.out.println("账户余额为: " + account.getBalance() + "元");
    }

    private static String generateAccountNumber() {
        // 简单生成账号的逻辑，可以根据实际需求修改
        return "6228" + (int) (Math.random() * 1000000000000000L);
    }
}

2．运行效果：