java语言之代码练习题汇总

形状类的子类：Rect(矩形),Circle(圆形)Rect类的子类：Square(正方形)不同的子类会有不同的计算周长和面积的方法解题思路：计算三个形状类的周长和面积，周长与面积是他们共有的结果，可以单独写一个类进行结果接收，其他类继承父类形状类定义各自的属性并封装，对属性提供get 和set 方法有参构造方法(根据需求而定，这个场景使用有参构造，可以初始化实例时，直接给属性赋值)重写父类方法(

罒王大虎

5878人浏览 · 2021-12-12 22:40:07

罒王大虎 · 2021-12-12 22:40:07 发布

1. 设计一个形状类Shape，方法：求周长和求面积

形状类的子类：Rect(矩形),Circle(圆形)

Rect类的子类：Square(正方形)

不同的子类会有不同的计算周长和面积的方法

解题思路：

计算三个形状类的周长和面积，周长与面积是他们共有的结果，可以单独写一个类进行结果接收，其他类继承父类
形状类定义各自的属性并封装，对属性提供get 和set 方法
有参构造方法(根据需求而定，这个场景使用有参构造，可以初始化实例时，直接给属性赋值)
重写父类方法(计算周长与面积)

package area;

public class Shape {
    public double sum = 0; //周长
    public double area = 0; //面积

    public double getSum(){
        return 0.0;
    }

    public double getArea(){
        return 0.0;
    }
}

package area;

public class Rect extends Shape{ //矩形
    private double length;
    private double wide;

    public void setLength(double length) {
        this.length = length;
    }

    public void setWide(double wide) {
        this.wide = wide;
    }

    public double getLength() {
        return length;
    }

    public double getWide() {
        return wide;
    }

    public Rect(double length,double wide){
        this.length = length;
        this.wide = wide;
    }

    @Override
    public double getSum() {
        sum = 2 * (this.length + this.wide);
        return sum;
    }

    @Override
    public double getArea() {
        area = this.length * this.wide;
        return area;
    }
}

package area;

public class Circle extends Shape {  //圆
    private final static double p = 3.1415926;
    private double radius;

    public Circle(double radius){
        this.radius =radius;
    }
    
    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public double getSum() {
        sum = 2 * p * radius;
        return sum;
    }

    @Override
    public double getArea() {
        area = radius * radius * p;
        return area;
    }

}

package area;

public class Square extends Shape{   //正方形
    private double sidelength;

    public Square(double sidelength){
        this.sidelength = sidelength;
    }

    public void setSidelength(double sidelength) {
        this.sidelength = sidelength;
    }

    public double getSidelength() {
        return sidelength;
    }

    @Override
    public double getSum() {
        sum = 4 * sidelength;
        return sum;
    }

    @Override
    public double getArea() {
        area = sidelength * sidelength;
        return  area;
    }
}

package area;

public class AreaTest {
    public static void main(String[] args) {
        Rect r = new Rect(4,5);  //矩形

        Circle c = new Circle(4.56);  //圆

        Square s = new Square(5.67); //正方形
        r.getSum();
        r.getArea();
        System.out.println("矩形的周长："+ r.getSum() +";矩形的面积："+ r.getArea());

        c.getSum();
        c.getArea();
        System.out.println("圆的周长："+ c.getSum() +";圆的面积："+ c.getArea());

        s.getSum();
        s.getArea();
        System.out.println("正方形的周长："+ s.getSum() +";正方形的面积："+ s.getArea());
    }

}

2. 设计一个台灯类(Lamp)其中台灯有灯泡类(Buble)这个属性，还有开灯(on)这个方法

设计一个灯泡类(Buble)，灯泡类有发亮的方法，其中有红灯泡类(RedBuble)和绿灯泡类(GreenBuble)，他们都继承灯泡类(Buble)一个发亮的方法

解题思路：

灯泡发光是一个事物的共同行为，可以作为父类，让具体的物品进行继承(使用抽象类而不是普通类，是因为发光的方法是需求必须要求实现的部分)
绿灯与红灯继承发光的方法并重写(每种灯发出光的方式或条件是不一样的，所以需要重写父类方法)
台灯打开开关，然后发光，除了需要电以外，他还需要一个灯泡，所以将灯泡的类实例化作为属性
灯泡作为父类，可以引用子类对象，最终Test类调用台灯开关ON()，并上传作为参数的灯泡(红灯与绿灯类)，达到需求不同灯泡发出不同光的需求。

package lantern;

public abstract class Buble {  //灯泡
    public abstract String lampOn();  //开灯，灯泡发亮啦！！
}

package lantern;

public class RedBuble extends Buble{ //继承灯泡的发亮的方法，并重写
    @Override
    public String lampOn() {
        return "红灯亮了！";
    }
}

package lantern;

public class GreenBuble extends Buble{
    @Override
    public String lampOn() {
        return "绿灯亮了！";
    }
}

package lantern;

public class Lamp {
    private Buble buble; //属性封装(一个类的属性可以是一个实例对象)

    public Buble getBuble() {  //提供读与写的方法
        return buble;
    }

    public void setBuble(Buble buble) {
        this.buble = buble;
    }

    public void on(Buble buble){ //传入Buble 类型的对象
        if(buble instanceof GreenBuble){//instanceof 严格来说是Java中的一个双目运算符
            String g = buble.lampOn();  //instanceof 用来测试一个对象是否为一个类的实例
            System.out.println("打开台灯："+ g);
        }else if(buble instanceof RedBuble){
            String r = buble.lampOn();  //父类调用子类重写方法
            System.out.println("打开台灯："+ r);
        }
    }
}

package lantern;

public class BubleTest {
    public static void main(String[] args) {
        Lamp l = new Lamp();
        Buble r = new RedBuble(); //父类引用子类对象
        Buble g = new GreenBuble();
        l.on(r);
        l.on(g);
    }
}

3. 写一个程序，把若干各种类型的员工放在一个Employee数组里，写一个方法，打印出某月每个员工的工资数额

Employee：这是所有员工总的父类
- 属性：员工的姓名，员工的生日月份
- 方法：
  - double getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100元
  - SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪
  - HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放。属性：每小时的工资、每月工作的小时数
  - SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定。属性：月销售额、提成率
  - BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，工资由底薪加上销售提成部分。属性：底薪。

要求：

写一个程序，把若干各种类型的员工放在一个Employee数组里，
写一个方法，打印出某月每个员工的工资数额。

注意：

要求把每个类都做成完全封装，不允许非私有化属性。

解题思路：

Employee类作为员工的基本信息，包含姓名、生日、薪资的属性
其他类(月薪、小时工、销售)分别继承父类信息，有销售底薪+提成的类继承销售提成的类，并实现各自的薪资的计算方式
通过getSalary方法进行调用和读取每月各自的薪资信息
这里用到了一个新实例，JDK8提供获的LocalDate类，取时间和写入时间更方便
要实现某个功能或需求，首先是要想清楚实现的方式和逻辑，脑子里要有个大概的框架，条理清晰，才不会被自己绕晕和想复杂(个人小感悟)

package employees;

import java.time.LocalDate;

public class Employee {  //员工信息
    private String name;
    private LocalDate birthday;
    public Employee(){   //默认构造(无参构造)

    }
    public Employee(String name, LocalDate birthday){ //类需要被集成，类中存在非默认构造需要手写默认构造
        this.name = name;
        this.birthday = birthday;
    }

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

    public void setBirthday(LocalDate birthday) {
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public double getSalary(int month){
        return 0;
    }
}

package employees;

import java.time.LocalDate;

public class HourlyEmployee extends Employee{ //按小时领取工资
    private double hourLyEmp;
    private int hours;

    public HourlyEmployee(){  //一个类中一定存在一个无参的默认构造，不写会编译会报错
    }

    public HourlyEmployee(String name, LocalDate birthday,int hourLyEmp,int hours){
        super(name, birthday);
        this.hourLyEmp = hourLyEmp;
        this.hours = hours;
    }

    public void setHourLyEmp(double hourLyEmp) {
        this.hourLyEmp = hourLyEmp;
    }

    public double getHourLyEmp() {
        return hourLyEmp;
    }

    public int getHours() {
        return hours;
    }

    public void setHour(int hour) {
        hours = hour;
    }

    @Override
    public double getSalary(int month) {
        double sum = 0.0;
        if(this.getBirthday().getMonthValue() == month){
            sum += 100;
        }
        if(hours <= 160){
            sum += hours * hourLyEmp;
        } else if(hours > 160){
            sum += 160 * this.getHourLyEmp() + (this.getHours() - 160) * (this.getHourLyEmp() * 1.5);
        }
        return sum;
    }
}

package employees;

import java.time.LocalDate;

public class SalariedEmployee extends Employee{ //拿固定工资
    private double monthLysalary;   //月薪

    public double getMonthLysalary() {
        return monthLysalary;
    }

    public void setMonthLysalary(double monthLysalary) {
        this.monthLysalary = monthLysalary;
    }
    public SalariedEmployee(){

    }

    public SalariedEmployee(String name, LocalDate birthday, double monthLysalary){
        super(name, birthday);
        this.monthLysalary = monthLysalary;
    }

    @Override
    public double getSalary(int month) {
        double num = this.getMonthLysalary();
        if(this.getBirthday().getMonthValue() == month){
            num += 100;
        }
        return num;
    }
}

package employees;

import java.time.LocalDate;

public class SalesEmployee extends Employee { //销售提成
    private double monthlySales; //月销售额
    private double commissionRate;  // 提成率

    public SalesEmployee(){

    }
    public SalesEmployee(String name, LocalDate birthday, double monthlySales, double commissionRate){
        super(name,birthday);
        this.monthlySales = monthlySales;
        this.commissionRate = commissionRate;
    }

    public double getMonthlySales() {
        return monthlySales;
    }

    public double getCommissionRate() {
        return commissionRate;
    }

    public void setMonthlySales(double monthlySales) {
        this.monthlySales = monthlySales;
    }

    public void setCommissionRate(double commissionRate) {
        this.commissionRate = commissionRate;
    }

    @Override
    public double getSalary(int month) {
        double sum = 0.0;
        if(this.getBirthday().getMonthValue() == month){
            sum +=100;
        }
        sum +=this.getMonthlySales() * this.getCommissionRate();
        return sum;
    }
}

package employees;

import java.time.LocalDate;

public class BasePlusSalesEmployee extends SalesEmployee { //底薪 + 提成
    private int baseSalary;
    public BasePlusSalesEmployee(String name, LocalDate birthday, double monthlySales, double commissionRate, int baseSalary){
        super(name, birthday, monthlySales, commissionRate);
        this.baseSalary = baseSalary;
    }
    public int getBaseSalary() {
        return baseSalary;
    }

    public void setBaseSalary(int baseSalary) {
        this.baseSalary = baseSalary;
    }

    @Override
    public double getSalary(int month) {
        double sum = 0.0;
        if (this.getBirthday().getMonthValue() == month) {
            sum += 100;     // + 生日奖金
        }
        sum += getBaseSalary(); // + 底薪
        sum += this.getMonthlySales() * this.getCommissionRate(); // + 销售提成
        return sum;
    }
}

package employees;

import java.time.LocalDate;

public class EmployeeTest {
    public static void main(String[] args) {
//      LocalDate now = LocalDate.now();  jdk 8  新提供的方法，获取当前日期
//      LocalDate.of(2018, 9, 24);        jdk 8  写入日期
        Employee [] employees = new Employee[4];  //除了new一个对象，我们还可以new一个数组
        HourlyEmployee h = new HourlyEmployee("张三", LocalDate.of(1995,12,17),50,160);
        SalariedEmployee s1 = new SalariedEmployee("李四",LocalDate.of(1994,11,17),5000);
        SalesEmployee s2 = new SalesEmployee("王五", LocalDate.of(1995,12,17),10000,0.1);
        BasePlusSalesEmployee b = new BasePlusSalesEmployee("张飞", LocalDate.of(1995,12,17),3000,0.1,10000);
        employees[0] =h;
        employees[1] =s1;
        employees[2] =s2;
        employees[3] =b;
        for (Employee e:employees) {
            System.out.println("姓名："+ e.getName() +"  "+ "薪资：" +  e.getSalary(12) +"  "+ "生日："+e.getBirthday());
        }
    }
}

4. 完成以下要求，最终创建Test类，完成Test的操作要求

要求如下：

创建一个Animal动物类，要求有方法eat（）方法，方法输出一条语句“吃东西”
创建一个接口A，接口里有一个抽象方法fly（）
创建一个Bird类继承Animal类并实现接口A里的方法输出一条有语句“鸟儿飞翔”，重写eat（）方法输出一条语句“鸟儿吃虫”
在Test类中向上转型创建b对象，调用eat方法。然后向下转型调用eat（）方法、fly（）方法

新知识点：

把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型，如：Father father = new Son()
把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型，要向下转型，必须先向上转型为了安全可以用instanceof判断
- 如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father，其中father前面的（Son）必须添加，进行强制转换
upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效，向上转型只能引用父类对象的属性，要引用子类对象属性，则要写getter函数
向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁，体现了JAVA的抽象编程思想

package Animal;

public class Animal {
    public void eat(){
        System.out.println("吃东西");
    }
}

package Animal;

public interface A {
    public abstract void fly();
}

package Animal;

public class Bird extends Animal implements A {
    @Override
    public void eat() {
        System.out.println("鸟儿 吃虫");
    }

    @Override
    public void fly() {
        System.out.println("鸟儿在飞翔");
    }
}

package Animal;

public class AnimalTest {
    public static void main(String[] args) {
        Bird b = new Bird();
        b.eat(); //调用子类本身的方法

        Animal a = new Bird(); //父类的引用指向了子类对象，子类对象转为父类。将子类的对象赋值给父类(向上转型)
        a.eat();//多态，执行子类中的方法，体现了多态的特性，同一种事物在不同情形下所表现出来的不同状态，只针对方法，不针对成员变量
        //eat()方法是子类重写父类方法(必须是父类的重写方法)，所以可以调用。。调用子类中独有的方法就会报错，如a.fly();

        Bird c = (Bird)a;  //子类的引用指向了父类，父类对象转为子类。并将父类强制转换为子类对象(向下转型)
        c.eat();
        c.fly();
    }
}

5. 按照以下场景要求，完成编码设计

创建一个Person抽象类
- 要求含有姓名（name）年龄（age）两个私有属性以及吃饭（eat）和睡觉（sleep）两个抽象方法，并写出带参构造方法
创建学生（student）和工人（worker）两个类，继承Person类
- 学生类多出了私有属性学号和学习方法（输出我爱学习）
- 工人类多出了私有属性工号和工作方法（输出我爱工作）
在主函数中创建学生和工人类的实例对象，使用构造方法赋值，并输出所有属性和方法

package person;

public abstract class  Person {
    private String name;
    private int age;

    public Person(){

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

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public abstract void eat();
    public abstract void sleep();
}

package person;

public class Student extends Person{
    private int number;

    public void setNumber(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    public void study(){   //学习方法
        System.out.println("我爱学习");
    }
    public Student(String name, int age,int number){
        super(name,age);
        this.number = number;
    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}

package person;

public class Worker extends Person{
    private int num;
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Worker(){

    }

    public Worker(String name,int age,int num){
        super(name,age);
        this.num = num;
    }

    public void working(){  //工作方法
        System.out.println("我爱工作");
    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}

package person;

public class PersonTest {
    public static void main(String[] args) {
        Student s = new Student("张同学",12,66);
        System.out.println("学生名字："+s.getName()+ "  年龄:"+s.getAge()+ "  学号:"+s.getNumber());

        Worker w = new Worker("王工人",23,1305);
        System.out.println("工人名字："+w.getName()+ "  年龄:"+w.getAge()+ "  工号:"+w.getNum());
    }
}

6. 编写测试类TestDemo，通过多态创建猫，通过多态创建狗，并调用猫对象的play方法，狗对象的play方法

要求如下：

首先定义一个抽象类Animal，抽象类中定义一个抽象方法play()抽象方法
创建一个猫Cat类，继承Animal并重写play()方法输出“我是猫，我玩老鼠”
创建一个狗类，继承Animal并重写play()方法输出“我是狗，我玩球”
最后编写测试类TestDemo，通过多态创建猫，通过多态创建狗，并调用猫对象的play方，狗对象的play方法

public abstract class Animal {
    public abstract void play();
}
class Cat extends Animal{
    @Override
    public void play() {
        System.out.println("猫玩老鼠");
    }
}

class Dog extends Animal{
    @Override
    public void play() {
        System.out.println("狗玩球");
    }
}

class TestDemo{
    public static void main(String[] args) {
        Cat c = new Cat();
        Dog d = new Dog();
        c.play();
        d.play();
    }
}

7. 创建跑车car2，用set方法赋值属性，输出属性，调用run()、price()方法

要求如下：

创建一个Car抽象类
- 要求有brand（品牌）属性，并且要求封装私有化，写出属性的 set、get方法
- 抽象类Car构造方法中也可以对brand属性赋值，写出一个抽象方法run （）。
创建一个跑车类SportsCar继承抽象类Car
- 实现Car抽象方法输出一条语句“超级跑车”，在本类中写出一个自己的方法price（），输出一条语句“售价100w”
在测试类Test类中创建跑车对象car1，用构造器赋值品牌属性，输出属性，调用run（）、 price（）方法
创建跑车car2，用set方法赋值属性，输出属性，调用run（）、price （）方法

package Car;

public abstract class Car {
    private String brand; // 品牌

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public Car(){

    }
    public Car(String brand){
        this.brand = brand;
    }

    public abstract void run();
}

package Car;

public class SportsCar extends Car{
    @Override
    public void run() {
        System.out.println("超级跑车！");
    }
    public SportsCar(){

    }
    public SportsCar(String brand){
        super(brand);
    }

    public void price(){
        System.out.println("售价100W");
    }
}

package Car;

public class CarTest {
    public static void main(String[] args) {
        SportsCar c = new SportsCar();  //set方法赋值属性
        c.setBrand("法拉第");
        System.out.println(c.getBrand());
        c.run();
        c.price();

        SportsCar c1 = new SportsCar("比亚迪");  //构造器赋值品牌属性
        System.out.println(c1.getBrand());
        c1.run();
        c1.price();
    }
}

8.在主方法中实例化Computer类，调用plugin方法，分别传递Flash和Print的对象，通过向上转型，完成功能

完成那个USB接口的例子，分别定义USB接口，两个方法start，stop
两个子类：Flash和Print，重写两个方法，方法中随便输出两句话
定义计算机类Computer，有一个plugin方法，有一个USB类型的参数，用来调用start和stop
在主方法中实例化Computer类，调用plugin方法，分别传递Flash和Print的对象，通过向上转型，完成功能

package Usb;

public abstract interface Usb {
    public abstract void start();
    public abstract void stop();
}

package Usb;

public class Flash implements  Usb {
    @Override
    public void start() {
        System.out.println("信号灯在闪亮");
    }

    @Override
    public void stop() {
        System.out.println("信号灯停止闪亮");
    }
}

package Usb;

public class Print implements Usb{
    @Override
    public void start() {
        System.out.println("开始打印");
    }

    @Override
    public void stop() {
        System.out.println("停止打印");
    }
}

package Usb;

public class Computer{
    public void plugin(Usb usb){
        usb.start();
        usb.stop();
    }
}

package Usb;

public class UsbTest {
    public static void main(String[] args) {
        Computer c = new Computer();
        Flash f = new Flash();
        Print p = new Print();
        c.plugin(f);
        c.plugin(p);
    }
}

9. 根据以下要求，完成编程设计

(1) 定义一个Flower花作为父类
属性：颜色价格
属性要进行封装（即为每条私有属性写set，get方法）
定义无参构造方法，和传两个参数的有参构造方法一个。
方法：显示详细信息的方法showInfo

(2) 定义一个Rose玫瑰花类继承Flower类
玫瑰花自己的属性：产地（要求对产地属性进行封装私有化属性）
重写父类中的显示详细信息的方法showInfo，在重写的showInfo方法中通过super调用父类的showInfo方法；并显示产地信息。
再定义一个方法warn警告显示：不要摘玫瑰花，小心扎手！

(3) 定义测试类Test完成：
①实例化Flower类，调用构造方法赋值，并调用方法，输出：
花的颜色是白色，价格是10元
②实例化玫瑰花类，调用方法，输出：
花的颜色是紫色，价格是30元
产地是大理
不要摘玫瑰花，小心扎手！

package Flower;

public class Flower {
    private String colour;
    private double price;

    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public Flower(){

    }
    public Flower(String colour,double price){
        this.colour = colour;
        this.price =price;
    }

    public void showInfo(){
//        System.out.println("我是花的详细信息");
    }

}

package Flower;

public class Rose extends Flower{
    private  String PlaceofOrigin;

    public String getPlaceofOrigin() {
        return PlaceofOrigin;
    }

    public void setPlaceofOrigin(String placeofOrigin) {
        PlaceofOrigin = placeofOrigin;
    }

    public Rose(String colour,double price){
        super(colour,price);
    }

    @Override
    public void showInfo() {
        System.out.println("产地来自："+ PlaceofOrigin);
    }

    public void Warn(){
        System.out.println("不要摘玫瑰花，小心扎手！");
    }
}

package Flower;

public class FlowerTest {
    public static void main(String[] args) {
        Flower f = new Flower("白色",10);
        System.out.println("花的颜色是"+ f.getColor()+"," +"价格是"+f.getPrice());

        Rose r = new Rose("紫色",30);
        System.out.println("花的颜色是"+ r.getColor()+"," +"价格是"+r.getPrice());
        r.setPlaceofOrigin("大理");
        r.showInfo();
        r.warn();
}

10. 第十题

(1) 首先定义一个程序员的接口Programmer,接口中定义一个抽象方法ACode（）
(2) 创建一个Student类，实现接口Programmer并实现ACode（）方法，ACode（）方法可输出输出“程序员在敲代码”， Student类有年龄，姓名，班级，性别私有属性（封装），各个属性的set，get方法，写空参构造方法，和一个有参构造方法包含这四个属性
(3) 定义测试类，在main方法中创建一个Student对象，将自己的年龄，姓名，班级，性别，赋值给这个对象，并在控制台打印出对象的各个属性。调用所有的方法

package programmer;

public interface Programmer {
    public abstract void Acode();
}

package programmer;

public class Student implements Programmer{
    private String name;
    private String grades;
    private int age;

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

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

    public void setGrades(String grades) {
        this.grades = grades;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGrades() {
        return grades;
    }

    @Override
    public void Acode() {
        System.out.println("程序员在敲代码");
    }

    public Student(){

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

package programmer;

public class ProgrammerTest {
    public static void main(String[] args) {
        Student s = new Student("张三","五年级",10);
        System.out.println("学生："+ s.getName());
        System.out.println("班级："+ s.getGrades());
        System.out.println("年龄："+ s.getAge());
        s.Acode();
    }
}

11. 感觉比较难

(1)、背景：

控制台应用程序的菜单处理，菜单会有子菜单项，可能会有多级。菜单项可能会随时更新和添加，需要能很方便地通过配置文件进行维护。

(2)、需求：

A. 首页菜单如下：

购物系统
--------------------------------------
1. 客户信息管理
2. 购物结算
3. 真情回馈
4. 注销
5. 退出
--------------------------------------
请选择（1～5）:

输入 1 时呈现：

购物系统 -- 客户信息管理
--------------------------------------
1. 显示所有客户信息
2. 添加客户信息
3. 修改客户信息
4. 查询客户信息
5. 返回上层
--------------------------------------
请选择（1～5）:

输入 2 时执行“购物结算”逻辑，假定只是输出“do 购物结算”，执行完成后显示首页菜单。
输入 3、4 时执行各模块逻辑，逻辑也是假定输出字符串，执行完成后显示首页菜单。
输入 5 时退出系统，终止程序。

B. 二级页面，客户信息管理

输入 1～4 执行各模块逻辑，假定输出字符串，执行完成后显示“客户信息管理”菜单。
输入 5 时则返回上层菜单，即返回首页菜单。

C. 其他要求

C.1 首页菜单及二级菜单的菜单项是不定的，可能会随时进行增、删，需要做到动态配置。
C.2 各菜单项可能有多级子菜单，也是会随时进行增、删，需要做到动态配置。
C.3 各菜单项所执行的功能应是单独的，互不影响，即撤换掉一个时不影响其他功能的使用。
C.4 在菜单停顿输入必须检查所输入的值，假定是“请选择（1～5）”，如果输入 6 的话则重显“请选择（1～5）”以便于能继续输入

12. 还是感觉比较难

(1). 背景

为了方便生成非数字的流水号，现在需要制作一个流水号生成器，每调用一
次可以获得流水号的下一个流水，并且能根据不同的要求进行变化

(2). 需求

2.1. 要求根据不同的场景生成流水号

2.2 流水号有多种表现形式，比如：M000001、M200903140001、20090314000001
等等之类的，流水号可能是从 1 开始的，但也可能根据设定时间段从 1 开
始

比如：M000001 的话，M 这个字符是固定的，而后面的数字是每调用一次流水号生成员都能获得下一个值
比如：20090314000001 的话，20090314 可能是当前的日期，也可能是当前的分钟或者说是小时，这样的话每一天或者每一小时或者是每一分钟的开始均从 1 开始
比如：M20090314000001 的话，M 是固定的，后面的与 B.2.2 一致
情况可能是多种多样的，具体的流水号产生逻辑今后可能还会增加，而且可以进行任意组合使用

2.3 流水号不同号码的长度是固定的，数字位数不足时前面添 0 补足位数

2.4 流水号可以放置于内存当中，但是为了停机后再次启动流水后也能延续下去，
就可能需要进行持久化处理，持久化暂时设置为文件和数据库，但是今后可
能会增加其他的持久化方式，比如 LDAP，FTP，SOCKET 等等。

(3) 要求

3.1 采用面向对象方式进行程序设计

3.2应做到设计合理，扩展方便，运行正确，需要考虑并发请求流水号的问题

3.3 代码格式标准，注释合理

3.4 提交代码时需要提供打包后的 jar 文件、所有源代码、Ant 或 Maven 构建脚本、有类图的话需要提供类图

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

Java Web 微信自助点餐系统系统源码-SpringBoot2+微信小程序+MyBatis+MySQL8【含文档】

2048 AI社区

【愚公系列】《人工智能70年》052-生成式Al的辉煌与难题（规模法则的是与非）

2048 AI社区

Agentic AI与提示工程：企业智能转型的双引擎

在当今数字化快速发展的时代，企业面临着日益激烈的竞争和不断变化的市场环境。为了保持竞争力并实现可持续发展，智能转型成为众多企业的必经之路。人工智能（AI）技术的崛起为企业提供了前所未有的机遇，其中Agentic AI和提示工程作为新兴的关键技术，正逐渐成为企业智能转型的核心驱动力。Agentic AI具备自主决策和行动能力，能够像智能的“代理人”一样，根据环境变化和目标设定，主动地执行任务。而提示