笔记：数组序章 2021-08-30

一、知识点

1、类名

简单类名：  SuperLinked
全类名：    com.lianxi.util.SuperLinked   （包名加类名）

2、包的引入

//该包下的内容全部引入
import com.lianxi.util.*;   
//只引入一个类
import com.lianxi.util.SuperLinked;

3、对象转型

强制转型：从父类的类型强制转为子类，如果传入的真的是该类型，则强转没有问题；如果不是就会报错。

合适的方法是使用instanceof 首先进行判断，确定类型之后再处理。

package com.lianxi.polymorphism;

/**
 * @author nnn
 * @date 2021/8/30
 **/
public class Girl {

    public void KeepAnimal(Animal animal){
        //使用instanceof 判断传进来的对象是不是一个Dog类型
        if(animal instanceof Dog){
            //强转成某一个子类
            Dog dog = (Dog)animal;
            dog.enjoy();
        }

        System.out.println("小姑娘开始给"+animal.getType()+"喂食。");
        //没有重写的方法，调用时就不叫多态
        animal.breathe();
        //重写了的方法会根据传入的实际的动物调用
        animal.eat();
    }
    public void buyCar(Carola car){
        System.out.println("小姑娘买车了！发动");
        car.run();
    }

}

4、泛型

  当某个类不知道自己内部处理的数据的真实类型时，可以使用泛型、方法是在类后加<T>，不一定是T，其他字母也行，但一般写成T或E。T就是个未知数，只有当你去new对象时指定了确定的类型时，代码里的T就会变为实际的类型，具体从代码里思考。

二、项目代码

package com.lianxi.util;

/**
 * @author nnn
 * @date 2021/8/30
 **/
public class SuperArray<T> extends Super<T> {

    //维护一个数组,要想什么都存，就要使用顶级父类
    private Object[] array;
    //当前最后一个数字的下边，要为-1 ，以为数组的第一个下标为0
    private int currentIndex = -1;

    //构造是初始化
    public SuperArray(){
        array = new Object[8];
    }

    //添加数据的方法
    public void add(T data){
        System.out.println("我是数组的实现！---add");
        currentIndex++;
        //自动扩容
        if(currentIndex > array.length-1){
            array = dilatation(array);
        }
        array[currentIndex] = data;
    }


    //根据下标查询数字
    public T get(int index){
        System.out.println("我是数组的实现---get");
        return (T)array[index];
    }

    //查看当前有多少个数字
    public int size(){
        return currentIndex + 1;
    }

    //数组扩容的方法
    private Object[] dilatation(Object[] oldArray){
        Object[] newArray = new Object[oldArray.length * 2];
        for (int i = 0; i < oldArray.length; i++) {
            newArray[i] = oldArray[i];
        }
        return newArray;
    }

    //验证下标是否合法
    private boolean validateIndex(int index) {
        //只要有一个不满足就返回false
        return index <= currentIndex && index >= 0;
    }

}

package com.lianxi.util;

/**
 * @author nnn
 * @date 2021/8/30
 **/
public class SuperLinked<T> extends Super<T> {

    private Node head = null;
    private Node tail = null;

    private int length = 0;

    //添加元素
    public void add(T data){
        System.out.println("我是链表的实现-----add");
        Node<T> node = new Node<>();
        node.setNum(data);
        if (length == 0) {
            //如果第一次添加一共就一个节点
            head = node;
        }else{
            //和尾巴拉手
            tail.setNextNode(node);
        }
        //把心添加进来的当成尾巴
        tail = node;
        length ++;
    }

    //根据下标查询数字,非常有意思的写法
    public T get(int index){
        System.out.println("我是链表的实现------get");
        if(index > length){
            return null;
        }
        //小技巧
        Node targetNode = head;
        for (int i = 0; i < index; i++) {
            targetNode = targetNode.getNextNode();
        }
        return (T)(targetNode.getNum());
    }

    //查看当前有多少个数字
    public int size(){
        return length;
    }

    class Node<T> {

        //存储的真实数据
        private T num;

        //写一个节点
        private Node nextNode = null;

        public T getNum() {
            return num;
        }

        public void setNum(T num) {
            this.num = num;
        }

        public Node getNextNode() {
            return nextNode;
        }

        public void setNextNode(Node nextNode) {
            this.nextNode = nextNode;
        }
    }
}

package com.lianxi.util;

/**
 * @author nnn
 * @date 2021/8/30
 **/
public abstract class Super<T> {

    /**
     * 标记所有的子类实现必须有add方法，添加数据
     * @param data
     */
    public abstract void add(T data);

    /**
     * 标记所有的子类实现必须有get方法，获取数据
     * @param index
     * @return
     */
    public abstract T get(int index);

    /**
     * 标记所有的子类实现必须有size方法，数据大小
     * @return
     */
    public abstract int size();

}