编程练习--Fruits

请使用面向对象的思想,实现杨梅和仙人蕉的信息描述。

程序参考运行效果图如下:

任务

思路分析:

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和它的重载方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package me.feihong.fruits;

public class Fruits {
// 私有属性:水果的形状(shape)和口感(taste)
private String shape;
private String taste;

public Fruits() {

}

// 带参构造函数(参数为shape和taste)
public Fruits(String shape,String taste) {
this.shape=shape;
this.taste=taste;
}

//通过封装实现对私有属性的get/set访问
public String getShape() {
return shape;
}

public void setShape(String shape) {
this.shape = shape;
}

public String getTaste() {
return taste;
}

public void setTaste(String taste) {
this.taste = taste;
}

// 创建无参无返回值得方法eat(描述内容为:水果可供人们食用!)
public String eat() {
return "水果可供人们食用!";
}

// 重写equals方法,比较两个对象是否相等(比较shape,taste)
public boolean equals(Object obj) {
if(obj==null)
return false;
Fruits temp=(Fruits)obj;
if(this.getShape().equals(temp.getShape())&&this.getTaste().equals(temp.getTaste()))
return true;
else
return false;
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package me.feihong.fruits;

//要求Waxberry类不允许有子类
public final class Waxberry extends Fruits {
// 私有属性:颜色(color)
private String color;

//创建构造方法,完成调用父类的构造方法,完成属性赋值
public Waxberry() {
super("圆形","果味酸甜适中");
}

// public Waxberry(Str)


public String getColor() {
return color;
}

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

//创建不允许重写的face方法,描述为:杨梅:**、**,果味酸甜适中

public final String face() {
return "杨梅:"+getShape()+"、"+getColor()+",果味酸甜适中。";
}

//重写父类eat方法,描述为:杨梅酸甜适中,非常好吃!
public String eat() {
return "杨梅酸甜适中,非常好吃!";
}

//重写toString方法,输出的表现形式不同(输出shape,color,taste)
public String toString() {
return "杨梅的信息:果实为"+getShape()+","+getColor()+","+getTaste()+",非常好吃!";
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package me.feihong.fruits;

public class Banana extends Fruits{
// 私有属性:品种(variety)
private String variety;

public String getVariety() {
return variety;
}

public void setVariety(String variety) {
this.variety = variety;
}

// public Banana(String variety,String shape) {
// this.variety = variety;
// shape=???;
// }
// 这里没有做出来

//无参构造方法
public Banana() {

}
//创建带参构造方法为所有属性赋值
public Banana(String variety) {
this.variety=variety;
}

//创建无参无返回值的advantage方法,描述为:**果形**,果肉香甜,可供生食。
public void advantage() {
System.out.println(getVariety()+"果形"+getShape()+",果肉香甜,可供生食。");
}

//创建重载advantage方法(带参数color),描述为:**颜色为**
public void advantage(String color) {
System.out.println(getVariety()+"颜色为"+color);
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


package me.feihong.fruits;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
// 实例化2个父类对象,传入两组相同的参数值
Fruits f1=new Fruits("圆形","果肉香甜");
Fruits f2=new Fruits("圆形","果肉香甜");

// 调用父类eat方法
System.out.println(f1.eat());

// 测试重写equals方法,判断两个对象是否相等
boolean flag=f1.equals(f2) ;
System.out.println("fru1和fru2的引用比较:"+flag);

System.out.println("————————————————————————————————————————");
// 实例化子类对象,并传入相关参数值
Waxberry wax=new Waxberry();
wax.setColor("紫红色");

// 调用子类face方法和eat方法
System.out.println(wax.face());
System.out.println(wax.eat());

// 测试重写toString方法,输出子类对象的信息
System.out.println(wax.toString());

System.out.println("——————————————————————————————————————————————");
// 实例化Banana类对象,并传入相关参数值
Banana ban=new Banana("仙人蕉");
ban.setShape("短而稍圆");

// 调用子类的advantage和它的重载方法
ban.advantage();
ban.advantage("黄色");

}

}
-------------本文结束感谢您的阅读-------------