面向对象第三天：
潜艇游戏第一天：
- 设计6个类，设计World类并测试
潜艇游戏第二天：
- 给6个类添加构造方法，并测试
潜艇游戏第三天：
- 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
- 设计SeaObject超类，6个类继承SeaObject
- 给SeaObject设计两个构造方法，6个派生类分别调用
- 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为SeaObject数组，并测试
回顾：
-
构造方法：构造函数、构造器、构建器--------复用给成员变量赋值
- 作用：给成员变量赋初值
- 与类同名，没有返回值类型(连void)
- 创建对象时被自动调用
- 若自己不写构造，默认一个无参构造，若自己写了构造，则不再默认提供
- 可以重载
-
this：指代当前对象，哪个对象调用方法它指的就是哪个对象
this的用法：
this.成员变量名-------------------------访问成员变量
-
null：表示空，没有指向任何对象
若引用的值为null，则该引用不能进行任何操作了，若操作则发生 NullPointerException空指针异常
-
引用类型数组：
Bomb[] bs = new Bomb[3]; bs[0] = new Bomb(100,200); //1)new bs[1] = new Bomb(200,300); bs[2] = new Bomb(300,400); System.out.println(bs[0].width); //2)访问属性需打点
笔记：
-
引用类型数组：
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) }; -
继承：
-
作用：代码复用
-
通过extends来实现继承
-
超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
-
派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的
-
一个超类可以有多个派生类
一个派生类只能有一个超类-----------单一继承
-
具有传递性
-
java规定：构造派生类之前必须先构造超类
- 派生类的构造方法中若没有调用超类的构造方法，则默认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("派生类构造"); } }
-
-
super：指代当前对象的超类对象
super的用法：
- super.成员变量名----------------------访问超类的成员变量(了解)
- super.方法名()---------------------------调用超类的方法----------明天讲
- super()-------------------------------------调用超类的构造方法
-
向上造型：---------------------代码复用
- 超类型的引用指向了派生类的对象
- 能点出来什么，看引用的类型-----------这是规定，记住就OK了
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(){ } }
精华笔记：
-
引用类型数组：
-
继承：
-
作用：代码复用
-
通过extends来实现继承
-
超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
-
派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的
-
一个超类可以有多个派生类
一个派生类只能有一个超类-----------单一继承
-
具有传递性
-
java规定：构造派生类之前必须先构造超类
- 派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
- 派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
-
-
super：指代当前对象的超类对象
super的用法：
- super.成员变量名----------------------访问超类的成员变量(了解)
- super.方法名()---------------------------调用超类的方法----------明天讲
- super()-------------------------------------调用超类的构造方法
-
向上造型：---------------------代码复用
- 超类型的引用指向了派生类的对象
- 能点出来什么，看引用的类型-----------这是规定，记住就OK了
补充：
- 继承意味着代码虽然我没有写，但也属于我，只是没有写在一起而已
- 泛化：将共有的抽出来的过程，泛化是设计层面的概念，从代码实现层面来说咱们就是继承，泛化就是继承
- 继承要符合is a(是一个)的关系
面向对象第三天作业：
- 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
- 设计SeaObject超类，6个类继承SeaObject
- 给SeaObject设计两个构造方法，6个派生类分别调用
- 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为SeaObject数组，并测试
1.创建侦察艇数组、鱼雷艇数组、水雷艇数组、水雷数组、深水炸弹数组，并测试。
完整代码：
package day03;
/** 整个游戏世界 */
public class World {
public static void main(String[] args) {
ObserveSubmarine[] oses = new ObserveSubmarine[3];
TorpedoSubmarine[] tses = new TorpedoSubmarine[2];
MineSubmarine[] mses = new MineSubmarine[3]; //水雷潜艇数组
mses[0] = new MineSubmarine();
mses[1] = new MineSubmarine();
mses[2] = new MineSubmarine();
for(int i=0;i<mses.length;i++){ //遍历所有水雷潜艇
System.out.println(mses[i].x+","+mses[i].y); //输出每个水雷潜艇的x和y坐标
mses[i].move(); //每个水雷潜艇移动
}
Torpedo[] ts = new Torpedo[2]; //鱼雷数组
ts[0] = new Torpedo(100,200);
ts[1] = new Torpedo(200,400);
for(int i=0;i<ts.length;i++){
System.out.println(ts[i].x+","+ts[i].y);
ts[i].move();
}
Mine[] ms = new Mine[3];
Bomb[] bs = new Bomb[2];
}
}
//注:其余类没有变化，此处省略
2.创建SeaObject超类，6个类继承超类
完整代码：
package day03;
import java.util.Random;
//海洋对象
public class SeaObject {
int width;
int height;
int x;
int y;
int speed;
void move(){
System.out.println("海洋对象移动");
}
}
package day03;
//战舰
public class Battleship extends SeaObject {
int life;
Battleship(){
width = 66;
height = 26;
x = 270;
y = 124;
speed = 20;
life = 5;
}
}
package day03;
import java.util.Random;
//侦察潜艇
public class ObserveSubmarine extends SeaObject {
ObserveSubmarine(){
width = 63;
height = 19;
x = -width;
Random rand = new Random();
y = rand.nextInt(479-height-150)+150;
speed = rand.nextInt(3)+1;
}
}
package day03;
import java.util.Random;
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject {
TorpedoSubmarine(){
width = 64;
height = 20;
x = -width;
Random rand = new Random();
y = rand.nextInt(479-height-150)+150;
speed = rand.nextInt(3)+1;
}
}
package day03;
import java.util.Random;
//水雷潜艇
public class MineSubmarine extends SeaObject {
MineSubmarine(){
width = 63;
height = 19;
x = -width;
Random rand = new Random();
y = rand.nextInt(479-height-150)+150;
speed = rand.nextInt(3)+1;
}
}
package day03;
//水雷
public class Mine extends SeaObject {
Mine(int x,int y){
width = 11;
height = 11;
this.x = x;
this.y = y;
speed = 1;
}
}
package day03;
//深水炸弹
public class Bomb extends SeaObject {
Bomb(int x,int y){
width = 9;
height = 12;
this.x = x;
this.y = y;
speed = 3;
}
}
//注:其余类没有变化，此处省略
3.给SeaObject添加两个构造方法，6个类继承超类
完整代码：
package day03;
import java.util.Random;
//海洋对象
public class SeaObject {
int width;
int height;
int x;
int y;
int speed;
SeaObject(int width,int height){
this.width = width;
this.height = height;
x = -width;
Random rand = new Random();
y = rand.nextInt(479-height-150)+150;
speed = rand.nextInt(3)+1;
}
SeaObject(int width,int height,int x,int y,int speed){
this.width = width;
this.height = height;
this.x = x;
this.y = y;
this.speed = speed;
}
void move(){
System.out.println("海洋对象移动");
}
}
package day03;
//侦察潜艇
public class ObserveSubmarine extends SeaObject {
ObserveSubmarine(){
super(63,19);
}
}
package day03;
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject {
TorpedoSubmarine(){
super(64,20);
}
}
package day03;
//水雷潜艇
public class MineSubmarine extends SeaObject {
MineSubmarine(){
super(63,19);
}
}
package day03;
//战舰
public class Battleship extends SeaObject {
int life;
Battleship(){
super(66,26,270,124,20);
life = 5;
}
}
package day03;
//水雷
public class Mine extends SeaObject {
Mine(int x,int y){
super(11,11,x,y,1);
}
}
package day03;
//深水炸弹
public class Bomb extends SeaObject {
Bomb(int x,int y){
super(9,12,x,y,3);
}
}
//注:其余类没有变化，此处省略
4.将侦察艇数组、鱼雷艇数组、水雷艇数组组合为SeaObject数组，并测试：
package day03;
//整个游戏世界
public class World {
public static void main(String[] args) {
SeaObject[] submarines = new SeaObject[5]; //潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)
submarines[0] = new ObserveSubmarine();
submarines[1] = new ObserveSubmarine();
submarines[2] = new TorpedoSubmarine();
submarines[3] = new TorpedoSubmarine();
submarines[4] = new MineSubmarine();
for(int i=0;i<submarines.length;i++){
System.out.println(submarines[i].x+","+submarines[i].y);
submarines[i].move();
}
Battleship s = new Battleship();
Mine[] ms = new Mine[2];
ms[0] = new Mine(100,200);
ms[1] = new Mine(200,400);
for(int i=0;i<ms.length;i++){
System.out.println(ms[i].x+","+ms[i].y);
ms[i].move();
}
Bomb[] bs = new Bomb[2];
bs[0] = new Bomb(100,200);
bs[1] = new Bomb(200,400);
for(int i=0;i<bs.length;i++){
System.out.println(bs[i].x+","+bs[i].y);
bs[i].move();
}
}
}
//注:其余类没有变化，此处省略
