接口方法

JAVA上机实验

实验名称：抽象类、接口与内部类

实验目的：掌握抽象类、接口的定义、实现与使用; 掌握内部类的创建；理解接口和继承的混合使用。

一、实验内容：

?1、定义接口Shape，其中包括一个方法size（）,设计“矩形”、“圆”、“圆柱体”等类实现Shape接口,其size（）方法分别表示计算矩形面积、圆面积、圆柱体的体积。分别创建代表“矩形”、“圆”、“圆柱体”的三个对象存入一个Shape类型的数组中，通过调用size （）方法将数组中各类图形的大小输出。

注意：

1、实现接口方法一定要与接口方法相同，

在对它进行修改，即重写（保证返回值类型、方法名、方法的基本类型相同，否则会出现错误：未添加接口方法或定义类为抽象）

2、创建接口方法时，不存在方法体的，即后面大括号的部分

3、Java中求函数的幂：Math.pow(x,y);

例如：Math.pow(3,2);

解释:3的2次方

4、我的疑问：

（1）如何将数组中的内容全部输出

（2）如何在接口对象中输出类中的属性值:

需要进行强制转可以输出类中的属性

例：Shape s[]=new Shape();

S[0]=new Juxing();

Juxing k =(Juxing) s[0];

package test;

public interface Shape {

//创建接口方法

public double size();

}

package test;

public class Juxing implements Shape {

//属性

double length;//矩形的长

double width;//矩形的宽

double height;//矩形的高

//创建构造方法

public Juxing(double l,double w,double h){

this.length=l;

this.width=w;

this.height=h;

}

//实现接口的方法

public double size(){

return length*width*height;

}

}

package test;

public class Yuan implements Shape{

//属性

double round;//圆的半径

//构造方法

public Yuan(double r ){

this.round=r;

}

//实现接口方法

public double size(){

double a;

a=Math.pow(round,4)/3;//在java中求函数的幂

return a;

}

}

package test;

public class Yuanzhu implements Shape{

//属性

double high;//圆柱的高

double round;//圆柱的半径

//构造方法

public Yuanzhu(double g,double r){

this.high=g;

this.round=r;

}

//实现接口方法

public double size(){

double b;

b=3.14*high*Math.pow(round, 2);

return b;

}

}

package test;

package test;

public class Test {

public static void main(String[]args){

Shape s[]=new Shape[3];

s[0]=new Juxing(5,4,3);

s[1]=new Yuan(3);

s[2]=new Yuanzhu(3,4);

//强制转换

Juxing k=(Juxing) s[0];

Yuan y=(Yuan) s[1];

Yuanzhu z=(Yuanzhu) s[2];

System.out.println("矩形的高"+k.height);

System.out.println("矩形的宽"+k.width);

System.out.println("圆的半径"+y.round);

System.out.println("圆柱的半径"+z.round);

System.out.println("圆柱的高"+z.high);

System.out.println("矩形的长"+k.length);

System.out.println("数组的长度"+s.length);

System.out.println("矩形的体积"+s[0].size());

System.out.println("圆形的体积"+s[1].size());

System.out.println("圆柱的体积"+s[2].size());

}

}

?2、定义一个抽象类-水果,其中包括getWeight()方法,编写程序分别创建苹果、桃子、橘子三个类，创建若干水果对象存放在一个水果类型的数组中，输出数组中所有水果的类型、重量。提示：利用对象的getClass().getName()方法可获取对象的所属类的名称。package two;

public abstract class Fruit {

//抽象方法，获得重量

public abstract double getWeight();

}

package two;

public class Apple extends Fruit{

//属性

double weight;//苹果的重量

String color;//苹果的颜色

public Apple(double weight, String color) {

this.weight = weight;

this.color = color;

}

public String getColor() {

return color;

}

//实现抽象方法

public double getWeight(){

Return weight;

}

}

package two;

public class Pear extends Fruit{

double weight;

public Pear(double weight) {

this.weight = weight;

}

//实现抽象方法

public double getWeight(){

Return weight;

}

}

package two;

public class Peach extends Fruit{

double weight;

public Peach(double weight) {

this.weight = weight;

}

//实现抽象方法

public double getWeight(){

Return weight;

}

}

package two;

public class Test {

public static void main(String[] args){

//创建水果数组

Fruit f[]=new Fruit[3];

f[0]=new Apple(3.8,"red");

f[1]=new Pear(2.4);

f[2]=new Peach(1.2);

//强制转换

Apple a=(Apple)f[0];

Pear p=(Pear)f[1];

Peach c=(Peach)f[2];

System.out.println("苹果的重量"+f[0].getWeight());

System.out.println("梨的重量"+f[1].getWeight());

System.out.println("桃的重量"+f[2].getWeight());

System.out.println("苹果的颜色"+a.getColor());

//获得对象的类名，直接引用Object类里的对象名。getClass,getName() System.out.println("f[0]类名"+f[0].getClass().getName());

System.out.println("f[1]类名"+f[1].getClass().getName());

System.out.println("f[2]类名"+f[2].getClass().getName());

//获得对象的类名

System.out.println("a的类名"+a.getClass());

System.out.println("p的类名"+p.getClass());

System.out.println("c的类名"+c.getClass());

}

?知识点：对象的类型转换分为两种：上转型（自动转换）和下转型（强制转换）

1.上转型实际就是子类转换成父类：（1）向上转型对象不能操作自雷中的新成员变量，

也不能使用子类新增的成员方法（2）上转型对象可以操作子类继承或隐藏的成员

变量，也可以使用子类继承的或重写的方法。即为上转型对象可以操纵父类原有的属性和功能，无论这些方法是否被重写。（3）可以将对象的上转型对象再强制转

换到一个子类对象，强制转换过的对象具有子类所有属性和功能。（4）上转型对象调用方法时，就是调用子类继承和重写过的方法。而不会是新增的方法，也不是父类原有的方法。

2.下转型实际就是将父类转换成子类（将父类的对象赋值给子类使用）

3、掌握上转型对象的使用：要求有一个abstract类，类名为Employee。Employee的子类有YearWorker、MonthWorker和WeekWorker。YearWorker对象按年薪领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个abstract 方法：Public abstract earnings（）；子类必须重写父类的earnings（）方法，给出各自领取报酬的具体方式。有一个Company类，该类用Employee数组作为成员，Employee 数组的单元可以是YearWorker对象的上转型对象、MonthWorker对象的上转型对象或WeekWorker对象的上转型对象。程序能输出Company对象一年需要支付的薪水总额。package ch01;

public abstract class Employee {

//抽象方法

public abstract double earnings();

}

package ch01;

public class YearWorker extends Employee{

//实现抽象方法

@Override

public double earnings() {

// TODO自动生成的方法存根

return 200000;

}

}

package ch01;

public class MonthWorker extends Employee{

//实现抽象方法

@Override

public double earnings() {

// TODO自动生成的方法存根

return 12*8000;

}

package ch01;

public class WeekWorker extends Employee{

//实现抽象方法

@Override

public double earnings() {

// TODO自动生成的方法存根

return 48*2000;

}

}

package ch01;

public class Company {

//定义Employee类数组

Employee employee[];

double sal=0;

//创建构造方法

public Company(Employee[] employee) {

this.employee = employee;

}

//成员对应的构造方法

public double salPay(){

sal=0;

for(int i=0;i

this.sal+=this.employee[i].earnings();

}

return this.sal;

}

}

package ch01;

public class Test {

public static void main(String[] args){

//创建数组对象

Employee employee[]=new Employee[20];

for(int i=0;i

if(i%3==0)

employee[i]=new WeekWorker();

else if(i%3==1)

employee[i]=new MonthWorker();

else if(i%3==2)

employee[i]=new YearWorker();

}

Company c=new Company(employee);

System.out.println("支付薪水总额"+c.salPay());

System.exit(0);

}

}

二、实验内容：

卡车要装载一批货物，货物有三种商品：电视、计算机和洗衣机。需要计算出大货车和小货车各自所装载的3种货物的总重量。

要求有一个ComputeWeight接口，该接口中有一个方法：

public double computeWeig（）

有3个实现该接口的类：Television、Computer和WashMachine。这3个类通过实现接口ComputeTotalSales给出自重。

有一个Car类，该类用ComputeWeight接口类型的数组作为成员，那么该数组的单元就可以存放Television对象的引用、Computer对象的引用或WashMachine对象的引用。程序能输出Car对象所装载的货物的总重量。