java练习（四）
一
题目
利用继承，来描述，人，老师，学生之间的关系
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();
}
}