day02-抽象类、接口、代码块，final、单例、枚举

最新推荐文章于 2024-07-22 14:15:06 发布

桀少_Bigdata

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量92

点赞数

分类专栏： Java进阶文章标签： java

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

版权

Java进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

目标：抽象类的入门概述。

引入：
    父类知道子类一定要完成某个功能，但是每个子类实现的情况都不一样
    而且子类都会用自己的功能了，父类的该功能就可以定义成抽象的方法。
    拥有抽象方法的类必须定义成抽象类。
什么是抽象方法?
    没有方法体，只有方法签名，必须用abstract修饰的方法就是抽象方法。
什么是抽象类？
    拥有抽象方法的类必须定义成抽象类。
    抽象类必须用abstract关键字修饰。
小结：
    抽象方法：没有方法体，只有方法签名，必须用abstract修饰的方法就是抽象方法。
    抽象类：拥有抽象方法的类必须定义成抽象类，必须用abstract修饰。

目标：抽象类的使用。

抽象类是为了被继承。

总结：
    一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类必须定义成抽象类。
    因为拥有抽象方法的类必须定义成抽象类。

目标：抽象类的特征研究和深入。

抽象类的特征：有得有失。
    有得：抽象类拥有了得到抽象方法的能力。
    失去：抽象类失去了创建对象的能力。

面试题：抽象类是否有构造器，是否可以创建对象，为什么?
     答：抽象类作为类一定有构造器，而且必须有构造器。
     提供给子类继承后调用父类构造器使用的。

     抽象类虽然有构造器，但是抽象类绝对不能创建对象。
     抽象类中可能存在抽象方法，抽象方法不能执行。
     抽象在学术上本身意味着不能实例化。

抽象类除了有得有失之外，类的其他成分人家都具备！！

小结：
    抽象类不能创建对象。
    抽象类除了不能创建对象之外，类的其他成分它都具备！
    抽象类中也可以没有抽象方法！！

目标：抽象类的意义

抽象类存在的意义有两点：
    （1）被继承，抽象类就是为了被子类继承，否则抽象类将毫无意义。(核心意义)
    （2）抽象类体现的是"模板思想"：部分实现，部分抽象。（拓展）
        -- 可以使用抽象类设计一个模板模式。

目标：使用抽象类设计一个模板模式。

设计模式：是前人（技术大牛，或者一些技术协会，或者一些大型知名的IT公司）
         已经研发好或者设计好或者在实战开发中发现的的优秀软件设计思想，开源出去
         后来者可以直接使用就能够得到很好的软件模式。

设计模式的目的：得到优秀的软件架构，从而提升代码的可重用性，扩展性，维护性，可读性。

模板模式是一种设计模式思想：
模板模式的作用：部分实现，部分抽象，可以极大的简化功能代码，提高开发效率

写一个模板模式的案例：作文模板。
    作文模板：
    标题和第一段 以及最后一段是固定的，
    正文部分交给使用模板的人自己来实现。
小结：
    抽象类是部分实现，部分抽象的含义，所以可以设计模板模式。
    好处：模板可以确定的模板自己实现，模板不能确定的定义成抽象方法交给使用模板的人重写。
    可以设计出优秀的设计模式，提升开发效率，提高代码的重用性！

目标：抽象类的注意事项和总结

 1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
     理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

 2. 抽象类一定有而且是必须有构造器，是供子类创建对象时，初始化父类成员使用的。
     理解：子类的构造器中，有默认的super()，需要访问父类构造器。

 3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

 4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类。

 5. 抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。
    理解：抽象类中已经实现的是模板中确定的成员，
    抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

目标：接口的概述和定义等。（以理解和记住语法为主）

 什么是接口？
 接口是更加彻底的抽象，接口中全部是抽象方法和常量，没有其他成分。（JDK 1.8之前）
 接口有啥用?
      接口体现的是规范思想，实现接口的类必须重写完接口中全部的抽象方法。
      规范 == 约束。
      接口称为被实现，实现接口的类称为实现类。

 定义接口的格式：
      修饰符 interface 接口名称{

      }
      interface:定义接口的关键字。
 接口中的成分研究（JDK 1.8之前）：
      1.抽象方法
           a.接口中的抽象方法默认会加上public abstract修饰,所以可以省略不写。
      2.常量
        常量：是指有public static final修饰的成员变量，有且仅能被赋值一次，值不能改变。
        常量的名称规范上要求全部大写，多个单词下划线连接。
        常量修饰的public static final 可以省略不写，默认会加上。
 小结：
      定义接口使用的关键字：interface
      接口中的成分在JDK 1.8之前只能有：常量和抽象方法
      接口中的成分在JDK 1.8之后的默认方法要用default修饰
      在接口中常量的修饰符：public static final 可以省略不写，默认会加上。
      在接口中抽象方法的修饰符：public abstract 可以省略不写，默认会加上。

目标：接口的基本实现

接口是用来被类实现的。

引入：
    类与类是继承关系：一个类只能直接继承一个父类。
    类与接口是实现关系：一个类可以实现多个接口。
    实现接口的类称为“实现类”。

    子类   继承   父类
    实现类 实现   接口

实现类实现接口的格式：
    修饰符 class 实现类名称 implements 接口1,接口2,接口3,....{

    }
    implements:实现的含义。
    接口是可以被多实现的：一个类可以实现多个接口。

小结：
    接口是用类被实现的，实现接口的类称为实现类。
    实现接口的关键字是：implements。
    接口是可以被类多实现的。
    注意：一个类实现接口必须重写完接口中全部抽象方法，否则这个类必须定义成抽象类！！

目标：接口的多实现

 实现类实现接口的格式：
     修饰符 class 实现类名称 implements 接口1,接口2,接口3,....{

     }

 类与类是单继承。
 类与接口是多实现。

小结：
    一个类可以实现多个接口。
    一个类如果实现了多个接口，必须重写完全部接口中的全部抽象方法
    否则这个类必须定义抽象类。

目标：接口与接口的多继承

引入：
    类与类是单继承关系：一个类只能继承一个直接父类。
    类与接口是多实现关系：一个类可以实现多个接口。
    接口与接口是多继承关系：一个接口可以继承多个接口。

拓展：实现多个接口的使用注意实现。(非常偏的语法，理解和了解即可)

1.如果实现了多个接口，多个接口中存在同名的静态方法并不会冲突，
    原因是只能通过各自接口名访问静态方法。

2.当一个类，既继承一个父类，又实现若干个接口时，(重点)
    父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

3.当一个类实现多个接口时，多个接口中存在同名的默认方法。
    实现类必须重写这个方法。

4.接口中，没有构造器，不能创建对象。(重点)
    接口是更彻底的抽象，连构造器都没有，自然不能创建对象！！

目标：代码块-静态代码块

代码块是类的成分之一：
    成员变量，方法，构造器，代码块，内部类。
代码块按照有无static修饰分为：
    1.静态代码块。
    2.实例代码块。
静态代码块的格式：
    static {

    }
静态代码块特点：
    -- 必须有static修饰。
    -- 会与类一起优先加载，且自动触发执行一次。
静态代码块作用：
    -- 可以在执行类的方法等操作之前先在静态代码块中进行静态资源的初始化操作。

小结：
    静态代码块有static修饰，与类一起加载，自动触发执行一次。
    静态代码块的作用：可以用于在静态代码块中进行静态资源的初始化操作。

目标：代码块-实例代码块

实例代码块的格式：
     {

     }

实例代码块的特点：
    -- 无static修饰。
    -- 会与类的对象一起加载，每次创建类的对象的时候，
        实例代码块都会被加载且自动触发执行一次。
    -- 实例代码块的代码在底层实际上是提取到每个构造器中去执行的！

实例代码块的作用：
    -- 实例代码块可以在创建对象之前进行实例资源的初始化操作。

小结：
    实例代码块无static修饰,属于对象，与对象一起加载执行。
    实例代码块的代码在底层实际上是提取到每个构造器中去执行的！
    实例代码块可以在创建对象之前进行实例资源的初始化操作。

目标：final关键字

final是最终的含义。
final用于修饰：类，方法，变量。

1.final修饰类，类不能被继承了。
2.final可以修饰方法，方法就不能被重写了。
3.final修饰变量总规则：变量有且仅能被赋值一次。

拓展：final和abstract的关系?
      互斥关系,不能同时修饰类或者同时修饰方法！！

目标：final修饰变量-局部变量

final修饰变量的总规则：有且仅能被赋值一次。

变量有几种？
    成员变量
        -- 静态成员变量：有static修饰，属于类，只加载一份。
        -- 实例成员变量：无static修饰，属于每个对象,与对象一起加载。
    局部变量
        -- 只能方法中，构造器中，代码块中，for循环中，用完作用范围就消失了。
final修饰局部变量：
        -- 让值被固定或者说保护起来，执行的过程中防止被修改。

目标：final修饰变量-局部变量

final修饰变量的总规则：有且仅能被赋值一次。

变量有几种？
    成员变量
        -- 静态成员变量：有static修饰，属于类，只加载一份。
        -- 实例成员变量：无static修饰，属于每个对象,与对象一起加载。
    局部变量
        -- 只能方法中，构造器中，代码块中，for循环中，用完作用范围就消失了。
final修饰局部变量：
        -- 让值被固定或者说保护起来，执行的过程中防止被修改。

目标：final修饰静态成员变量

final修饰变量的总规则：有且仅能被赋值一次。
final修饰静态成员变量，变量变成了常量。
常量：有public static final修饰，名称字母全部大写，多个单词用下划线连接。

拓展：
    final修饰静态成员变量可以在哪些地方赋值一次：
    1.定义的时候赋值一次。
    2.可以在静态代码块中赋值一次。

目标：final修饰实例成员变量。(了解。用不到)

 final修饰变量的总规则：有且仅能被赋值一次。
 拓展：
    final修饰实例成员变量可以在哪些地方赋值1次：
        1.定义的时候赋值一次。
        2.可以在实例代码块中赋值一次。
        3.可以在每个构造器中赋值一次。

目标：面试常考（单例模式）

 单例模式的含义： 单例模式，是一种常用的软件设计模式。通过单例模式可以保证系统中，
     应用该模式的这个类永远只有一个实例。即一个类永远只有一个对象实例。
     单例是为了节约内存，单例在有些业务场景下还必须用到！！

 单例的应用场景：在实际开发中，有很多业务对象永远只需要一个，无论启动多少次
 我们只需要一个对象，例如任务管理对象，只需要一个对象。节约内存和性能。
 因为对象越多内存占用越大，极有可能出现内存溢出！

 实现单例模式目前提供两种方式：
        1.饿汉单例设计模式
             在用类获取对象的时候，对象已经提前为你创建好了。
             设计步骤：
             a.定义一个类，把构造器私有。
             b.定义一个静态变量存储一个对象。
             c.提供一个返回单例对象的方法。

public class SingleInstanceDemo01 {
    public static void main(String[] args) {
        Singleton01 s1 = Singleton01.getInstance();
        Singleton01 s2 = Singleton01.getInstance();
        System.out.println(s1 == s2);
    }
}

// 饿汉单例设计模式
class Singleton01{
    //  b.定义一个静态变量存储一个对象( 在用类获取对象的时候，对象已经提前为你创建好了。)
    private static final Singleton01 INSTANCE = new Singleton01();
    //  a.定义一个类，把构造器私有。
    private Singleton01(){
    }
    // c.提供一个返回单例对象的方法。
    public static Singleton01 getInstance(){
        return INSTANCE;
    }
}

        2.懒汉单例设计模式
             在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。
             设计步骤：
             a.定义一个类，把构造器私有。
             b.定义一个静态变量存储一个对象。
             c.提供一个返回单例对象的方法。

// 懒汉单例设计模式
class Singleton02{
    //  b.定义一个静态变量存储一个对象(这里不能创建对象，需要的时候才创建，这里只是一个变量用于存储对象！)
    public static Singleton02  instance ;

    //   a.定义一个类，把构造器私有。
    private Singleton02(){

    }
    //  c.提供一个返回单例对象的方法。
    public static Singleton02 getInstance(){
        if(instance == null){
            // 第一次来拿单例对象！需要创建一次对象，以后直接返回！！
            instance = new Singleton02();
        }
        return instance;
    }
}

目标：枚举的概述和作用

枚举是Java中的一种特殊类型。
枚举的作用：是为了做信息的标志和信息的分类。

定义枚举的格式：
    修饰符 enum 枚举名称{
        第一行都是罗列枚举实例的名称。
    }
枚举类的编译以后源代码：
     public final class Season extends java.lang.Enum<Season> {
         public static final Season SPRING = new Season();
         public static final Season SUMMER = new Season();
         public static final Season AUTUMN = new Season();
         public static final Season WINTER = new Season();

         public static Season[] values();
         public static Season valueOf(java.lang.String);
     }
枚举的特点：
     1.枚举类是用final修饰的，枚举类不能被继承！
     2.枚举类默认继承了java.lang.Enum枚举类。
     3.枚举类的第一行都是常量,存储都是枚举类的对象。
     4.枚举类的第一行必须是罗列枚举类的实例名称。
     所以：枚举类相当于是多例设计模式。
小结：
     枚举类的特点：
     1.枚举类是用final修饰的，枚举类不能被继承！
     2.枚举类默认继承了java.lang.Enum枚举类。
     3.枚举类的第一行都是常量,存储都是枚举类的对象。
     4.枚举类的第一行必须是罗列枚举类的实例名称。
     所以：枚举类相当于是多例设计模式。

目标：枚举的作用：是为了做信息的标志和信息的分类

常量做信息分类和信息标志：
    虽然可以实现可读性，但是入参不受限制！！！

Java建议做信息标志和信息分类应该使用枚举实现：最优雅的方式。
    可以实现可读性，而且入参受限制，不能乱输入！！！

小结：
    枚举的作用：是为了做信息的标志和信息的分类。

桀少_Bigdata

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
day02-抽象类、接口、代码块，final、单例、枚举

目标：抽象类的入门概述。引入：父类知道子类一定要完成某个功能，但是每个子类实现的情况都不一样而且子类都会用自己的功能了，父类的该功能就可以定义成抽象的方法。拥有抽象方法的类必须定义成抽象类。什么是抽象方法? 没有方法体，只有方法签名，必须用abstract修饰的方法就是抽象方法。什么是抽象类？拥有抽象方法的类必须定义成抽象类。抽象类必须用abstract关键字修饰。小结：抽象方法：没有方法体，只有方法签名，必须用abstract修饰
复制链接

扫一扫