java 语言程度设计 李元朝 第8章 接口和包 练习题

1.什么是抽象类？它的特点是什么？

  抽象类是专门设计用来让子类继承的类。

  特点：抽象类通常都包括一个或多个抽象方法（只有方法说明，没有方法体），抽象类的子类必须实现其父类定义的每个抽象方法，除

          非该子类也是抽象类。

2.什么是接口？它的特点是什么？

    接口：是由一些抽象方法和常量所组成的集合。

    特点：

         1.接口可以实现多继承。多继承可以通过在extends后面使用多个父接口来实现

         2.接口不存在最高层，与类的最高层为object类是不同的

         3.接口中的方法都是使用abstract修饰的方法。

         4.接口中的成员变量默认为final定义的常量。 

3.什么是包？包的作用是什么？

      包是java语言提供的组织类和接口的工具，包是一组相关类和接口的集合。

      包的作用：由于同一包中的类在缺省情况下可以相互访问，所以为了方便编程和管理，通常把需要在一起工作的类放在一个包中。

      由于java程序模块是动态装载，为了防止名字空间的冲突，java对其成员变量和方法采用类似于internet上的命名方式来定义。成

      员变量和方法是类的重要成分，在类中定义，而每个类又都是包的一部分，这样就可以通过包名、类名和类成员这样的层次来定义

4.编写一个应用抽象类的程序。要求设计抽象类，设计继承抽象类并实现抽象类中抽象方法的子类。

     定义抽象类bank,它包含oneyearRate(一年定期利率)、oneyearNationaldebt(一个国债利率）和interestRate（按年计算的活期

     利率）常数，count()方法及show（）方法。count()方法计算存款一个所得利息及缴利息税后的总金额（原存款额+税后利息）而

      show()方法显示总额

     由于定期存款、活期存款和国债的利率不同，此程序定义了3个类，分别表示这3种储蓄。3个类都继承抽象类Bank中的count()和

     show()抽象方法，完成对利息和总金额的计算和显示功能。

abstract class Bank {
	protected static final float oneyearRate=0.0178f;     		//定期利率
	protected static final float oneyearNationaldebt=0.0198f;  	//国债利率
	protected static final float interestRate=0.0078f;			//活期利率
	abstract void count();
	abstract void show();
}

class OneyearNationaldebtCalcute extends Bank {
    private float saving;
    private double sum;
    OneyearNationaldebtCalcute(float i)  {  saving=i; count(); }
    public void count()
     {
        sum=saving+(saving*Bank.oneyearNationaldebt);
     }
    public void show()
      {
        System.out.println(" With national debt rate, sum= "+sum);
    }
}

class OneyearRateCalcute extends Bank {
    private float saving;       //原存款金额
    private double sum;       //1年后的总金额
    OneyearRateCalcute(float i)   {  saving=i; count(); } 
    public void count()    //实现count()方法
     {
      sum=saving+(saving*Bank.oneyearRate*0.8);       //税后总金额
     }
    public void show()    //实现show()方法
     {   
       System.out.println(" With fixed rate, sum="+sum);
     }
}

class InterestRateCalcute extends Bank {
    private float saving;
    private double sum;
    InterestRateCalcute(float i)    {  saving=i;count(); }
    public void count(){
        sum=saving+(saving*Bank.interestRate*0.8);     //税后总金额
    }
    public void show()
   {
        System.out.println(" With current interest rate, sum= "+sum);
    }
}

class Calculate {
public static void main(String args[])
  {
        int mon=10000;
        OneyearRateCalcute rate=new OneyearRateCalcute(mon);
        rate.show();
        OneyearNationaldebtCalcute debt=new OneyearNationaldebtCalcute(mon);
        debt.show();
        InterestRateCalcute interest=new InterestRateCalcute(mon);
        interest.show();
    }
}

5.将题4中的抽象类改为接口，实现相同的功能。

interface Bank {
    float oneyearRate=0.0178f;        //下面是不同的存款利率
    float oneyearNationaldebt=0.0198f;
    float interestRate=0.0078f;
    abstract void count();                    //抽象方法
    abstract void show();
}

class InterestRateCalcute implements Bank{
    private float saving;       //原存款金额
    private double sum;        //1年后的税后总金额
    InterestRateCalcute(float i)    {  saving=i;count(); }
    public void count(){
        sum=saving+(saving*Bank.interestRate*0.8);     //税后总金额
    }
    public void show()
   {
        System.out.println(" With current interest rate, sum= "+sum);
    }
}

class OneyearNationaldebtCalcute implements Bank{
    private float saving;   //原存款金额
    private double sum;     //1年后的总金额
    OneyearNationaldebtCalcute(float i)  {  saving=i; count(); }
    public void count()
     {
        sum=saving+(saving*Bank.oneyearNationaldebt);   //总金额
     }
    public void show()
      {
        System.out.println(" With national debt rate, sum= "+sum);
    }
}

class OneyearRateCalcute implements Bank{
    private float saving;       //原存款金额
    private double sum;       //1年后的税后总金额
    OneyearRateCalcute(float i)   {  saving=i; count(); } 
    public void count()    //实现count()方法
     {
      sum=saving+(saving*Bank.oneyearRate*0.8);       //税后总金额
     }
    public void show()    //实现show()方法
     {   
       System.out.println(" With fixed rate, sum="+sum);
     }
}

class Calculate {
  public static void main(String args[])
  {
        int mon=10000;
        OneyearRateCalcute rate=new OneyearRateCalcute(mon);
        rate.show();
        OneyearNationaldebtCalcute debt=new OneyearNationaldebtCalcute(mon);
        debt.show();
        InterestRateCalcute interest=new InterestRateCalcute(mon);
        interest.show();
    }
}

6.编写一个应用包的程序。要求定义包、导入并引用包中的类。

分别定义myclass1类和myclass2类，将这两个类组织在mypackage包中，保存到当前路径下的子目录mypackage中

如果要引用这两个类，需要使用import 导入

  注意：myclass1.lass和myclass2.class必须放置在当前路径下的子目录mypackage中

//MyClass1.java文件
package mypackage;   // 声明包mypackage
public class MyClass1
 {
	protected static final int m=10;
	protected static final int n=20;
	public int sum()
     {
		return m+n;
	 }
}

// MyClass2.java文件
package mypackage;    //声明包mypackage
public class MyClass2
 {
	protected  int x=10;
	protected  int y=20;
	public int multi()
	{
		return x*y;
   }
}

//Play.java文件
import mypackage.MyClass1;  // 导入类MyClass1
import mypackage.MyClass2;  // 导入类MyClass2
class Play
 {
	public static void main(String args[])
	 {
		MyClass1c1=new MyClass1();
		System.out.println("Sum result is "+c1.sum());
		MyClass2 c2=new MyClass2();
		System.out.println("Multiply result is "+c2.multi());
	}
}

 

转载于:https://www.cnblogs.com/elite-2012/archive/2013/04/13/3018629.html