1
编程练习：
1. 定义一个父类Animal类
属性：kind(种类)
方法：创建带参（kind为参数）构造方法
创建cry():void方法
2. 编写三个具体的子类Cat类、Dog类、Sheep类
分别重写父类中的 cry() 方法，输出信息分别为
Cat类：小猫的叫声：喵喵喵~~~
Dog类：小狗的叫声：汪汪汪~~~
Sheep类：小羊的叫声：咩咩咩~~~
3. 编写测试类，首先生成长度为3的父类对象数组，然后依次向数组中存入数据，现设定存储规则为：
b) 生成一个 Cat 类的对象，存入数组中第一个位置
c) 生成一个 Dog 类的对象，存入数组中第二个位置
d) 生成一个 Sheep 类的对象，存入数组中第三个位置
最后循环输出数组成员，并分别调用 cry() 方法。运行效果：
小猫的叫声：喵喵喵~~~
小狗的叫声：汪汪汪~~~
小羊的叫声：咩咩咩~~~
我的答案：得分： 33.3分
class Animal{
public String kind;
public Animal(){}
public Animal(String kind){
this.kind=kind;
}
public void cry(){
}
public static void main(String[] args) {
Animal[] a=new Animal[3];
a[0]=new cat();
a[1]=new Dog();
a[2]=new Sheep();
for (int i = 0; i < a.length; i++) {
a[i].cry();
}
}
}
class cat extends Animal{
public void cry(){
System.out.println("小猫的叫声：喵喵喵~~~");
}
}
class Dog extends Animal{
public void cry(){
System.out.println("小狗的叫声：汪汪汪~~~");
}
}
class Sheep extends Animal{
public void cry(){
System.out.println("小羊的叫声：咩咩咩~~~");
}
}2
编程练习：
1、创建一个抽象类Vehicle，拥有一个抽象方法getWheels()，返回值类型为String。
2、创建两个类Car和Motobike继承自Vehicle类，并实现getWheels()方法。
3、创建测试类Test，在主方法中创建Car和Motobike类的实例对象，调用getWheels()，并将信息显示在控制台。运行效果如下：
汽车有四个车轮
摩托车有两个车轮
我的答案：得分： 33.3分
abstract class Vehicle{
abstract public String getWheels();
public static void main(String[] args) {
Car c1=new Car() {
@Override
public String getWheels() {
return super.getWheels();
}
};
System.out.println(c1.getWheels());
Motobike m1=new Motobike() {
@Override
public String getWheels() {
return super.getWheels();
}
};
System.out.println(m1.getWheels());
}
}
abstract class Car extends Vehicle{
public String getWheels(){
return "汽车有四个车轮";
}
}
abstract class Motobike extends Vehicle{
public String getWheels(){
return "摩托车有两个车轮";
}
}3
编程练习：
1、根据杨梅和香蕉的共性，抽取父类水果（Fruits）
私有属性：水果的形状（shape）和口感（taste）
方法：
1) 带参构造函数（参数为shape和taste）
2) 创建无参无返回值得方法eat（描述内容为：水果可供人们食用！）
3) 重写equals方法，比较两个对象是否相等（比较shape，taste）
2、子类Waxberry
私有属性：颜色（color）
方法：
1) 调用父类的构造方法，完成属性赋值
2) 创建不允许重写的face方法，描述为：杨梅：**、**，果味酸甜适中。
3) 重写父类eat方法，描述为：杨梅酸甜适中，非常好吃！
4) 重写toString方法，输出的表现形式不同（输出shape,color,taste）
5) 要求Waxberry类不允许有子类
3、子类：Banana
私有属性：品种（variety）
方法：
1) 带参构造方法为所有属性赋值
2) 创建无参无返回值的advantage方法，描述为：**果形**,果肉香甜，可供生食。
3) 重载要求(2)中的advantage方法（带参数color），描述为：**颜色为**
4、测试，运行效果参照效果图：
1) 实例化2个父类对象，并传入两组相同的参数值
2) 调用父类eat方法
3) 测试重写equals方法，判断两个对象是否相等
4) 实例化子类Wacberry对象，并传入相关参数值
5) 调用子类face方法和重写父类eat方法后的eat方法
6) 测试重写toString方法，输出子类对象的信息
7) 实例化Banana类对象，并传入相关参数值
8) 调用子类的advantage和它的重载方法
我的答案：得分： 33.4分
public class Test {
public static void main(String[] args) {
// 实例化2个父类对象，传入两组相同的参数值
Fruits fru1=new Fruits("杨梅","果味酸甜适中");
Fruits fru2=new Fruits("杨梅","果味酸甜适中");
// 调用父类eat方法
fru1.eat();
// 测试重写equals方法，判断两个对象是否相等
System.out.println("fru1和fru2的引用比较："+fru1.equals(fru2));
System.out.println("—————————————————————————");
// 实例化子类对象，并传入相关参数值
Waxberry waxberry=new Waxberry("圆形","酸甜适中","紫红色");
// 调用子类face方法和eat方法
waxberry.face();
waxberry.eat();
// 测试重写toString方法，输出子类对象的信息
System.out.println(waxberry);
System.out.println("—————————————————————————");
// 实例化Banana类对象，并传入相关参数值
Banana banana=new Banana("短而稍圆","果肉香甜","仙人蕉");
// 调用子类的advantage和它的重载方法
banana.advantage();
banana.advantage("黄色");
}
}
class Fruits {
// 私有属性：水果的形状（shape）和口感（taste）
private String shape;
private String taste;
public Fruits() {
}
// 带参构造函数（参数为shape和taste）
public Fruits(String shape,String taste) {
this.setShape(shape);
this.setTaste(taste);
}
//通过封装实现对私有属性的get/set访问
public void setShape(String shape){
this.shape=shape;
}
public String getShape(){
return this.shape;
}
public void setTaste(String taste){
this.taste=taste;
}
public String getTaste(){
return this.taste;
}
// 创建无参无返回值得方法eat（描述内容为：水果可供人们食用！）
public void eat(){
System.out.println("水果可供人们食用！");
}
// 重写equals方法，比较两个对象是否相等（比较shape，tast）
public boolean equals(Object obj){
if(obj==null)
return false;
Fruits f=(Fruits)obj;
if(this.getShape().equals(f.getShape())&& this.getTaste().equals(f.getTaste()))
return true;
else return false;
}
}
final class Waxberry extends Fruits{
// 私有属性：颜色（color）
private String color;
public void setColor(String color){
this.color=color;
}
public String getColor(){
return this.color;
}
//创建构造方法，完成调用父类的构造方法，完成属性赋值
public Waxberry(String shape,String taste,String color){
super(shape,taste);
this.setColor(color);
}
//创建不允许重写的face方法，描述为：杨梅：**、**，果味酸甜适中
public final void face(){
System.out.println("杨梅："+this.getColor()+"、"+this.getShape()+"，果味酸甜适中。");
}
//重写父类eat方法，描述为：杨梅酸甜适中，非常好吃！
public void eat(){
System.out.println("杨梅酸甜适中，非常好吃！");
}
//重写toString方法，输出的表现形式不同（输出shape,color,taste）
public String toString(){
return "杨梅的信息：果实为"+this.getShape()+"、"+this.getColor()+"、"+this.getTaste()+",非常好吃！";
}
}
class Banana extends Fruits{
// 私有属性：品种（variety）
private String variety;
public void setVariety(String variety){
this.variety=variety;
}
public String getVariety(){
return this.variety;
}
//创建带参构造方法为所有属性赋值
public Banana(String shape,String taste,String variety){
super(shape,taste);
this.setVariety(variety);
}
//创建无参无返回值的advantage方法，描述为：**果形**,果肉香甜，可供生食。
public void advantage(){
System.out.println(this.getVariety()+"果形"+this.getShape()+"，果肉香甜，可供生食。");
}
//创建重载advantage方法（带参数color），描述为：**颜色为**
public void advantage(String color){
System.out.println(this.getVariety()+"颜色为"+color+"。");
}
}
4875
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
