学习java面向对象第三天：引用类型数组、继承、super、向上造型

1.引用类型数组：

1)Bomb[] bs = new Bomb[3];
  bs[0] = new Bomb(100,200);
  bs[1] = new Bomb(200,300);
  bs[2] = new Bomb(300,400);
  System.out.println(bs[0].width); //输出第1个炸弹的宽
  bs[1].x = 250; //修改第2个炸弹的x为250
  bs[2].move(); //第3个炸弹移动
  
  for(int i=0;i<bs.length;i++){ //遍历所有子弹
      System.out.println(bs[i].height); //输出每个子弹的高
      bs[i].move(); //每个子弹移动
  }
2)Bomb[] bs = new Bomb[]{ //了解
      new Bomb(100,200),
      new Bomb(200,300),
      new Bomb(300,400)
  };

2.继承：

• 作用：代码复用
• 通过extends来实现继承
• 超类/父类：共有的属性和行为
• 派生类/子类：特有的属性和行为
• 派生类即能访问自己的，也能访问超类的，但超类不能访问派生类的
• 一个超类可以有多个派生类
• 一个派生类只能有一个超类------单一继承
• 具有传递性
• java规定：
  派生类的构造方法中若没有调用超类的构造方法，则默认super（）调用超类的无参构造方法
  派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
  （super（）调用超类构造方法，必须位于派生类构造方法的第一行）

//super的演示
public class SuperDemo {
    public static void main(String[] args) {
        Boo o = new Boo();
    }
}
class Coo{
    Coo(int a){
    }
}
class Doo extends Coo{
    Doo(){
        super(5); //调用超类的有参构造
    }
    /*
    //如下代码为默认的:
    Doo(){
        super();
    }
     */
}

class Aoo{
    Aoo(){
        System.out.println("超类构造");
    }
}
class Boo extends Aoo{
    Boo(){
        //super(); //默认的，调用超类的无参构造
        System.out.println("派生类构造");
    }
}

3.super：指代当前对象的超类对象

super的用法：

• super.成员变量名------访问超类的成员变量
• super.方法名（）------调用超类的方法
• super（）----------------调用超类的构造方法

4.向上造型：------代码复用

• 超类型的引用指向了派生类的对象
• 能点出来什么，看引用的类型

package ooday03;
//向上造型的演示
public class UploadDemo {
    public static void main(String[] args) {
        Eoo o1 = new Eoo();
        o1.a = 1;
        o1.show();
        //o1.b = 2;  //编译错误
        //o1.test(); //编译错误，超类不能访问派生类的

        Foo o2 = new Foo();
        o2.b = 1;
        o2.test();
        o2.a = 2;  //正确
        o2.show(); //正确，派生类可以访问超类的

        Eoo o3 = new Foo(); //向上造型
        o3.a = 1;
        o3.show();
        //o3.b = 2;  //编译错误
        //o3.test(); //编译错误，能点出来什么，看引用的类型
    }
}

class Eoo{
    int a;
    void show(){
    }
}
class Foo extends Eoo{
    int b;
    void test(){
    }
}

补充：

1.继承意味着代码虽然我没有写，但也属于我，只是没有写在一起而已
2.泛化：将共有的抽出来的过程，泛化是设计层面的概念，从代码实现层面来说咱们就是继承，泛化就是继承
3.继承要符合is a(是一个)的关系