java练习

srmmh

已于 2022-08-25 16:37:39 修改

阅读量1.5k

点赞数 2

分类专栏：笔记文章标签： java

于 2020-05-18 17:12:11 首次发布

本文链接：https://blog.csdn.net/u013074761/article/details/106196982

版权

笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

题目

在程序中经常要对时间进行操作但是并没有时间类型的数据。那么我们可以自己实现一个时间类来满足程序中的需要。定义名为MyTime的类其中应有三个整型成员时hour分minute秒second为了保证数据的安全性这三个成员变量应声明为私有。为MyTime类定义构造方法以方便创建对象时初始化成员变量。重写toString()方法用于将时间信息打印出来,打印时间格式(时：分：秒)。为MyTime类添加以下方法 setSecond(int sec) setMinute(int min) setHour(int hou)分别对时、分、秒进行加减运算。注意时、分、秒可以大于或小于0，在进行计算时还应该注意进位。如当前时间12：20：40，当调用addSecond(30)时，则时间变为：12：21：10

代码

Test.java

public class Test {
    public static void main(String[] args) {
        MyTime time = new MyTime(12,20,40);
        time.addHour(-13);
        System.out.println(time);
    }
}

MyTime

public class MyTime {
   private int hour;
  private   int minute;
  private   int second;
    // 构造方法，用于方便为属性赋值
public MyTime(int hour ,int minute,int second){
    this.hour=hour;
    this.minute=minute;
            this.second=second;
}
public void addHour(int hour){
    this.hour+=hour;
    this.hour%=24;//1天24小时
    if(this.hour<0){
        this.hour+=24;
    }
}

public void addMinute(int minute){
    this.minute+=minute;
    this.hour=this.minute/60;//通过整除求出小时数
    this.minute%=60;
    if(this.minute<0){
        hour--;
        this.minute+=60;
    }
    this.addHour(hour);
}
public void addSecond(int second){
    this.second+=second;
    int minute = this.second/60;//通过整除求出分钟数
    this.second%=60;//通过求余求出当前的秒数
    if(this.second<0){//如果小于0，需要从分钟那边借值
        minute--;//分钟-1
        this.second+=60;
    }
    this.addMinute(minute);//对秒的操作可能对分钟产生影响

}
@Override
    public String toString(){
    return hour+":"+minute+":"+second;
}

}

一

题目

Java程序用于显示人的姓名和年龄。定义一个人类Person该类中应该有两个私有属性姓名name和年龄age。定义构造方法用来初始化数据成员。再定义显示display方法将姓名和年龄打印出来。在main方法中创建人类的实例然后将信息显示。

代码

Person.Java

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

    public static void main(String[] args) {

        Person person = new Person();
        person.setName("xz");
        person.setAge(3);
        display();
    }

    private static void display() {

        System.out.println(name);
        System.out.println(age);
    }

    public Person() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }
}

二

题目

构造方法的重载定义一个名Vehicles 交通工具的基类，该类中应包含String类型的成员属性brand 商标和color 颜色，还应包含成员方法run行驶，在控制台显示“我已经开动了” 和showInforclk返回商标和颜色并编写构造方法初始化其成员属性。编写Car 小汽车类继承于Vehicles类增加int型成员属性seats 座位还应增加成员方法showCar ，返回小汽车的信息，并编写构造方法。编写Truck 卡车类继承于Vehicles类增加float型成员属性load 载重还应增加成员方法showTruck，返回卡车的信息，并编写构造方法。在main方法中测试以上各类。

代码

public class Vehicles {
    static String brand;
    static String color;

    private static void run() {
        System.out.println("我已经开动了");

    }
    private static void init() {
        Vehicles vehicles = new Vehicles();
        vehicles.setBrand("宝马");
        vehicles.setColor("白色");
        Car car = new Car();
car.setSeats(15);
Truck truck = new Truck();
truck.setLoad(20);
    }
    public static class Truck extends Vehicles{
        static float load;

        public float getLoad() {
            return load;
        }

        public void setLoad(float load) {
            this.load = load;
        }
    }
    public static class Car extends Vehicles{
        static int seats;

        public int getSeats() {
            return seats;
        }

        public void setSeats(int seats) {
            this.seats = seats;
        }
    }
    /*
    构造方法的重载 定义一个名Vehicles 交通工具的基类，该类中应包含String类型的成员属性brand 商标 和color 颜色，还应包含成员方法run行驶，
    在控制台显示“我已经开动了” 和showInforclk返回商标和颜色 并编写构造方法初始化其成员属性。 编写Car 小汽车 类继承于Vehicles类 增加int型成员属性seats
     座位
    还应增加成员方法showCar ，返回小汽车的信息，并编写构造方法。 编写Truck 卡车 类继承于Vehicles类 增加float型成员属性load 载重
    还应增加成员方法showTruck
    ，返回卡车的信息，并编写构造方法。 在main方法中测试以上各类。
     */
    public static void main(String[] args) {
        init();
        run();
        showInforclk();
        showCar();
        showTruck();

        System.out.println(brand);
        System.out.println(color);
        System.out.println(Car.seats);
        System.out.println(Truck.load);

    }

    private static void showTruck() {
    }

    private static void showCar() {


    }

    public String getBrand() {
        return brand;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    private static void showInforclk() {


    }
}

三

题目

构造方法与重载，定义一个网络用户类，要处理的信息有用户ID、用户密码、email地址。在建立类的实例时，通过构造方法为属性赋值，其中用户ID和用户密码时必须的，缺省的email地址是用户ID加上字符串"@gameschool.com"

代码

public class NetWeb {
    static int id;
    static int password;
    static String email;

    public static void main(String[] args) {
       NetWeb netWeb = new NetWeb();
      netWeb.setId(521);
      netWeb.setPassword(521);
      netWeb.setEmail(email);
        System.out.println("账号是"+NetWeb.id);
        System.out.println("密码是"+NetWeb.password);
        System.out.println("邮箱是"+NetWeb.getEmail());


    }

    public NetWeb() {
    }

    public NetWeb(int id, int password, String email) {
        this.id = id;
        this.password = password;
        this.email = email;
    }

    /**
     * 获取
     * @return id

     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     * @return password
     */
    public int getPassword() {
        return password;
    }

    /**
     * 设置
     * @param password
     */
    public void setPassword(int password) {
        this.password = password;
    }

    /**
     * 获取
     * @return email
     */
    public static String getEmail() {
        return email=id+"@gameschool.com";
    }

    /**
     * 设置
     * @param email
     */
    public void setEmail(String email) {
        this.email = email;
    }

    public String toString() {
        return "NetWeb{id = " + id + ", password = " + password + ", email = " + email + "}";
    }
}

四

题目

构造方法与重载、包：编写Addition类，该类中应包含一组实现两数相加运算的重载方法。实现加法运算的方法add，应接受两个参数,即加数和被加数,方法将两个参数进行加法运算后输出运算结果。考虑可能针对不同的数据类型进行计算，重载一组方法，包括整型、长整型、浮点型、双精度浮点型、还有字符串。在main方法中创建Addition类的实例分别调用重载方法测试其效果

代码

public class Addition {
  static int a=1;
  static int b=2;
  static Integer a1=1;
  static Integer b1=2;
  static float a2=1;
  static float b2=2;
  static double a3=1;
  static double b3=2;
  static String a4="1";
  static String b4="2";
  static short a5=1;
  static short b5=2;

    public static void main(String[] args) {
        System.out.println("a=1,b=2");
        IntAddition();
        IntegerAddition();
        FloatAddition();
        DoubleAddition();
        StringAddition();
        ShortAddition();

        Addition addition = new Addition();
        Addition.IntAddition();
        Addition.DoubleAddition();
        Addition.FloatAddition();
        Addition.IntegerAddition();
        Addition.ShortAddition();
        Addition.StringAddition();



    }

    private static void ShortAddition() {
        short c;
        c= (short) (a5+b5);
        System.out.println("短整型的结果"+c);
    }

    private static void StringAddition() {
        String c;
        c=a4+b4;
        System.out.println("字符串的结果"+c);
    }

    private static void DoubleAddition() {
        double c;
        c=a3+b3;
        System.out.println("双精度浮点型"+c);

    }

    private static void FloatAddition() {
        float c;
        c = a2+b2;
        System.out.println("浮点类型"+c);


    }

    private static void IntegerAddition() {
        Integer c;
        c=a1+b1;
        System.out.println("包装类的整数型"+c);
    }

    private static void IntAddition() {
        int c;
        c=a+b;
        System.out.println("整数型"+c);
    }

}

一

题目

抽象类：创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个抽象方法NoOfWheels方法，使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承，并在这两个类中实现NoOfWheels方法。在Car类中，应当返回“四轮车”信息；而在Motorbike类中，应当返回“双轮车”信息。创建另一个带main方法的类在该类中创建Car和Motorbike的实例并在控制台中显示消息。

代码

Car.java

public class Car extends  Vehicle {
    @Override
    public String NoOfWheels(){
        return  "四轮车";
    }
}

Motorbike.java

public class Motorbike extends Vehicle{
    @Override
    public String NoOfWheels(){
        return "双轮车";
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        Vehicle car1 = new Car();
        Vehicle bike1 = new Motorbike();
        System.out.println(car1.NoOfWheels());
        System.out.println(bike1.NoOfWheels());
    }
}

Vehicle.java

public abstract class Vehicle {
public abstract String NoOfWheels();
}

二

题目

接口：创建一个名称为Vehicle的接口，在接口中添加两个方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口，实现接口中的方法，在方法中输出车辆信息。创建一个名称为InterfaceDemo的类，在InterfaceDemo的main()方法中创建Bike和Bus对象，并访问start()和stop()方法。

代码

Bike.java

public class Bike implements Vehicle{
    @Override
    public void start(){
        System.out.println("自行车-start");
    }
    @Override
    public void stop(){
        System.out.println("自行车-stop");
    }
}

Bus.java

public class Bus implements Vehicle {
    @Override
    public void start(){
        System.out.println("公交车-start");
    }
    @Override
    public void stop(){
        System.out.println("公交车-stop");
    }
}

Vehicle.java

public interface Vehicle {
public void start();
public void stop();
}

InterfaceDemo.java

public class InterfaceDemo {
    public static void main(String[] args) {
        Vehicle bike = new Bike();
        Vehicle bus = new Bus();
        bike.start();
        bike.stop();
        bus.start();
        bus.stop();
    }
}

三

题目

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

代码

A.java

public interface A {
    public void fly();

}

Animal.java

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

Bird.java

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

Test.java

public class Test {
    public static void main(String[] args) {
        Animal b = new Bird();
        b.eat();
        Bird b1 = (Bird) b ;
        b1.eat();
        b1.fly();
    }
}

四

题目

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

显示结果如下：

姓名：李四，年龄：18，学号：1024

食堂吃饭

我爱学习

姓名：张三，年龄：20，工号：1025

自己做饭

在家躺着睡觉

我爱工作

代码

Person.java

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 abstract void  eat();
    public abstract void sleep();

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "姓名："+this.name+", 年龄:"+this.age;
    }
}

Student.java

public class Student extends Person{
    private int stuNum;
    public Student(String name,int age,int stuNum){
        super(name,age);
        this.stuNum=stuNum;
    }

    public Student() {
    }

    public Student(int stuNum) {
        this.stuNum = stuNum;
    }

    public void study() {
        System.out.println("我爱学习");

    }
    @Override
    public void eat() {
        System.out.println("食堂吃饭");

    }

    @Override
    public void sleep() {

    }


    /**
     * 获取
     * @return stuNum
     */
    public int getStuNum() {
        return stuNum;
    }

    /**
     * 设置
     * @param stuNum
     */
    public void setStuNum(int stuNum) {
        this.stuNum = stuNum;
    }
@Override
    public String toString() {
        return super.toString()+", 学号："+this.stuNum;
    }
}

Worker.java

public class Worker extends Person {
   private String wNum;

    public Worker() {
    }

    public Worker(String wNum) {
        this.wNum = wNum;
    }

    public  void work(){
       System.out.println("我爱工作");
   }
   public Worker(String name,int age,String stuNum){
       super(name, age);
       this.wNum=stuNum;
   }
    @Override
    public void eat() {
        System.out.println("自己做饭");
    }

    @Override
    public void sleep() {
        System.out.println("在家躺着睡觉");

    }

    /**
     * 获取
     * @return wNum
     */
    public String getWNum() {
        return wNum;
    }

    /**
     * 设置
     * @param wNum
     */
    public void setWNum(String wNum) {
        this.wNum = wNum;
    }
@Override
    public String toString() {
        return super.toString()+", 工号："+this.wNum;
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        Student stu = new Student("小A",20,184001);
        Worker worker = new Worker("老林",35,"101010");
        System.out.println(stu);
        stu.eat();
        stu.study();
        System.out.println(worker);
        worker.eat();
        worker.sleep();
        worker.work();
    }
}

一

题目

利用继承，来描述，人，老师，学生之间的关系

1）老师含有属性：name，age，subject，含有方法：eat，teach，toString

2）学生含有属性：name，age，clsName，含有方法：eat，study，toString

3）利用继承的思想，从老师和学生中抽象出人，并创建Test进行调用并输出

判分标准

1）创建类Person，含有属性：name姓名，age年龄。含有方法void eat(String something)；方法中打印输出“我爱吃XXX”。含有构造方法，带两个参数，分别是name和age，并利用this关键字传值到成员变量中。

2）创建类Student，含有属性：clsName班级，含有方法，void study(String subject)；方法打印输出：我热爱学习subject。创建包含三个参数的构造方法，分别是name，age，clsName，利用super实现父类构造方法传值。重写toString方法，打印输出：我的名字是XX，我的年龄是XX，我的班级是XX

3）创建类Teacher，含有属性：subject，含有方法，void teach()；方法打印输出：我教授的是subject。创建包含三个参数的构造方法，分别是name，age，subject，利用super实现父类构造方法传值。重写toString方法，打印输出：我的名字是XX，我的年龄是XX

4）创建Test测试类，创建Student对象，并调用带3个参数的构造方法，自己赋值，然后依次调用study方法，eat方法，toString方法

5）创建Teacher对象，并调用带3个参数的构造方法，自己赋值，然后依次调用teach方法，eat方法，toString方法

代码

Person.java

/*
创建类Person，含有属性：name姓名，age年龄。含有方法void eat(String something)；方法中打印输出“我爱吃XXX”。
含有构造方法，带两个参数，分别是name和age，并利用this关键字传值到成员变量中 。
 */
public abstract class Person {
    public String name;
    public int age;
    void eat(String something){
        System.out.println("我爱吃xxx");
    }
    public Person() {
    }

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







    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }
}

Student.java

public class Student extends Person {

    private String clsName;
    void study(String subject){
        System.out.println("我热爱学习subject");
    }

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

    public Student() {
    }

    public Student(String clsName) {
        this.clsName = clsName;
    }

    /**
     * 获取
     * @return clsName
     */
    public String getClsName() {
        return clsName;
    }

    /**
     * 设置
     * @param clsName
     */
    public void setClsName(String clsName) {
        this.clsName = clsName;
    }

    @Override
    public String toString() {
        return "Person{我的名字是 = " + name + ", 我的名字是 = " + age + ", 我的班级是 ="+clsName+"}";
    }
    //3）创建类Teacher，含有属性：subject，含有方法，void teach()；方法打印输出：我教授的是subject。
    // 创建包含三个参数的构造方法，分别是name，age，subject，利用super实现父类构造方法传值。
    // 重写toString方法，打印输出：我的名字是XX，我的年龄是XX

}

Teacher.java

class Teacher extends Person{
    public String subject;

    public Teacher() {
    }

    public Teacher(String subject) {
        this.subject = subject;
    }

    void teach(){
        System.out.println("我教授的是subject");
    }
    public Teacher(String name, int age,String subject) {
        super(name, age);
        this.subject = subject;
    }


    /**
     * 获取
     * @return subject
     */
    public String getSubject() {
        return subject;
    }

    /**
     * 设置
     * @param subject
     */
    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String toString() {
        return "Teacher{我的名字是 = " + name + "我的年龄是"+age+ "}";
    }
}

Test.java

//创建Test测试类，创建Student对象，并调用带3个参数的构造方法，自己赋值，然后依次调用study方法，eat方法，toString方法
public abstract class Test {
    public static void main(String[] args) {
        Student student = new Student("moli",18,"3");
        student.study("subject");
        student.eat("蟹堡");
        student.toString();
        //创建Teacher对象，并调用带3个参数的构造方法，自己赋值，然后依次调用teach方法，eat方法，toString方法
        Teacher teacher = new Teacher("java");
        teacher.teach();
        teacher.eat("蟹堡");
        teacher.toString();
    }


}

二

题目

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

效果如：

我是猫，我玩老鼠

我是狗，我玩球

评分标准

1）创建Animal抽象类，并定义抽象方法play.

2）创建Dog类继承Animal类，重写play方法。

3）创建Cat类继承Animal类，重写play方法。

4）编写测试类，通过多态创建猫对象，狗对象

代码

Animal.java

public abstract class Animal {
    abstract void play();

}

Cat.java

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

Dog.java

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

TestDemo.java

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

三

题目

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

评分标准：

1）正确写出抽象类Car ，封装属性，写出抽象方法

2）封装属性，写出set、get、抽象方法

3）正确继承Car类写出SportsCar类和并实现run（）方法。

4）创建car1、car2对象并调用方法

5）成功正确输出

显示结果如下：

法拉利

超级跑车

售价100w

兰博基尼

超级跑车

售价100w

代码

car.java

ublic abstract class Car {
    private String brand;

    public Car() {

    }

    abstract void run();

    public String getBrand() {
        return brand;
    }

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

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

}

SportsCar.java

public class SportsCar extends Car {
    void price(){
        System.out.println("售价100w");
    }
    public SportsCar(String brand) {
        super(brand);
    }

    public SportsCar() {
        super();
    }

    @Override
    void run() {
        System.out.println("超级跑车");
    }

}

Test1.java

public class Test1 {
    public static void main(String[] args) {
        SportsCar car1 = new SportsCar("法拉利");
        System.out.println(car1.getBrand());
        car1.run();
        car1.price();
        SportsCar car2 = new SportsCar();
        car2.setBrand("兰博基尼");
        System.out.println(car2.getBrand());
        car1.run();
        car1.price();
    }
}

四

题目

（1）定义一个Flower花作为父类

属性：颜色价格

属性要进行封装（即为每条私有属性写set，get方法）

定义无参构造方法，和传两个参数的有参构造方法一个。

方法：显示详细信息的方法showInfo

（2）定义一个Rose玫瑰花类继承Flower类

玫瑰花自己的属性：产地（要求对产地属性进行封装私有化属性）

重写父类中的显示详细信息的方法showInfo，在重写的showInfo方法中通过super调用父类的showInfo方法；并显示产地信息。

再定义一个方法warn警告显示：不要摘玫瑰花，小心扎手！

（3）定义测试类Test完成：

①实例化Flower类，调用构造方法赋值，并调用方法，输出：

花的颜色是白色，价格是10元

②实例化玫瑰花类，调用方法，输出：

花的颜色是紫色，价格是30元

产地是大理

不要摘玫瑰花，小心扎手！

代码

Flower.java

public class Flower {
    private String color;
    private int price;

    public void showInfo() {

    }

    public Flower() {
    }

    public Flower(String color, int price) {
        this.color = color;
        this.price = price;
    }

    /**
     * 获取
     * @return color
     */
    public String getColor() {
        return color;
    }

    /**
     * 设置
     * @param color
     */
    public void setColor(String color) {
        this.color = color;
    }

    /**
     * 获取
     * @return price
     */
    public int getPrice() {
        return price;
    }

    /**
     * 设置
     * @param price
     */
    public void setPrice(int price) {
        this.price = price;
    }

    public String toString() {
        return "Flower{color = " + color + ", price = " + price + "}";
    }
}

Rose.java

public  class Rose extends  Flower {
    public String where;
    public Rose(String color,int price) {
        super(color,price);
    }
    public void warn() {
        System.out.println("不要摘玫瑰花，小心扎手！");

    }

    @Override
    public void showInfo() {

        System.out.println(where);
    }

    public Rose() {
    }

    public Rose(String where) {
        this.where = where;
    }

    /**
     * 获取
     * @return where
     */
    public String getWhere() {
        return where;
    }

    /**
     * 设置
     * @param where
     */
    public void setWhere(String where) {
        this.where = where;
    }

    public String toString() {
        return "Rose{where = " + where + "}";
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        Flower flower = new Flower("白色",10) ;
        System.out.println("花的颜色是"+flower.getColor()+" 花的价格是"+flower.getPrice());
        Rose rose = new Rose("紫色",30);
        rose.setWhere("大理");
        System.out.println("玫瑰花的颜色是"+rose.getColor()+" 玫瑰花的价格是"+rose.getPrice());
        rose.warn();


    }

}