javase第八章知识点整理

最新推荐文章于 2024-11-10 08:43:33 发布

奋斗着，享受着

最新推荐文章于 2024-11-10 08:43:33 发布

阅读量65

点赞数

分类专栏： Javase学习笔记文章标签： java

本文链接：https://blog.csdn.net/vgfvgf/article/details/129380358

版权

Javase学习笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的面向对象特性，包括继承、抽象类与抽象函数、final关键字、接口、多态、内部类的定义和访问权限，以及枚举和泛型的概念。重点讨论了类与类、接口与接口之间的继承关系，以及静态成员和抽象函数的特点。此外，还提到了包和权限控制的作用。

摘要由CSDN通过智能技术生成

子父类中 成员函数的特点 和 子父类中成员变量的调用形式很像
如果父类没有，子类有 -> 调用子类的 showC
如果父类有，子类没有 -> 调用父类的 showB
如果父类有，子类有   -> 调用子类的 showA

对于 如果父类有，子类有 的情况 在Java称之为重写Over概念
【重写】前提：如果父类有，子类有
需要注意的是，子类重写父类函数时
(1)函数名必须保持一致
(2)返回值类型必须保持一致
(3)参数列表必须保持一致
(4)子类的权限必须大于等于父类函数的权限(除了private)
一旦父类中有private，子类一律获取不到！
【子父类中 静态成员的特点】
静态变量的特点同成员变量
    父类有 子类无 调用的就是父类的
    父类无 子类有 调用的就是子类的
    父类有 子类有 调用的就是子类的
静态函数的特点同静态变量
    父类有 子类无 调用的就是父类的
    父类无 子类有 调用的就是子类的
    父类有 子类有 调用的就是子类的
    注意：静态函数不存在重写的问题！

【final】关键字
    final修饰基本数据类型
    final修饰引用数据类型
    final修饰函数
    final修饰类

【抽象类】
    把若干个类当中，将相同的部分进行抽取 -> 父类
    抽象类一般也是作为父类存在的，他也是被若干个子类抽取出来的共性内容
    抽象：不具体的，模糊的，不明确的
抽象类和一般类的区别？
    唯一的区别就是抽象类中包含了抽象函数而已，也不能创建对象，剩下的和一般类一样
    对于抽象类而言，也可以由构造函数，成员变量，成员函数
    既然抽象类不能创建对象，那么还保留成员变量和成员函数干嘛？一般作为父类存在，留给子类使用的

对于abstract关键而言，它不能和那些关键字共存？
    abstract class Animal {
        public abstract void jiao();
    }

    final
        在抽象函数上不行，抽象函数就等着被子类重写，与final的含义冲突
        在抽象类上不行，抽象类一般是作为父类存在，如果没有子类的话，该类的定义就没有意义，抽象类自身也创建不了对象啊
    private
        在抽象函数上不行，抽象函数就等着被子类重写，但是private表示能被继承但无法访问
    static
        在抽象函数上不行，静态函数可以直接被类调用，必须是具体的内容。静态优先对象加载进方法区的，此时和子类没有任何关系

对于抽象类的子类而言
    (1)继承抽象类，但不重写抽象函数，那就接着声明为抽象类
    (2)继承抽象类，重写抽象函数

对于子类而言，既然继承了一个抽象类，它有两种处理方式
(1)不去重写父类的抽象函数，该类只能继续声明为抽象类
(2)要么重写父类的抽象函数

抽象类的特点：
(1)抽象类和抽象函数都需要被abstract关键字修饰，抽象函数一定在抽象类中
(2)抽象类不能创建对象
(3)子类只有重写了父类所有的抽象函数之后，才能创建对象，否则本身也是一个抽象类

一些细节问题需要注意的：
(1)抽象类一定是父类？
    是的，抽象类本身就是有若干个子类抽取共性而创建出来的
    如果它没有子类，它本身也不能创建对象，所以它的存在就没有任何意义
(2)抽象类是否有构造函数？
    抽象类和一般的类唯一的区别在于抽象类中包含抽象函数且不能创建对象
    其他的和一般类是一样的
    相同点：
        它们都是用来描述事物的
        它们之中都可以定义属性和行为
    不同点：
        一般类可以具体的描述事物，抽象类描述事物的信息不具体
        抽象类中比一般类可以多定义一个成员：抽象函数
        一般类可以创建对象，抽象类不可以创建对象

【接口】
    接口其实就是抽象类的另外一种表现形式
    如果某一个抽象类中的所有方法都是抽象函数时，那么就可以用接口这个形式来表现

接口的内容和类的内容是有区别的
(1)接口中定义的变量，都是public static final - 全局静态常量
    public static final 这三个关键字都可以省略 不代表没有
(2)接口中定义的函数，都是public abstract - 全局抽象函数
    public abstract 这两个关键字都可以省略 不代表没有
(3)接口不能创建对象
    构造函数是没有抽象的！！！
    接口中是不存在构造函数的！！！
    所以，这个时候，接口所表现出来的行为和类是完全不一样的！
    接口虽然可以用来表示抽象类，但接口绝不是一个类！！它没有类相关的性质！
(4)接口所表现的是什么关系？
    类与类之间是单继承关系
为什么Java不支持多继承，主要是因为父类中可能存在同名函数
并且这些函数都有具体的执行内容，所以对于子类而言，无法区分到底执行哪个，调用的不确定性
就产生了二义性，从这一点而言，不能有多个父类
从社会现实来看，儿子只能有一个亲爸爸
所以在Java中 类与类之间 只能是单继承关系！

接口与接口之间是多继承关系

接口与抽象类的区别
    相同点：
        都是位于继承的顶端，用于被其他子类实现或继承
        都不能创建对象
        都包含了抽象函数，其子类都必须重写这些抽象函数(如果不重写 就抽象类)
    不同点：
        抽象类为部分方法提供实现，避免子类重复实现这些方法（可以包含一般的成员函数用于继承）
        接口只能包含抽象函数(JDK1.8及其以后 接口可以包含一般函数 静态函数 成员函数)

【Java中后面常用的接口】
    Comparable
        public int compareTo(T o);
    让类具有可比较性，比较两个类之间的大小，类自发的去和别人比较

    Iterable
        Iterator<T> iterator();
    让类具有可迭代性，一般这个类作为一个容器，用于存储多个元素
    可以创建一个迭代器来遍历容器中所有的元素

    Serializable
        没有函数功能
    让类具有序列化性，就是将该类的对象从堆内存中提取出来存储到硬盘里
    反序列化，将对象数据从硬盘里提取出来在堆内存中创建该对象

    Runnable
        public abstract void run();
    让类具有多线程性，让该类中需要被另开线程执行的内容写入到run函数中即可
    结合Thread这个类去使用

    Collection
        int size();
        boolean isEmpty();
        boolean contains(Object o);
        ....
    让类具有集合性，一般这个类作为一个容器，用于存储多个元素，声明相关的增删改查的方法

    Comparator
        int compare(T o1, T o2);
    比较器，相当于是一个裁判，用于比较两个对象的大小，一般会创建该接口的实现子类对象
    不是类自发的去比较，而是被动的，将两个对象传给这个裁判，由裁判来决定大小关系

    Iterator
        boolean hasNext();  //是否有下一个元素
        E next();           //返回当前元素 并移动到下一个
    迭代器，用于具体遍历某个类中所表示的容器里所有的元素

    CharSequence
    字符序列接口，一般定义的是由字符元素组成的容器

【多态】
    多种状态的含义 前提是要有继承/实现的关系
    在代码表现中，父类变量指向的是子类的对象
    class Fu{}
    class Zi extends Fu{}
    Fu fu = new Fu();
    Zi zi = new Zi();
    //多态：父类变量指向的是子类的对象
    Fu fu = new Zi();
    //错误
    Zi zi = new Fu();
    大类型的变量指向小类型的数据，只能从大到小，不能从小到大

    多态就是将子类的身份提高到了父类的身份，但是并不会改变子类对象本质

【内部类】
    就是我们在描述一个事物的时候，发现该事物中又存在其他的事物
    外面的事物-外部类   class 人
    里面的事物-内部类   class 心脏 class 肺 class 胃
    链表内部是由若干个结点组成的 LinkedList - Node

    所以所谓的内部类 其实就是某一个类的成员(实例 静态)而已
    如果是实例 class Inner 非静态内部类
    如果是静态 static class Inner 静态内部类

    什么时候定义静态内部类，当内部类中需要存在静态内容 该内部类必须定义为静态内部类

    静态内部类中不能直接访问外部类中的非静态成员，但是非静态内部类是可以的（静态 非静态）

    静态内部类的创建
        外部类.内部类 变量名 = new 外部类.内部类();
    非静态内部类的创建
        外部类.内部类 变量名 = new 外部类().new 内部类();

【包与权限】
    包：在Java工程项目中，其实指的就是文件系统
    (1)用于给代码进行分类
        都是在src这个目录下
            com.baidu.www
            com目录
                baidu目录
                    www目录
    (2)对代码进行命名空间
        package 用于标记该类所属的空间
        对同名的类做区分
        import 用于导入其他包中的类

    权限 主要限制的是访问范围（外部类/内部类 成员/静态/构造函数 成员/静态变量）
    PS:在函数内部不存在权限问题的，只有类及其成员存在权限问题的
                public      protected       default     private
    同一个类中   OK          OK              OK          OK
    同一个包中   OK          OK              OK
    同包子类中   OK          OK              OK
    异包子类中   OK          OK
    不同的包中   OK

【枚举与泛型】
    枚举：其实就是在定义一些静态变量时，另外一种表现形式
        (1)无值化表现 不需要用数值来表现一个常量问题
        (2)约束范围和个数

    泛型：参数化类型 不确定操作的元素是什么类型 假设为X即可
    如果定义了泛型 - 当成引用数据类型来使用 - 引用数据类型之间的大小关系是不能使用< >