day03-多态、包、权限修饰符、内部类，Object类，Date类

桀少_Bigdata

于 2021-08-20 21:47:47 发布

阅读量217

点赞数 1

分类专栏： Java进阶

本文链接：https://blog.csdn.net/qq_40908729/article/details/119822254

版权

Java进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

目标：多态的入门概述。

面向对象的三大特征：封装，继承，多态。

多态的形式：
    父类类型 对象名称 = new 子类构造器;
    接口    对象名称 = new 实现类构造器;

    父类类型的范围 > 子类类型范围的。

多态的概念：
    同一个类型的对象，执行同一个行为，在不同的状态下会表现出不同的行为特征。

多态的识别技巧：
    对于方法的调用：编译看左边，运行看右边。
    对于变量的调用：编译看左边，运行看左边。

多态的使用前提：
    （1）  必须存在继承或者实现关系。
    （2）  必须存在父类类型的变量引用子类类型的对象。
    （3）  需要存在方法重写。

小结：
    记住多态的形式，识别，概念等语法即可！

目标：多态的优劣势。

优势：
    1.在多态形式下，右边对象可以实现组件化切换，业务功能也随之改变，
       便于扩展和维护。可以实现类与类之间的解耦。
    2.实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，
        可以传入一切子类对象进行方法的调用，更能体现出多态的扩展性与便利。

劣势：
    1.多态形式下，不能直接调用子类特有的功能。编译看左边!! 左边
    父类中没有子类独有的功能，所以代码在编译阶段就直接报错了！(引用类型强转)
小结：
     记住以上语法！

目标：引用类型强制类型转换

引用类型强制类型转换的语法：
    1.父类类型的变量或者对象必须强制类型转换成子类类型的变量，否则报错!

强制类型转换的格式：
    类型 变量名称 = (类型)(对象或者变量)

注意：有继承/实现关系的两个类型就可以进行强制类型转换，编译阶段一定不报错！
     但是运行阶段可能出现：类型转换异常 ClassCastException

Java建议在进行强制类型转换之前先判断变量的真实类型，再强制类型转换!
    变量 instanceof 类型： 判断前面的变量是否是后面的类型或者其子类类型才会返回true,

小结：
    有继承/实现关系的两个类型就可以进行强制类型转换，编译阶段一定不报错！
    但是运行阶段可能出现：类型转换异常 ClassCastException
    Java建议在进行强制类型转换之前先判断变量的真实类型，再强制类型转换!
        变量 instanceof 类型： 判断前面的变量是否是后面的类型或者其子类类型才会返回true

目标：内部类的概述和分类。

内部类是类的五大成分之一：成员变量，方法，构造器，代码块，内部类。

什么是内部类？
    定义在一个类里面的类就是内部类。

内部类有什么用？
    可以提供更好的封装性, 内部类有更多权限修饰符 , 封装性有更多的控制。
    可以体现出组件的思想。

内部类的分类:
    （1）静态内部类。
    （2）实例内部类。（成员内部类）
    （3）局部内部类。
    （4）匿名内部类。（重点）

目标：静态内部类的研究（了解语法即可）

什么是静态内部类？
    有static修饰，属于外部类本身，会加载一次。

静态内部类中的成分研究：
    类有的成分它都有，静态内部类属于外部类本身，只会加载一次
    所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

    外部类=宿主
    内部类=寄生

静态内部类的访问格式：
    外部类名称.内部类名称

静态内部类创建对象的格式：
    外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器;

静态内部类的访问拓展：
    静态内部类中是否可以直接访问外部类的静态成员?可以的，外部类的静态成员只有一份，可以被共享！
    静态内部类中是否可以直接访问外部类的实例成员?不可以的,外部类的是成员必须用外部类对象访问！！
小结：
     静态内部类属于外部类本身，只会加载一次
     所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

目标：内部类_实例内部类（成员内部类）(了解语法为主)

什么是实例内部类：
    无static修饰的内部类，属于外部类的每个对象的，跟着对象一起加载的。

实例内部类的成分特点：
    实例内部类中不能定义静态成员，其他都可以定义。
    可以定义常量。

实例内部类的访问格式：
    外部类名称.内部类名称。

创建对象的格式：
    外部类名称.内部类名称 对象名称 = new 外部类构造器.new 内部构造器;

拓展：
    实例内部类中是否可以直接访问外部类的静态成员？可以的，外部类的静态成员可以被共享访问！
    实例内部类中是否可以访问外部类的实例成员？可以的，实例内部类属于外部类对象，可以直接访问当前外部类对象的实例成员！
小结：
    实例内部类属于外部类对象，需要用外部类对象一起加载，
    实例内部类可以访问外部类的全部成员！

目标：局部内部类。（几乎不用）

定义在方法中，在构造器中，代码块中，for循环中定义的内部类
就是局部内部类。

局部内部类中的成分特点：
    只能定义实例成员，不能定义静态成员
    可以定义常量的。
小结：
    局部内部类没啥用。

目标：匿名内部类的概述

什么是匿名内部类？
    就是一个没有名字的局部内部类。
    匿名内部类目的是为了：简化代码，也是开发中常用的形式。

匿名内部类的格式：
    new 类名|抽象类|接口(形参){
        方法重写。
    }
 匿名内部类的特点：
     1.匿名内部类是一个没有名字的内部类。
     2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回。
     3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。
小结：
     1.匿名内部类是一个没有名字的内部类。
     2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回。
     3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。

目标：匿名内部类的使用形式。(关注语法)

需求：很多角色要一起参加游泳比赛（老师，学生，运动员）

目标：包和权限修饰符。

 包：
     分门别类的管理各种不同的技术。
     企业的代码必须用包区分。便于管理技术，扩展技术，阅读技术。

 定义包的格式：package 包名; 必须放在类名的最上面。
    一般工具已经帮我们做好了。

 包名的命名规范：
     一般是公司域名的倒写+技术名称：
     http://www.itheima.com => com.itheima.技术名称
     包名建议全部用英文，多个单词用”.“连接，必须是合法标识符，不能用关键字

 注意：
    相同包下的类可以直接访问。
    不同包下的类必须导包,才可以使用！
       导包格式：import 包名.类名;

目标：权限修饰符。

权限修饰符：有四种（private -> 缺省 -> protected - > public ）
可以修饰成员变量，修饰方法，修饰构造器，内部类，不同修饰符修饰的成员能够被访问的权限将受到限制!

四种修饰符的访问权限范围：
                    private    缺省       protected   public
    本类中           √           √          √           √
    本包下其他类中    X           √          √           √
    其他包下的类中    X           X          X           √
    其他包下的子类中  X           X          √           √

目标：常用API的学习-Object类的equals方法使用详解。

包：java.lang.Object
Object类是Java中的祖宗类。
一个类要么默认继承了Object类，要么间接继承了Object类。
Object类的方法是一切子类都可以直接使用的，所以我们要学习Object类的方法。

Object类的常用方法：
    （1）public String toString():
            -- 默认是返回当前对象在堆内存中的地址信息：com.itheima._12Object类的详细使用.Student@735b478
            -- 默认的地址信息格式：类的全限名@内存地址
            -- 直接输出对象名称，默认会调用toString()方法，所以直接输出对象可以省略toString()不写。
            -- 实际开发中直接输出对象，输出对象的地址其实是没有意义的。
               所以toString方法存在的意义是为了被子类重写。
               以便能够返回对象的数据内容输出。因为实际开发中我们
                输出对象更多的时候是希望看到对象的数据内容信息。

            小结：开发中如果希望输出对象看到对象的内容，
                 只需要重写toString()方法即可。
                 所以toString方法存在的意义是为了被子类重写。

    （2）public boolean equals(Object o):
            -- 默认是比较两个对象的地址是否相同。相同返回true,反之。
            -- 直接比较两个对象的地址是否相同完全可以用“==”替代equals。
               所以equals存在的意义是为了被子类重写，以便程序员可以
                自己来定制比较规则。
            -- 需求：只要两个对象的内容一样，我们就认为他们是相等的。
        小结：
             equals存在的意义是为了被子类重写，以便程序员可以
             自己来定制比较规则。

目标：Objects类的使用。

Objects类与Object还是继承关系。
Objects类是从JDK 1.7开始之后才有的。

Objects的方法：
    1.public static boolean equals(Object a, Object b)
        -- 比较两个对象的。
        -- 底层进行非空判断，从而可以避免空指针异常。更安全！！推荐使用！！
         public static boolean equals(Object a, Object b) {
                 return a == b || a != null && a.equals(b);
         }
    2.public static boolean isNull(Object obj)
        -- 判断变量是否为null ,为null返回true ,反之！

目标：Date日期类的使用。

Java是面向对象的，会用一个类代表一个事物。
Date类在Java中代表的是系统当前此刻日期时间对象。

Date类：
    包：java.util.Date。
    构造器：
        -- public Date():创建当前系统的此刻日期时间对象。
        -- public Date(long time):
    方法：
         -- public long getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来走过的总的毫秒数。

    时间记录的两种方式：
         a.Date日期对象。
         b.时间毫秒值：从1970-01-01 00:00:00开始走到此刻的总的毫秒值。 1s = 1000ms

    小结：
        Date可以代表系统当前此刻日期时间对象。
        时间记录的两种方式：
             Date日期对象。
             时间毫秒值：从1970-01-01 00:00:00开始走到此刻的总的毫秒值。 1s = 1000ms
    拓展：时间毫秒值的作用。
            时间毫秒值可以用于做时间的计算：例如代码的执行性能分析。

目标:Date类的有参数构造器的使用。

构造器：
     -- public Date():创建当前系统的此刻日期时间对象。
     -- public Date(long time):把时间毫秒值转换成日期对象。
流程：
    Date日期对象 -> getTime() -> 时间毫秒值
    时间毫秒值 -> new Date(时间毫秒值) -> Date日期对象
小结：
    public Date(long time):把时间毫秒值转换成日期对象。