ArrayList类及子类继承

ArrayList

• 类, 用来存储数据, 可变长数组 -> 集合
  所属软件包: java.util
  数组长度不可变, 数组如果要扩容, 需要用到数组的复制
  为了解决数组长度不可变的问题, 可以实现数组长度动态变化。
  int[ ] Student[ ] int[ ] [ ] Room [ ][ ]
  ArrayList 仅支持引用类型
  1.构造方法
  空参构造器: 没有内容的空的集合
  ArrayList arrList = new ArrayList()
  : 泛型, 可以所有的引用类型, 规定集合中元素类型的
  基本数据类型都有对应的引用类型
  int -> Integer
  char -> Character
  byte -> Byte
  boolean -> Boolean
  double -> Double
  2.常用API
  void add(E e)
  E remove(int index): 移除掉index位置的元素, 并返回
  E get(int index)
  int size()
  3. < E >: 泛型, 规定集合中元素的类型
  没有规定泛型, 集合中的元素可以是任意类型
  所以使用get()之类的方法时, 就不能确定返回值类型
  所以, 使用集合时, 需要规定泛型

设计题：酒店管理系统

提取对象: 1个酒店, n个房间, 若干顾客
对象对应类
类: 成员变量 --> 构造方法
成员方法

Guest //顾客类

  package jiudianguanli;

/**
 * 顾客类
 */
public class Guest {
    String name;
    // --成员变量
    //名字
    Guest(String name){
        this.name=name;
    }
}

Room//房间类

package jiudianguanli;
/*
//房间类
*/
 
public class Room {
    int num;
    Guest guest;
    Room(int num){
        this.num=num;

    }
}

Hotel//酒店类

package jiudianguanli;



public class Hotel {
    //--成员变量
    //很多个房间
    Room[][] rooms = new Room[8][6];

    Hotel() {
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms[i].length; j++) {
                rooms[i][j] = new Room((i + 1) * 1000 + j + 1);
            }

        }
    }

    //--成员方法 - 功能
    //入住1001 lucy rooms[0][0]
    void in(int roomNum, String name) {
        int i = roomNum / 1000 - 1;
        int j = roomNum % 1000 - 1;
        //设置对应的房间顾客为name构造出来的Guest对象
        rooms[i][j].guest = new Guest(name);
        System.out.println(name + "成功入住" + roomNum);
    }

    //退房
    void out(int roomNum) {
        int i = roomNum / 1000 - 1;
        int j = roomNum % 1000 - 1;
        rooms[i][j].guest = null;
        System.out.println(roomNum + "成功退房");

    }
}

Main//主方法类

package jiudianguanli;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //程序开始
        System.out.println("欢迎进入酒店管理系统！");
        Hotel hotel = new Hotel();
        System.out.println(hotel.rooms[3][4].num);
        hotel.in(2003,"lucy");
        hotel.out(2003);
    }
}

运行结果：

飞机大战:

提取对象: 自己的飞机, 敌机, 小蜜蜂, 子弹

子类 extends 父类
自己的飞机:
发射的子弹, int life, int 分数
敌机:
int life
小蜜蜂:
int life
子弹:
以上类中相同的成员变量, 和相同的方法, 提取出来
父类:
int x, int y, 图片, int width, int height
move() - 移动

Animal 类 Dog 类 Cat 类

继承: extends
1.概念:子类/衍生类/扩展类: Dog
父类/基类: Animal
2.子类继承父类, 就继承了父类所有的成员变量和方法
3.所有的类, 都有唯一的父类,
如果没有写父类, 说明父类就是 Object
4.子类中还可以定义自己的独特的成员变量和方法
子类的功能一定比父类要强大

Animal类

package Animal;

public class Animal {
    String name;
   char sex;
    int leg;
    String kind;
    void zl(){
        System.out.println("这个动物叫"+kind);
    }
     void xm(){
         System.out.println("这只"+kind+"的名字叫"+name);
     }
     void eat(){
        System.out.println(name+"吃东西");
    }
    void hunt(){
        System.out.println(name+"捉老鼠");
    }
    void tui(){
        System.out.println(name+"有"+leg+"条腿");
    }
    void xb(){
        System.out.println(name+"是"+sex+"的");
    }
}

Dog类

package Animal;

public class Dog extends Animal {

    public static void main(String[] args) {

        Dog d=new Dog();
        d.kind="🐕";
        d.name="招财";
        d.sex='公';
        d.leg=4;
        d.zl();
        d.xm();
        d.xb();
        d.eat();
        d.tui();


    }
}

Cat类

package Animal;



public class Cat extends Animal{
    public static void main(String[] args) {
        Cat c=new Cat();
      c.kind="🐱";
        c.name="进宝";
        c.sex='母';
        c.leg=4;
        c.zl();
        c.xm();
        c.xb();
        c.hunt();
        c.eat();
        c.tui();



    }
}

运行结果

特殊情况:
1.子类中的成员变量和父类同名 name
Dog d = new Dog();
d.name -> 就是指自己定义的name,不是继承过来的name
结论: 父子类中的成员变量不要同名
2.子类中可以引用父类对象
super
3.创建子类对象之前, 会先创建父类对象
加载子类之前, 会先加载父类
4.构造方法: 父类的构造方法不能被子类继承的
创建子类对象, 会先默认调用父类的无参构造器
原因: 子类构造方法中, 第一行默认 super()
可以手动调用父类其他构造方法
结论: 子类构造方法中, 一定会先调用父类的构造方法
父类中, 建议先写无参构造器
5.通过子类对象调用方法时
先看子类中有没有定义这个方法, 定义了, 调用子类方法
子类中没有这个方法, 调用父类继承的方法

方法的重写\覆盖:

• 重写是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型不同（而不是引用类型）而调用不同的版本。

重写和重载的区别

重载与重写是完全不同的语法现象，区别如下：
• 重载Overload是指在一个类中定义多个方法名相同但参数列表不同的方法，在编译时，根据参数的个数和类型来决定绑定哪个方法。
• 重写Override是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型不同（而不是引用类型）而调用不同的版本。

abstract: - 抽象的

抽象方法: 方法没有方法体
一个类中, 存在抽象方法, 那么这个类就必须也是abstract
抽象类: 用abstract修饰的类
抽象类不能直接new对象
有构造方法, 为了给子类使用
抽象类的非抽象子类, 必须实现/重写抽象类的所有抽象方法
判断:
1.有抽象方法的类叫抽象类 √
2.抽象类就是有抽象方法的类 ×
3.抽象类中可以没有抽象方法 √