AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java程序设计实验3 | 面向对象（上）（二）

2024-05-27 44
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 分数的分子和分母用两个整型数表示，类所拥有的方法包括对分数进行加、减、乘、除等运算，以及输出分数的方法，输出分数的格式应该是：分子/分母。

Java程序设计实验3 | 面向对象（上）（一）+ https://developer.aliyun.com/article/1520470?spm=a2c6h.13148508.setting.14.de6d4f0e3Ph7xG



4、设计一个分数类


分数的分子和分母用两个整型数表示，类所拥有的方法包括对分数进行加、减、乘、除等运算，以及输出分数的方法，输出分数的格式应该是：分子/分母。


在测试类中定义分数类对象，运算并输出运算结果。


本题若不考虑分数的约分，难度会小一些。在该题的拓展部分介绍了约分的方式。


整体思路如下面源代码所示：


  • 定义一个Fraction分数类，其中包含mol（分子，molecule）和den（分母，denominator）两个成员变量。


  • 重写toString()方法，指定以 mol+"/"+den 的格式输出。


  • 通过含参构造方法实例化分数类。注意分母不能为0的限定条件。若分母为0，在构造函数中抛出异常。


  • 设计加减乘除四则运算。注意这里的思路。以分数加法的方法为例：
public Fraction add(Fraction x){
    return new Fraction(this.mol*x.den + x.mol*this.den,  this.den*x.den);
}

两个分数运算后得到的结果仍然是分数。因此，该成员方法的返回值为Fraction，传入的运算参数类型也为Fraction。确定了方法的返回值与参数后，那么问题就来了：如何让当前分数对象与传入的分数对象x做运算呢？


有些同学可能会想到一个思路，就是求出当前对象的分数值后再直接与x相加。即：


this.mol/this.den + x;    //Error


但这种做法是完全行不通的。首先这一定会遇到类型转换的问题：this.mol/this.den是int类型，而x是Fraction类型，二者之间不能进行运算。这时又有人想到，可以通过构造方法把 this.mol/this.den 以似乎是Fraction类型的形式表现出来，即：


new Fraction(this.mol,this.den) + x;    //Error


但事实上，这也是完全错误的。Fraction是引用类型，两个引用类型之间怎么能用+号进行运算呢？



出现这两种错误思路的根本原因在于：没有意识到到底是谁在进行运算。两个引用类型之间能直接进行四则运算吗？当然是不能的。而是引用类型的成员之间进行四则运算。就和两个引用类型进行比较一样，它们不能用大于号小于号等于号直接比较，而要用equals或Comparable接口实现compareTo()接口后，按照某种指定的规则进行比较。


同样地，当我们说两个分数进行相加，并不是“分数”这个概念进行的运算，而是分子和分母之间进行的运算。正确的做法是：通过构造方法将分子相加的结果、分母相加的结果得到一个新的分数，这个分数才是最终的结果。即：


new Fraction(this.mol*x.den + x.mol*this.den,  this.den*x.den);
//括号中的内容即通分相加的过程


其余的三则运算同理。一个引用类型与它的成员是密不可分的。当要对某一个引用类型进行操作时，要顺带考虑一下是否关系到它的成员。

源代码：


class Fraction {
    private int mol;    //分子
    private int den;    //分母
 
    public Fraction(int x, int y) {
        if (y == 0){
            throw new ArithmeticException("分母为0！");
        }
        this.mol = x;
        this.den = y;
    }
 
    public Fraction add(Fraction x){
        return new Fraction(this.mol * x.den + x.mol * this.den,this.den * x.den);
    }
    public Fraction sub(Fraction x){
        return new Fraction(this.mol * x.den - x.mol * this.den,this.den * x.den);
    }
    public Fraction mul(Fraction x){
        return new Fraction(this.mol * x.mol,this.den * x.den);
    }
    public Fraction div(Fraction x){
        if(x.mol == 0) {
            throw new ArithmeticException("除数为0！");
        }
        return new Fraction(this.mol * x.den,this.den * x.mol);
    }
 
    @Override
    public String toString() {
        return mol+"/"+den;
    }
}


public class S3_4 {
    public static void main(String[] args) {
        Fraction fraction1 = new Fraction(4,5);
        Fraction fraction2 = new Fraction(3,4);
        System.out.println("分数1：" + fraction1 + " 分数2：" + fraction2);
        System.out.println("add:" + fraction1.add(fraction2));
        System.out.println("sub:" + fraction1.sub(fraction2));
        System.out.println("mul:" + fraction1.mul(fraction2));
        System.out.println("div:" + fraction1.div(fraction2));
    }
}


列出测试数据和实验结果截图：



令fraction1的分母为0，则：



令fraction2的分子为0（即令fraction2为0），则除数为零，则：



⭐拓展：分数约分


分数约分的本质是找到分子mol与分母den的最大公约数。分子与分母同时除以该最大公约数的过程就是约分。本文在此拓展求最大公约数的方法：辗转相除法。


内容扩展：

🔗迭乘法、辗转相除法、试除法：最大公约数与最小公倍数问题


迭代版


import java.util.Scanner;
 
public class Test {
    public static void main(String[] args) {
        //辗转相除法求最大公约数、最小公倍数
        Scanner reader = new Scanner(System.in);
 
        //输入两个数
        int n = reader.nextInt();
        int m = reader.nextInt();
 
/*因为求最大公约数和最小公倍数都需要用到m、n，且辗转相除的过程会改变n、m的值，
故再创建两个变量n2、m2，把m和n的值拷贝一份再做运算*/
        int m2 = m;
        int n2 = n;
 
        int r = n2 % m2;
        //最大公约数
        while (r != 0) {
            n2 = m2;
            m2 = r;    //注意：m2才是所求的最大公约数的结果，而不是r
            r = n2 % m2;
        }
        System.out.println(m2);
    }
}




递归版


public static int getComDivisor(int a , int b){
    if(a % b == 0) {
        return b;
    }
 
    return getComDivisor(b,a % b);
}


public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);
 
    //输入两个数
    int n = reader.nextInt();
    int m = reader.nextInt();
 
    System.out.println(getComDivisor(n,m));
}



运用到该题


源代码：

public class S3_4 {
    public static void main(String[] args) {
        Fraction fraction1 = new Fraction(4,5);
        Fraction fraction2 = new Fraction(3,4);
        System.out.println("分数1：" + fraction1 + " 分数2：" + fraction2);
        System.out.println("add:" + fraction1.add(fraction2));
        System.out.println("sub:" + fraction1.sub(fraction2));
        System.out.println("mul:" + fraction1.mul(fraction2));
        System.out.println("div:" + fraction1.div(fraction2));
    }
}
 
class Fraction {
    private int mol;    //分子
    private int den;    //分母
 
    //新增
    private int getComDivisor(int a , int b){
        if(a % b == 0) {
            return b;
        }
 
        return getComDivisor(b,a % b);
    }
 
    public Fraction(int x, int y) {
        if (y == 0){
            throw new ArithmeticException("分母为0！");
        }
        this.mol = x;
        this.den = y;
        int tmp = getComDivisor(x,y);
        this.mol = x/tmp;
        this.den = y/tmp;
    }
    //
 
    public Fraction add(Fraction x){
        return new Fraction(this.mol * x.den + x.mol * this.den,this.den * x.den);
    }
    public Fraction sub(Fraction x){
        return new Fraction(this.mol * x.den - x.mol * this.den,this.den * x.den);
    }
    public Fraction mul(Fraction x){
        return new Fraction(this.mol * x.mol,this.den * x.den);
    }
    public Fraction div(Fraction x){
        if(x.mol == 0) {
            throw new ArithmeticException("除数为0！");
        }
        return new Fraction(this.mol * x.den,this.den * x.mol);
    }
 
    @Override
    public String toString() {
        return mol+"/"+den;
    }
}


列出测试数据和实验结果截图：



5、设计一个雇员类


（1）属性包括：编号、姓名、年龄、职务、部门，要求合理选定属性类型；该雇员类还拥有统计出勤人数的功能，可以考虑为雇员类设计一个静态属性；方法包括：构造方法、输出信息的方法、签到方法；


（2）创建雇员类对象，统计雇员的出勤人数。注意考虑属性和方法的访问权限，方法的功能，及main方法中如何实现要求统计的信息。


本题的思路如下：


1、成员属性编号、姓名、年龄、职务、部门封装，用private修饰，设计setter与getter方法。


2、静态属性attendance用于统计雇员出勤人数，用static修饰。默认初始化为0.


3、输出信息的方法通过重写toString()方法完成。


4、签到方法的功能是提示签到成功，并令attendance++，以达到统计出勤人数的目标。


源代码：


public class S3_5 {
    public static void main(String[] args) {
        //实例化雇员对象
        Employee employee1 = new Employee(1001,"虹猫",20,"产品经理","开发部");
        Employee employee2 = new Employee(1002,"蓝兔",19,"食堂队长","后勤部");
        Employee employee3 = new Employee(1003,"大奔",21,"技术总监","技术部");
        Employee employee4 = new Employee(1004,"莎莉",18,"销售总监","销售部");
        
        //签到
        Employee[] employees = {employee1,employee2,employee3,employee4};
        for (Employee x : employees) {
            System.out.println(x.toString());
            Employee.signIn(x);
        }
 
        //公布出勤人数
        System.out.println("共" + Employee.attendance + "人出勤！");
        
    }
}
 
class Employee{
    //出勤人数，默认初始化为0
    public static int attendance;  
 
    //成员属性
    private int ID;
    private String name;
    private int age;
    private String post;
    private String department;
 
    //getter与setter
    public int getID() {
        return ID;
    }
 
    public void setID(int ID) {
        this.ID = ID;
    }
 
    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 getPost() {
        return post;
    }
 
    public void setPost(String post) {
        this.post = post;
    }
 
    public String getDepartment() {
        return department;
    }
 
    public void setDepartment(String department) {
        this.department = department;
    }
 
    //构造方法
    public Employee(int ID, String name, int age, String post, String department) {
        this.ID = ID;
        this.name = name;
        this.age = age;
        this.post = post;
        this.department = department;
    }
 
    //输出信息的方法：重写toString()
    @Override
    public String toString() {
        return  "ID=" + ID +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", post='" + post + '\'' +
                ", department='" + department + '\'' +
                '}';
    }
    
    //签到方法
    public static void signIn(Employee x) {
        System.out.println(x.name + "签到成功！");
        Employee.attendance++;    //用于统计
    }
}


列出测试数据和实验结果截图：



6、设计一个电视机类


属性包括商品编号、开关状态、音量、频道等，同时设计一些方法对电视机的状态进行控制。例如，方法应包括开/关电视机、更换频道、提高/减小音量等。要求商品编号自动生成（可以考虑为电视机类设置一个管理商品编号的静态成员变量，或者专门设置一个编号管理类）。


注意：有些成员变量需要定义为静态的（static），控制和操纵静态成员变量的方法应是静态的（static）。


本题思路如下：


1、设计静态变量num用于自动生成产品编号。每次构造一个电视机实例，num值加一。将num值赋给电视机编号itemNO即可实现自动生成。


2、开关电视机的成员方法tvSwitch()。用boolean变量status控制电视机的开关。该方法用于改变status的值，若为true，则改为false；若为false则改为true，以此实现电视机的开关。


3、调节音量的实现方式是令音量值向上增1或向下减1.要向上调节音量还是向下调节取决于用户传入的adjust变量值为true还是false。true则向上调节，false则向下调节。音量的调节范围是0~100.对临界情况的调节要予以考虑。


4、调节频道有两个重载的方法。可以通过和音量一样的调节方式调节，也可以由用户指定频道，直接跳转到目标频道。频道的调节范围是0~100.对临界情况的调节要予以考虑。


5、注意：在对电视机进行操作之前，必须确保电视机是开机状态，即status为true。否则不能进行相关操作。


6、main方法中设计了4个不同状态的电视机对象，对Television类进行测试。最终输出四个对象的相关信息，通过重写toString方法实现。


源代码：


public class S3_6 {
 
    public static void main(String[] args) {
        Television tv1 = new Television();
        Television tv2 = new Television();
        Television tv3 = new Television();
        Television tv4 = new Television();
 
        //打开tv1、tv2、tv3
        tv1.tvSwitch();
        tv2.tvSwitch();
        tv3.tvSwitch();
        System.out.println("电视机tv1、tv2、tv3已打开！");
 
        //尝试将tv1的音量上调(true)、tv2的音量下调(false)
        System.out.println("==========尝试将tv1的音量上调(true)、tv2的音量下调(false)==========");
        tv1.adjustVolume(true);
        tv2.adjustVolume(false);
 
        //尝试将tv3的频道换成50、将tv1的频道换成100
        System.out.println("==========尝试将tv3的频道换成50、将tv1的频道换成100==========");
        tv3.changeChannel(50);
        tv1.changeChannel(100);
        //尝试将tv3向下调台、将tv1向上调台
        System.out.println("==========尝试将tv3向下调台、将tv1向上调台==========");
        tv3.changeChannel(false);
        tv1.changeChannel(true);
 
        //获取tv2当前的频道和音量
        System.out.println("==========获取tv2当前的频道和音量==========");
        System.out.println(tv2.getVolume());
        System.out.println(tv2.getChannel());
 
        //对未开机的tv4进行操作时：
        System.out.println("==========对未开机的tv4进行操作==========");
        tv4.changeChannel(50);
        tv4.adjustVolume(true);
 
        //输出各个电视机的信息
        System.out.println("==========输出各个电视机的信息==========");
        System.out.println(tv1.toString());
        System.out.println(tv2.toString());
        System.out.println(tv3.toString());
        System.out.println(tv4.toString());
    }
}
 
 
//电视机类
class Television{
    private static int num; //管理商品编号的静态成员变量
    private String itemNO; //商品编号
    private boolean status; //开关状态
    private int volume; //音量
    private int channel;    //频道
 
    public int getVolume() {
        if (this.status) {
            return volume;
        }else {
            return -1;
        }
    }
 
    public boolean isStatus() {
        return status;
    }
 
    public int getChannel() {
        if (this.status) {
            return this.channel;
        }else {
            return -1;
        }
    }
 
 
    //构造方法，自动生成产品编号
    public Television() {
        Television.num++;
        this.itemNO = "tv000" + Television.num;
    }
    //开关电视机
    public boolean tvSwitch() {
        if(!this.status) {
            this.status = true;
        } else {
            this.status = false;
        }
        return this.status;
    }
    //上调或下调频道
    public void changeChannel(boolean change){
        if(change) {
            this.channel++;
            if(channel > 100) {
                System.out.println("已达最大频道，无法增加！");
                this.channel--;
            }
        }else{
            this.channel--;
            if(channel < 0) {
                System.out.println("已达最小频道，无法下降！");
                this.channel++;
            }
        }
        System.out.println(this.itemNO + "当前频道为：TV" + this.channel);
    }
    //重载：更换为指定频道
    public void changeChannel(int newChannel) {
        //判断电视机是否开启，若未开启，则直接返回
        if(!this.status) {
            System.out.println("电视机未开机！无法操作！");
            return;
        }
 
        if(newChannel < 0 || newChannel > 100) {
            System.out.println("该频道不存在！");
        } else {
            this.channel = newChannel;
        }
        System.out.println(this.itemNO + "当前频道为：TV" + this.channel);
    }
    //增减音量
    public void adjustVolume(boolean adjust) {
        //判断电视机是否开启，若未开启，则直接返回
        if(!this.status) {
            System.out.println("电视机未开机！无法操作！");
            return;
        }
        if(adjust){
            this.volume++;
            if(this.volume > 100) {
                System.out.println("已达音量最大值！无法提高音量！");
                this.volume--;
            }
        } else {
            this.volume--;
            if(this.volume < 0) {
                System.out.println("已达音量最小值！无法降低音量！");
                this.volume++;
            }
        }
        System.out.println(this.itemNO + "当前音量为：" + this.volume);
    }
 
    @Override
    public String toString() {
        return "Television{" +
                "itemNO='" + itemNO + '\'' +
                ", status=" + status +
                ", volume=" + volume +
                ", channel=" + channel +
                '}';
    }
}


列出测试数据和实验结果截图：



7、仿照超市购物的例子编写一个学生借书的程序。

提示：思考需要定义的类，例如：本程序需要用到学生、借书卡、书等对象，最后实现借书的过程，如果有指定的书，则输出“***借到了***书”，否则输出“****没有借到****书”。


还需要认真思考每个类中有哪些属性和方法，能够更好的完成这个程序。


本题相较于上面几题，稍微有些复杂。下面是思路：


1、学生类。学生类中需要有学生的基本信息，即学号、姓名。然后根据需求进行封装，提供相应的getter和setter接口；提供相应的构造方法；重写toString方法便于信息输出。


class Student{
    private int stuID;
    private String name;
 
    public String getName() {
        return name;
    }
 
    public Student(int stuID, String name) {
        this.stuID = stuID;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return  "stuID=" + stuID + ", name='" + name;
    }
}


2、图书类。图书类中也要提供图书的相关信息，包括图书号、图书名两个成员属性，相应的构造方法和toString方法。注意，不同的是，这里必须重写equals方法。这在判断学生要借的图书是否存在时，有重大用处。


class Book{
    private int bookNo;
    private String name;
 
    public Book(int bookNo, String name) {
        this.bookNo = bookNo;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "[" + bookNo +
                ", " + name +
                ']';
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return bookNo == book.bookNo && name.equals(book.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(bookNo, name);
    }
}


3、图书馆类。图书馆类相当于是一个书架。用ArrayList集合进行图书的预存放。直接调用集合中的各种方法对图书进行操作，非常方便。当然，也可以自定义一维数组完成相同的功能。展示书架上的图书这一方法中用到了迭代器，因为这样可以自定义打印出来的格式。如果不使用迭代器，也可以直接System.out.print(libBook)；因为ArrayList中重写过toString方法。


class Library{
    //书架
    List<Book> libBook;
 
    public Library() {
        this.libBook = new ArrayList<>();
    }
    //设置书架上的图书
    public void setBooks(Book book){
        libBook.add(book);
    }
    //展示书架上的图书
    public void showBooks() {
        Iterator it = libBook.listIterator();
        while(it.hasNext()) {
            System.out.print(it.next() + "   ");
        }
        System.out.println();
    }
}


4、借记卡类。借记卡的基本信息是卡号、学生、已借阅的图书与已借阅的图书数量这四个成员属性。其中，已借阅的图书也用ArrayList集合来存放。在构造方法中，只有学生的信息是需要外界传入的。卡号采取自动随机生成的方式赋值，采用了Random类来生成随机数。


在借书方法中，需要判断要借的书在书架上是否存在。采用的是ArrayList中的cntains方法进行判断。然而，在用contains将传入图书与已有图书比较的过程中，拿什么进行比较就很重要。java中ArrayList的contains方法，作用是用来判断元素是否在集合中，本质上使用的是比较对象的equals的方法来去比较。注意：若此时比较对象的equlas方法没有重写，则会进入Object的equlas方法比较地址，libBook中的任一元素与我们传入的book的地址肯定是不同的，因此一定会返回false。


而重写了equals方法，则能避免这些问题。若判断该书不存在，则抛出异常。


class DebitCard{
    private int cardID;
    private Student stu;
    private List<Book> books;
    private int bookNum;
 
    //借记卡构造方法
    public DebitCard(Student stu) {
        Random random = new Random();
        this.cardID = random.nextInt(900)+100;
        this.stu = stu;
        this.books = new ArrayList<>();
    }
    //借书 若书在图书馆中存在，则借记成功，若不存在，则抛出异常
    public void borrowBooks(Book book,Library library) throws BookNotExistException{
        if(library.libBook.contains(book)){
            books.add(book);
            bookNum = books.size();
        }else{
            throw new BookNotExistException("该书不存在！无法借记！");
        }
    }
 
    @Override
    public String toString() {
        return "DebitCard{" +
                "借记卡号：" + cardID +
                ", 已借阅图书：" + books +
                ", 已借阅图书数量：" + bookNum +
                '}';
    }
}


自定义的异常类：


public class BookNotExistException extends RuntimeException{
    public BookNotExistException() {
    }
 
    public BookNotExistException(String message) {
        super(message);
    }
}


5、设计好各个类之后，在main方法中进行测试即可。分为如下几步：预存放书架上的书、创建学生对象、注册借记卡、借书。


源代码：


import java.util.*;
 
public class S3_7 {
    public static void main(String[] args) {
        //给图书馆书架上设置图书
        Library library = new Library();
        Book book1 = new Book(1111,"《Java程序设计》");
        Book book2 = new Book(2222,"《C++程序设计》");
        Book book3 = new Book(3333,"《Python程序设计》");
        Book book4 = new Book(4444,"《Web程序设计》");
        library.libBook.add(book1);
        library.libBook.add(book2);
        library.libBook.add(book3);
        library.libBook.add(book4);
 
        //展示书架上的图书
        System.out.println("书架上现有图书：");
        library.showBooks();
 
        //创建学生对象
        Scanner reader = new Scanner(System.in);
        System.out.println("请输入学生学号：");
        int stuID = reader.nextInt();
        System.out.println("请输入学生姓名：");
        String stuName = reader.next();
        Student stu = new Student(stuID,stuName);
 
        //申请借记卡
        DebitCard debitCard = new DebitCard(stu);
        //展示借记卡信息
        System.out.println(debitCard);
 
        //进行借书
        System.out.println("请输入要借的图书编号：");
        int bookNO = reader.nextInt();
        System.out.println("请输入要借的图书名：");
        String boName = reader.next();
        try {
            debitCard.borrowBooks(new Book(bookNO,"《" + boName +"》"),library);
        }catch(BookNotExistException e){
            System.out.println(stu.getName() + "没有借到" + boName);
            e.printStackTrace();
            System.out.println(debitCard);
            System.exit(-1);
        }
        System.out.println(stu.getName() + "借到了" + boName);
        System.out.println(debitCard);
 
    }
}
 
class Student{
    private int stuID;
    private String name;
 
    public String getName() {
        return name;
    }
 
    public Student(int stuID, String name) {
        this.stuID = stuID;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return  "stuID=" + stuID + ", name='" + name;
    }
}
class DebitCard{
    private int cardID;
    private Student stu;
    private List<Book> books;
    private int bookNum;
 
    //借记卡构造方法
    public DebitCard(Student stu) {
        Random random = new Random();
        this.cardID = random.nextInt(900)+100;
        this.stu = stu;
        this.books = new ArrayList<>();
    }
    //借书 若书在图书馆中存在，则借记成功，若不存在，则抛出异常
    public void borrowBooks(Book book,Library library) throws BookNotExistException{
        if(library.libBook.contains(book)){
            books.add(book);
            bookNum = books.size();
        }else{
            throw new BookNotExistException("该书不存在！无法借记！");
        }
    }
 
    @Override
    public String toString() {
        return "DebitCard{" +
                "借记卡号：" + cardID +
                ", 已借阅图书：" + books +
                ", 已借阅图书数量：" + bookNum +
                '}';
    }
}
 
class Book{
    private int bookNo;
    private String name;
 
    public Book(int bookNo, String name) {
        this.bookNo = bookNo;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "[" + bookNo +
                ", " + name +
                ']';
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return bookNo == book.bookNo && name.equals(book.name);
    }
 
/*    @Override
    public int hashCode() {
        return Objects.hash(bookNo, name);
    }*/
}
 
class Library{
    //书架
    List<Book> libBook;
 
    public Library() {
        this.libBook = new ArrayList<>();
    }
    //设置书架上的图书
    public void setBooks(Book book){
        libBook.add(book);
    }
    //展示书架上的图书
    public void showBooks() {
        Iterator it = libBook.listIterator();
        while(it.hasNext()) {
            System.out.print(it.next() + "   ");
        }
        System.out.println();
    }
}


public class BookNotExistException extends RuntimeException{
    public BookNotExistException() {
    }
 
    public BookNotExistException(String message) {
        super(message);
    }
}


列出测试数据和实验结果截图：

借记成功：



借记失败：



三、实验总结


1. 经过本次实验，我掌握了以下内容：


  1. 我理解了面向对象的相关基本概念，学会了如何声明类。通过构造方法实例化一个类，并通过对象名或类名进行调用。



  1. 我掌握了成员方法及构造方法的定义。成员方法可以实现类的各种功能，它有方法名、返回值和参数；构造方法用于对实例进行初始化。构造方法的名字必须与类名完全相同，且不能写返回值。


  1. 我掌握了方法重载的用法，方法重载就是方法之间的名称相同而参数列表不同，返回值没有影响。通过方法的重载，能够使代码更加灵活。

  1. 我理解了值传递和地址传递两种参数传递方式的区别。基本数据类型作为参数一般是值传递，也就是传递变量的内容；而引用数据类型作为参数则是地址传递。


  1. 我掌握了this关键字的用法。this关键字代表当前对象的引用。在同一个类中，this可以调用当前的成员变量与成员方法。语法是this.成员属性，this.成员方法(参数列表)。同时，this也可以用于在一个构造方法中调用另一构造方法，语法是this()，this(参数列表)。this调用构造方法只能出现在构造方法的第一句。


  1. 我掌握了static关键字的用法。static关键字修饰的成员属性或成员方法代表静态的成员属性或成员方法。类变量是脱离对象的，没有实例化的对象也可以使用类变量，它在类加载的时候会分配空间，通过类名进行调用。类中的所有对象共享静态成员（同一块堆内存空间，可以同时被多个栈内存所指向，不同的栈可以修改同一块堆内存的内容）。需要注意的是：静态方法中出现的成员变量只能是静态变量，出现的方法只能是静态方法，而不能是非静态的。static也可以修饰代码块，被其修饰的代码块为静态代码块。


  1. 引用数据类型与基本数据类型最大的不同在于引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，只要使用引用数据类型就要使用关键字new来分配内存空间。


  1. 我掌握了访问控制符的使用以实现类的封装和信息隐蔽。在类中用private修饰成员属性，之后再提供相应的setter或getter方法来修改或获取值。


2、通过掌握以上内容，我能够初步进行类的设计，编写基本的面向对象的程序；


3. 遇到了一些语法上的问题，这是由于代码敲的不多，对语言不熟练。不会的地方通过翻书、查资料，基本能够解决问题。


文章标签：
Java
关键词：
Java程序设计
Java实验
Java面向对象
Java程序设计实验面向对象
Java程序设计实验
碳基肥宅
目录
相关文章
bug菌
|
24天前
|
Java 测试技术 开发者
💡Java 零基础：彻底掌握 for 循环，打造高效程序设计
【10月更文挑战第15天】本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
bug菌
109 63
土木林森
|
19天前
|
Java 关系型数据库 数据库
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析，详细介绍了面向对象设计的五大核心原则：单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统，不仅适用于Java，也适用于其他面向对象编程语言。
土木林森
13 2
杀死一只知更鸟debug
|
2月前
|
Java 编译器
封装，继承，多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性：封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态，继承允许新类扩展现有类的功能，而多态则允许对象在不同情况下表现出不同的行为，这些特性共同提高了代码的复用性、扩展性和灵活性。
杀死一只知更鸟debug
42 2
封装，继承，多态【Java面向对象知识回顾①】
java冯坚持
|
1月前
|
算法 搜索推荐 Java
java 后端 使用 Graphics2D 制作海报，画echarts图，带工具类，各种细节：如头像切割成圆形，文字换行算法（完美实验success），解决画上文字、图片后不清晰问题
这篇文章介绍了如何使用Java后端技术，结合Graphics2D和Echarts等工具，生成包含个性化信息和图表的海报，并提供了详细的代码实现和GitHub项目链接。
java冯坚持
105 0
java 后端 使用 Graphics2D 制作海报，画echarts图，带工具类，各种细节：如头像切割成圆形，文字换行算法（完美实验success），解决画上文字、图片后不清晰问题
刘大猫.
|
2月前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
刘大猫.
35 4
杀死一只知更鸟debug
|
2月前
|
Java
接口和抽象类【Java面向对象知识回顾②】
本文讨论了Java中抽象类和接口的概念与区别。抽象类是不能被实例化的类，可以包含抽象和非抽象方法，常用作其他类的基类。接口是一种纯抽象类型，只包含抽象方法和常量，不能被实例化，且实现接口的类必须实现接口中定义的所有方法。文章还比较了抽象类和接口在实现方式、方法类型、成员变量、构造方法和访问修饰符等方面的不同，并探讨了它们的使用场景。
杀死一只知更鸟debug
26 0
接口和抽象类【Java面向对象知识回顾②】
Codelinghu
|
1月前
|
存储 Java 程序员
Java基础-面向对象
Java基础-面向对象
Codelinghu
16 0
源码星辰
|
2月前
|
安全 Java Go
面向对象程序设计语言：Java
Java语言语法和C语言和C++语言很接近，很容易学习和使用，Java丢弃了C++中很少使用的、很难理解的、令人迷惑的特性，Java语言不使用指针，而是引用，并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧
源码星辰
56 2
java的细水长流
|
2月前
|
Java 开发者
Java 面向对象
Java 是一种面向对象的编程语言，通过对象与类的概念组织代码和数据。面向对象编程的核心包括类、对象、继承、多态、封装和抽象。类是对象的蓝图，定义了属性和行为；对象则是类的实例。继承允许子类继承父类的属性和方法，增强代码复用性；多态则支持通过相同接口调用不同类型对象的行为，包括方法重载和重写。封装通过公共方法隐藏对象细节，提高安全性；抽象则对对象特征进行提炼，通过抽象类和接口实现。理解这些概念有助于设计高效、可维护的 Java 应用程序。
java的细水长流
22 0
历年考试不作弊
|
2月前
|
Java 开发者
Java编程之旅：探索面向对象的力量
【9月更文挑战第16天】在编程的世界中，Java以其强大的面向对象编程特性而闻名。本文将带你走进Java的世界，一起探索类与对象的奥秘，学习如何通过封装、继承和多态性构建健壮的软件系统。无论你是初学者还是有经验的开发者，本文都旨在提供实用的代码示例，帮助你提升Java技能。准备好开始这段旅程了吗？让我们启程吧！
历年考试不作弊
14 0

热门文章

最新文章

  • 1
    Java 生成 UUID
  • 2
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 3
    【Java用法】使用Java导出word文档的解决方案（适用于从服务器上下载到本地电脑）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    JDK6笔记（5）----JDBC4
  • 6
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 7
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 8
    （十三）java类的继承
  • 9
    Java基础之004-面向对象
  • 10
    java 定时调用 bat
  • 1
    Dubbo03【管理控制台和监控中心搭建】，Java开发实用必备的几款插件
    56
  • 2
    Java中int[]与Integer[]相互转化的方法，java基础知识面试重点总结
    35
  • 3
    Java 并发编程中的锁优化策略
    34
  • 4
    Java一分钟之-设计模式：装饰器模式与代理模式
    63
  • 5
    《手把手教你》系列技巧篇（四十六）-java+ selenium自动化测试-web页面定位toast-下篇（详解教程）
    63
  • 6
    刷题两个月，从入门到字节跳动offer丨GitHub标星16k+，美团Java面试题
    65
  • 7
    《MySQL 入门教程》第 05 篇 账户和权限，Java高并发编程详解深入理解pdf
    53
  • 8
    Java的前景如何，好不好自学？，万字Java技术类校招面试题汇总
    54
  • 9
    es集群安装，邮储银行java面试
    79
  • 10
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    98

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问