java-实验13

实验13

实验内容

1.  接口实验 

运行下列程序，然后按【思考问题】内容修改和观察程序。

interface rec_Area_Peri

{

int getArea();

 int getPerimeter();

}

class rectangle implements rec_Area_Peri

{ int width,length;

 rectangle(int w,int l)

 {width=w;

 length=l;

 }

 public int getArea()

 {return width*length;}

 public int getPerimeter()

 {return (2*(width+length));}

}

 

public class Ex

 

{ public static void main(String args[])

 { rectangle rect=new rectangle(10,20);

 System.out.println("矩形面积="+rect.getArea());

 System.out.println("矩形周长="+rect.getPerimeter());

 }

} 

【思考问题并写出答案】 

① 在实现类rectangle中注释掉一个方法后进行编译，看发生了什么?为什么？

解：编译失败：The type rectangle must implement the inherited abstract method rec_Area_Peri.getPerimeter()，接口中的所有方法均要实现。 

②在实现类rectangle中将各实现方法前的public修饰符去掉再进行编译，看发生了

什么?为什么？ 

解：编译错误:Cannot reduce the visibility of the inherited method from rec_Area_Peri，子类实现某个接口时，方法的权限不可以高于原来的权限值，接口中的方法默认为public static ，而是实现时不加public声明，则默认为default;权限变高；

③将接口rec_Area_Peri中定义的两个方法前加上abstract修饰符再编译，看对程序

有影响否？为什么？ 

解：没有影响，接口中的所有方法均默认为抽象方法；

④不用单独的实现类rectangle，直接在主类classe Ex中实现那两个方法，如何

修改程序？ 

package my;

 

interface rec_Area_Peri

{

 int getArea();

 int getPerimeter();

}

class rectangle{

int width,length;

rectangle(){}

}

 

public class Ex extends rectangle implements rec_Area_Peri{

static int area,perimeter;

 Ex(int w,int l){

 width=w;

 length=l;

 }

 Ex(){

 width=30;

 length=20;

 area=getArea();

 perimeter=getPerimeter();

 }

public static void main(String args[])  {

 System.out.println("方式一(构建有参构造函数初始化，创建对象，调用函数)：");

 Ex e=new Ex(10,20);

 System.out.println("面积："+e.getArea()+" "+"周长："+e.getPerimeter());

 System.out.println("方式二(再定义面积和周长两个变量，存放函数计算出的结果，再直接调用成员变量输出结果)：");

 Ex p=new Ex();

 System.out.println("面积："+p.area+" "+"周长："+p.perimeter);

 

    }  

 public int getArea() {

this.area=width*length;

 return width*length;

 }

 public int getPerimeter() {

 this.perimeter=2*(width+length);

 return (2*(width+length));

}

}

⑤将接口rec_Area_Peri中定义的两个方法拆分定义成两个接口，即每个接口只定义

一个方法，程序将如何修改？。

interface rec_Area_Peri1

{ int getArea(); }

interface rec_Area_Peri2{

int getPerimeter();}

class rectangle implements rec_Area_Peri1,rec_Area_Peri2

{ int width,length;

 rectangle(int w,int l)

 {width=w;

 length=l;

 }

 public int getArea()

 {return width*length;}

 public int getPerimeter()

 {return (2*(width+length));}

}

public class Ex

{ public static void main(String args[])

 { rectangle rect=new rectangle(10,20);

 System.out.println("矩形面积="+rect.getArea());

 System.out.println("矩形周长="+rect.getPerimeter());

 }

} 

 

2.根据下面要求写Student类，使之继承Person类并实现Swimmer，和Singer类。

interface Swimmer

{

public void swime();

public void rest();

}

 

interface Singer

{

public void sing();

}

abstract class Person implements Singer

{

private String name;

person(String name)

{

this.name = name;

}

public abstract void sing();

public void work()

{

System.out.println(this.name + " is working");

}

}

/------------------------------------完整代码------------------------------------/

package my;

public class StudentTest {

    public static void main(String[] args) {

    //接口或抽象类指向其子对象，只能调用自己已有的方法；

    Student p=new Student("谷谷");

    Swimmer s=new Student("风清");

    Singer sg=new Student("古昔");

    Person r=new Student("蛮风");

    p.swime();  p.rest();p.sing(); p.work();

    s.swime();s.rest();

     sg.sing();

    r.sing();r.work();

    }

}

interface Swimmer

{

public void swime();

public void rest();

}

 

interface Singer

{

public void sing();

}

abstract class Person implements Singer

{

private String name;

Person(String name)

{

this.name = name;

}

public abstract void sing();

public void work()

{

System.out.println(this.name + " is working");

}

}

class Student extends Person implements Swimmer{

Student(String name){

super(name);

}

public void sing() {

System.out.println("song of the person!");

}

public void swime() {

System.out.println("the person is swimming");

}

public void rest() {

System.out.println("the person is sleeping");

}

}

3.找出下面程序中的错误，并说明原因（请先自行查错，然后再编译验证）。

abstract class Father1{public abstract void f1(){}}//抽象类中的抽象方法不能包含方法体

class Son extends Father1{}//Son是普通类，必须实现Father1中的所有抽象方法

final class Father2{}

class Son2 extends Father2{}//final修饰的类不可在继承

interface in1{}

class Son3 extends in1{}//in1是接口，应用implements

interface in2{}

class Son4 extends Father1 implements Father2{}//Father2并不是接口

class Father3{}

class Son5 extends Father3 implements in1,in2{}

 

class Father4{public final void f(){}}

class Son6 extends Father4{

public void f(){}//final修饰的方法不可再重写

}

public class FindError {

final int i=10;

final int j;

final int k;

 final int l;

public static final int s=100;

{

i=11;j=12;//不可再更改i的值，i开始已经初始化为10

}

FindError(){//必须保证所有final 的变量都要初始化

k=13;

j=9;//final修饰j,静态块中已经给j赋值为12,不可再赋值

 //添加

 l=10;

}

public void print(final int a){

final int b;

a=12;//a的值在传参时已经确定了，不可再赋值

b=13;

l=1000;//FindError已经对其初始化，不可再更改

}

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

s++;//已赋初值，不可再更改；

}

 

}

————————更改后的完整代码——————————————————

package my;

 

abstract class Father1{public abstract void f1();}//抽象类中的抽象方法不能包含方法体

class Son extends Father1{public void f1() {}}

final class Father2{}

class Son2 {}//final修饰的类不可在继承

interface in1{}

class Son3 implements in1{}//in1是接口，应用implements

interface in2{}

class Son4 extends Father1{public void f1() {}}//Father2并不是接口

class Father3{}

class Son5 extends Father3 implements in1,in2{}

 

class Father4{public final void f(){}}

class Son6 extends Father4{

//public void f(){}//final修饰的方法不可再重写

}

public class FindError {

final int i=10;

final int j;

final int k;

    final int l;

public static final int s=100;

{

//i=11;//不可再更改i的值，i开始已经初始化为10

j=12;

}

FindError(){

     k=13;

     //j=12;

     l=18;

//j=9;

}

public void print(final int a){

final int b;

//a=12;//a的值在传参时已经确定了，不可再赋值

b=13;

       // l=1000;

System.out.println("i:"+i+" j:"+j+" k:"+k+" l:"+l+" s:"+s);

}

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

//s++;

FindError e=new FindError();

e.print(3);

}

 

}