JAVA基础习题3-类的继承

一、实验目的：

1、掌握类和构造方法的定义

2、类的继承。

 

二、实验内容和要求：

1．运行下面的程序，理解成员变量的继承与隐藏。

import java.io.*;
 class sum_3{
            int sum,num1,num2;
            static int num3;
            //定义构造函数初始化对象
     sum_3(){
                   num1=0;
                   num2=0;
                   num3=0;
                   sum=0;
            }
 }
 class sub_sum3 extends sum_3{
            int sum,num1,num2;        //隐藏父类sum_3中的实例变量
            static int num3;                //隐藏父类sum_3中的类变量
               void sum(int i,int j,int k){
                   num1=i;
                   num2=j;
                   num3=k;
                   sum=num1+num2+num3;
            }
 }
 public class computing{
     public static void main (String arg[]){
           sub_sum3 m1=new sub_sum3();
        m1.sum(100,200,300);
        System.out.println("sum="+m1.num1+"+"+m1.num2+"+"+m1.num3+"="+m1.sum);
        }
 }

运行结果：

问题：a、子类的sum,num1,num2分别是多少，父类的sum,num1,num2 分别是多少，如何在main中输出父类的sum,num1,num2。

父类的sum=0；num1=0；num2=0

子类的sum=600；num1=100；num2=200；

输出：先继承父类的tostring方法

 

b、就这个例子，谈谈你对覆盖的理解？

覆盖是指在子类中定义与父类同名且参数类型和个数都相同的方法。

2.运行下面的程序，理解方法的继承。

2．class Sort3{
            double max1,max2,max3;
            Sort3(){
                   max1=-1;
                   max2=-1;
                   max3=-1;
            }
         void sort(){
                   double s;
                   if (max1<max2){ s=max1;max1=max2;max2=s; }
                   if (max1<max3){ s=max1;max1=max3;max3=s; }
                   if (max2<max3){ s=max2;max2=max3;max3=s; }
            }
  }
 class sub_Sort3 extends Sort3{
            void subsort(double i,double j,double k){
                   max1=i;
                   max2=j;
                   max3=k;
                sort();  //调用父类中的方法sort() …….①              }
 }
 public class Class1{
                 public static void main (String args[]){
              sub_Sort3 m1 = new sub_Sort3();
                    m1.subsort(100,200,300);
                  System.out.println("三个数从大到小为："+m1.max1+","+m1.max2+","+m1.max3);
                 }
 }

 

3．运行下面的程序，理解方法的重载。

class Sort2or3{
          double max1,max2,max3;
         Sort2or3(){
                   max1=-1;
                    max2=-1;
                   max3=-1;
            }
            void sort(double i,double j){
                   double s;
                   max1=i;
                   max2=j;
                   if(max1<max2){ s=max1;max1=max2;max2=s; }
            }
            void sort(double i,double j,double k){
                   double s;
                   max1=i;
                   max2=j;
                   max3=k;
                   if (max1<max2){ s=max1;max1=max2;max2=s; }
                   if (max1<max3){ s=max1;max1=max3;max3=s; }
                   if (max2<max3){ s=max2;max2=max3;max3=s; }
            }
 }
 public class Class1{
            public static void main (String args[]){
                 Sort2or3 m1 = new Sort2or3();
                 m1.sort(100,200);
                 System.out.println("两个数从大到小为："+m1.max1+","+m1.max2);
                 m1.sort(50,150,100);
                 System.out.println("三个数从大到小为："+m1.max1+","+m1.max2+","+m1.max3);
            }
 }

运行结果为：

 

4．运行下面的程序，理解方法的覆盖。

class sort_Demo{
            int i,j,k,swap;
            sort_Demo(){
                   i=j=k=swap=0;
            }
            void sort(int t1,int t2[]){                   //父类中的方法用来实现升序
                   //用选择法按升序排列
                   for(i=0;i<t1-1;i++){
                          k=i;
                          for(j=i+1;j<t1;j++)
                                 if(t2[j]<t2[k]) k=j;
                          if (k!=i){
                                 swap=t2[i];
                                 t2[i]=t2[k];
                                 t2[k]=swap;
                          }
                   }
            }
 }
 class sub_sort_Demo extends sort_Demo{
            void sort(int t1,int t2[]){            //子类中的方法实现降序
                //用选择法实现降序排列
                   for(i=0;i<t1-1;i++){
                          k=i;
                          for(j=i+1;j<t1;j++)
                                 if(t2[j]>t2[k]) k=j;
                          if (k!=i){
                                 swap=t2[i];
                                 t2[i]=t2[k];
                                 t2[k]=swap;                         }                    }
            }
        } 
 public class Class1{
            public static void main (String args[]){
                   int a[]={34,12,8,67,88,23,98,101,119,56};
                sort_Demo m1=new sort_Demo();
                   sub_sort_Demo m2=new sub_sort_Demo();
                         System.out.println("排序前的数据为：");
                   for (int i=0;i<10;i++)
                          System.out.print("  "+a[i]);
                   //调用父类中的sotr()方法
         m1.sort(a.length ,a);
                   System.out.println("\n按升序排列的数据为：");
                   for (int i=0;i<10;i++)
                          System.out.print("  "+a[i]);
                   //调用子类中的sort()方法,该方法实现了对父类中方法的覆盖
         m2.sort(a.length ,a);
                         System.out.println("\n按降序排列的数据为：");
                   for (int i=0;i<10;i++)
                          System.out.print("  "+a[i]);               } }

问题 ：比较3和4，谈谈你对重载和重写的认识，最好可以自己举例说明

重载 可以实现本类内的方法多态性， 重写 可以实现子类或实现类的多态性

5.按如下要求定义两个类A和B, 类A中定义一个int 类型属性x（将其赋值为8）和一个在命令行下输出x值的方法myPrint()。类B是类A的子类，其中也定义一个int 类型属性y（将其赋值为16）和String类型的属性s（将其赋值为"java program!"）；一个在命令行下输出y和s值的方法myPrint()；类B中还有一个方法printAll( )，该方法中分别调用父类和子类的myPrint()方法。编写Application，创建类类B的对象b，调用printAll( )方法，输出结果

lass A {

    int x = 8;

    void myPrint() {
        System.out.println("x的值为：" + x);
    }
}

class B extends  A {
        int y=16;
        String s="java program!";
        void myPrint(){
            System.out.println("y的值为："+y);
            System.out.println("s的值为："+s);

        }
        void printAll(){
            super.myPrint();
            this.myPrint();
        }

    public static void main(String[] args) {
        B b=new B();
        b.printAll();
    }
}

6.请编写应用程序，它由两个类定义组成：类A中定义了int型变量i和float型变量x，及一个带两个参数的构造函数（为变量i和x做初始化）。主类test中创建了一个A类的对象a（i的初始值2，x的初始值8.0），还定义了一个方法b，b的参数和返回值均为A类的对象，功能为将参数对象的属性i加1，属性x加2。请在main()方法中显示调用b(a)后的a的两个成员变量的变化结果。

public class Application{
    public String toString;
    private int i;
    private float x;

    public Application(int i, float x) {
        this.i = i;
        this.x = x;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    public float getX() {
        return x;
    }

    public void setX(float x) {
        this.x = x;
    }
    public String toString(){
        return "Application[i="+i+",x="+x+"]";
    }
}
class ApplicationTest {
    public static void main(String[] args) {
        Application a=new Application((int)2,(float)8);
        System.out.println(a.toString());
        System.out.println(b(a).toString);

    }
    public static Application b(Application a){
        a.setI((int)(a.getI()+1));
        a.setX((float)(a.getX()+2));
        Application k=new Application(a.getI(),a.getX());
        return k;
    }


}