main方法#

关键字#

字面量#

除此之外还有一些转义字符

字符串可直接拼接

变量#

• 变量定义

  数据类型 变量名 = 数值

不同于C的随机初始值 Java的变量必须要赋值才可使用

数据存储#

• 整型存储：二进制存储

• 字符存储

  • 英文：ASCII码表
  • 汉字：

• 浮点数存储

  IEEE发布的存储规则，划定不同位的存储内容 详见C语言

• 图片存储

  像素存储，其中

  • 黑白图可视为0/1
  • 灰度图以0~255表示颜色由黑到灰到白
  • 彩图以R/G/B三原色表示，其中每个原色的范围是0~255

• 声音存储

  离散采样声波波形图，同样以二进制表示

  

数据类型、标识符、键盘录入#

Random类#

1
import java.util.Random //导包
2
Random r = new Random();//创建对象
3
int num = r.nextInt(随机数的范围);//使用  //例如： int num = r.nextInt(101); 表示0~100随机数

IDEA#

• 项目格式

  

• IDEA的自动补全

  1
  psvma  --> public static void main(String[] args){}

  1
  sout --> System.out.println("");

• 格式化代码格式快捷键

  ctrl+alt+l

算术#

加、减、乘、除、取模

• 注意1：小数的的运算会因为存储规则而导致不精确

• 注意2：运算时注意数据类型类型转换

  Java中对类型有着严格要求，除了要遵守隐式类型转换外，运算后的结果也需赋值给相应类型。

  Java中的byte、shrot、char 在进行运算时会自动转换为int

  

  如上图所示，两个byte相加会进行类型转换，必须以int类型接收

  如需以byte类型接收 则需强制类型转换

• 注意3：Java中支持字符串的拼接

  

  注意：多个+出现时从左到右依次计算

自增自减#

注意前置后置的区别

赋值#

= += /= *= %= -=

关系运算符#

== != > < >= <=

逻辑运算符#

符号	作用	说明
&	逻辑与（且）	并且，两边都为真，结果才是真
|	逻辑或	或者，两边都为假，结果才是假
^	逻辑异或	相同为 false，不同为 true
!	逻辑非	取反

• 其实Java的上述四个运算符同样具有位运算的功能，但是不同于C，Java中的这四个位运算符同时具有逻辑判断的功能

  & 与 &&的区别 （|同样适用）

  &为非短路与 而 &&为短路与

  1
  false & (++i>0);  //非短路与，最终结果仍为false ， 但是 ++i>0仍会执行
  2
  false && (++i>0);  //短路与，识别到有false后 后面的都不执行 ++i>0不执行

  相对之下短路运算符效率高 tip：短路关系运算符和C中一样

三元运算符#

表达式1?表达式1：表达式2

同C

位运算符#

& | ^ ! >> <<

分支结构#

循环结构#

数组的定义#

1. 数据类型 [] 数组名 更加规范

   如：int [] arr

2. 数据类型 数组名[]

   如：int arr[]

初始化#

• 静态初始化

  • 完整格式

    数据类型[] 数组名 = new 数据类型[]{元素1，元素2…}

  • 简化格式

    数据类型[] 数组名 = {元素1，元素2…};

  1
  int [] arr = new int[] {1,2,3,4};

  • 数组的地址

    

    ’[‘表示是一个数组 D表示数据类型是double @是一个间隔符号 @后为地址的十六进制表示

• 动态初始化

  数据类型[] 数组名 = new 数据类型[数组长度]；

  1
  int[] arr = new int[3];

• 各数据类型数组的默认初始值 （由虚拟机JVM给出）

  整数类型：默认初始化值0

  小数类型：默认初始化值0.0

  字符类型：默认初始化值’\u0000’ 空格

  布尔类型：默认初始化值 false

  引用数据类型：默认初始化值 null

引用和赋值#

数组名[i] 同C

数组遍历的一些新颖形式#

1. 1
   for(int i = 0;i<arr.length;i++){
   2
   
   3
   }

   在IDEA中同样有快捷方式

   1
   数组名.fori
   2
       //如
   3
       arr.fori

2. 1
   for(数据类型 i:arr){
   2
       System.out.println(i);
   3
   }//i的数据类型需要和arr中类型一致

   

数组内存图#

• Java内存分配

  • 栈

    方法运行时使用的内存，比如main方法运行，进入方法栈中执行

  • 堆

    存储对象或数组，new来创建，都存储在堆内存

  • 方法区

    存储可运行的class文件

    • TIP：JDK7及以前方法区和堆是连在一起的，是一块连续的内存空间 JDK8开始取消了方法区，新增了元空间。将方法区的功能进行拆分，有的在元空间中 有的在堆中

  • 本地方法栈

    JVM在使用操作系统功能时使用，与开发无关

  • 寄存器

    给CPU使用，与开发无关

• 数组内存

  不同于C中数组在堆栈中均可开辟空间，Java中的数组都存储在堆空间中（所以Java数组初始化的语法一定会有new）

  

  如上图，在栈空间中定义arr 其值为数组在堆空间中的地址 引用数组元素时用地址找

二位数组#

• 初始化

  1
  int [][]arr = new int[][]{{11.22},{33,44}};
  2
  int [][]arr = new int[m][n];//第一个m必须写 n可以不写 和C刚好相反   扩展到多位数组，Java中依旧是只写第一个即可

  TIP：虽然动态初始化必须写第一个[]内的内容 但是当多维数组在方法中传递时一个[]都不用写

• 内存图

  

概念#

程序中最小的执行单元，类似C/Cpp中的函数。

用于提高代码的复用性和可维护性

格式#

类和对象#

• 类：对象共同特征（设计图）的描述

  • 类的定义

    1
    public class 类名{
    2
        1.成员变量
    3
        2.成员方法
    4
        3.构造器
    5
        4.代码块
    6
        5.内部类
    7
    }

    

    成员变量的完整定义格式是：修饰符 数据类型 变量名 = 初始值； 一般无需指定初始值，存在默认值

• 对象：真实存在的具体的对象

  

• Java中 必须先设计类，才能获得对象

• 用来描述一类事物的类，专业叫做：Javabean 类。

  在 Javabean 类中，是不写 main 方法的。

• 在以前，编写 main 方法的类，叫做测试类。

  我们可以在测试类中创建 javabean 类的对象并进行赋值调用。

• 一个代码文件中可以定义多个类，但只有一个是pubic修饰的，且public修饰的要与文件名相同，实际开发中建议一个Java文件中定义一个class类

private关键词#

• private修饰的成员只能在类中被访问

  可以对private修饰的成员变量构建一个成员方法接口对外提供，在方法中对数据范围进行判断

  

  如此可以确保数据的安全性，防止非法数据传入

概述#

• Java定义好的类，定义在java.lang包中，所以使用时不需要导包

• Java中所有字符串文字都被视为此类的对象

• 字符串不可变，它们的值在创建后不可更改

  

String的创建#

1. 直接赋值

   1
   String name = "abc"

2. new

   构造方法	说明
   public String()	创建空白字符串，不含任何内容
   public String(String original)	根据传入的字符串，创建字符串对象
   public String(char[] chs)	根据字符数组，创建字符串对象
   public String(byte[] chs)	根据字节数组，创建字符串对象

   

String内存分析#

• String Table 串池

  

1. 直接赋值创建String

   直接赋值的字符串会创建在串池中

   

   此时的String作为字符串常量，若已经存在不会创建新的，String对象所存储的是其地址值

2. new创建String

   

   这种情况的字符串不会复用

String比较#

1. ==比较

   这种比较方式比较的是地址的值（字符串对象存储的都是地址值）。可以用于直接赋值法创建的字符串，因为串池中的字符串常量地址是唯一的、可复用。但是对于new出来的字符串，就算其内容相同，其地址也不相同

   • Scanner录入的字符串也是通过new出来的

     输入abc结果为false

     next源码阅读（IDEA鼠标置于next 快捷键ctrl+b）

2. 利用API比较

   1. boolean equals（完全一致）
   2. boolean equalsIgnoreCase(忽略大小写)
   

charAt API#

• public char charAt(int index)

  可根据索引返回字符串中对应字符

  

一些练习#

• 数组转字符串方法

  

• 金额转换

  • 效果

    

  • 思路

    

  • 代码

    

substring API#

• String substring(int beginIndex,int endIndex) 截取字符串 tip:范围左闭右开

  • 注意：若无endIndex则截取到末尾
  

replace API#

• String replace （旧值，新值） 字符串的替换，返回值为替换后的结果

  

toCharArray API#

• 把字符串变成字符数组

  

概述#

StringBuilder可以视为一个容器，创建后里面的内容是可变的

• 作用

  提高字符串操作效率

• 常用于字符串拼接和反转

构造方法与成员方法#

• 构造方法

  • 空参

    public StringBuilder()

  • 有参

    public StringBuilder(String str);

• 常用成员方法

  方法名	说明
  public StringBuilder append(任意类型)	添加数据，并返回对象本身
  public StringBuilder reverse()	反转容器中的内容
  public int length()	返回长度（字符出现的个数）
  public String toString()	通过 toString () 就可以实现把 StringBuilder 转换为 String

  

链式编程思想#

• 依赖前一个方法的返回值调用其他方法

  

  原因：StringBuilder中append的返回还是Stringbuilder

概述#

• StringJoiner也是一个容器，内部内容是可变的
• 作用：提高字符串操作效率，代码简洁

构造方法和成员方法#

• 构造方法

  1. public StringJoiner(间隔符号);
  2. public StringJoiner(间隔符号，开始符号，结束符号);

• 成员方法

  方法名	说明
  public StringJoiner add (添加的内容)	添加数据，并返回对象本身
  public int length()	返回长度（字符出现的个数）
  public String toString()	返回一个字符串（该字符串就是拼接之后的结果）

  

拼接底层原理#

1. 拼接时无变量参与

   

   由于在编译阶段就对其进行了优化，所以无变量参与这种情况的字符串是在串池中的

2. 拼接时有变量参与

   • JDK8之前会创建StringBuilder拼接

     

     tip：toString方法是通过new把StringBuilder变成String

     由此可见，直接用StringBuilder不仅可以简化代码 还可以提高运行效率

   • JDK8后会先预估最后字符串的长度，再根据最后长度创建数组，一次性拼接。但是这样仍然效率不高，所以我们自己拼接时最好直接用StringBuilder/StringJoiner

StringBuilder源码分析#

• 原理

  StringBuilder默认容量为16，当容量不够后会扩容 新的容量=2*旧容量+2 而若是一次性加入的字符串长度比扩容后还要长 则会创建一个长度=字符串长度的数组并存入

• 具体分析

  视频 28min开始

static修饰成员变量#

• static修饰成员变量—静态变量

  静态变量被所有对象共享，推荐使用类名调用

  静态变量存放在堆空间中的静态区中（JDK8后），在包含类的class文件加载到方法取后，静态区就随之出现。 静态变量随类的加载而出现，是先于对象出现的

  

static修饰成员方法#

• static修饰成员方法—静态方法

  静态方法多被用于测试类和工具类，Javabean类中很少用到

  • 工具类：可以帮助我们做一些事情，但不描述任何事物的类

    • 要求1：类名见名知意

    • 要求2：私有化构造方法 — 不让外界创建对象（无意义）

    • 方法全都定义为静态 –> 直接用类名调用

    

static注意事项#

1. 静态方法中，只能访问静态变量/方法。

   静态方法是随着类的加载而出现，是先于对象出现的，此时非静态变量都没在堆中开辟空间，更别提访问了 静态方法若能调用非静态方法，那非静态方法中的this会不知道指向谁，所以不能访问非静态变量

2. 非静态方法可以访问所有。

3. 静态方法中没有this关键字

   原因：this本质是指向调用者的指针，所有对象都可以调用静态方法，这样this指针就不知道该指向谁了。并且我们调用静态的方法一般都是用类名去调用，所以静态方法中用this指针的意义也不大

概述#

• 当封装的Javabean类过多时，难免会有许多重复的内容，可以将重复的变量/方法封装在某个大类中，创建小类时继承这些属性即可。提高代码复用性

  

实现#

• Java中提供了extends关键字

  

• 如何设计？

  • 何时会用到继承？

    当类与类之间存在相同的内容时，并满足子类是父类中的一种，就可以考虑使用继承

继承特点#

• Java中只支持单继承，不支持多继承，但支持多层继承

  单继承：一个子类只能继承一个父类

  tip：相较于Cpp中的支持多继承，Java中只支持单继承更加规范

  • 多层继承

    

    • 最大祖宗类

      Java中每个类都直接或间接继承于Object类（Java提供的默认继承）

      

子类可继承的内容#

• 子类可以继承父类哪些内容？

  

  注意：继承不代表可以使用

• 构造方法

  由于构造方法的方法名必须与类名相同，所以父类的构造方法无论如何都不能被子类继承

• 成员变量

  不论是私有还是共有都可以继承，只不过私有的成员变量继承下来后不能直接使用—需要根据继承下来的对应的get/set方法使用

  :star<可以理解为>：成员变量会按照父类中的成员变量原模原样的继承下来（包括private关键词），若是private的变量，父类Javabean中必定会有public的成员set/get方法，这个也会被继承下来，所以可以使用set/get调用

• 成员方法

  • 方法的继承实际上继承的是虚方法表

    

    实际上子类会把父类中的所有方法都继承下来，除此之外还会把虚方法表继承下来

    虚方法表中存储了各个虚方法的地址，若调用虚方法，直接查表调用虚方法

    而若想要调用非虚方法时 （即：final修饰和static修饰，private修饰无法被调用）

    

子类访问继承内容#

• 成员变量访问特点 — 就近原则

  

  • this和super关键字

    

  tip：super不能链式调用

• 成员方法的访问特点

  • 直接调用 — 就近原则
  • super调用 — 直接访问父类
  

  第一个例子中的this调用和直接调用等价

• 构造方法访问特点

  • 子类中的所有构造方法都是先访问父类中的无参构造（构造方法无法继承，但可以用super访问），再执行自己

    原因：子类初始化时可能会用到父类中的数据

    

    如图所示，Tedy和Harshiky这两个Dog的子类再构造时都使用了Dog的无参构造

  • 如何调用父类构造方法？

    子类构造的第一句一般都为：super()，一般JVM虚拟机会自动加上

    若子类要调用父类的带参构造直接在super()的括号中传参即可 //需要自己写

    

    如图所示，manager继承于emoply 当写带全部参数的构造函数时，可以用super()调用employ中的构造函数用以构造继承下来的变量

方法的重写#

• 即：在子类中重写一个与父类同名的方法 适用于父类方法不能满足子类需求的情况

• 重写流程

  

• 例子

  

  其中Cat继承Animal 重写了eat方法

• 重写的本质 — 虚方法表的覆盖

  

  上图中B先对method2进行重写 A继承后又重写method2

• 重写注意事项

  1. 重写方法的名称、形参列表必须与父类方法中的一致
  2. 重写方法的访问权限子类必须>=父类
  3. 子类重写的方法的返回值类型必须<=父类

  对于2，3的建议：重写方法尽量和父类保持一致

  4. 只有被添加到虚方法表里的方法才能重写

概述#

多态即对象的多种形态

• 作用

  

  遇到此类情况，若没有多态就要写三个接口，代码冗余

  

  使用多态的技术，参数写的是三者共同的父类Person，如此一来三者都可以被函数正常接收。

多态的实现#

• 多态的表现形式

  1
  父类类型 对象名称 = 子类对象

• 多态的前提

  1. 有继承关系
  2. 有父类引用指向子类对象（子类对象赋值给父类类型）
  3. 有方法重写

多态调用成员的特点#

• 变量调用

  编译看左边，运行也看左边

  

• 方法调用

  编译看左边，运行看右边

  

• 理解

  以Animal a = new Dog();为例

  此时a的类型是Animal，所以默认都会从Animal类中去寻找

  • 成员变量

    子类会继承父类的所有成员变量，调用成员变量时由于a是Animal类型的 所以会直接从Animal类（父类）中寻找

  • 成员方法

    子类继承成员方法本质是通过虚方法表继承的，当我们在子类中对某函数进行重写后虚方法表会被覆盖，所以用的是子类中的方法

  • 原理图

    

多态的优势和弊端#

• 优势

  • 多态形势下，右边对象可以实现解耦合，便于扩展和维护

    

  • 定义方法时，使用父类作为参数，可以接受所有子类对象，体现多态的扩展和便利

    

    如图所示，StringBuilder的append方法就是对object类中的复写，如此一来借助多态所有类的数据都可以放入append()中

• 弊端

  多态无法调用子类中特有的方法

  • 例子

    如：有一个Animal类其子类为Dog类，Dog类中有一个特有方法为public lookinghome(){}，当Animal a = new Dog()；时，我们无法用a去调用Dog类中的lookinghome方法

  • 原因：

    对于方法，编译看左边运行看右边，编译时看的是父类中有无此方法，对于父类中没有的方法会直接报错

  • 解决

    把父类强制转换成子类 如:

    1
    Animal a = new Dog();
    2
    Dog d = (Dog) a;
    3
    //注意：不能随便转换
    4
    //如：Cat c = (Cat) a;   a本身时Animal/Dog 不能转换成其他类型的 会报错
    5
    //为防止上述情况出现，Java中提供了instanceof关键词
    6
    if(a instanceof Dog){ //用instanceof先进行判断
    7
        Dog d = (Dog) a;
    8
    }
    9
    
    10
    //Jdk14后的新特性
    11
    if(a instanceof Dog d); //表示先判断，若判断正确则直接强转，转换之后变量名为d

包#

真正使用某个类时，实际上是要把包名加上的（不同包中可能会有同名类） 这被称为全类名（全限定名）

由于这样写过于麻烦，所以可以使用import把包导入 — 导包

final#

• final可用于修饰方法、类、变量

  • 修饰方法

    表明该方法是最终方法，不能被重写

  • 修饰类

    表明该类为最终类，不能被继承

  • 修饰变量

    叫做常量，只能被赋值一次且必须初始化。类似Cpp中的const

    • 取名规范

      单个单词，全部大写

      多个单词，全部大写，单词之间用 _ 隔开, tip<下划线一般用于常量的取名中>

    • 细节

      final修饰基本类型数据，变量存储的数据值不可发生改变

      final修饰引用数据类型，变量中存储的地址值不能发生改变，但此地址指向的对象还是可以改变的

• 拓展：String类的实现

  

  如图可见，

  1. 字符串是把字符存在一个byte [] value数组中的，首先对这个数组进行了final修饰，使得value的指向无法发生变化。
  2. 但如果只有final，仍可以通过如value[x]=y对字符串内容进行改变。所以又加上private进行修饰，使得外界无法访问value，如此实现了字符串内容不可变的效果
  3. String类本身就是final修饰的，使其无法被继承，从而杜绝了通过子类重写函数修改字符串内容的情况
  4. String类中的所有方法都遵循了不修改字符串内容的规则，即：返回一个新字符串，而不是在原有字符串基础上修改

权限修饰符#

• 作用：用来控制一个成员能被访问的范围，可以用于修饰成员变量、方法、构造方法、内部类

• 按作用范围排序：private<空着不写（缺省/默认）<protected<public

  修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
  private	√
  空着不写	√	√
  protected	√	√	√
  public	√	√	√	√

• 使用规则

  实际开发中一般只用private和public，即Javabean类中的成员变量私有，方法公开

  • 特例

    如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有。

    简而言之就是为某方法提供某功能的中间方法，是不对外界提供接口的。如：ArrayList类中的扩容方法，当我们添加元素检测到容量不够时会调用扩容，扩容的方法是不对外界提供接口的 用private修饰

代码块#

• 局部代码块（了解）

  

  出了代码块后变量a会立马被回收，起到节约内存的作用，现在已经用不到了

• 构造代码块

  ​

  1. 构造代码块即写在成员位置的代码块
  2. 作用：把多个构造方法中重复的代码抽取出来
  3. 执行时机：创建对象时，优先于构造方法执行

  由于写法不够灵活，已被淘汰。现在一般将构造方法中重复的部分写为另一个构造方法，在需要调用的时候用this调用

  

• :star<静态代码块>

  在构造代码块的基础上用static修饰

  • 特点：随着类的加载而加载，自动触发，只执行一次

  • 使用场景：在类加载的时候，做一些数据初始化

抽象类#

• 抽象方法：将**共性的行为（方法）**抽取到父类之后。 由于每一个子类执行的内容是不一样， 所以，在父类中不能确定具体的方法体。 该方法就可以定义为抽象方法。

  

  如图，三个动物都有 “吃” 的动作，但是吃的东西各不相同，如此就可以定义一个抽象方法，具体的方法体由各子类重写

• 抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类

• 定义格式

  1
  public abstract 返回值类型 方法名(参数列表);//抽象方法
  2
  public abstract class 类名{}//抽象类

• 注意事项

  1. 抽象类不能实例化**（防止抽象方法被调用）**
  2. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  3. 抽象类可以有构造方法**（作用：创建的子类对象可以用super调用赋值）**
  4. 抽象类的子类
     1. 要么也是抽象类
     2. 要么重写抽象类中的所有抽象方法

• 抽象类的意义

  抽象类为其子类提供了一个模板，当多人一起开发时，重写的代码的调用以及返回值类型更加统一

接口#

• 为什么有接口？

  

  上图中，游泳只是是部分成员的共性，不能直接写到其父类中。但是如果在各自子类中书写又会引起格式的不统一

  所以可以定义一个抽象方法的接口使得代码格式一致

  总而言之：接口不是一类事物，接口只是行为的抽象

• 接口的定义和使用

  • 定义

    1
    public interface 接口名{}

  • 使用

    接口与类之间是实现关系，用implements关键词表示

    1
    public class 类名 implements 接口名1.接口名2...{}
    2
    //接口的实现和继承不冲突
    3
    public class 类名 extends 父类 implements 接口1，接口2...{}

  • 接口的子类被称为实现类，通过重写接口中的所有抽象方法实现

  • 注意：接口不能实例化

  • 接口很像是没有成员变量的抽象类，里面全是抽象方法，因为接口更加侧重功能的实现

• 接口中成员的特点

  • 成员变量

    由于接口侧重于方法的实现，所以接口中要么没有成员变量，要么成员变量都是常量(final)

  • 构造方法：没有

  • 成员方法

    只能是抽象方法

    默认修饰符：public abstract

• 接口和类之间的关系

  实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口 若多个接口中有重名的方法，那么只需要重写一次即可

• 接口与接口之间的关系

  继承关系，可以单继承，也可以多继承

  细节：若实现类实现了最下面的子接口，那么就需要重写所有的抽象方法（最下面的子接口继承了先前所有接口的抽象方法）

内部类#

• 类的五大成员

  属性、方法、构造方法、代码块、内部类

• 内部类定义

  即：在类的内部再定义一个类

  1
  public class outer{//外部类
  2
      public class inner{//内部类
  3
  
  4
      }
  5
  }

• 应用

  

  内部类表示的事物是外部类的一部分

  内部类单独出现是没有任何意义的

• 访问特点

  1. 内部类可以直接访问外部类成员，包括私有成员
  2. 外部类要访问内部类成员就必须创建内部类的对象

Object#

所有类的顶级父类，由于所有的类是没有共同的属性的，所以Object中是没有成员变量的，所以Object只有空参构造

• 常用成员方法

  方法名	说明
  public String toString()	返回对象的字符串表示形式
  public boolean equals(Object obj)	比较两个对象是否相等
  protected Object clone()	对象克隆

• toString应用

  1
  System.out.println();

  上面这个输出的方法在底层的逻辑为

  1. 当打印一个对象时，底层会调用对象的toString方法（重写Object中的toString），把对象变成字符串
  2. 然后打印在控制台上并完成换行处理

• equals

  Object中的equals是比较二者地址值是否相同，所以对于某个JavaBean如果不提供equals的重写就会调用Object中的equals

• clone

  1. 由于clone是protected，只有本类、同包、子类才可以使用

     假设：有一个Student类，一个Test类，都默认继承于Object，在它们内部直接使用super.clone()是允许的。但是在Test类中创建了一个Student对象s s.clone();是不被允许的

     所以我们就需要在Student内部去重写clone方法，向外界提供一个clone的方法

     1
     @Override
     2
     public Object clone() throws CloneNotSupportedException {
     3
         return super.clone();
     4
     }
     5
     //如此返回的是Object类型 接收时需要强转
     6
     s1 = (Student)s.colne();

     除此之外子类还需接入一个Cloneable接口，用于标记（Cloneable接口中没有任何抽象方法，只用作标记）

     1
     public class Student implements Cloneable{
     2
     
     3
     }

  2. 深浅克隆问题

     • 浅克隆（Object中的默认克隆方式）

       

       问题：数组指向的是同一块空间，这样当克隆体/主体改变其中内容时，另一方中的数据也会受到影响，这样就无法做到隔离性

     • 深克隆

       重新new一个数组并将数据拷贝过来

       

       • 深克隆的实现

         

       • 一般会用其他人提供的第三方工具

         1
         //第三方的工具
         2
         //1.第三方写的代码导入到项目中
         3
         //2.编写代码
         4
         Gson gson = new Gson();
         5
         //把对象变成一个字符串
         6
         String s = gson.toJson(u1);
         7
         //再把字符串变回对象就可以了
         8
         User user = gson.fromJson(s, User.class);
         9
         //打印对象
         10
         System.out.println(user);

         

Objects#

• 一个工具类，提供了一些方法完成一些功能

  方法名	说明
  public static boolean equals(Object a, Object b)	先做非空判断，比较两个对象
  public static boolean isNull(Object obj)	判断对象是否为 null，为 null 返回 true，反之false
  public static boolean nonNull(Object obj)	判断对象是否为 null，跟 isNull 的结果相反

BigInteger#

• 超大整数

• 构造方法

  方法名	说明
  public BigInteger(int num, Random rnd)	获取随机大整数，范围：[0∼2^num^−1]
  public BigInteger(String val)	获取指定的大整数
  public BigInteger(String val, int radix)	获取指定进制的大整数
  public static BigInteger valueOf(long val)	静态方法获取对象，内部有优化

  

  第四种方法的优化：对 -16~16范围内的数字进行了优化，即：提前创建好了-16 ~16的BigInteger对象，这样多次创建时就不会重复创建了

  

• 成员方法

  方法名	说明
  public BigInteger add(BigInteger val)	加法
  public BigInteger subtract(BigInteger val)	减法
  public BigInteger multiply(BigInteger val)	乘法
  public BigInteger divide(BigInteger val)	除法，获取商
  public BigInteger[] divideAndRemainder(BigInteger val)	除法，获取商和余数
  public boolean equals(Object x)	比较是否相同
  public BigInteger pow(int exponent)	次幂
  public BigInteger max/min(BigInteger val)	返回较大值 / 较小值
  public int intValue(BigInteger val)	转为 int 类型整数，超出范围数据有误

• 底层原理

  BigInteger的底层原理就是使用数组进行存储

  1. 首先会将数字转换为二进制补码
  2. 转为补码后以**32位为一组（int的大小）**对二进制补码进行分组
  3. 将每组转换为十进制并存入int数组
  

BigDecimal#

• 超大/精确浮点数

• 构造方法

  有许多种构造方法，但现在只需掌握以下两种

  1
  //1.表示的数不大，不超出double范围
  2
  BigDecimal bd = BigDecimal.valueof(double val/long val);
  3
  //这种方法同BigInteger同样有优化，对于long类型的0~10之内的数据是提前准备好的
  4
  
  5
  //2.数字超出double范围
  6
  BigDecimal bd = BigDecimal("xxxxxx.xxxxx");

• 成员方法

  方法名	说明
  public static BigDecimal valueOf(double val)	获取对象
  public BigDecimal add(BigDecimal val)	加法
  public BigDecimal subtract(BigDecimal val)	减法
  public BigDecimal multiply(BigDecimal val)	乘法
  public BigDecimal divide(BigDecimal val)	除法
  public BigDecimal divide (BigDecimal val, 精确几位，舍入模式)	除法

  对于除不尽的运算需要使用最后一种除法

  例：

  Java把舍入方式单独定义在了RoundingMode（枚举类型）里面

  RoundingMode里面还有许多其他舍入方法如：UP，DOWN，CEILING，FLOOR,HALF_DOWN

• 底层存储

  遍历字符串，存储每一位对应的ASCII码

  

  若是负数，会把负号也存储进来

爬虫#

• 爬虫所实现的功能就是从一段文本中爬取所需信息，即实现了正则表达式的作用二

  • 分类

    爬虫分为本地爬虫和网络爬虫

• Pattern类：正则表达式对象（java.util.regex.Pattern）

  不能直接new，需要用compile方法获取

• Matcher类：文本匹配器，按照正则表达式的规则读取字符串（从头开始读取）

• 实现步骤

  1. 用compile方法创建一个Pattern对象并赋予其正则表达式
  2. 调用Pattern中的matcher方法，其返回值为matcher

  本地爬虫

  网络爬虫，以URL为入口

（非）捕获分组#

• 正则的分组

  即：用()进行表达式的分组，分组编号规则如下

  

• 捕获分组：将规定组的数据捕获出来再用一次

  

  以a123a为例，为了判断第一个字符和最后一个字符是否一致，其正则表达式为：“(.).+\\1” 其中\\1即为分组1

  • 需求1

    

  • 需求2

    

  • 需求3

    

    需求3中**((.)\\2*)** 这一整个整体为组1，里面的(.)为组2 则：(.)和\\2是一样的 \\2的 * 作用于\\2表示其在后面重复出现0或多次， 所以**((.)\\2)**就可以表示多个重复的字母 将其看为一整个整体\\1就可以用到后面了

  • 案例

    

• 非捕获分组

  分组后不需要再用本组数据，仅仅只是把数据括起来，非捕获分组不占用组号