oop面向对象第8天

功能步骤:
1.画对象:
1)FlyingObject父类设计抽象方法getImage()
2)所有子类重写getImage()
3)FlyingObject父类设计普通方法paint(g)
4)Sky类重写FlyingObject类的paint(g)
5)World类重写paint(g)方法，调用对象的paint()
2.敌人入场:
1)World类设计nextOne()方法实现随机生成敌人对象
2)action()中做定时器，定时调用enterAction()实现敌人入场
3)enterAction()调用生成敌人、扩容、赋到最后一个元素

3.飞行物移动:
1)FlyingObject类中设计抽象方法step()
2)子类重写step()
3)World类的定时器中，调用stepAction()
4)stepAction()调用对象的step()
4.子弹入场:
1)Hero类中设计shoot()发射子弹的方法(创建子弹对象)
2)World类的定时器中，调用shootAction()
3)shootAction()调用shoot()发射子弹、扩容、数组追加
5.英雄机随着鼠标移动:
1)Hero类中设计moveTo()随着鼠标而移动的方法
2)侦听器中重写mouseMoved()鼠标移动方法，
调用Hero的moveTo()方法
6.删除越界的飞行物:
1)FlyingObject类中设计抽象方法outOfBounds()
2)子类重写outOfBounds()
3)World类中定时器中，调用outOfBoundsAction()
4)outOfBoundsAction()删除越界的敌人和子弹
7.子弹与敌人的碰撞:
1)Enemy接口，Airplane和BigAirplane实现Enemy接口
Award接口，Bee实现Award接口
2)FlyingObject类中设计hit()方法实现碰撞的检测
3)FlyingObject类中设计goDead()方法修改为死去的状态
4)Hero类中设计addLife()和addDoubleFire()
5)World类中定时器中，调用bulletBang()
6)bulletBang()判断碰撞，撞上删除并得东西(分，命，火力)
8.画分和画命:
1)Hero类中设计getLife()
2)World类中的paint()方法中画分和画命

练习:-------------------至少完成两次
1.保证程序的正常运行
2.完成子弹与敌人的碰撞
3.完成画分和画命

设计规则:
1)将所有子类共有的属性和行为，抽象到父类中
2)所有子类行为都一样时，设计为普通方法
所有子类行为都不一样时，设计为抽象方法
3)部分子类共有的行为，抽象到接口中
接口是对继承的单根性的扩展-------实现多继承
符合既是也是原则时，应使用接口

笔记:
1.接口:
1)是一种数据类型(引用类型)
2)由interface定义的
3)接口中只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现(继承)的，实现类(子类):
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号分隔
若又继承又实现时，应先继承后实现
7)接口可以继承接口

一个好的设计者，绝不应该仅仅只看当前的需求

2.多态:
1)多态的意义:
1.1)同一类型的引用，在指向不同的对象时，有不同的实现
---------行为的多态:cut(),run()
1.2)同一个对象，被造型为不同的类型时，有不同的功能
---------对象的多态:我,水
2)向上造型:
2.1)父类型的引用指向子类的对象
2.2)能造型成为的类型有: 父类+所实现的接口
2.3)能点出来什么，看引用的类型
3)强制类型转换，成功的条件有两种:
3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现了该接口
4)强转时若不符合如上两个条件，
则发生ClassCastException类型转换异常，
建议在强转之前先通过instanceof来判断
引用指向的对象是否是该类型

画分和画命

//子弹与敌人的碰撞
public void bulletBang(){
for(int i=0;i<bullets.length;i++){
Bullet b = bullets[i];
for(int j=0;j<enemies.length;j++){
FlyingObject f = enemies[j];
if(b.isLife() && f.isLife() && f.hit(b)){ //撞上了
b.goDead();
f.goDead();

//Airplane(1)
//BigAirplane(3)
//BigYellowBee(6)
if(f instanceof Enemy){ //敌人能得分的
Enemy e = (Enemy)f;
score += e.getScore();
}
//Bee,BigYellowBee
if(f instanceof Award){ //能得奖励的
Award a = (Award)f;
int type = a.getType();
switch(){
...
}
}

}
}
}
}

子弹与敌人的碰撞:
1.判断是否撞上了---FlyingObject碰撞算法hit()，返回boolean类型
2.若为true，则表示撞上了:
1)子弹消失、敌人消失-----goDead()
2)得分或得奖励(英雄机增命addLife()、英雄机增火力addDoubleFire())

运行结果:
1)子弹与敌人消失
2)英雄机得火力

1)子弹与敌人的碰撞
2)英雄机与敌人的碰撞

class FlyingObject{
碰撞(子弹/英雄机)------敌人和子弹撞/英雄机撞

public boolean hit(FlyingObject obj){
//this:敌人 obj:子弹/英雄机
}

}

子弹与敌人(小敌机+大敌机+小蜜蜂)的碰撞:
1)碰撞的行为既是子弹行为也是敌人行为也是英雄机行为
--------------碰撞行为

class Bullet{
碰撞------与敌人撞
}
class FlyingObject{
碰撞------与子弹撞+与英雄机撞
public boolean hit(FlyingObject obj){
//this:敌人
//obj:子弹、英雄机
}
public boolean hit(Bullet b){
...
}
public boolean hit(Hero h){
...
}
}
class Hero{
碰撞------与敌人撞
}

英雄机与敌人(小敌机+大敌机+小蜜蜂)的碰撞:

为什么要造型，造型之后为什么还要强转回来

Aoo o1 = new Boo(); //向上造型(自动类型转换)
Boo o2 = (Boo)o1; //符合条件1
Inter1 o3 = (Inter1)o1; //符合条件2
Coo o4 = (Coo)o1; //ClassCastException类型转换异常
if(o1 instanceof Coo){ //false
Coo o5 = (Coo)
}

System.out.println(o1 instanceof Boo); //true
System.out.println(o1 instanceof Inter1); //true
System.out.println(o1 instanceof Coo); //false

interface Inter1{}
class Aoo{}
class Boo extends Aoo implements Inter1{}
class Coo extends Aoo{}

 

基本类型的强制类型转换，有可能溢出或精度丢失

 

 

步骤:
1)设计接口Enemy，包含getScore():
1.1)小敌机Airplane，实现Enemy接口，重写getScore()
1.2)大敌机BigAirplane，实现Enemy接口，重写getScore()
2)设计接口Award，包含DOUBLE_FIRE,LIFE,getType():
2.1)小蜜蜂Bee，实现Award接口，重写getType()

子弹打的是小敌机----------玩家得1分
子弹打的是大敌机----------玩家得3分
----------得分这个行为，小敌机有，大敌机有
----------将得分设计在接口中(部分子类共有)

子弹打的是小蜜蜂----------玩家得奖励
子弹打的是大黄蜂----------玩家得奖励
----------得奖励这个行为，小蜜蜂有
----------将得奖励设计在接口中(部分子类共有)