oo.day07

Shoot射击游戏第一天:
1.创建了6个对象类，并创建World类测试

Shoot射击游戏第二天:
1.给6个对象类添加构造方法，并测试

Shoot射击游戏第三天:
1.设计小敌机、大敌机、小蜜蜂、子弹数组，并测试
2.设计FlyingObject超类，6个对象类分别继承
3.给FlyingObject超类设计两个构造方法，对象类分别调用

Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组，并测试
2.在6个对象类中重写超类的step()移动
3.画窗口

Shoot射击游戏第五天:
1.给类中的成员添加访问控制修饰符
2.给6个对象类添加图片属性

Shoot射击游戏第六天:
1.设计窗口的宽和高为常量，适当地方做修改
2.画对象:
  1)想画对象需要获取对象的图片，每个对象都能获取图片，
    意味着获取图片行为为共有的行为，所以设计在超类中，
    每个对象获取图片的行为都是不一样的，所以设计为抽象方法
    ----在FlyingObject中设计抽象方法getImage()用于获取图片
  2)在获取图片时，因为不同的状态下需要获取不同的图片，
    所以需要去考虑对象的状态，每个对象都有状态，为共有的，
    所以将状态设计在超类中，状态一般都是常量
    ----在FlyingObject中设计三个常量，state变量表示当前状态
    在获取图片时，需要去判断对象的状态，
    每个对象都得判断，为共有的，所以设计在超类中，
    每个对象判断状态的行为都是一样的，所以设计为普通方法
    ----在FlyingObject中设计isLife()、isDead()、isRemove()
  3)重写FlyingObject的getImage():
    3.1)天空Sky，直接返回image即可
    3.2)子弹Bullet:
        3.2.1)若活着呢，直接返回image即可
    3.2.2)若死了的，直接删除
    3.3)英雄机Hero:
        3.3.1)若活着呢，返回images[0]和images[1]切换
    3.4)小敌机Airplane:
        3.4.1)若活着呢，直接返回images[0]即可
    3.4.2)若死了的，返回images[1]到images[4]轮换，4之后则删除
    3.5)大敌机Airplane:
        3.4.1)若活着呢，直接返回images[0]即可
    3.4.2)若死了的，返回images[1]到images[4]轮换，4之后则删除
    3.6)小蜜蜂Airplane:
        3.4.1)若活着呢，直接返回images[0]即可
    3.4.2)若死了的，返回images[1]到images[4]轮换，4之后则删除
  4)前面3步准备好图片之后，可以开画了，
    每个对象都能画，所以将画对象的行为设计在超类中，
    每个对象画的方式都是一样的，所以设计为普通方法
    ----在FlyingObject中设计普通方法paintObject()实现画对象
  5)天空每次需要画2张图，所以重写超类的paintObject()
    ----在Sky中重写paintObject()画对象
  6)在World类中重写paint()----调用paintObject()即可

Shoot射击游戏第七天:
1.敌人入场:
  1)敌人是由窗口创建的，所以在World类中设计nextOne()生成敌人对象
  2)敌人入场为定时发生的，在run()中调用enterAction()实现敌人入场
    在enterAction()中:
      每400毫秒，获取敌人，enemies扩容，装到最后元素上
2.子弹入场:
  1)子弹是由英雄机发射出来的，所以在Hero类中设计shoot()生成子弹对象
  2)子弹入场为定时发生的，在run()中调用shootAction()实现子弹入场
    在shootAction()中:
      每300毫秒，获取子弹，bullets扩容，数组的追加
3.飞行物移动:
  1)飞行物移动为所有派生类所共有的行为，设计在超类中
    因所有派生类行为不同，所以设计为抽象step()实现飞行物移动
    所有派生类中重写抽象step()方法
  2)飞行物移动为定时发生的，在run()中调用stepAction()实现飞行物移动
    在stepAction()中:
      天空动，遍历敌人敌人动，遍历子弹子弹动

回顾:
1.static final常量:
    必须声明同时初始化、类名点来访问，不能被改变、大写
    编译器在编译时自动转换为具体的值，效率高
    何时用:数据永远不变，并且经常使用
2.抽象方法:
    abstract，只能方法的定义，没有具体的实现
3.抽象类:
    abstract，包含抽象方法的类必须是抽象类
    抽象类是不能被实例化的，需要被继承的，派生类:
      1)重写所有抽象方法
      2)也声明为抽象类
    抽象类的意义:
      封装共有的属性和行为----------代码复用
      为所有派生类提供统一的类型----向上造型
      可以包含抽象方法，为所有派生类提供统一的入口
        派生类的具体行为不同，但入口是一致的

设计规则:
1)将派生类所共有的属性和行为，抽到超类中----抽共性
2)所有派生类的行为都一样，设计为普通方法
  所有派生类的行为都不一样，设计为抽象方法
3)

笔记:
1.成员内部类:应用率低，了解
  1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类
  2)内部类通常只服务于外部类，对外不具备可见性
  3)内部类对象通常只在外部类中创建
  4)内部类中可以直接访问外部类的成员(包括私有的)
    内部类中有隐式的引用指向了创建它的外部类对象
      eg: 外部类名.this.
2.匿名内部类:
  1)若想创建一个类(派生类)的对象，并且对象只被创建一次，
    此时该类不必命名，称为匿名内部类
  2)匿名内部类中若想访问外面的变量，该变量必须是final的(JDK1.7(含)以前)

面试题:
问:内部类有独立的.class吗?
答:有

功能实现的步骤:
1)先写行为:
  1.1)为对象所特有的行为，将其设计在特定的类中
  1.2)为所有对象所共有的行为，将其设计在超类中
2)页面调用:
  2.1)定时触发的，在定时器中调用
  2.2)事件触发的，在侦听器中调用

当程序的运行结果与你所预期的结果不同时:
1)打桩: System.out.println(数据);
2)Debug调试工具

定时，多线程

5+1-----------加1
5+(-1)--------减1

int shootIndex = 0;
public void shootAction() { //10毫秒
  shootIndex++;
  if(shootIndex%30==0){ //300毫秒
    Bullet[] bs = hero.shoot();
    bullets = Arrays.copyOf(bullets,bullets.length+bs.length);
    System.arraycopy(bs,0,bullets,bullets.length-bs.length,bs.length); //数组的追加
  }
}

class Hero{
  public Bullet[] shoot(){ //生成子弹对象(英雄机发射子弹)
    int xStep = this.width/4; //1/4英雄机的宽
    int yStep = 20;
    if(doubleFire>0){ //双
      Bullet[] bs = new Bullet[2];
      bs[0] = new Bullet(this.x+1*xStep,this.y-yStep); 
      bs[1] = new Bullet(this.x+3*xStep,this.y-yStep); 
      doubleFire-=2;
      return bs;
    }else{ //单
      Bullet[] bs = new Bullet[1];
      bs[0] = new Bullet(this.x+2*xStep,this.y-yStep); 
      return bs;
    }
  }
}

int enterIndex = 0; //计数器
public void enterAction() { //10毫秒走一次
  enterIndex++; //每10毫秒增1
  if(enterIndex%40==0){ //400(40*10)毫秒走一次
    FlyingObject obj = nextOne();
    enemies = Arrays.copyOf(enemies,enemies.length+1);
    enemies[enemies.length-1] = obj;
  }
}

paint()方法的调用方式:
1)frame.setVisible(true);
2)repaint();

假设有5个敌人了，又来了一个敌人

敌人入场:
子弹入场:
飞行物移动:

  //生成敌人(小敌机、大敌机、小蜜蜂)对象
  public FlyingObject nextOne(){
    Random rand = new Random();
    int type = rand.nextInt(20); //0到19
    if(type<4){ //0到3
      return new Bee();
    }else if(type<12){ //4到11
      return new Airplane();
    }else{ //12到19
      return new BigAirplane();
    }
  }

    Random rand = new Random();
    int type = rand.nextInt(3); //0到2
    if(type==0){
      return new Bee();
    }else if(type==1){
      return new Airplane();
    }else{
      return new BigAirplane();
    }

?处设计为什么类型:
  既能接收小敌机对象，
  也能接收大敌机对象，
  也能接收小蜜蜂对象

敌人入场:
  敌人是由窗口产生的，所以行为设计在窗口类中

子弹入场:
  子弹是由英雄机产生的，所以行为设计在英雄机类中

飞行物移动:
  飞行物移动为共有的行为，所以行为设计在超类中

1)敌人入场
2)子弹入场
3)飞行物移动

              TimerTask,            long,long
timer.schedule(new TimerTask(){
  public void run(){ //定时干的那个事--每10毫秒走一次
    //敌人入场，子弹入场，飞行物移动
    //...
    //...
  }
},10,10);

class Aoo extends ?{
  
}

第1个10:从程序启动到第一次触发的时间间隔
第2个10:从第一次触发到第二次触发的时间间隔
        从第二次触发到第三次触发的时间间隔
    从第三次触发到第四次触发的时间间隔
    ...

字母、数字、_和$符

Mama$Baby.class
NstInnerClassDemo$1.class
NstInnerClassDemo$2.class
NstInnerClassDemo$3.class

jdk1.0/1.1/1.2/1.3/1.4/1.5/1.6/1.7-----内存几乎没变
jdk1.8---------------------------------几存做了改变

Aoo o1 = new Aoo();
Boo o2 = new Boo(); //编译错误

class Aoo{
  private int a;
  void create(){
    Boo o = new Boo();
  }
  class Boo{
    void test(){
      System.out.println(a);
      System.out.println(Aoo.this.a);
      System.out.println(this.a); //编译错误
    }
  }
}

项目功能:
1)敌人入场
2)子弹入场
3)飞行物移动