大家好，我是💖星仔💖。一个致力于为大家分享各种Java知识的博主。

✨专栏汇总✨

        🍋《星仔带你部署银河麒麟RAM架构服务器》

        🍋《星仔带你学消息队列（RebbitMQ）》

        🍋《星仔带你学Java》

        🍋《星仔带你学Elasticsearch》

        🍋《星仔带你搞定Java开发小技巧》

        🍋《星仔带你学Java设计模式》

        🍋《星仔带你搞定【软考-系统架构设计师】》

        🍋《星仔带你玩转Java面试》

    本博客收录于《华星详谈-学习中心》。本学习中心收集了Java整个技术体系的所有技术要点。每篇博客后面或者知识点结尾都附带有面试题，提供给大家巩固本章内容。

为各位同胞们能够系统性的掌握整个Java技术体系而建立的学习中心。星仔正在努力的更新学习中心中的内容。望诸君共勉！！！

一、代码块

1.1 什么是代码块

        在类或者在方法中，直接使用 “{}” 括起来的一段代码，表示一块代码区域。代码块里面的变量属于局部变量，只在自己所在区域（前后的{}）内有效。根据代码块定义的位置的不同，我们又将代码块分成三种形式：局部代码块、初始化代码块（构造代码块）、静态代码块。

1.2 局部代码块

        局部代码块：直接定义在方法内部的代码块；一般我们是不会直接使用局部代码块的，只不过我们会结合if、while、for、try等关键字联合，表示一块代码区域；

1.3 初始化代码块（构造代码块）

        初始化代码块（构造代码块）：直接定义在类中；每次创建对象的时候都会执行初始化代码块。每次创建对象都会调用构造器，在调用构造器之前会先执行本类中的初始化代码块。通过反编译之后，我们发现可以发现初始化代码也作为构造器的最初的语句。

       在开发中一般不建议使用初始化代码块。主要是因为代码看起来不优雅（难看）。即使要做初始化操作我们一般在构造器中做即可，如果做初始化操作的代码比较多此时构造器的结构比较混乱，这时专门定义一个方法做初始化操作，再在构造器中调用即可。

1.4 静态代码块

        静态代码块：使用static修饰的初始化代码块；在主方法执行之前执行静态代码块，而且只执行一次。 

问题：main方法是程序的入口，那为什么静态代码块优先于main方法执行呢？

        静态成员随着字节码的加载也加载进JVM，此时main方法还没执行，因为方法需要JVM调用。先把字节码加载进JVM后,  JVM再调用main方法。一般我们使用静态代码块用来做初始化操作（加载资源、加载配置文件等）。

二、final修饰符

2.1 理解final

        为什么得需要使用final修饰符呢？主要是由于继承关系最大弊端是破坏封装（子类能访问父类的实现细节，而且可以通过方法覆盖的形式修改实现细节）。而final本身的含义是“最终的、不可改变的”。它可以修饰非抽象类，非抽象方法和变量。

注意：构造方法不能使用final修饰，因为构造方法不能被继承，肯定是最终的。

2.2 final类

        final修饰的类表示最终的类，该类不能再有子类。只要满足以下条件就可以把一个类设计成final类：

        ①　某类不是专门为继承而设计。

        ②　出于安全考虑，类的实现细节不许改动，不准修改源代码。

        ③　确信该类不会再被拓展。

面试题:列举5个Java中内置的使用final修饰的类.

java里final修饰的类有很多，比如八大基本数据类型保证类和String等。

2.3 final方法

final修饰的方法表示最终的方法，该方法不能被子类覆盖。

什么时候的方法需要使用final修饰？

          1)、在父类中提供的统一的算法骨架，不准子类通过方法覆盖来修改。此时使用final修饰，即模板方法设计模式。

          2)、在构造器中调用的方法(初始化方法)，此时一般使用final修饰。

注意: final修饰的方法，子类可以调用，但是不能覆盖。

2.4 final变量

        final修饰的变量：最终的变量,常量,该变量只能赋值一次，不能再赋值。final是唯一可以修饰局部变量的修饰符。

        final修饰的变量表示常量，只能赋值一次，不能在赋值。final变量必须显示地指定初始值，系统不会为final字段初始化。final变量一旦赋予初始值，就不能被重新赋值。

常量名规范：常量名符合标识符，单词全部使用大写字母，如果是多个单词组成,单词间使用下划线隔开。比如说int类型的最大值：final int MAX_VALUE = ....;

     补充概念：全局静态常量: public  static  final 修饰的变量直接使用类名调用即可。

面试题：final修饰的引用类型变量到底表示引用的地址不能改变，还是引用空间中的数据不能改变。

答：final修饰基本类型变量：表示该变量的值不能改变，即不能用“=”号重新赋值。

       final修饰引用类型变量：表示该变量的引用的地址不能变，而不是引用地址里的内容不能变。

final是唯一可以修饰局部变量的修饰符，他的目的何在呢？期待局部内部类。局部内部类只能访问final修饰的局部变量

什么时候使用常量:

    当在程序中多个地方使用到共同的数据，且该数据不会改变，此时我们专门定义全局的常量。一般我们在开发中会专门定义一个常量类，专门用来存储常量数据。

常量分类

       1)、字面值常量（直接给出的数据值/直接量）。比如：整数常量1，2，3，小数常量3.14，布尔常量false，true等。

       2)、定义的final变量。

2.5 final修饰符的使用场景之一：单例设计模式

        设计模式（Design pattern）：是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

        单例设计模式(singleton)：最常用,最简单的设计模式，单例的编写有N种写法。单例设计模式的目的是保证某一个在整个应用中某一个类有且只有一个实例（一个类在堆内存只存在一个对象），即所有指向该类型实例的引用都指向同一块内存空间。  

实战示例：定义一个数组的工具类（ArrayUtil）,使用单例模式解决

写单例模式的步骤：单讲饿汉式.

      1)、必须在该类中自己先创建出一个对象；

      2)、私有化自身的构造器，防止外界通过构造器创建新的对象；

      3)、想外暴露一个公共的静态方法用于获取自身的对象；

/**
 * @description：数组单例模式
 * @author: yaogx
 * @time: 2022/6/22 20:02
 */
public class ArrayUtil {
    /**
     * step 1 创建一个实例
     */
    private static final ArrayUtil arrayUtil = new ArrayUtil();
 
    /**
     * step 2 私有化构造器
     */
    private ArrayUtil() {
    }
 
    /**
     * step 3 暴露一个公共方法获取该类的唯一实例
     * @return
     */
    public static ArrayUtil getInstance() {
        return arrayUtil;
    }
}

  

三、基本类型包装类

     问题1：在面向对象中，”一切皆对象”。现在问题来了，int  age = 17;请问这age代码哪里有对象？而基本类型变量不是对象此时有矛盾。

     问题2：现在给你一个复杂的十进制数据，请你迅速在程序中转换为2进制、8进制、16进制；

     问题3：现在使用double类型来表示学生的考试成绩，double类型初始值为0.0；但是你怎么表示一个人缺考和考试得0分。

上述的问题就是因为基本数据类型缺少对象，如果需要对象则必须先有类。这个时候就不得不说基本类型包装类了，此时我们可以为每一个基本类型都编写一个对应的包装类，类中包含了该基本类型的一个值。

八大基本数据类型的包装类都使用final修饰，都是最终类，都不能被继承。

3.1 装箱和拆箱

装箱：把基本类型数据转成对应的包装类对象。

拆箱：把包装类对象转成对应的基本数据类型数据。

 

在Java的集合框架中，只能存储对象，不能存储基本类型值。每次存储到集合中的基本数据都得手动来装箱，很麻烦。故Sun公司从Java5开始提供了的自动装箱（Autoboxing）和自动拆箱（AutoUnboxing）功能 ：

自动装箱：可把一个基本类型变量直接赋给对应的包装类变量。

自动拆箱：允许把包装类对象直接赋给对应的基本数据类型变量。

        自动装箱和拆箱其实是一个语法糖，是编译器级别新特性，在底层依然是手动装箱和拆箱操作。但是：装箱操作使用的是 Integer.valueOf 的方式，而不是直接new Integer。

 

switch支持的数据类型：byte、short、char、int，也支持对应的包装类。那这是为何呢？其原因就在于在底层switch中会对包装类做手动拆箱操作。

解释Object obj = 17;

    1)、自动装箱:   Integer  i = 17;

    2)、引用的自动类型转换，把子类对象赋给父类变量:   Object obj = i;  Object可以接受一切数据类型的值

3.2 基本使用即包装类的常用操作方法:

3.2.1 包装类中的常量

      MAX_VALUE、MIN_VALUE、SIZE（在内存中存储占多少位）、TYPE（对应的基本类型）

3.2.2 包装类的构造器

xxx类型的包装类Xxx：xxx表示8大基本数据类型。

   Xxx(xxx value)：接受自己的基本类型值。如Integer(int val)、Boolean(boolean val)

   Xxx(String value)：Character除外；

3.3.3 基本类型和包装类型的转换（装箱和拆箱）

   装箱:

Integer i1 = new Integer(123);

Integer i2 = Integer.valueOf(123);//推荐,带有缓存

   拆箱:

int val = i1.intValue();

 

3.3.4 String和基本类型/包装类型之间的转换操作

     String和int、Integer之间的转换操作：转换方法必须在String类中或Integer类中。

把String转换为包装类类型：

    方式1、static Xxx  valueOf(String str) ：把String转换为包装类的对象

Integer i1 = Integer.valueOf(“123”);

    方式2、new  Xxx(String str):

Integer i2= new Integer(“123”);

把包装类对象转换为String.

String  str =  任何对象.toString();

把基本数据类型转换为String:

String  str = 17 + ””;

把String转换为基本数据类型:

static xxx parseXxx(String s)      :xxx表示8大基本数据类型

String  input=”12345”;

int num = Integer.parseInt(input);

 

3.4.5 Boolean 类型的转换

Boolean b = new Boolean("SB");//false

以上代码输出的是false，其原因是Boolean类型只认可true/TRUE为true，其他都是false。

3.3 享元模式

        包装类中的缓存设计（享元模式），本质就是缓存设计。Byte、Short、Integer、Long：缓存[-128，127]区间的数据；Character：缓存[0，127]区间的数据；

 

3.4 Integer与int的区别（包装类型和基本数据类型的区别）

  1)、默认值:

           int的默认值是0；

           Integer的默认值为null；

           推论：Integer既可以表示null，又可以表示0；

   2)、包装类中提供了该类型相关的很多算法操作方法

static String toBinaryString(int i) :把十进制转换为二进制

static String toOctalString(int i) : :把十进制转换为八进制

static String toHexString(int i) : :把十进制转换为十六进制

   3)、在集合框架中，只能存储对象类型，不能存储基本数据类型值

   4)、Integer和int不是相同的数据类型

   5)、方法中的基本类型变量存储在栈中，包装类型存放于堆中

一般我们在开发中建议使用包装类型，而非它的基本类型。

四、抽象类

4.1 引出抽象方法

案例：求圆(circle)、矩形(rectangle)、三角形(Triangle )的面积？

 上述设计的问题

    1)、每一个图形都有面积，所在在Graph类中定义求面积的方法getArea没问题.。但是不同的具体图形求面积的算法是不一样的，也就是说每一个图形的子类都必须去覆盖getArea方法，如果不覆盖该语法报错，故必须覆盖。

    2)、在图形类中定义了getArea方法，该方法不应该存在方法体，因为不同图形子类求面积算法不一样。父类真不知道该怎么写，所以应该提供无方法体。这个时候就不得不说Java中的抽象方法了。

4.2 抽象方法和抽象类

4.2.1 抽象方法

使用abstract修饰且没有方法体的方法，称为抽象方法。

特点：

        ①　使用抽象abstract修饰，方法没有方法体，留给子类去实现/覆盖。

        ②　抽象方法修饰符不能是private 和 final以及static，为什么？

        ③　抽象方法必须定义在抽象类或接口中。

一般我们习惯性把abstract写在方法修饰符最前面，这样可以一看就知道是抽象方法。

4.2.2 抽象类

使用abstract关键字修饰的类。

特点：

        ①　不能创建实例即不能new一个抽象类,即使创建出抽象类对象,调用抽象方法,根本没有方法体。

        ②　可以不包含抽象方法，若一旦包含，该类必须作为抽象类,抽象类可以包含普通方法(留给子类调用的),抽象类是有构造器的,子类构造器必须先调用父类构造器。

        ③　若子类没有实现/覆盖父类所有的抽象方法，那么子类也得作为抽象类(抽象派生类)。

        ④　构造方法不能都定义成私有的，否则不能有子类(创建子类对象前先调用父类构造方法)。

        ⑤　抽象类不能使用final修饰，因为必须有子类，抽象方法才能得以实现。

        ⑥　是不完整的类，需作为父类(必须要有子类)，功能才能得以实现。

        在抽象类中，我们起名习惯使用Abstract作为前缀，让调用者一看就知道是抽象类。抽象类中可以不存在抽象方法，如此这样没有太大的意义，但是可以防止外界创建对象，所以我们会发现有些工具类没有抽象方法，但是也使用abstract来修饰。

注意：抽象类不能实例化

4.2.3 抽象类和普通类的区别

   普通类有的成员（方法、字段、构造器）抽象类都有。

   抽象类不能创建对象，抽象类中可以包含抽象方法。

五、模板方法设计模式

 

需求：统计不同操作的耗时时间模板操作。统计String连接10000此时和int相加10000次的时间差

模板方法设计模式：在父类的一个方法中定义一个总体算法的骨架（模板方法），而将某一些一些步骤延迟到子类中，因为不同的子类实现细节不同。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。抽象父类负责定义操作中的业务骨架，而把某些具体的实现步骤延迟到子类中去实现。

抽象父类至少提供的方法：

        模板方法：一种通用的处理方式，即模板（总体算法的骨架）；

        抽象方法：一种具体的业务功能实现，由子类完成；

注意：抽象父类提供的模版方法只是定义了一个通用算法，其实现必须依赖子类的辅助。

把以上的需求转化为模板方式的形式代码：