JavaSE——面向对象练习题

已于 2024-10-04 21:00:07 修改
阅读量99 收藏 3
点赞数 5
分类专栏： # JavaSE 文章标签： java 面向对象 super this
于 2024-10-04 19:09:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Helen_1997_1997/article/details/127712557
版权

1.对象数组排序

        定义一个Person类{name,age,job}，初始化Person对象数组，有3个person对象，并按照age从小到大进行冒泡排序；再按照name的长度从小到大进行选择排序。

public class HomeWork01 {
    public static void main(String[] args) {
        Person[] persons = new Person[4];
        persons[0] = new Person("zhangsan", 18, "java工程师");
        persons[1] = new Person("lisi", 32, "项目经理");
        persons[2] = new Person("wangwu", 10, "小学生");
        persons[3] = new Person("tom", 50, "BOSS");
        System.out.println("原始数组：" + Arrays.toString(persons));

        for (int i = 0; i < persons.length - 1; i++) {
            for (int j = 0; j < persons.length - 1 - i; j++) {
                if (persons[j].getAge() > persons[j + 1].getAge()) {
                    Person temp = persons[j];
                    persons[j] = persons[j + 1];
                    persons[j + 1] = temp;
                }
            }
        }
        System.out.println("按照年龄[从小到大]进行冒泡排序：" + 
                                Arrays.toString(persons));

        for (int i = 0; i < persons.length - 1; i++) {
            for (int j = i + 1; j < persons.length; j++) {
                if (persons[i].getName().length() > persons[j].getName().length()) {
                    Person temp1 = persons[i];
                    persons[i] = persons[j];
                    persons[j] = temp1;
                }
            }
        }

        System.out.println("按照姓名长度[从小到大]进行选择排序：" +
                                 Arrays.toString(persons));
    }
}

class Person {
    private String name;
    private int age;
    private String job;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = job;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                '}';
    }
}

运行结果：

2.super与this区别 

3.判断输出结果(super与this区分)

public class Homework07 {
    public static void main(String[] args) {

    }
}

class Test { //父类
    String name = "Rose";

    Test() {
        System.out.println("Test");//(1)
    }

    Test(String name) {//name john
        this.name = name;//这里把父类的 name 修改 john
    }
}

class Demo extends Test {//子类
    String name = "Jack";

    Demo() {
        super();
        System.out.println("Demo");//(2)
    }

    Demo(String s) {
        super(s);
    }

    public void test() {
        System.out.println(super.name);//(3) Rose (5) john
        System.out.println(this.name);//(4) Jack (6) Jack
    }

    public static void main(String[] args) {
        //1. new Demo()
        new Demo().test(); //匿名对象
        new Demo("john").test();//匿名
    }
}

运行结果：

4.模拟银行存取款业务

class BankAccount {
    private double balance; // 余额

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

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

    // 取款
    public void withdraw(double amount) {
        balance -= amount;
    }
}

题目要求：

(1)在上面类的基础上扩展新类CheckingAccount，对每次存款和取款都收取1美元的手续费。

首先，我们对BankAccount类添加get与set方法：

class BankAccount {
    private double balance; // 余额

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

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

    // 取款
    public void withdraw(double amount) {
        balance -= amount;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

创建新类CheckingAccount：

class CheckingAccount extends BankAccount {

    public CheckingAccount(double initialBalance) {
        super(initialBalance);
    }

    /**
     * 存款收取1美元手续费，相当于少存1美元
     *
     * @param amount
     */
    @Override
    public void deposit(double amount) {
        super.deposit(amount - 1);
    }

    /**
     * 取款收取1美元手续费，相当于再给银行1美元
     *
     * @param amount
     */
    @Override
    public void withdraw(double amount) {
        super.withdraw(amount + 1);
    }
}

结果检验：

public class HomeWork08 {
    public static void main(String[] args) {
        CheckingAccount checkingAccount = new CheckingAccount(1000);
        checkingAccount.deposit(100);
        System.out.println(checkingAccount.getBalance()); // 1099.0

        checkingAccount.withdraw(20);
        System.out.println(checkingAccount.getBalance()); // 1078.0
    }
}

(2)扩展前一个练习的BankAccount类，新类SavingsAccount每个月都有利息产生(earnMonthlyInterest方法被调用)，并且有每月三次免手续费的存款或取款。在earnMonthlyInterest方法中重置交易计数。

SavingsAccount类：

class SavingsAccount extends BankAccount {
    // 定义计费次数
    private int count = 3;

    // 定义银行利率
    private double rate = 0.01;


    public SavingsAccount(double initialBalance) {
        super(initialBalance);
    }

    /**
     * 每月重新计算利率
     */
    public void earnMonthlyInterest() {
        // 重新初始化计费次数
        this.count = 3;

        // 每月重新计算计算余额
        super.deposit(getBalance() * rate);
    }

    /**
     * 重写存款方法，存款前查看存款是否超过3次
     *
     * @param amount 存入的金额
     */
    @Override
    public void deposit(double amount) {
        if (count > 0) {
            super.deposit(amount);
        } else {
            super.deposit(amount - 1);
        }
        count--;
    }

    /**
     * 重写取款方法，取款前查看取款是否超过3次
     *
     * @param amount 取款的金额
     */
    @Override
    public void withdraw(double amount) {
        if (count > 0) {
            super.withdraw(amount);
        } else {
            super.withdraw(amount + 1);
        }
        count--;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public double getRate() {
        return rate;
    }

    public void setRate(double rate) {
        this.rate = rate;
    }
}

结果检验： 

public class HomeWork08 {
    public static void main(String[] args) {   
        SavingsAccount savingsAccount = new SavingsAccount(1000);
        savingsAccount.deposit(100);
        savingsAccount.deposit(100);
        savingsAccount.deposit(100);
        System.out.println(savingsAccount.getBalance()); // 1300.0

        savingsAccount.withdraw(10); // 第4次存取，需要征收手续费
        System.out.println(savingsAccount.getBalance()); // 1289.0

        // 月初初始化计费次数
        savingsAccount.earnMonthlyInterest();
        System.out.println(savingsAccount.getBalance()); // 1301.89

        savingsAccount.deposit(100);
        System.out.println(savingsAccount.getBalance()); // 1401.89

        savingsAccount.withdraw(50);
        savingsAccount.withdraw(50);
        savingsAccount.withdraw(50); // 征收手续费
        System.out.println(savingsAccount.getBalance()); // 1250.89
    }
}

5.重写equals方法判断两个对象是否相等

        编写Doctor类{name,age,job,gender,sal}相应的getter()和setter()方法，5个参数的构造器，重写父类(Object)的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同。 

public class HomeWork10 {
    public static void main(String[] args) {
        Doctor doctor = new Doctor("张三", 32, "主治医师", '男', 25000);
        Doctor doctor2 = new Doctor("张三", 32, "主治医师", '男', 25000);
        System.out.println(doctor.equals(doctor2)); // true
    }
}

class Doctor {
    private String name;
    private int age;
    private String job;
    private char gender;
    private double sal;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        // 判断obj 是否是 Doctor类型或其子类
        if (!(obj instanceof Doctor)) {
            return false;
        }

        // 向下转型, 因为obj的运行类型是Doctor或者其子类型
        Doctor doctor = (Doctor) obj;
        return this.name.equals(doctor.getName()) &&
                this.age == doctor.getAge() &&
                this.job.equals(doctor.getJob()) &&
                this.gender == doctor.getGender() &&
                this.sal == doctor.getSal();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public Doctor(String name, int age, String job, char gender, double sal) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.gender = gender;
        this.sal = sal;
    }

6.写出向上转型和向下转型代码 

public class HomeWork11 {
    public static void main(String[] args) {
        // 向上转型代码
        // 父类的引用指向子类对象
        Person2 p = new Student();
        p.run(); // student run
        p.eat(); // person eat

        // 向下转型代码
        // 把指向子类对象的父类引用，转成指向子类对象的子类引用
        Student student = (Student) p;
        // 注意动态绑定问题
        student.run(); // student run
        student.study(); // student study..
        // 因为Student是Person2的子类，所以可以调用父类eat方法
        student.eat(); // person eat
    }
}

class Person2 {
    public void run() {
        System.out.println("person run");
    }

    public void eat() {
        System.out.println("person eat");
    }
}

class Student extends Person2 {
    @Override
    public void run() {
        System.out.println("student run");
    }

    public void study() {
        System.out.println("student study..");
    }
}

7.判断输出结果

public class HomeWork14 {
    public static void main(String[] args) {
        C c = new C();
    }
}

class A {
    public A() {
        System.out.println("我是A类");
    }
}

class B extends A {
    public B() {
        System.out.println("我是B类的无参构造");
    }

    public B(String name) {
        System.out.println(name + "我是B类的有参构造");
    }
}

class C extends B {
    public C() {
        this("hello");
        System.out.println("我是C类的无参构造");
    }

    public C(String name) {
        super("hahah");
        System.out.println("我是C类的有参构造");
    }
}

运行结果：

雷神乐乐
关注
专栏目录
JAVASE.面向对象(1)
12-22
面向对象是Java编程的核心概念，它允许我们模拟现实世界中的对象和它们之间的交互。在Java中，面向对象主要包含三个基本特征：封装、继承和多态。 1. 封装：封装是隐藏对象的属性和实现细节，仅对外提供公共访问...
JavaSE进阶 面向对象多态
11-12
JavaSE 进阶 面向对象多态 在 JavaSE 中，面向对象多态是指同一个对象可以具有多种形态，例如一个人可以是老师、丈夫、父亲等。这种多态性是通过方法的重写和重载来实现的。 多态的形式有很多，例如： 1. 方法...
JavaSE进阶 面向对象继承
11-12
JavaSE进阶面向对象继承 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为。继承的优点是可以提高代码的可重用性，减少代码冗余，提高开发效率。 1. 继承的定义：继承是指一个类继承另一个类的...
6、JavaSE：面向对象.pdf
04-24
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想是将数据和操作数据的方法封装在一起，形成类和对象，以此来模拟现实世界中的事物。与面向过程（Procedure-Oriented Programming）不同...
面向对象下代码（JAVASE）
09-06
面向对象下代码（JAVASE）
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 400
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 509
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 780
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1147
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 318
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1101
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
Java - LeetCode面试经典150题 - 哈希表 (二)
心如冰清，天塌不惊
09-28 897
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 859
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 406
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 324
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
JAVA开源项目 旅游管理系统 计算机毕业设计
最新发布
as230627的博客
10-03 1013
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 382
记忆中，两个指针合并即可。
Java中ResultSet接口的详细介绍
2301_77032029的博客
09-28 452
ResultSet接口是Java JDBC API中的一个核心接口，用于表示从数据库查询返回的结果集。它允许用户遍历查询结果，并从中提取数据。ResultSet接口代表从数据库查询返回的结果集，它提供了以下功能：遍历结果集：允许用户向前或向后移动指针，以便访问结果集中的每一行。
[C++][程序退出]详细讲解
SnowK博客
09-30 2758
[C++][程序退出]详细讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值