Java学习笔记6

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

//例6.4
public class SonAddClass extends AddClass {
    int a = 0, b = 0, c = 0;

    // 构造方法
    SonAddClass(int x) {
        super(x);
        a = x + 7;
    }

    SonAddClass(int x, int y) {
        super(x, y);
        a = x + 5;
        b = y + 5;
    }

    SonAddClass(int x, int y, int z) {
        super(x, y, z);
        a = x + 4;
        b = y + 4;
        c = z + 4;
    }

    public int add() {
        System.out.println("supper: x + y + z = " + super.add());
        return a + b + c;
    }

    public static void main(String[] args) {
        SonAddClass p1 = new SonAddClass(2, 3, 5);
        SonAddClass p2 = new SonAddClass(10, 20);
        SonAddClass p3 = new SonAddClass(1);

        System.out.println("a + b + c = " + p1.add());
        System.out.println("a + b + c = " + p2.add());
        System.out.println("a + b + c = " + p3.add());
    }
}


class AddClass {
    public int x = 0, y = 0, z = 0;

    // 构造方法
    AddClass(int x) {
        this.x = x;
    }

    AddClass(int x, int y) {
        this(x);
        this.y = y;
    }

    AddClass(int x, int y, int z) {
        this(x, y);
        this.z = z;
    }

    public int add() {
        return x + y + z;
    }
}

//例6.6
public class Construct extends Pare {
    int i = 8;

    Construct() {
    }

    Construct(int num) {
        this();
    }

    int getSuper() {
        return super.i;
    }

    public static void main(String[] args) {
        Construct ct = new Construct(9);
        System.out.println(ct.i);
        System.out.println(ct.getSuper());
    }
}

// 父类
class Pare {
    int i = 3;
    Pare() {}
}

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

运用类的组合，把一个类的引用作为另一个类的属性

class A{
  private B b;
  public void setB(B_b){
    if(_b!-null){b=_b}
  }
  public B getB(){
    if(b!=null){return b}
    else return null;
  }
}
class B{
  A a;
  public B(A aaa){
    this.a=aaa;
    aaa.setB(this);
}

③谈谈组合与继承的区别以及两者的使用场景

区别：继承是子类对父类的发展，组合是一个类把另一个类当作组件来用。
使用场景：

组合：需要保证类的安全性，不破坏封装，一个类只作为另一个类的组件。

继承：两个类具有发展关系，一个类是另一个类的具象化，是另一个类的特例。

④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) */

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

interface Shapes 
{  public double getArea();
   public double getPerimeter();
}
class Rect implements Shapes 
{ private int k;
  private int m;
  public Rect(int k, int m){
        this.k=m;
        this.k=m;
    }
  public double getArea()
	  { return(k*m); }
  public double getPerimeter()
	  { return(2*k+2*m);}
}
class Triangle implements Shapes
{   private int k;
    private int x;
    private int y;
    public Triangle(int k, int x, int y){
        this.k=k;
        this.x=x;
        this.y=y;
    }
    public double getArea()
    { double m=(x+y+z)/2.0;
      return(Math.sqrt(m*( m-k)*( m-x)*(m-y)));}
    public double getPerimeter()
	 {return(k+x+y);}
   }
class Circle implements Shapes
{   private int m;
    public Circle(int m){
        this.m=m;
    }
   public double getArea()
   //Math是java.lang包中的类，PI是静态其属性，其值为Π
		{return(m* m *Math.PI);}
    public double getPerimeter()
		{return(2*Math.PI* m);}
}
public class RunShape extends Applet
{ Rect rect=new Rect(5,15,25,25);
  Triangle tri=new Triangle(5,5,8);
  Circle cir =new Circle(13,90,25);
  public void paint(Graphics g)
  { 
	//绘制矩形，输出矩形的面积和周长
	g.drawRect(rect.x,rect.y,rect.k,(int)rect.m);
	g.drawString("Rect Area:"+rect.getArea(),50,35);
	g.drawString("Rect Perimeter:"+rect.getPerimeter(),50,55);
	//输出三角形的面积和周长
	g.drawString("Triangle Area:"+tri.getArea(),50,75);
	g.drawString("Triangle Perimeter:"+tri.getPerimeter(),50,95);
	//绘制圆，输出圆的面积和周长
    g.drawOval(cir.x-(int)cir.k/2,cir.y-(int)cir.k/2,cir.k,cir.k);	
    g.drawString("Circle Area:"+cir.getArea(),50,115);
	g.drawString("Circle Perimeter:"+cir. getPerimeter(),50,135); 
  }
}

⑥简述运算符instanceof的使用场景。

boolean result = a instanceof B
如果a是B的实例化对象或者B的子类的实例对象，返回ture，
否则返回false。
当需要判断指定 对象(实际引用的对象实例) 是否是 指定类或者指定类的子类 的实例时，使用运算符instanceof