实训十五天 继承（final、object）

1.学习重点

1.final关键字

2.重写注释

3.object祖先类

4.超级数组

2.学习心得

今天结束了继承的学习，感觉如果单独看继承这个知识点，还是能理解的，但是今天做了几个小案例，还是没有头绪啊！身边的大佬们都开始研究链和栈了，我也要加把劲啊！

3.学习内容

final关键字

最终的，终极的

---

final可以修饰的结构

1.类 public final class
最终类，终极类
修饰后无法被子类继承（String，Math）

2.属性 private final String name
常量，不能改变
常量的命名规则：单词的所有字母都大写
常量不能只声明不赋值

3.方法 private final void show
修饰后无法被重写

---

方法的重写： @Override 注释
我们建议在方法的重写处表明重写的注释

---

Object

祖先类（最顶级父类）
如果一个类没有明确的写出它的父亲是谁，那它的父类就是Object

Object类中的11个方法
1.hashCode():它的返回值实际上就是对象运行时的内存地址
hash算法：一般翻译”散列“，把任意长度的输入，通过一个散列算法变换成固定长度的输出，输出结果就是散列值（哈希值）
密码加密MD5 SHA家族
2.equals():和==没区别，比地址，为了让子类重写
3.toString():转换成字符串，当我们直接使用对象时，会默认调用toString，为了让子类重写
4.finalize():垃圾回收的方法
5.clone():克隆，必须实现Cloneable接口

---

案例：

信息录入：
录入老师信息，身份证号相同的就是同一个人。重写toString方法
录入学生信息，身份证号相同的就是同一个人。重写toString方法
一个老师教多个学生。
分析：使用，has，is
老师类中，有一个teach方法，最终会展示出他教哪些学生。
学生类中，有一个study方法，最终会展示出他跟着哪个老师学习。
学校类，有很多老师，很多学生，最终会展示出哪些老师和哪些学生。
在Demo类中测试相关功能！
1.创建一个老师，再来一个老师，比较一下。
2.学生比较。
3.老师教的学生信息

Person类

public class Person {

    private String name;
    private Integer age;
    private String cardId;

    public Person() {
    }

    public Person(String name, Integer age, String cardId) {
        this.name = name;
        this.age = age;
        this.cardId = cardId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    @Override
    public boolean equals(Object obj) {
        Person person = (Person) obj;
        if(this == person){
            return true;
        }
        if(this.cardId.equals(person.cardId)){
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", cardId='" + cardId + '\'' +
                '}';
    }
}

Student类

public class Student extends Person {

    private String stuNo;

    private Teacher teacher;

    public Student() {
    }

    public Student(String name, Integer age, String cardId, String stuNo, Teacher teacher) {
        super(name, age, cardId);
        this.stuNo = stuNo;
        this.teacher = teacher;
    }

    public String study(){
        return this + "，\n 老师是：" + teacher;
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return super.toString() + "Student{" +
                "stuNo='" + stuNo + "}";
    }
}

Teacher类

public class Teacher extends Person {

    private String teaNo;

    private Student [] stus;

    public Teacher() {
    }

    public Teacher(String name, Integer age, String cardId, String teaNo) {
        super(name, age, cardId);
        this.teaNo = teaNo;
    }

    public String teach() {

        return this + "，\n" + Arrays.toString(stus);
    }

    public String getTeaNo() {
        return teaNo;
    }

    public void setTeaNo(String teaNo) {
        this.teaNo = teaNo;
    }

    public Student[] getStus() {
        return stus;
    }

    public void setStus(Student[] stus) {
        this.stus = stus;
    }

    @Override
    public String toString() {
        return super.toString() + "Teacher{" +
                "teaNo='" + teaNo;
    }
}

School类

public class School {

    private Teacher [] teacher;

    private Student [] students;

    public Teacher[] getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher[] teacher) {
        this.teacher = teacher;
    }

    public Student[] getStudents() {
        return students;
    }

    public void setStudents(Student[] students) {
        this.students = students;
    }

    public void showTeachers() {
        // 老师和他对应的学生的信息
        for (Teacher teacher1 : teacher) {
            System.out.println(teacher1.teach());
        }
    }
    public void showStudents() {
        // 学生和他对应的老师的信息
        for (Student student : students) {
            System.out.println(student.study());
        }
    }
}

---

超级数组

public class SuperArray {

    // 维护一个数组，要考虑的是怎么存
    private Integer [] array;

    // 超级数组的长度
    private int size;

    // 数组当前的容量
    private int capacity;

    public SuperArray(){
//        array = new Integer[10];
        this(10);
//        capacity = 10;
    }

    public SuperArray(int capacity){
        array = new Integer[capacity];
        this.capacity = capacity;
    }

    // 添加数据，默认添加，在数组的尾部添加
    public void add(Integer data) {
        // 添加时要确保容量足够，如果不够，就需要扩容
        ensureCapacity(size + 1);
        // 真正的添加数据
        array[size++] = data;

    }
    // 添加数据，传入两个参数
    // 在指定位置添加
    public void add(int index,Integer data){
        if(rangeCheck(index)){
            ensureCapacity(size + 1);
            System.arraycopy(array,index,array,index + 1,size - index);
            // 真正的添加数据
            array[index] = data;
            size++;
        }

    }

    // 获取超级数组的长度
    public int size(){

        return size;
    }

    // 获取指定下标的元素
    public Integer get(int index) {
        // 判断一下index和合法性
        if(rangeCheck(index)){
            return array[index];
        }
        return null;
    }

    private boolean rangeCheck(int index) {
        // index >= 0
        // index <= size - 1
        return (index >=0 && index <= size - 1);
    }

    public void change(int index,Integer data){
        if(rangeCheck(index)){
            array[index] = data;
        }
    }

    // 这个方法只在当前类使用，所以声明成private
    private void ensureCapacity(int needCapacity) {
//        System.out.println(needCapacity + "-----" + capacity);
        if(needCapacity > capacity){
            // 1.5倍
            capacity = capacity + (capacity >> 1);
            //  创建一个新的扩容好的数组
            Integer [] newArray = new Integer[capacity];
            // 把原数组的数据拷贝过来
            /*
                src：原数组
                srcPos：拷贝原始数组的起始位置
                dest：目标数组
                destPos：目标数组的起始位置
                length：拷贝数据的长度
             */
            System.arraycopy(array,0,newArray,0,array.length);
            array = newArray;
        }
    }

}

标签：return,String,23,张鑫,name,teacher,cardId,public,07
来源： https://www.cnblogs.com/zxscj/p/16513074.html