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

转载于:https://www.cnblogs.com/494625951-wangyikai/p/6725692.html