首页 > 分享 > Java第五周作业下

Java第五周作业下

萌宠菠菠乐园
2024-09-14 06:51

1.实验：利用IDE的debug功能给例6.4和例6.6的new语句设置断点，使用单步调试（step into/step over）跟踪子类对象化实例（初始化）的执行顺序，并总结该过程。

2.如何实现两个对象之间互发消息，请举例说明。

1）引用必须真实引用了特定的对象。

2）被访问对象必须定义了相应的属性或方法。

3）被访问的属性或方法必须具有可访问的权限。

------------恢复内容开始------------

2.如何实现两个对象之间互发消息，请举例说明。

1）引用必须真实引用了特定的对象。

2）被访问对象必须定义了相应的属性或方法。

3）被访问的属性或方法必须具有可访问的权限。

------------恢复内容开始------------

1）为对象分配内存空间，对成员变量进行默认的初始化。（局部变量必须进行显示初始化）

2）绑定构造方法，将new中的参数传递给构造方法的形式参数。

3）调用this或super语句（二者必居其一，不能同时存在），执行流程如图所示。

4）进行实例变量的显示初始化操作。如：

1 public class A{ 2 int value=4; //显示初始化 3 B b = new B(); //显示初始化，注： B为另一个类 4 }

5）执行当前构造方法的方法体中的程序代码。

2.如何实现两个对象之间互发消息，请举例说明。

1）引用必须真实引用了特定的对象。

2）被访问对象必须定义了相应的属性或方法。

3）被访问的属性或方法必须具有可访问的权限。

1 class FighterPlane{
2 3 String name; 4 int missileNum; 5 public FighterPlane(String _name,int _missileNum){ 6 name = _name; 7 missileNum = _missileNum; 8 } 9 public void fire(){ 10 if (missileNum>0){ 11 System.out.println("now fire a missile !"); 12 missileNum -= 1; 13 } 14 else{ 15 System.out.println("No missile left !"); 16 } 17 } 18 } 19 20 class A 21 { 22 FighterPlane fp; 23 public A(FighterPlane fpp){ 24 this.fp = fpp; //A对象中拥有了FighterPlane对象的引用 25 } 26 public void invoke(){ 27 //A中对象发送消息给FighterPlane的对象 28 System.out.println(fp.name); 29 } 30 } 31 public class Run{ 32 public static void main(String[] args) 33 { 34 FighterPlane ftp = new FighterPlane("su35",10); 35 //产生A对象，并将ftp对象引用作为参数传入 36 A a = new A(ftp); 37 //发送消息，产生调用关系 38 a.invoke(); 39 } 40 }

3.谈谈组合与继承的区别以及两者的使用场景（即什么时候宜用组合？什么时候宜用继承？）

组合：在新的类中产生现有类的对象。由于新的类是由现有类的对象所组成，所以这种方法称为组合。该方法只是复用了现有程序代码的功能，而非它的形式。

继承：按照现有的类型来创建新类。无需改变现有类的形式，采用其形式并在其中添加新代码。这种方式称为继承。

当要设计的新类与原有的类的关系是“has-a”（有一个）时，适合用组合的方式。

例如，一个简单的房子（SimpleHouse)有两个窗户（Window）、有一个门（Door）、有一个桌子（Table）以及四个椅子（Chair）等等，可以用如下代码描述：

1 //: SimpleHouse.java 2 public class SimpleHouse { 3 private Window[] windows = new Window[2]; 4 private Door door = new Door(); 5 private Table table = new Table(); 6 private Chair[] chairs = new Chair[4]; 7 /*some code...*/ 8 } 9 10 class Window {/*some code...*/} 11 class Door {/*some code...*/} 12 class Table {/*some code...*/} 13 class Chair {/*some code...*/} 14 //:~

当要设计的新类原有的类的关系是“is-a”时，适合用组合的方式。

例如，狗是一个宠物，猫是一个宠物，而宠物是一个原有的类，可以用如下代码描述。

1 //: Pet.java 2 abstract public class Pet { 3 public void jump() { 4 System.out.println(this.getClass().getSimpleName()+" jump"); 5 } 6 abstract public void say(); 7 /*some code...*/ 8 } 9 10 class Dog extends Pet { 11 @Override 12 public void say() { 13 System.out.println("woof!"); 14 } 15 /*some code...*/ 16 } 17 18 class Cat extends Pet { 19 @Override 20 public void say() { 21 System.out.println("meow~"); 22 } 23 /*some code...*/ 24 } 25 //:~

4.Java中的运行时多态的含义是什么？有什么作用？请举例说明。

通过方法覆盖实现（子类覆盖父类方法）。

可以进行动态绑定，使用父类引用指向子类对象，再调用某一父类中的方法时，不同子类会表现出不同结果。这样做的作用就是拓展性极好。

//假设有一个类叫鸟类，它拥有属性翅膀，拥有方法鸣叫，如下 public class Bird{ private Wing wing; public void moo(){ System.out.println("鸟叫声"); } } /*鸟类封装了翅膀类和moo方法；另外有两个类都继承鸟类并重写了moo方法，分别是鹦鹉和麻雀如下：*/ //鹦鹉类： public class Parrot extends Bird{ public void moo(){ System.out.println("鹦鹉的叫声"); } } //麻雀类： public class Sparrow extends Bird{ public void moo(){ System.out.println("麻雀的叫声"); } } /*然后你有个妻子她想听鸟叫，就有个妻子类*/ public class Wife{ public void listen(Bird bird){ bird.moo(); } /*这时多态就很好的体现了，你妻子想听鸟叫，无论什么鸟都可以给她，但是你想让她和鹦鹉说话，你就买了一只鹦鹉传给listen方法，结果你妻子听到了鹦鹉的叫声，程序输出：鹦鹉的叫声 */ public static void main(String[] args) { new Wife().listen(new Parrot()); } } /*多态实现了动态绑定，让程序有了很好的扩展性，比如你以后想买一只燕子送给你妻子，就只需要写个燕子类Swallow继承Bird方法就可以了，而不需要再在妻子类里添加一个方法listen(Swallow swallow) */

5.使用接口改写例6.8中的程序。

1 //Shapes接口 2 package runshape; 3 4 public interface Shapes { 5 public double getArea(); 6 public double getPerimeter(); 7 public void show(); 8 }

圆形类

1 package runshape; 2 3 public class Circle implements Shapes{ 4 private int r; 5 public Circle(int r){ 6 this.r=r; 7 } 8 9 public double getArea() { 10 return Math.PI*Math.pow(r, 2); 11 } 12 public double getPerimeter(){ 13 return 2*Math.PI*r; 14 } 15 16 public void show(){ 17 System.out.println("圆形:"); 18 System.out.println("圆的面积是"+this.getArea()); 19 System.out.println("圆的周长是"+this.getPerimeter()); 20 } 21 }

矩形类

1 package runshape; 2 3 public class Rect implements Shapes{ 4 private int height; 5 private int width; 6 public Rect(int height, int width){ 7 this.height=height; 8 this.width=width; 9 } 10 public double getArea(){ 11 return height*width; 12 } 13 public double getPerimeter(){ 14 return 2 * height + 2 * width; 15 } 16 public void show(){ 17 System.out.println("矩形:"); 18 System.out.println("矩形的面积是"+this.getArea()); 19 System.out.println("矩形的周长是"+this.getPerimeter()); 20 } 21 22 }

三角形类

1 package runshape; 2 3 public class Triangle implements Shapes { 4 private int x; 5 private int y; 6 private int z; 7 public Triangle(int x, int y, int z){ 8 this.x=x; 9 this.y=y; 10 this.z=z; 11 } 12 13 @Override 14 public double getArea() { 15 double m=(x+y+z)/2.0; 16 return Math.sqrt(m*(m-x)*(m-y)*(m-z)); 17 } 18 19 @Override 20 public double getPerimeter() { 21 return x+y+z; 22 } 23 24 public void show(){ 25 System.out.println("三角形:"); 26 System.out.println("三角形的面积是"+this.getArea()); 27 System.out.println("三角形的周长是"+this.getPerimeter()); 28 } 29 30 }

打印

1 package runshape; 2 3 public class RunShape { 4 public static void print(Shapes s){ 5 s.show(); 6 } 7 public static void main(String[] args) { 8 Rect rect=new Rect(25,25); 9 Triangle triangle=new Triangle(5,5,8); 10 Circle circle=new Circle(12); 11 12 //打印输出 13 print(rect); 14 15 print(triangle); 16 17 print(circle); 18 } 19 20 21 }

6.简述instanceof的使用场景

用instanceof判断一个对象是不是某个类或者其子类的实例，还可以将这个对象强制转换成这个类的类型。

public class Test { static class A{ } static class B extends A{ } public static void main(String[] args) { A a = new A(); B b = new B(); System.out.println( "a instanceof A 的结果:" + ( a instanceof A ) ); System.out.println( "b instanceof A 的结果:" + ( b instanceof A ) ); System.out.println(); System.out.println( "a instanceof B 的结果:" + ( a instanceof B ) ); System.out.println( "b instanceof B 的结果:" + ( b instanceof B ) ); System.out.println(); /* 注意: 下面用Object类对象引用某个类实例是实际应用中非常常见的 object instanceof class ,如果object 实际引用的对象实例是 class 的实例对象或者 class 的子类实例对象，则返回true 注意 “实际引用的对象实例” 这个词强调的'实际引用'. */ Object o = new A(); System.out.println( "o instanceof A 的结果:" + ( o instanceof A ) ); System.out.println( "o instanceof B 的结果:" + ( o instanceof B ) ); System.out.println(); o = new B(); System.out.println( "o instanceof A 的结果:" + ( o instanceof A ) ); System.out.println( "o instanceof B 的结果:" + ( o instanceof B ) ); System.out.println(); } }

------------恢复内容结束------------