2017《Java》实验4 计算机1501 王奕开
（一）学习总结
1.思维导图：
2.阅读下面程序，分析是否能编译通过？如果不能，说明原因。应该如何修改？程序的运行结果是什么？为什么子类的构造方法在运行之前，必须调用父 类的构造方法？能不能反过来？
class Grandparent {
public Grandparent() {
System.out.println("GrandParent Created.");
}
public Grandparent(String string) {
System.out.println("GrandParent Created.String:" + string);
}
}
class Parent extends Grandparent {
public Parent() {
System.out.println("Parent Created");
super("Hello.Grandparent.");
}
}
class Child extends Parent {
public Child() {
System.out.println("Child Created");
}
}
public class Test1{
public static void main(String args[]) {
Child c = new Child();
}
}
不能运行，对父类含参数的构造方法，子类可以通过在定义自己的构造方法中使用super关键字来调用它，但这个调用语句必须是子类构造方法的第一个可执行语句。
将super（）语句放在第一个， 必须放在第一个不然无法执行。
3 . 阅读下面程序，分析程序中存在哪些错误，说明原因，应如何改正？正确程序的运行结果是什么？
class Animal{
void shout(){
System.out.println("动物叫!");
}
}
class Dog extends Animal{
public void shout(){
System.out.println("汪汪......!");
}
public void sleep() {
System.out.println("狗狗睡觉......");
}
}
public class Test{
public static void main(String args[]) {
Animal animal = new Dog();
animal.shout();
animal.sleep();
Dog dog = animal;
dog.sleep();
Animal animal2 = new Animal();
dog = (Dog)animal2;
dog.shout();
}
}
用向上转型创建一个Dog类的animal，首先animal必须强制转化成Dog类的，将animal转化成Dog类的，第二个再向下转型的时候，要先发生向上转型的关系
修改后的代码如下：
public class Test1{
public static void main(String args[]) {
Animal animal = new Dog();
animal.shout();
((Dog) animal).sleep();
Dog dog = (Dog) animal;
dog.sleep();
Animal animal2 = new Dog();
dog = (Dog)animal2;
dog.shout();
}
}
结果为：
汪汪......!
狗狗睡觉......
汪汪......!
狗狗睡觉......
4.运行下列程序
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
}
public class Test{
public static void main(String args[]){
Person per = new Person("张三",20) ;
System.out.println(per);
System.out.println(per.toString()) ;
}
}
（一）不能直接输出一个per的对象，应该在person类中加一个toString（）的方法
（二）源码：
public void println (Obiect x){
String s = String valueOf(x);
synchronized(this){
print(s);
newLine();
}
}
（三）修改代码：
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String toString(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
}
public class test21{
public static void main(String args[]){
Person per = new Person("张三",20) ;
System.out.println(per.toString()) ;
}
}
（二）代码分析
2.按照下面要求完成类的设计
（1）设计一个平面图形抽象类(提供求该类对象周长和面积的方法）和一个立体图形抽象类（提供求该类对象表面积和体积的方法）
（2）设计球类、圆柱类，圆锥类、矩形类、三角形类、圆类，分别继承平面图形抽象类和立体图形抽象类。
（3）建立测试类，进行测试。画出类图。
设计思路：
首先建立两个抽象类，平面和立体的抽象类
在创建球类、圆柱类，圆锥类、矩形类、三角形类、圆类，在里面创建函数
abstract class tuxing{
private double chang;
private double kuan;
private double R;
private double H;
public double getChang() {
return chang;
}
public void setChang(double chang) {
this.chang = chang;
}
public double getKuan() {
return kuan;
}
public void setKuan(double kuan) {
this.kuan = kuan;
}
public double getR() {
return R;
}
public void setR(double r) {
R = r;
}
public double getH() {
return H;
}
public void setH(double h) {
H = h;
}
public abstract double zhouchang(double chang,double kuan);
public abstract double mianji(double x,double y);
}
abstract class liti{
public abstract double tiji(double R);
public abstract double biaomianji(double R);
}
class qiu extends liti{
private double R;
private double V;
private double S;
public qiu(double R){
this.R=R;
}
public qiu() {
// TODO Auto-generated constructor stub
}
public double tiji(double R) {
V=4/3.0*3.14*R*R*R;
return V;
}
public double biaomianji(double R) {
S=4.0*3.14*R*R;
return S;
}
}
class yuanzhu extends liti{
private double R;
private double V;
private double S;
private double H;
public yuanzhu(double R){
this.R=R;
}
public yuanzhu() {
}
public double biaomianji(double R) {
S=3.14*R*R;
return S;
}
public double tiji(double R,double H) {
V=3.14*R*R*H;
return V;
}
public double tiji(double R) {
return 0;
}
}
class yuanzhui extends liti{
private double R;
private double V;
private double S;
private double H;
public yuanzhui(double R){
this.R=R;
}
public yuanzhui() {
// TODO Auto-generated constructor stub
}
public double biaomianji(double R) {
S=3.14*R*R;
return S;
}
public double tiji(double R,double H) {
V=3.14*R*R*H;
return V;
}
public double tiji(double R) {
// TODO Auto-generated method stub
return 0;
}
}
class juxing extends tuxing{
public juxing(double chang, double kuan) {
this.chang=chang;
this.kuan=kuan;
}
public juxing() {
}
private double chang;
private double kuan;
private double C;
private double S;
public double zhouchang(double chang,double kuan) {
C=(chang+kuan)*2.0;
return C;
}
public double mianji(double chang,double kuan) {
S=chang*kuan;
return S;
}
public double getC() {
return C;
}
public void setC(double c) {
C = c;
}
public double getS() {
return S;
}
public void setS(double s) {
S = s;
}
}
class sanjiaoxing extends tuxing{
private double bian;
private double h;
private double C;
private double S;
public sanjiaoxing(double bian, double h) {
this.bian=bian;
this.h=h;
}
public sanjiaoxing() {
// TODO Auto-generated constructor stub
}
public double zhouchang(double bian,double h) {
C=3.0*bian;
return C;
}
public double mianji(double bian,double h) {
S=bian*h/2.0;
return S;
}
public double getBian() {
return bian;
}
public void setBian(double bian) {
this.bian = bian;
}
public double getH() {
return h;
}
public void setH(double h) {
this.h = h;
}
public double getC() {
return C;
}
public void setC(double c) {
C = c;
}
public double getS() {
return S;
}
public void setS(double s) {
S = s;
}
}
class yuan extends tuxing{
private double R;
private double C;
private double S;
public yuan(double R){
this.R=R;
}
public yuan() {
// TODO Auto-generated constructor stub
}
public double zhouchang(double R) {
C=2*3.14*R;
return C;
}
public double mianji(double R) {
S=R*R*3.14;
return S;
}
public double getR() {
return R;
}
public void setR(double r) {
R = r;
}
public double getC() {
return C;
}
public void setC(double c) {
C = c;
}
public double getS() {
return S;
}
public void setS(double s) {
S = s;
}
public double zhouchang(double chang, double kuan) {
// TODO Auto-generated method stub
return 0;
}
public double mianji(double x, double y) {
// TODO Auto-generated method stub
return 0;
}
}
public class test{
public static void main(String []args){
tuxing JX=new juxing();
tuxing SJX=new sanjiaoxing();
juxing j=(juxing) JX;
sanjiaoxing s=(sanjiaoxing) SJX;
tuxing YUAN=new yuan();
yuan y=(yuan) YUAN;
liti QIU=new qiu();
qiu q=(qiu) QIU;
liti YUANZHU=new yuanzhu();
yuanzhu yz=(yuanzhu)YUANZHU;
liti YUANZHUI=new yuanzhui();
yuanzhui yzhui=(yuanzhui)YUANZHUI;
System.out.println("平面图形：");
System.out.println("矩形周长为:"+j.zhouchang(13.0, 5.0)+"矩形面积为:"+j.mianji(13.0,5.0));
System.out.println("三角形周长为:"+s.zhouchang(5.0, 6.0)+"三角形面积为:"+s.mianji(5.0,6.0));
System.out.println("园周长为:"+y.zhouchang(1.0)+"园面积为:"+y.mianji(1.0));
System.out.println("**********************************************************************");
System.out.println("立体图形：");
System.out.println("球的体积为:"+q.tiji(1.0)+"球的表面积"+q.biaomianji(2.0));
System.out.println("圆柱的体积为："+yz.tiji(2.0,2.0)+"圆柱表面积为："+yz.biaomianji(2.0));
System.out.println("圆锥的体积为："+yzhui.tiji(2.0,2.0)+"圆柱表面积为："+yzhui.biaomianji(2.0));
}
}
3.. 参考类图，重构下面的实例，分析和理解多态的含义和用途
（1）某动物园有一饲养员小李，每天需要给他所负责饲养的一只狮子、五只猴子和十只鸽子喂食。 请用一个程序来模拟他喂食的过程。
设计思路：建4个类，Lion，Monkey，Pigeon三个类中有eat()函数，在feeder类中使用函数进行调用
class Lion{
private String lion;
public Lion(String lion){
this.lion=lion;
}
public void eat(String lion){
System.out.println("狮子吃："+lion);
}
}
class Monkey{
private String monkey;
public Monkey(String monkey){
this.monkey=monkey;
}
public void eat(String monkey){
System.out.println("猴子吃："+monkey);
}
}
class Pigeon{
private String pigeon;
public Pigeon(String pigeon){
this.pigeon=pigeon;
}
public void eat(String pigeon){
System.out.println("鸽子吃："+pigeon);
}
}
class Feeder{
private String name;
private Lion lion;
private Monkey monkey;
private Pigeon pigeon;
private String lionfood;
private String monkeyfood;
private String pigeonfood;
public Feeder(String name,String lionfood,String monkeyfood,String pigeonfood){
this.name=name;
this.lionfood=lionfood;
this.monkeyfood=monkeyfood;
this.monkeyfood=monkeyfood;
}
public void feedLion(Lion lion){
lion.eat(lionfood);
}
public void feedMonkey(Monkey monkey){
monkey.eat(monkeyfood);
}
public void feedPigeon(Pigeon pigeon){
pigeon.eat(pigeonfood);
}
}
public class siyanger{
public static void main(String []args){
Lion lion=new Lion("肉");
Monkey monkey=new Monkey("香蕉");
Pigeon pigeon=new Pigeon("饲料");
Feeder feeder=new Feeder("小李","肉","香蕉","饲料");
feeder.feedLion(lion);
feeder.feedMonkey(monkey);
feeder.feedPigeon(pigeon);
}
}
分析：这种方法都用到了eat（）函数，重复用，比较麻烦。
（2）第一次重构，引入继承，利用抽象类和对象多态重构程序，Animal类采用抽象类， 合并Feeder类中的方法
设计思路：创建抽象类，利用多态性，进行创建eat()函数
abstract class animal{
private String food;
public animal(String food){
this.food=food;
}
public abstract void print(String food);
}
class Lion extends animal{
public Lion(String food) {
super(food);
}
public void print(String food) {
System.out.println("狮子吃:"+food);
}
}
class Monkey extends animal{
public Monkey(String food) {
super(food);
}
public void print(String food) {
System.out.println("猴子吃:"+food);
}
}class Pigeon extends animal{
public Pigeon(String food) {
super(food);
}
public void print(String food) {
System.out.println("鸽子吃:"+food);
}
}
class Feeder{
private String name;
private Lion lion;
private Monkey monkey;
private Pigeon pigeon;
public Feeder(String name){
this.name=name;
}
public void feederLion(Lion lion){
lion.print("肉");
}
public void feederMonkey(Monkey monkey){
monkey.print("香蕉");
}
public void feederPigeon(Pigeon pigeon){
pigeon.print("饲料");
}
}
public class siyang{
public static void main(String []args){
Feeder feeder=new Feeder("小李");
Lion lion=new Lion("肉");
Monkey monkey=new Monkey("香蕉");
Pigeon pigeon=new Pigeon("饲料");
feeder.feederLion(lion);
feeder.feederMonkey(monkey);
feeder.feederPigeon(pigeon);
}
}
（3）第二次重构，修改feedAnimals方法，让它接收一个Animal数组
import java.util.Scanner;
class feeder{
private String name;
private Animal []animal;
public feeder(String name){
this.name=name;
}
public void feedAnimal(Animal[] animal){
for(int i=0;i<animal.length;i++){
animal[i].animaleat();
}
}
public String toString(){
return "饲养员名字:"+this.name;
}
}
abstract class Animal{
public abstract void animaleat();
}
class Lion extends Animal{
public void animaleat(){
System.out.println("狮子吃肉");
}
}
class Monkey extends Animal{
public void animaleat(){
System.out.println("猴子吃香蕉");
}
}
class Pigeon extends Animal{
public void animaleat(){
System.out.println("鸽子吃饲料");
}
}
public class test1 {
public static void main(String[] args) {
feeder feerder=new feeder("李明");
Animal animal[];
animal=new Animal[]{new Lion(),new Monkey(),new Pigeon()};
System.out.println(feerder.toString());
for(int i=0;i<1;i++){
feerder.feedAnimal(animal);
}
}
}
好处：用多态可以对父类的方法进行重写和覆盖，非常方便。
（三）代码托管
码云地址：
https://git.oschina.net/wangyikai1996/shiyansi.git
