0
点赞
收藏
分享

微信扫一扫

ooday03 2022.01.12 面向对象第三天

蓝哆啦呀 2022-01-12 阅读 24
java

在这里插入图片描述

面向对象第三天：

潜艇游戏第一天：

  1. 设计6个类，设计World类并测试

潜艇游戏第二天：

  1. 给6个类添加构造方法，并测试

潜艇游戏第三天：

  1. 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
  2. 设计SeaObject超类，6个类继承SeaObject
  3. 给SeaObject设计两个构造方法，6个派生类分别调用
  4. 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为SeaObject数组，并测试

回顾：

  1. 构造方法：构造函数、构造器、构建器--------复用给成员变量赋值

    • 作用：给成员变量赋初值
    • 与类同名，没有返回值类型(连void)
    • 创建对象时被自动调用
    • 若自己不写构造，默认一个无参构造，若自己写了构造，则不再默认提供
    • 可以重载

  2. this：指代当前对象，哪个对象调用方法它指的就是哪个对象

    this的用法：

    this.成员变量名-------------------------访问成员变量

  3. null：表示空，没有指向任何对象

    ​ 若引用的值为null，则该引用不能进行任何操作了，若操作则发生 NullPointerException空指针异常

  4. 引用类型数组：

    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. 引用类型数组：

    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的演示
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. 向上造型：---------------------代码复用

    • 超类型的引用指向了派生类的对象
    • 能点出来什么，看引用的类型-----------这是规定，记住就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(){
    }
}

精华笔记：

  1. 引用类型数组：

  2. 继承：

    • 作用：代码复用

    • 通过extends来实现继承

    • 超类/父类：共有的属性和行为

      派生类/子类：特有的属性和行为

    • 派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的

    • 一个超类可以有多个派生类

      一个派生类只能有一个超类-----------单一继承

    • 具有传递性

    • java规定：构造派生类之前必须先构造超类

      • 派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
      • 派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

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

    super的用法：

    • super.成员变量名----------------------访问超类的成员变量(了解)
    • super.方法名()---------------------------调用超类的方法----------明天讲
    • super()-------------------------------------调用超类的构造方法

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

    • 超类型的引用指向了派生类的对象
    • 能点出来什么，看引用的类型-----------这是规定，记住就OK了

补充：

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

面向对象第三天作业：

  1. 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
  2. 设计SeaObject超类，6个类继承SeaObject
  3. 给SeaObject设计两个构造方法，6个派生类分别调用
  4. 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为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();
        }
    }
}

//注:其余类没有变化，此处省略
举报

相关推荐

ooday03

java

第三天

单片机c语言51单片机单片机/工控嵌入式

#第三天

关键字指针C/C++编程语言

【JavaSE 第三天】

java开发语言后端

Ajax第三天

ajaxjavascript前端

学习第三天

倍增跑路货车运输对应原理相关速度编程语言

第三天打卡

leetcode

RHCA第三天

运维

出差第三天

百度数据遥感图像Java编程语言

第三天学习

学习csshtml
0 条评论