《Java程序设计》试验七-继承和多态

前言

记录一下做过的题目，虽然作为入门题目很简单，不过还是可以学到东西的hh。

程序设计一 继承：

题目：

编写程序设计模拟中国人、美国人及北京人，除主类外，有4个类，People、ChinaPeople、AmericanPeople和BeijingPeople。要去如下：

（1）People类有权限是protected的double型成员变量height和weight，以及public void speakHello()、public void averageHeight()、public void averageWeight()方法。

（2）ChinaPeople类是People的子类，新增了public void chinaGongfu()（输出“坐如钟、站如松、睡如弓”）方法。根据people类，重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法。

（3）AmericanPeople类是People的子类，新增了public void americanBoxing()（输出“直拳、勾拳、组合拳”）方法。根据people类，重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法。

（4）BeijingPeople类是ChinaPeople的子类，新增了public void BeijingOpera()（输出“花脸、青衣”）方法。根据ChinaPeople类，重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法。

（5）主类中：分别创建ChinaPeople、AmericanPeople、BeijingPeople对象，通过对象分别调用继承的方法：speakHello()、averageHeight()、averageWeight()方法，及子类中自己的方法。

People类

package 实验7people类;

public class People{
    protected double height,weight;
    People(){}
    People(double height,double weight){
        this.height=height;
        this.weight=weight;
    }
    public void speakHello(){
    }
    public void averageHeight(){
        System.out.printf("人类平均身高：%.2f\n",height);
    }
    public void averageWeight(){
        System.out.printf("人类平均体重：%.2f\n",weight);
    }
}

ChinaPeople类

package 实验7people类;

public class ChinaPeople extends People{
    ChinaPeople(){}
    ChinaPeople(double height,double weight){
        super(height, weight);
    }
    public void chinaGongfu(){
        System.out.println("坐如钟、站如松、睡如弓");
    }
    public void speakHello(){
        System.out.println("你好！");
    }
    public void averageHeight(){
        System.out.printf("中国人平均身高：%.2f\n",height);
    }
    public void averageWeight(){
        System.out.printf("中国人平均体重：%.2f\n",weight);
    }
}

AmericanPeople类

package 实验7people类;

public class AmericanPeople extends People{
    AmericanPeople(){}
    AmericanPeople(double height,double weight){
        super(height, weight);
    }
    public void americanBoxing(){
        System.out.println("直拳、勾拳、组合拳");
    }
    public void speakHello(){
        System.out.println("Hello!");
    }
    public void averageHeight(){
        System.out.printf("美国人平均身高：%.2f\n",height);
    }
    public void averageWeight(){
        System.out.printf("美国人平均体重：%.2f\n",weight);
    }
}

BeijingPeople类

package 实验7people类;

public class BeijingPeople extends People{
    BeijingPeople(){}
    BeijingPeople(double height,double weight){
        super(height, weight);
    }
    public void BeijingOpera(){
        System.out.println("花脸、青衣");
    }
    public void speakHello(){
        System.out.println("您吃了吗？");
    }
    public void averageHeight(){
        System.out.printf("北京人平均身高：%.2f\n",height);
    }
    public void averageWeight(){
        System.out.printf("北京人平均体重：%.2f\n",weight);
    }
}

主函数

package 实验7people类;

public class Main{
    public static void main(String[] args){
        ChinaPeople cp=new ChinaPeople(10.0,5.0);
        AmericanPeople ap=new AmericanPeople(11.0,6.0);
        BeijingPeople bp=new BeijingPeople(12.0,5.5);
        cp.chinaGongfu();
        cp.speakHello();
        cp.averageHeight();
        cp.averageWeight();
        ap.americanBoxing();;
        ap.speakHello();
        ap.averageHeight();
        ap.averageWeight();
        bp.BeijingOpera();;
        bp.speakHello();
        bp.averageHeight();
        bp.averageWeight();
    }
}

小tips:

• 如果想要A类继承B类，只需要在A类的名字后加 extends B 。
• java 中子类只能继承一个父类。
• 如果子类重写了父类的方法，那么子类对象在调用该方法时，将默认调用子类方法。如果想调用父类被重写的方法，需要用 super 关键字。
• 加载子类前会先加载父类，所以父类的构造方法会在子类的构造方法之前执行。当子类实例化的时候父类不会实例化，但是会执行父类的构造方法。
• 子类会继承父类的方法和属性，也可以重写父类的方法。如果要重写，要求：子类的返回值、方法名、参数必须均与父类相同。如果满足要求，在子类中所写的方法会自动覆盖父类的方法。
• 当我们创建了People父类以及它的众多子类后，当我们想创建People类的某个子类的对象时，我们依然可以将其声明为父类，而构造器用子类的构造器，例如：People cp=new ChinaPeople(10.0,5.0); 。这样 cp 是使用的依然是子类重写后的方法，但是cp中将不包含子类独有的方法或属性，如果想要使用子类独有的属性或方法，我们可以进行强制转换：ChinaPeople cc=(ChinaPeople)cp; 。注意，不可以强制转换 cp 为 ChinaPeople 类。
• 注意：Java 中没有虚函数的概念，它的普通方法就相当于 c++ 中的虚函数，动态绑定是 Java 的默认行为。如果你不希望 Java 中某个方法具有虚函数的特性，可以使用 final 关键字使其变为非虚函数（Java 中的方法，等价于 c++ 中的函数）。

程序设计二 多态：

题目：

通过面向抽象的方式，完成：计算若干个任意图形面积的程序设计，参考思路如下：

（1）面向抽象类的程序设计：编写一个TotalArea类，为计算若干个任意图形的面积；在该类中，有一个tuxing数组的属性，表示若干个任意的图形；建立一个public double computerTotalArea()方法，用来计算全部的若干个图形的面积和；

（2）根据面向抽象类的程序设计：编写一个抽象类，定义图形tuxing，都要有一个给出面积的方法getArea()，来返回tuxing的面积。

在主类中，通过TotalArea, 建立15个圆和15个矩形，边长和半径均不相同，计算全部圆形和矩形的面积之和。

图形类

package 实验七图形类;

public abstract class tuxing {
    //抽象类不能有函数体
    public abstract double getArea();
}

圆形类

package 实验七图形类;

public class yuan extends tuxing{
    double banjing;
    yuan(){};
    yuan(double banjing){
        this.banjing=banjing;
    }
    public double getArea(){
        //Math.PI：调用Math类的属性PI，其中存着π的值。
        //Math.pow(double a,double b); 返回a^b^
        return Math.PI*Math.pow(banjing,2);
    }
}

矩形类

package 实验七图形类;

public class juxing extends tuxing{
    double chang,kuan;
    juxing(){};
    juxing(double chang,double kuan){
        this.chang=chang;
        this.kuan=kuan;
    }
    public double getArea(){
        return chang*kuan;
    }
}

TotalArea类

package 实验七图形类;

public class TotalArea {
    tuxing[] tx;
    static double sum;
    TotalArea(){};
    TotalArea(int n){
        tx=new tuxing[n];
        sum=0;
    }
    public double computerTotalArea(){
        for(tuxing c:tx){
            sum+=c.getArea();
        }
        return sum;
    }
}

主函数

package 实验七图形类;

public class Main {
    public static void main(String[] args){
        TotalArea tx=new TotalArea(30);
        for(int i=0;i<30;++i)
        {
            //三目运算符写法：   
            //tx.tx[i]=i%2==0?new yuan(i):new juxing(i*1.0,i+0.5); √
            //i%2==0?tx.tx[i]=new yuan(i):tx.tx[i]=new juxing(i*1.0,i+0.5); ×
            //i&1?tx.tx[i]=new yuan(i):tx.tx[i]=new juxing(i*1.0,i+0.5); ×
            if(i%2==0) tx.tx[i]=new yuan(i);
            else tx.tx[i]=new juxing(i*1.0,i+0.5); 
        }
        System.out.printf("各种图形的面积之和是：%.2f",tx.computerTotalArea());
    }
}

小tips:

• 所谓多态，就是让父类的对象，可以在不同情况下，使用不同子类的方法。。使用前提是：继承、重写、父类引用指向子类对象 Parent p = new Child();。

• 抽象类也是为多态服务的。我们知道，java 所有的对象都通过类来描述，但并不是所有的类都用来描述对象。抽象类就是这样的类。它不具备足够的信息来描述一个具体的对象，所以**抽象类不能实例化对象。**但除此之外与其他类相同。

• 由于抽象类不能实例化对象，所以抽象类必须被继承后才能使用。抽象类表示的是一种继承关系。

• java 中用 abstract class 来定义抽象类。用 abstract 关键字来定义抽象方法，抽象方法名后直接跟一个分号，没有花括号。例如： abstract double Childname(); 该方法的具体实现由该方法所属类的子类决定。

• **抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类。**任何子类必须重写父类的抽象方法，否则必须声明自己也是抽象类。

• 关于三目运算符：tx.tx[i]=i%2==0?new yuan(i):new juxing(i*1.0,i+0.5); 这样写是正确的。而 i%2==0?tx.tx[i]=new yuan(i):tx.tx[i]=new juxing(i*1.0,i+0.5); 这样写就不对。同时意外发现 & 不能用于判断条件中。

• Math.PI：调用Math类的属性PI，其中存着π的值。

• Math.pow(double a,double b); 返回值： a^b 。