面向对象基础的Java作业十

已于 2023-12-16 20:34:04 修改
阅读量72 收藏
点赞数
分类专栏： Java 文章标签： java
于 2023-12-16 20:33:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang2001106/article/details/135037474
版权

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

(1) 在类中定义两个Collection集合，并向其中一个集合中添加数据

(2) 用Collection接口中的方法对定义的两个集合进行各种操作。

1．代码

import java.util.ArrayList;
import java.util.Collection;

public class Test1 {
    public static void main(String[] args) {
        // 创建两个Collection集合
        Collection<String> collection1 = new ArrayList<>();
        Collection<String> collection2 = new ArrayList<>();

        // 向collection1中添加数据
        collection1.add("数据1");
        collection1.add("数据2");
        collection1.add("数据3");

        // 向collection2中添加数据
        collection2.add("数据4");
        collection2.add("数据5");
        collection2.add("数据6");

        // 输出collection1中的数据
        System.out.println("collection1中的数据：");
        for (String data : collection1) {
            System.out.println(data);
        }

        // 输出collection2中的数据
        System.out.println("collection2中的数据：");
        for (String data : collection2) {
            System.out.println(data);
        }

        // 清空collection1
        collection1.clear();

        // 输出清空后的collection1中的数据
        System.out.println("清空后的collection1中的数据：");
        for (String data : collection1) {
            System.out.println(data);
        }

        // 将collection1中的数据添加到collection2中
        collection2.addAll(collection1);

        // 输出添加后的数据
        System.out.println("添加后的数据：");
        for (String data : collection2) {
            System.out.println(data);
        }
    }
}
  1. 运行效果：

collection2中的数据：

数据4

数据5

数据6

清空后的collection1中的数据：

添加后的数据：

数据4

数据5

数据6

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

(1) 在类中定义两个list集合，并向其中一个集合中添加数据。

(2) 用 subList(int fromIndex, int toIndex)方法获取集合的一部分

(3) 用set(int index, E element)方法修改一个元素

(4) 用add(int index, E element)方法增加一个元素

1．代码

import java.util.ArrayList;
import java.util.List;

public class Test2 {
    public static void main(String[] args) {
        // 创建两个List集合
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        // 向list1中添加数据
        list1.add("A");
        list1.add("B");
        list1.add("C");

        // 向list2中添加数据
        list2.add("D");
        list2.add("E");
        list2.add("F");

        // 获取list1的一部分
        List<String> subList = list1.subList(1, 3);
        System.out.println("SubList: " + subList);

        // 修改list1中的一个元素
        list1.set(1, "X");
        System.out.println("List1 after modification: " + list1);

        // 在list1的指定位置增加一个元素
        list1.add(1, "Y");
        System.out.println("List1 after adding an element: " + list1);

        // 将list2的一部分添加到list1的指定位置
        list1.addAll(2, list2.subList(0, 1));
        System.out.println("List1 after adding a subList of list2: " + list1);
    }
}

2．运行效果：

SubList: [B, C]

List1 after modification: [A, X, C]

List1 after adding an element: [A, Y, X, C]

List1 after adding a subList of list2: [A, Y, D, X, C]

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

(1) 在类中定义一个ArrayList集合

(2) 用add()方法向集合中添加元素

(3) 用get()方法获取集合中的指定元素，由于ArrayList集合的索引的取值范围是从0开始的，最后一个索引是size-1。所以，要获取集合中的第2个元素应该是get(1)。

1．代码

import java.util.ArrayList;

public class Test3 {
    public static void main(String[] args) {
        // 创建一个ArrayList集合
        ArrayList<String> list = new ArrayList<>();

        // 向集合中添加元素
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 获取集合中的指定元素
        String element = list.get(1);
        System.out.println("集合中的第2个元素是：" + element);
    }
}

2．运行效果：

集合中的第2个元素是：元素2

4. 编写 Java 程序，定义Test4类，在该类中定义一个LinkedList集合

(1) 分别使用addFirst()和addLast()方法向集合中添加元素

(2) 使用peekFirst()方法获取集合中的第一个元素

(3) 使用pollFirst()方法获取并移除集合中的第一个元素

(4) 使用pollLast()方法获取并移除集合中的最后一个元素

(5) 此时，集合中应该没有元素了，用peekLast()方法获取集合中的最后一个元素，由于集合为空，应该返回NULL

1．代码

import java.util.LinkedList;

public class Test4 {
    public static void main(String[] args) {
        // 创建一个LinkedList集合
        LinkedList<String> list = new LinkedList<>();

        // 向集合中添加元素
        list.addFirst("元素1");
        list.addLast("元素2");

        // 获取集合中的指定元素
        String element = list.peekFirst();
        System.out.println("集合中的第一个元素是：" + element);

        // 获取并移除集合中的第一个元素
        element = list.pollFirst();
        System.out.println("被移除的第一个元素是：" + element);

        // 获取并移除集合中的最后一个元素
        element = list.pollLast();
        System.out.println("被移除的最后一个元素是：" + element);

        // 此时，集合中应该没有元素了，用peekLast()方法获取集合中的最后一个元素，由于集合为空，应该返回NULL
        element = list.peekLast();
        System.out.println("尝试获取的最后一个元素是：" + (element == null ? "NULL" : element));
    }
}

2．运行效果：

集合中的第一个元素是：元素1

被移除的第一个元素是：元素1

被移除的最后一个元素是：元素2

尝试获取的最后一个元素是：NULL

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

(1) 在类中定义一个List集合，并向集合中添加数据

(2) 通过调用List集合的iterator()方法获得迭代器对象

(3) 在while循环条件中使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素

1．代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test5 {
    public static void main(String[] args) {
        // 创建一个List集合，并向集合中添加数据
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 通过调用List集合的iterator()方法获得迭代器对象
        Iterator<String> iterator = list.iterator();

        // 在while循环条件中使用hasNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

2．运行效果：

元素1

元素2

元素3

6. 编写 Java 程序，定义Test6类，在该类中定义一个HashSet集合hs

(1) 向集合hs中添加6个元素，其中有一些重复的元素

(2) 用size()方法获取添加完元素后集合中元素的个数

(3) 用Iterator迭代器遍历集合的每一个元素

(4) 观察在输出结果中，是否存在重复的元素

1．代码

import java.util.HashSet;
import java.util.Iterator;

public class Test6 {
    public static void main(String[] args) {
        // 创建一个HashSet集合hs,并向集合中添加6个元素，其中有一些重复的元素
        HashSet<String> hs = new HashSet<>();
        hs.add("元素1");
        hs.add("元素2");
        hs.add("元素3");
        hs.add("元素4");
        hs.add("元素5");
        hs.add("元素1");

        // 用size()方法获取添加完元素后集合中元素的个数
        System.out.println("集合中元素的个数为：" + hs.size());

        // 用Iterator迭代器遍历集合的每一个元素
        Iterator<String> iterator = hs.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }

        // 观察在输出结果中，是否存在重复的元素
        System.out.println("是否存在重复的元素：" + hs.contains(iterator.next()));
    }
}

运行效果：

元素1

元素2

元素3

元素4

元素5

思考题1，定义一个List容器，并向容器中添加、移除元素。

1．代码

import java.util.ArrayList;
import java.util.List;

public class Test7 {
    public static void main(String[] args) {
        // 创建一个List容器，并向容器中添加元素
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");
        System.out.println("添加元素后的集合为：" + list);

        // 从集合中移除元素
        list.remove("元素2");
        System.out.println("移除元素后的集合为：" + list);
    }
}

2．运行效果：

添加元素后的集合为：[元素1, 元素2, 元素3]

移除元素后的集合为：[元素1, 元素3]

思考题2，编写一个程序，模拟学生管理系统。可以实现对学生信息的添加、删除、修改和查询功能，要求使用List集合存储自定义的对象集合，并熟练使用List集合的中常用方法实现相关的操作。

分析：（1）定义学生类，自定义对象属性。

（2）学生管理系统的主界面的代码编写，创建集合对象，用于存储学生数据，打印学生管理系统主界面的相关功能，创建键盘输入功能，用switch语句实现选择的功能。最后为了实现多次操作并且手动退出系统。用while(true)循环实现.

（3） 学生管理系统查询所有学生信息的代码编写，首先判断集合中是否有数据，如果没有数据就给出提示，并让该方法不在继续往下执行。如果有数据。遍历集合输出打印数据。

（4） 学生管理系统添加学生信息的代码编写，首先输入学生学号，判断学号有没有被人占用，如果被占用重新输入学号，没有被占用继续录入学生姓名、年龄。家庭住址等信息。创建学生对象，将录入的数据存入对象。最后将学生对象添加入集合，添加学生信息成功。

（5） 学生管理系统删除学生信息的代码编写，键盘录入一个学号，到集合中去查找，看是否有学生使用该学号，如果有就删除该学生信息。如果没有学生使用该学号，返回主界面。

（6）学生管理系统修改学生信息的代码编写。键盘录入一个学号，到集合中去查找，看是否有学生使用该学号，如果过有就修改学生信息。反之返回主界面。

1．代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

class Student {
    private String studentId;
    private String name;
    private int age;
    private String address;

    public Student(String studentId, String name, int age, String address) {
        this.studentId = studentId;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    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 getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "studentId='" + studentId + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

class StudentManagementSystem {
    private List<Student> studentList = new ArrayList<>();
    private Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        StudentManagementSystem system = new StudentManagementSystem();
        system.run();
    }

    public void run() {
        while (true) {
            System.out.println("学生管理系统");
            System.out.println("1. 查询所有学生信息");
            System.out.println("2. 添加学生信息");
            System.out.println("3. 删除学生信息");
            System.out.println("4. 修改学生信息");
            System.out.println("0. 退出系统");

            int choice = scanner.nextInt();
            scanner.nextLine(); // Consume the newline character

            switch (choice) {
                case 1:
                    displayAllStudents();
                    break;
                case 2:
                    addStudent();
                    break;
                case 3:
                    deleteStudent();
                    break;
                case 4:
                    updateStudent();
                    break;
                case 0:
                    System.out.println("感谢使用学生管理系统，再见！");
                    System.exit(0);
                default:
                    System.out.println("无效的选项，请重新输入。");
            }
        }
    }

    private void displayAllStudents() {
        if (studentList.isEmpty()) {
            System.out.println("暂无学生信息！");
        } else {
            System.out.println("所有学生信息：");
            for (Student student : studentList) {
                System.out.println(student);
            }
        }
    }

    private void addStudent() {
        System.out.println("请输入学生学号：");
        String studentId = scanner.nextLine();

        // 检查学号是否已存在
        for (Student student : studentList) {
            if (student.getStudentId().equals(studentId)) {
                System.out.println("该学号已被占用，请重新输入。");
                return;
            }
        }

        System.out.println("请输入学生姓名：");
        String name = scanner.nextLine();

        System.out.println("请输入学生年龄：");
        int age = scanner.nextInt();
        scanner.nextLine(); // Consume the newline character

        System.out.println("请输入学生家庭住址：");
        String address = scanner.nextLine();

        Student newStudent = new Student(studentId, name, age, address);
        studentList.add(newStudent);
        System.out.println("学生信息添加成功！");
    }

    private void deleteStudent() {
        System.out.println("请输入要删除的学生学号：");
        String studentId = scanner.nextLine();

        Iterator<Student> iterator = studentList.iterator();
        while (iterator.hasNext()) {
            Student student = iterator.next();
            if (student.getStudentId().equals(studentId)) {
                iterator.remove();
                System.out.println("学生信息删除成功！");
                return;
            }
        }

        System.out.println("未找到学生信息，删除失败。");
    }

    private void updateStudent() {
        System.out.println("请输入要修改的学生学号：");
        String studentId = scanner.nextLine();

        for (Student student : studentList) {
            if (student.getStudentId().equals(studentId)) {
                System.out.println("请输入新的学生姓名：");
                String name = scanner.nextLine();
                student.setName(name);

                System.out.println("请输入新的学生年龄：");
                int age = scanner.nextInt();
                scanner.nextLine(); // Consume the newline character
                student.setAge(age);

                System.out.println("请输入新的学生家庭住址：");
                String address = scanner.nextLine();
                student.setAddress(address);

                System.out.println("学生信息修改成功！");
                return;
            }
        }

        System.out.println("未找到学生信息，修改失败。");
    }
}

2．运行效果：

学生管理系统

1. 查询所有学生信息

2. 添加学生信息

3. 删除学生信息

4. 修改学生信息

0. 退出系统

1

暂无学生信息！

学生管理系统

1. 查询所有学生信息

2. 添加学生信息

3. 删除学生信息

4. 修改学生信息

0. 退出系统

2

请输入学生学号：

200110

请输入学生姓名：

uj

请输入学生年龄：

12

请输入学生家庭住址：

km

学生信息添加成功！

学生管理系统

1. 查询所有学生信息

2. 添加学生信息

3. 删除学生信息

4. 修改学生信息

0. 退出系统

1

所有学生信息：

Student{studentId='200110', name='uj', age=12, address='km'}

学生管理系统

1. 查询所有学生信息

2. 添加学生信息

3. 删除学生信息

4. 修改学生信息

0. 退出系统

3

请输入要删除的学生学号：

200110

学生信息删除成功！

学生管理系统

1. 查询所有学生信息

2. 添加学生信息

3. 删除学生信息

4. 修改学生信息

0. 退出系统

1

暂无学生信息！

学生管理系统

1. 查询所有学生信息

2. 添加学生信息

3. 删除学生信息

4. 修改学生信息

0. 退出系统

0

感谢使用学生管理系统，再见！

……

思考题3，编写一个java程序，模拟百度翻译。用户输入英文之后搜索程序中对应的中文，如果搜索到对应的中文就输出搜索结果，反之给出提示。要求使用Map集合实现英文与中文的存储。

分析：（1）百度翻译主要用于翻译对应的意思。这是一种映射关系。因此可以用 Map集合来实现，所以首先就是定义Map集合，存储数据。

（2）用键盘录入功能获取我们要翻译的单词。

（3）定义一个方法，在该方法中实现对单词的查询操作，并且根据不同情况给出相关提示。

（4）调用查询的方法，实现翻译。并将结果输出到控制台。

1．代码

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

public class BaiduTranslate {
    private Map<String, String> translationMap = new HashMap<>();
    private Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        BaiduTranslate translator = new BaiduTranslate();
        translator.initializeTranslationMap(); // 初始化映射关系
        translator.translate(); // 执行翻译
    }

    private void initializeTranslationMap() {
        // 初始化映射关系，这里只是一个简单的示例，实际应用中可能需要更多的映射数据
        translationMap.put("hello", "你好");
        translationMap.put("world", "世界");
        translationMap.put("java", "Java编程语言");
        // 可以根据实际需要扩展映射数据
    }

    private void translate() {
        while (true) {
            System.out.println("请输入要翻译的英文单词（输入exit退出翻译）：");
            String input = scanner.nextLine().toLowerCase(); // 将输入转换为小写，以匹配映射关系

            if (input.equals("exit")) {
                System.out.println("感谢使用百度翻译，再见！");
                break;
            }

            String translation = searchTranslation(input);
            if (translation != null) {
                System.out.println("翻译结果：" + translation);
            } else {
                System.out.println("抱歉，未找到对应的中文翻译。");
            }
        }
    }

    private String searchTranslation(String word) {
        return translationMap.get(word);
    }
}

2．运行效果：

请输入要翻译的英文单词（输入exit退出翻译）：

holle

抱歉，未找到对应的中文翻译。

请输入要翻译的英文单词（输入exit退出翻译）：

java

翻译结果：Java编程语言

请输入要翻译的英文单词（输入exit退出翻译）：

hello

翻译结果：你好

请输入要翻译的英文单词（输入exit退出翻译）：

world

翻译结果：世界

请输入要翻译的英文单词（输入exit退出翻译）：

exit

感谢使用百度翻译，再见！

你二舅ya
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java 面向对象基础
一只coding 的koala
08-26 159
最近的生活被笔试面试充斥着 。。。。。。生无可恋。。。。。。。好多基础知识看了忘，忘了看。。。。。。。 那就写一下。。。。。 1.重写 重载的区别：   （1）、重写是子类对父类的重写。重写的参数列表，方法名、返回值必须与被重写的方法一致。  被重写的方法不能是private，否则只是在子类中重新定义一个方法。   （2）、重载是一个类中多态性的一种体现，多个同名函数同时存在，就是类有一个
java面向对象作业
llqq314的博客
04-14 717
一、选择 1.B 2.A 3.D 4.A 5.C 6.AC 7.A 8.D 9.BC 二、编程 创建Person类和测试类 属性：名字（name），年龄（age）,年级（ grade）方法： 无参无返回值的student方法，描述为：我是一名学生！带参数（性别sex）的方法，描述为：我是一个**孩！（其中，**为传入参数）无参无返回值的mySelf方法，介绍自己的姓名、年龄、年级（参数参考效果图）...
Java学生管理系统（List）
weixin_45690561的博客
05-11 548
学生类 package StuOfMan; public class Student { private String sname; private String sid; private String sgender; public Student() { } public Student(String sname, String sid, String sgender) { this.sname = sname; this.sid = sid; this..
Java集合（二）之List
LanceToBigData
05-28 291
前言 List本身是Collection接口的子接口，具备了Collection的所有方法。 ListIterator是List集合特有的迭代器。 ListIterator it = list.listIterator;//取代Iterator it = list.iterator; List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。 - ArrayLis...
学习java的第十五天。。。（方法）
qihaojinqiuma的博客
07-29 182
学习Java的第十五天，今天学习了方法，方法的返回值，方法调用，带参方法
Java基础之 List接口
Rnight阿布的博客
04-18 273
一、List的特点和常用的方法 List是有序、可重复的容器。 有序：List中每个元素都是有索引标记。可以根据元素的索引标记访问元素，从而精确控制这些元素。 可重复：List运行加入重复的元素。更确切的讲，List通常允许满足e1.equals（e2）的元素重复加入容器。 之前Collection接口中的方法在List中都能用，还有一些List特有的跟索引有关的方法： 同时，List接口常用的...
JAVA基础 集合类（1）[案例练习+知识点+代码]
心态的博客
05-01 1510
JAVA基础 集合类（1）[案例练习+知识点+代码] 看了就会，简单易懂。。。还有学习目标、知识总结哦。。。
Java 基础之面向对象编程教程
01-22
Java 基础之面向对象编程教程，主要类和对象、如何定义类、成员函数、访问控制修饰符、构造方法、类变量、类方法、方法重载、方法覆盖、抽象、封装、继承、多态、抽象类、接口和New 运算符等概念的介绍和例题介绍...
【面向对象程序设计】Java大作业 租车系统V4.0
10-28
【面向对象程序设计】Java大作业 - 租车系统V4.0是一个综合性的项目，旨在教授和应用Java编程语言的面向对象特性，同时结合数据库管理技术，构建一个汽车租赁管理平台。在这个项目中，学生将面临设计和实现一套完整...
java实现面向对象
11-08
以上是Java实现面向对象的一些基础知识，实际编程中还会涉及到访问修饰符、包、访问控制、异常处理、集合框架、IO流、线程等更多内容。通过不断学习和实践，你将能更好地理解和运用面向对象编程。
Java面向对象程序设计
03-17
以上就是对Java面向对象程序设计的详细解析，涵盖了从基础到进阶的关键概念，为学习和掌握Java编程打下坚实的基础。通过深入理解和实践这些知识点，开发者可以构建出高效、稳定且易于维护的Java应用程序。
java程序设计基础作业-咖啡系统.zip
01-28
总结来说，这个"java程序设计基础作业-咖啡系统.zip"涵盖了Java编程基础、面向对象编程原理以及实际项目开发的实践经验。通过完成这个作业，学生不仅可以巩固Java语言的知识，还能提升分析问题和解决问题的能力，为...
java list能作为入参吗_Java中可变参数与List入参如何选择？
weixin_42186579的博客
02-16 1597
先说结论：都不好！您这样设计违反了开闭原则。如果您只是想写个demo测试下代码能否跑通，那我下面的回答就是偏题了。---------分割线------------无论是用可变参数String ...，还是List，它们都是具体实现。它肯定能通过一部分的测试用例。但是它毕竟不是接口，当遇到一些其它情况，你不得不重写这个方法，比如下列不安全的情况：输入的参数类型不合法select("a","b","1...
java中list集合入参格式
weixin_44149903的博客
01-02 5024
入参是List集合的json格式 [ { "name": "postgres", "port": "80" { "name": "postgres", "port": "80" ] 如果入参是一个类，该类中存在集合 { "dsList": [ { "name": "postgres", "port": "80" }, { "name...
入参有List
zhangxiangbin001的专栏
02-07 794
1、xml  id="newFailMap" class="java.util.HashMap">     "returnUserId" jdbcType="VARCHAR" javaType="java.lang.String" mode="IN">     "businessRetrunDesc" jdbcType="VARCHAR" javaType="java.lang.St
List--方法内的list传递给入参后方法外获取不到的原因和解决办法
qq_28096687的博客
03-31 5233
我们经常使用List来做数据集合存放数据，经常使用时我们知道list是可以实现地址传递，也就是在list通过方法的入参传递到方法内后，整个list的值可以在方法内使用:通过add方法可以在原来的基础上增加新值，也可以通过set(index,值)的方式改变原来index位置的数据而且入参传递的值经过add、set等后再方法外也是生效的，就是这个操作后的值，这就是地址传递，也就是对象传递。但是，我们容...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1089
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
面向对象程序设计(Java)教学方案
"JAVA面向对象程序的设计教学方案" 本教学方案主要针对西南财经大学天府学院13级专科计算机、网络和软件专业的学生，旨在教授Java面向对象程序设计。课程由贾砚池老师任教，采取讲授、讨论和上机实践相结合的方式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你二舅ya

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值