Fork me on GitHub

JavaSE Day10 继承 final

目录

继承

定义

根据已有的类 派生出新类的技术；

作用：

  1. 代码重用
  2. 方便维护
  3. 高耦合===类之间的紧密连接程度；
package day10;
//父类，超类，基类
public class Teacher {
    private String name;
    public Teacher(){
        this.name = name;
        System.out.println("父类构造");
    }
    public String getName() {
        return name;
    }

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

    public void getLesson() {
        System.out.println("将数学课");
    }
}

class SqlTeacher {
    public void dance(){
        System.out.println("跳舞");
    }
}

class JavaTeacher extends Teacher {
    //String name;// 覆盖了父类的属性；
    String tattoo;

    JavaTeacher(){
        System.out.println("子类构造");
    }
    public void sing(){
        System.out.println(getName()+"唱歌");
    }

    public void display(){
        super.getLesson();
    }
    public void getLesson() {
        System.out.println(getName()+"将java课");
    }
}

java只支持单继承，不允许多继承；

也就是只有一个父类

子类：

  1. 子类可以继承父类的成员（属性和方法）
  2. 也可以有自己的独特的成员；

注意

  1. 有些成员不能继承；
    • 私有的不能被继承；（不能调用父类属性；）
    • 不同程序包下，使用默认访问权限的成员，不能被继承；
    • 构造器不能继承；（先调用父类构造，在调用子类构造，加载类加载父类，在加载子类；）
  2. 能被继承的成员，才能被直接访问，否则子类没有权限这个属性；只能通过父类提供的公共方法来访问；

继承设计原则

里氏替换原则 LSP：在一个软件系统中，子类对象可以替换所有使用的父类对象，且程序行为没有变化

方法重写

定义

  1. 子类重写（覆盖）了父类的方法；
  2. 在子类中，必须是实例方法，方法名相同，参数列表相同，返回值类型相同。
package day10;

import java.util.List;

class Base{
    public Base f(List<String> a){
        return new Base();
    }
}

class Sub extends Base{

    // 注解,注解可以让编译器自动检查代码是否符合规范
    @Override
    public Base f(List a){
//        Base base = new Base();
        return new Sub();
    }
}

public class TestBase {
    public static void main(String[] args) {

    }
}

注意

  • 参数列表
    父类参数擦除后与子类相同(泛型)

  • 返回值类型
    引用类型，子类的返回值类型范围比父类要小，也就是说子类的返回值类型可以是父类返回值的子类型。

  • 访问修饰符
    不能比父类更严格

  • 异常处理
    不能比父类范围更大

为什么要重写

  • 子类修改了父类的功能
  • 子类扩充了父类的功能

查看对象的类型
对象.getClass().getName()

super

表示父类范围

作用

  • 调用父类成员
  • 区分同名的子类和父类的成员
  • 调用父类构造

调用构造

  1. 创建子类对象时，一定要先调用父类构造(一直到object类的构造)；然后在调用子类构造
  2. 子类构造器中，如果没有显示调用父类构造super()或者构造this()，那么编译器一定会分配一个super()；
  3. 父类中显示定义了构造器，而且只有带参数构造，那么子类构造器中，必须显示super(参数)调用父类带参构造；

继承传递性

  1. 子类可以继承直接父类 和间接父类中的成员
  2. super只能调用直接父类的成员；间接父类需要在直接父类中使用super来调用；

object类

所有类的直接或间接父类，在java.lang包中

finalize（）

  1. 垃圾回收器释放对象之前调用
  2. 用于释放资源或者给对象恢复引用

equals()

  1. 比较两个对象是否相等，地址是否相等
  2. 对称性
    如果x.equals(y)返回是"true"，那么y.equals(x)也应该返回是"true"
  3. 反射性
    x.equals(x)必须返回是"true"。
  4. 类推性
    如果x.equals(y)返回是"true"，而且y.equals(z)返回是"true"，那么z.equals(x)也应该返回是"true"。
  5. 一致性
    如果x.equals(y)返回是"true"，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是"true"。
  6. 非空性
    x.equals(null)，永远返回是"false"；x.equals(和x不同类型的对象)永远返回是"false"。

toString()

对象的字符串描述信息，在调用print()和println()；输出对象名时，会自动隐式调用toString()。

  1. getClass
    获取类在加载时，在堆内存中的对象模板的地址
  2. getName
    获取堆内存中对象模板的地址的名字

哈希

是对数据唯一的标识

哈希值

把一些数据 使用哈希算法 变换成固定的数值，这个数值就是哈希值

哈希算法：

  1. 可以做为文件或数据的唯一标识
  2. 节省系统的开销；
  3. 加密；

算法：

  1. 直接寻址法
    直接从所有数据中取出同一个属性当做哈希值；

  2. 数字分析法
    从所有数据中的一个属性中，找不同的地方，作为哈希值；

  3. 平方取中法
    取出数据中平方后，中间的数字

  4. 折叠法

  5. 随机数法

  6. 除留余数法

final

表示终态

修饰

类

  1. 此类不能被继承
    例如 String System
  2. 设计
    1. 为了类的安全性
    2. 继承是破坏封装的
    3. 类中的方法有复杂的调用关系
    4. 是最终版本的类

方法

  1. 此方法不能被重写
  2. 所有子类使用同一版本的方法

变量

  1. 此变量就是常量
  2. 只能赋值一次
  3. 不能修改常量的值
    但是如果常量的值是引用类型，是可以修改属性的值
  4. 命名规范
    1. 所有字母都大写
    2. 多个单词组成由下划线链接
  5. 作用
    1. 数值安全
    2. 可维护
    3. 可读性

设计一个可以被继承的类

  1. 继承的层次关系最好不要超过3层
  2. 最好有详细的文档说明，方法的自用性是什么，重写后会带来什么影响
  3. 要封装
  4. 访问的权限
    • 如果对所有用户开放就用public
    • 对子类开放用protected
    • 对子类开放，有不希望子类更改代码，定义final

什么样需要扩展子类

  1. 增加了独特的属性
  2. 增加了独特的功能

继承的优缺点

优点

  • 代码重用
  • 高耦合

缺点

  • 破坏了封装
  • 高耦合
posted @ 2018-10-03 00:52  耳_东  阅读(123)  评论(0)    收藏  举报