JAVA 面向对象编程作业(Chapter08)

最新推荐文章于 2022-12-17 11:35:14 发布
最新推荐文章于 2022-12-17 11:35:14 发布
阅读量825 收藏
点赞数
分类专栏： JAVA 基础学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W1H1J1/article/details/124569930
版权

第八章作业（面向对象编程）

1.定义person类，初始化对象数组，有3个person对象，按照age从大到小进行排序。

package com.HomeworkChapter08;

public class Homework01 {
    public static void main(String[] args) {
        //根据 age 使用冒泡排序法
        //思路：用数组保存三个人的信息，然后直接使用冒泡排序
        Person person[] = new Person[3];
        person[0] = new Person("jack01", 23, "教授");
        person[1] = new Person("jack02", 56, "经理");
        person[2] = new Person("jack03", 43, "工人");
        Person temp;//创建一个中间转换用的引用
        for (int i = 1; i < person.length; i++) {
            for(int j = 0; j < person.length - i; j++) {
                if (person[j].getAge() < person[j + 1].getAge()){
                    temp = person[j + 1];
                    person[j + 1] = person[j];
                    person[j] = temp;
                }
            }
        }
        for (int i = 0; i < person.length; i++) {
            System.out.println(person[i].toString());
        }
    }
}
class Person {
    private String name;
    private int age;
    private String job;

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = 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;
    }

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

2.写出四种访问修饰符和各自的访问权限

访问修饰符同类同包子类不同包
public可以可以可以可以
protected可以可以可以不可以
默认可以可以不可以不可以
private可以不可以不可以不可以

3.编写教师类、及其子类，并初始化对象，后测试使用。（具体要求省略，题目简单）

package com.HomeworkChapter08;


public class Teacher {
    private String name;
    private int age;
    private String post;//对应职称
    private double sal;

    public Teacher(String name, int age, double sal) {
        this.name = name;
        this.age = age;
        this.sal = sal;
    }

    public Teacher(String name, int age, String post, double sal) {
        this.name = name;
        this.age = age;
        this.post = post;
        this.sal = sal;
    }

    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 double getSal() {
        return sal;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", post='" + post + '\'' +
                ", sal=" + sal +
                '}';
    }
    public void introduce() {//实现输出一个教师的信息
        System.out.println("Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", post='" + post + '\'' +
                ", sal=" + sal +
                '}');
    }
}

package com.HomeworkChapter08;

public class Professor extends Teacher {
    private double level = 1.3;
    public Professor(String name, int age,  double sal) {
        super(name, age,  sal);
        super.setPost("Professor");
    }

    public double getLevel() {
        return level;
    }

    public void setLevel(double level) {
        this.level = level;
    }

    @Override
    public void introduce() {
        System.out.println("Professor{" +
                "name='" + super.getName() + '\'' +
                ", age=" + super.getAge() +
                ", post='" + super.getPost() + '\'' +
                ", sal=" + super.getSal() +
                ", salary level=" + this.level +
                '}');
    }
}

package com.HomeworkChapter08;

import java.security.PrivateKey;

public class Homework02 {
    public static void main(String[] args) {
        Professor professor = new Professor("jack", 34, 1223);
        professor.introduce();
    }
}

4.通过继承实现员工工资核算打印功能。

package com.HomeworkChapter08;

public class Homework04 {
    public static void main(String[] args) {
        Manager manager = new Manager("jack", 100, 34);
        Worker worker = new Worker("Rose", 100, 34);
        manager.showSalary();
        worker.showSalary();


    }
}
class Employee {
    //抽象出属性和方法
    //属性：姓名 单日工资 工作天数 等级；
    private String name;
    private double sal;
    private int day;
    private double grade ;//等级

    public Employee(String name, double sal, int day, double grade) {
        this.name = name;
        this.sal = sal;
        this.day = day;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

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

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public double getGrade() {
        return grade;
    }

    public void setGrade(double grade) {
        this.grade = grade;
    }

    //方法： 打印工资
    public void showSalary(){
        System.out.println("name: " + name + " 工资为:" + sal * day * grade);
    }
}
class Manager extends Employee {
    public Manager(String name, double sal, int day) {
        super(name, sal, day, 1.2);
    }

    @Override
    public void showSalary() {
        System.out.println("Manager name: " + getName() + " 工资为:" + (1000 + getSal() * getDay() * getGrade()));
    }
}
class Worker extends Employee {
    public Worker(String name, double sal, int day) {
        super(name, sal, day, 1.0);
    }
    @Override
    public void showSalary() {
        System.out.println("Worker name: " + getName() + " 工资为:" +  getSal() * getDay() * getGrade());
    }
}

5.设计员工类（父类）和子类，打印年工资。

package com.HomeworkChapter08;

public class Homework05 {
    public static void main(String[] args) {
        Worker02 worker = new Worker02("jack", 1000);
        Teacher02 teacher = new Teacher02("Rose", 3000, 120, 10);
        Scientist scientist = new Scientist("richard", 5000, 20000);
        worker.showSal();
        teacher.showSal();
        scientist.showSal();
    }
}
class Employee02 {//同包避免重名
    private String name;
    private double sal;//每月基本工资

    public Employee02(String name, double sal) {
        this.name = name;
        this.sal = sal;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
    public void showSal(){
        System.out.println("name: " + name + " 全年工资： " + 12 * sal);
    }
}
class Worker02 extends Employee02 {
    public Worker02(String name, double sal) {
        super(name, sal);
    }

    @Override
    public void showSal() {
        System.out.println("Worker name: " + getName() + " 全年工资： " + 12 * getSal());
    }
}
class  Teacher02 extends Employee02{
    private int classDay;
    private double classSal;//上课

    public Teacher02(String name, double sal, int classDay, double classSal) {
        super(name, sal);
        this.classDay = classDay;
        this.classSal = classSal;
    }

    public int getClassDay() {
        return classDay;
    }

    public void setClassDay(int classDay) {
        this.classDay = classDay;
    }

    @Override
    public void showSal() {
        System.out.println("Teacher name: " + getName() +
                " 全年工资： " + (12 * getSal() + classDay * classSal));
    }
}
class Scientist extends Employee02 {
    private double bonus;

    public Scientist(String name, double sal, double bonus) {
        super(name, sal);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void showSal() {
        System.out.println("Worker name: " + getName() + " 全年工资： " + (12 * getSal() + this.bonus));
    }
}

6.super 和 this 的访问权限

关键字属性方法
super父类的属性（public，protected以及同包的默认无访问修饰符的属性）父类的方法（满足访问修饰符的限制范围）
this子类的所有属性以及父类可以访问的属性子类的所有方法以及父类可以访问的方法

具体看笔记关于super和this的区别 P309.

7.写出程序结果

考察的是子类父类构造器的调用。

子类构造器默认调用父类无参构造器，可通过super选择构造器的使用。

8.银行存款问题扩展：体会函数重写的优点

父类中有存款取款函数，子类存取款需要修改，则直接调用然后修改参数即可。super.deposit(amount - fee)

package com.HomeworkChapter08;

public class Homework08 {
    public static void main(String[] args) {
        SavingAccount savingAccount = new SavingAccount(1000);
        savingAccount.deposit(1000);
        savingAccount.deposit(1000);
        savingAccount.deposit(1000);
        System.out.println(savingAccount.getBalance());
        savingAccount.deposit(1000);
        System.out.println(savingAccount.getBalance());
        savingAccount.earnMoneyInterest();
        System.out.println(savingAccount.getBalance());


    }
}
class BankAccount{
    private double balance;

    public BankAccount(double balance) {
        this.balance = balance;
    }
    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;
    }
}
class CheckingAccount extends BankAccount {
    private double fee = 1.0;//手续费

    public CheckingAccount(double balance, double fee) {
        super(balance);
        this.fee = fee;
    }

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

    public double getFee() {
        return fee;
    }

    public void setFee(double fee) {
        this.fee = fee;
    }

    @Override
    public void deposit(double amount) {
        super.deposit(amount - 1);
    }

    @Override
    public void withdraw(double amount) {
        super.withdraw(amount + 1);
    }
}
class SavingAccount extends BankAccount{
    private int count = 3; //免手续费的操作次数
    private  double moneyInterest = 0.03;//利息

    public SavingAccount(double balance, int count, double moneyInterest) {
        super(balance);
        this.count = count;
        this.moneyInterest = moneyInterest;
    }

    public SavingAccount(double balance) {
        super(balance);
    }

    public int getCount() {
        return count;
    }

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

    public double getMoneyInterest() {
        return moneyInterest;
    }

    public void setMoneyInterest(double moneyInterest) {
        this.moneyInterest = moneyInterest;
        this.count = 3;//重置次数
    }

    public void earnMoneyInterest() {
        super.deposit(getBalance() * moneyInterest);//重新设置利润
        count = 3;
    }

    @Override
    public void deposit(double amount) {
        if (this.count > 0) {
            count--;
            super.deposit(amount);//不需要手续费
        } else {
            super.deposit(amount - 1);//需要手续费
        }
    }

    @Override
    public void withdraw(double amount) {
        if (this.count > 0) {
            count--;
            super.withdraw(amount);//不需要手续费
        } else {
            super.withdraw(amount + 1);//需要手续费
        }
    }
}

9.构造器的使用。super

class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}
class LabelPoint extends Point {
    private String name;

    public LabelPoint( String name, double x, double y) {
        super(x, y);
        this.name = name;
    }
}

10.掌握 equals 函数的重写（自带的和自己写的）

首先判断是否是同一个对象，若是，则直接相等；

若不是同一个对象，则判断是否是同一类，（getclass() 返回的是运行类型）

最后判断内容是否相等。记得要向下转型，这样才能访问子类的特有方法和属性

//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (o == null || getClass() != o.getClass()) return false;
//        Doctor doctor = (Doctor) o;
//        return age == doctor.age &&
//                gender == doctor.gender &&
//                Double.compare(doctor.sal, sal) == 0 &&
//                Objects.equals(name, doctor.name) &&
//                Objects.equals(job, doctor.job);

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Doctor)) return false;
        Doctor obj = (Doctor)o;
        return this.age == obj.age &&
                this.gender == obj.gender &&
                this.sal == obj.sal &&
                this.name.equals(obj.name) &&
                this.job.equals(obj.job);
    }

11.向上转型和向下转型

  • 向上转型：父类的引用指向了子类的对象，可以调用父类的所有成员（遵守访问权限），不能调用子类的特有成员
  • 向下转型：把指向子类对象的父类引用，转成指向子类对象的子类引用，转型后可以调用子类类型中的所有成员。

12.== 和 equals 的区别

名称概念基本数据类型引用类型
==比较运算符号可以，判断数数值是否相等可以，用于判断两个对象是否相等，判断的是对象地址
equalsObject类的方法，Java类都可使用equals不可以可以，默认是判断对象是否相等，但是子类往往需要重写，比较对象的属性是否相等。

13.老师和学生继承person类，然后再分别写特有方法以及重写play方法

     package com.HomeworkChapter08;

public class Homework13 {
    public static void main(String[] args) {
        Student student = new Student("小明", 15, '男', "00023102");
        Teacher03 teacher03 = new Teacher03("张飞", 30, '男', 5);
        student.printInfo();
        System.out.println("-----------------");
        teacher03.printInfo();
        Person01[] person = new Person01[4];//创建数组，开辟三个数组空间
        person[0] = new Student("小明", 15, '男', "00023102");
        person[1] = new Student("小红", 18, '男', "00023102");
        person[2] = new Teacher03("王刚", 34, '男', 6);
        person[3] = new Teacher03("张飞", 30, '男', 5);
        for (int i = 0; i < person.length; i++) {
            System.out.println(person[i].getName() + "  " + person[i].getAge());
        }
        //要求按照年龄从高到低进行排序
        Person01 temp;//创建中间替换的对象引用
        for (int i = 1; i < person.length; i++) {
            for (int j = 0; j < person.length - i; j++) {
                if (person[j].getAge() < person[j + 1].getAge()) {
                    temp = person[j + 1];
                    person[j + 1] = person[j];
                    person[j] = temp;
                }
            }
        }
        System.out.println("-------------------");
        for (int i = 0; i < person.length; i++) {
            System.out.println(person[i].getName() + "  " + person[i].getAge());
        }
        Person01 person01 = new Person01("小东", 13, '男');
        person01.call(student);

    }
}

class Person01 {
    private String name;
    private int age;
    private char gender;

    public Person01(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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 char getGender() {
        return gender;
    }

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

    public String play() {
        return this.name + "爱玩";
    }

    public void printInfo() {
        System.out.println("姓名：" + this.name +
                "\n年龄：" + this.age +
                "\n性别：" + this.gender);
    }

    public void call(Person01 p) {
        Student student = (Student)p;
        student.study();
//        System.out.println(student.play());
    }
}

class Student extends Person01 {
    private String stu_id;

    public Student(String name, int age, char gender, String stu_id) {
        super(name, age, gender);
        this.stu_id = stu_id;
    }

    public String getStu_id() {
        return stu_id;
    }

    public void setStu_id(String stu_id) {
        this.stu_id = stu_id;
    }

    public void study() {
        System.out.println("我承诺，我会好好学习。");
    }

    @Override
    public String play() {
        return super.play() + "足球.";
    }

    @Override
    public void printInfo() {
        System.out.println("学生的信息：");
        super.printInfo();
        this.study();
        System.out.println(this.play());
    }
}

class Teacher03 extends Person01 {
    private int work_age;

    public Teacher03(String name, int age, char gender, int work_age) {
        super(name, age, gender);
        this.work_age = work_age;
    }

    public int getWork_age() {
        return work_age;
    }

    public void setWork_age(int work_age) {
        this.work_age = work_age;
    }

    public void teach() {
        System.out.println("我承诺，我会认真教学。");
    }

    @Override
    public String play() {
        return super.play() + "象棋.";
    }

    @Override
    public void printInfo() {
        System.out.println("老师的信息：");
        super.printInfo();
        this.teach();
        System.out.println(this.play());
    }
}

14.构造器的使用

子类的构造器会调用的父类的构造器。若子类中构造器中调用了this（），则在调用的构造器中再调用父类的构造器。

public class Test01 {
    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 类的有参构造器");
    }
}

我是 A 类
hahah我是 B 类的有参构造。
我是 C 类的有参构造器
我是 C 类的无参构造器

15.多态的含义和体现

多态概念：方法或对象具有多种形态，是 OOP 的第三大特征，是建立在封装和继承的基础上

多态体现：

  • 方法多态：（1）重载体现多态 （2）重写体现多态
  • 对象多态：
    • 1.编译类型和运行类型可以不一致，编译在定义时就确定，不能变化；
    • 2.运行类型时可以变化的，可以通过getclass（）查看运行类型；
    • 编译看 == 左边 ，运行类型看 == 右边

16.Java的动态绑定机制是什么

  • 1.当调用对象的方法时，该方法会和对象的内存地址/运行类型绑定；
  • 2.当调用对象的属性时，没有动态绑定机制，那里声明，哪里使用。
Java作业之面向对象篇
m0_56423338的博客
07-25 766
面向对象
Java面向对象作业题
PPDY93的博客
11-15 871
文章目录一、编写代码二、问题简答 一、编写代码 根据需求，完成如下代码（找出继承关系,分析哪些需要定义成抽象类,哪些需要定义成具体的类），并在测试类中进行测试。 要求:所有的成员变量全部私有,并提供公共的访问接口 已知学生类(Student)和老师(Teacher)类如下： 属性:姓名,年龄 行为:吃饭 老师有特有的方法:讲课 学生有特有的方法:学习 package org.oracle.test; public class Student extends Person {
java_面向对象
zn_wuxunian的博客
06-19 236
1.创建一个Test类，包含有一个public权限的int型成员变量与一个char类型的成员变量，观察在main方法中的初始值。class Test1{ public int a; public char b;//"/u0000"==空格 } public class Test { public static void main(String[] args){ Test1 a=new T...
java面向对象作业_Java面向对象作业总结
weixin_39870700的博客
02-20 248
前言：这次的博客是针对第一次学习Java面向对象课程的总结与思考，主要是通过作业来体现一、作业的总结：在学习Java的这段时间内，我完成了三次作业。第一次的作业是选择结构类型的题目，难度并不是很大，第二次的作业是关于设计计算日期的，比如判断输入的日期星期几以及求前n天或后一天，涉及到的知识有选择、循环、方法、数组，较第一次作业难度增加了。第三次作业是关于类与对象以及构造方法和类之间关系的题目。这三...
java-面向对象作业-002
cloud
03-27 1615
java-面向对象作业-002-2020-3-27 Client.java /* * 程序名称:面向对象作业第二次 * 程序作者:cloud */ package zuoye_03; public class Client {//客户类 private String name;//姓名 private String company;//公式 /*通讯*/ pr...
Java面向对象总结(作业)
最新发布
D2562397719的博客
12-17 156
如果在Java程序中没有定义任何的构造方法，则编译器将会自动加上一个不带任何参数的构造方法即缺省构造方法，该方法不存在于源程序中，但可以使用。在Java中，关键字“extends”表示继承，后面紧跟父类的类名.在Java中，被继承的类叫父类或超类，继承父类的类叫子类或派生类。封装就是把对象的属性（状态）和方法（行为）结合在一起，并尽可能。，成为一个不可分割的独立单位（即对象），对外形成一个边界，只。构造方法是一种特殊的方法，在对象被创建时用来初始化对象；对象：具体的某一事物，代表自身的一些属性和方法。
Java面向对象第2版代码.zip
07-03
《Java面向对象编程第二版》是一本深入探讨Java编程中面向对象特性的教材。这个压缩包包含了一系列章节的源代码示例，旨在帮助学习者更好地理解和应用Java的面向对象概念。下面将对这些章节涉及的知识点进行详细阐述...
孙卫琴java面向对象编程源码
06-14
《孙卫琴java面向对象编程源码》是针对Java编程初学者和进阶者的一份宝贵资源，由知名作者孙卫琴编著。这个压缩包包含的源代码旨在帮助读者深入理解Java语言的核心面向对象特性，通过实际示例来阐述理论知识。下面将...
Java面向对象编程：抽象、封装、继承与多态
"Accp 6.0 Java面向对象编程 Chapter01-08 包含了关于抽象、封装、继承、多态和接口的基础知识，适合初学者学习。资源来源于北大青鸟的教学资料，包括多个示例代码，强调了Java中类的创建、对象的实例化以及命名规范...
Java面向对象——对象（Java笔记作业）
qq_59109713的博客
11-23 131
Java老师布置的作业笔记，emmm
【无标题】
weixin_59182119的博客
12-06 280
任务3.1创建员工类 3.1.1任务要求 员工类属性有姓名（属性名为name），工号（属性名为ID），职位（属性名为position），工资（属性名为salary），入职时间：年（属性名为year），入职时间：月（属性名为month），入职时间：日（属性名为day）。掌握类的定义，以及类中的属性和方法的编辑、重载。 3.1.2知识准备 1）面向对象的基本概念 面向对象程序设计又称为OOP（Objiect-orientend...
Java面向对象程序设计作业目录（作业笔记）
热门推荐
杨明金的博客
05-08 1万+
持续更新中............. 我的大学笔记>>> 第1章 面向对象 >>> 1.1.5编写Java程序，创建Dota游戏中的防御塔类，通过两个坐属性显示防御塔所在的位置 1.2.4编写Java程序，方法练习题__构建英雄类，定义一个int类型的变量output，表示英雄的血量 1.3.4编写Java程序，通过给定可变参数方法，计算任意给定...
面向对象程序设计2018上机题（2）
SunXiaoying2016的博客
11-03 572
/*根据下列要求，编写完整程序。 设计一个类，用于对10元整型数组进行管理。要求： （1）在定义对象时，能够为数组元素清0. （2）定义成员函数input, 用于为数组元素输入数据。 （3）定义成员函数disp，用于显示数组的每个元素值。 （4）定义成员函数max，用于找出数组元素的最大值及其个数，其中最大值由函数值返回，个数由参数带回。 （5）定义成员函数find，用于找出数组中重...
接口的两种方式
weixin_44619579的博客
04-27 698
接口的两种方式 一. interface A. 类与类之前需要特定的接口进行协调，而不在乎其如何实现。 B. 作为能够实现特定功能的标识存在，也可以是什么接口方法都没有的纯粹标识。 C. 需要将一组类视为单一的类，而调用者只通过接口来与这组类发生联系。 D. 需要实现特定的多项功能，而这些功能之间可能完全没有任何联系 二. abstract class 一句话，在既需要统一的接口，又需要实例变量或缺省的方法的情况下，就可以使用它。最常见的有： A. 定义了一组接口，但又不想强迫每个实现类都必须实现所有的接口
java面向对象作业
llqq314的博客
04-14 760
一、选择 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面向对象作业_java面向对象作业
weixin_42511091的博客
02-12 183
/*** Animal.java*/package animal;public class Animal {private String name; //名称private int bodySize; //大小private float weight; //体重public Animal (String name, int bodySize, float weight) {this.name = ...
java-面向对象作业-1
ljl17880248619的博客
08-06 200
java-面向对象作业-1
java-面向对象作业-001
cloud
03-19 1460
6个成员变量 2个构造器方法 3个函数成员 /* * 程序名称:面向对象作业第二次 * 程序作者:cloud */ package zuoye_02; public class Student { private String banji;//班级 private int banji_number=34;//班级人数 private int student_id;//学号 private...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值