Katharsis_1
Java第五周作业下

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

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

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

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

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

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

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

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

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

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

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

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

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

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();
    }
}

 

 

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

posted on 2020-10-18 09:21  Katharsis_1  阅读(186)  评论(0)    收藏  举报

博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3 Powered By博客园