Java day06——集合、继承、重写、抽象、设计酒店管理系统

集合

ArrayList - 类, 用来存储数据, 可变长数组 -> 集合

• 因为数组长度不可变, 数组如果要扩容, 需要用到数组的复制
• 为了解决数组长度不可变的问题, ArrayList可以实现数组长度动态变化
• ArrayList 仅支持引用类型

构造方法

空参构造器: 没有内容的空的集合
ArrayList< E> arrList = new ArrayList< E>()
< E>: 泛型, 可以所有的引用类型, 规定集合中元素类型的
基本数据类型都有对应的引用类型
int -> Integer
char -> Character
byte -> Byte
boolean -> Boolean
double -> Double

常用API

void add(E e)增加

		ArrayList<String> list = new ArrayList();
 		// 向集合中添加元素, 参数: 要加的元素
        list.add("haha");
        list.add("heihei");

E remove(int index): 移除掉index位置的元素, 并返回值

		// 从集合中删除元素, 参数: 下标
        String remove = list.remove(4);
        System.out.println(list);

E get(int index)获得元素

		// 从集合中获得元素  arr[3]
        String get = list.get(3);

int size()获得元素个数/长度

		// 获得集合中元素的个数 - 长度
        int size = list.size();

< E> 泛型

< E>: 泛型, 规定集合中元素的类型
没有规定泛型, 集合中的元素可以是任意类型
所以使用get()之类的方法时, 就不能确定返回值类型
所以, 使用集合时, 需要规定泛型想

继承extends

要点

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

特殊情况

1. 子类中的成员变量和父类同名 name
   Dog d = new Dog();
   d.name -> 就是指自己定义的name,不是继承过来的name
   结论: 父子类中的成员变量不要同名
2. 子类中可以引用父类对象，用 super

Dog(String name) {
      super(); // 默认调用父类无参构造方法
      super.name = name;
      this.name = "小强";
      System.out.println("Dog有参构造器");
  }

3. 创建子类对象之前, 会先创建父类对象
   加载子类之前, 会先加载父类
4. 构造方法: 父类的构造方法不能被子类继承的
   创建子类对象, 会先默认调用父类的无参构造器
   原因: 子类构造方法中, 第一行默认 super()
   可以手动调用父类其他构造方法

  Dog(){
      // 调用父类有参构造方法
      super("");
      System.out.println("Dog空参构造器");
  }
  Dog(String name){
      super(); // 默认调用父类无参构造方法
      super.name = name;
      this.name = "小强";
      System.out.println("Dog有参构造器");
  }

结论: 子类构造方法中, 一定会先调用父类的构造方法
父类中, 建议先写无参构造器
5. 通过子类对象调用方法时
先看子类中有没有定义这个方法, 定义了, 调用子类方法
子类中没有这个方法, 调用父类继承的方法

方法重写/覆盖

子类中定义的方法, 方法返回值类型\方法名\参数列表都和父类中定义的方法完全一致

public class Animal{
	void eat(){
        System.out.println(this.name + "在吃好吃的!");
    }
}
public class Dog extends Animal{
	void eat(){
        // 子类自己的功能
        System.out.println(this.name + "舔舔小爪子!");
        // 和父类中的eat方法一致
        super.eat();
        // 子类自己的功能
        System.out.println(this.name + "舔舔嘴巴!");
    }
}

抽象

例：飞机大战:
提取的父类: move()
move() 在所有的子类中都要重写, 父类中的move()方法体就没有意义
方法 -> 抽象方法 abstract

抽象方法

方法没有方法体
一个类中, 存在抽象方法, 那么这个类就必须也是abstract

public abstract class FlyObject {
   int x;
   int y;
   FlyObject() {
       System.out.println();
   }
   // 公共部分, 为了让所有的子类统一
   // 父类方法体没有意义 - 抽象方法
   abstract void move();
}

抽象类

用abstract修饰的类
有构造方法, 为了给子类使用

public abstract class Airplane extends FlyObject {
 	FlyObject() {
        System.out.println();
    }
}

抽象类不能实例化，不能直接new对象
抽象类的非抽象子类, 必须实现/重写抽象类的所有抽象方法，否则会报错

public class Hero extends FlyObject {
    int score;
    //重写抽象类的抽象方法
    void move() {
        System.out.println("英雄机跟着鼠标动, 发射");
    }
}
public static void main(String[] args) {
        // 抽象类不能直接new对象
		//FlyObject fly = new FlyObject();
		//抽象类的非抽象子类可以new对象
        Hero hero = new Hero();
        hero.move();

判断√

• 有抽象方法的类叫抽象类 √
  （类中如果有抽象方法，类就一定是抽象类）
• 抽象类就是有抽象方法的类 ×
• 抽象类中可以没有抽象方法 √

设计酒店管理系统

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