学习笔记：黑马程序员Java-中级篇（第二部分）

最新推荐文章于 2024-06-06 13:30:07 发布

2401_84023683

最新推荐文章于 2024-06-06 13:30:07 发布

阅读量584

点赞数 15

文章标签： java 学习笔记

本文链接：https://blog.csdn.net/2401_84023683/article/details/138248077

版权

class Animal{
    public  void eat()｛
        System.out.println("动物吃东西！")
    ｝
}
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
   
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
}

class Test{
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
        a.catchMouse();//编译报错，编译看左边，Animal没有这个方法
    }
}

10.6.7引用类型转换

10.6.7.1概述

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

回顾基本数据类型转换

自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14

多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。

10.6.7.2向上转型（自动转换）

向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

**原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。**所以子类范围小可以直接自动转型给父类类型的变量。

10.6.7.3向下转型（强制转换）

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

基本用例

/\* 格式：
子类类型 变量名 = (子类类型) 父类变量名; \*/
Aniaml a = new Cat();
Cat c =(Cat) a;

10.6.7.4案例-转型演示

步骤一：定义父类

定义Animal作为父类

abstract class Animal {  
    abstract void eat();  
}

步骤二：定义子类

1.创建Cat实体类，并继承Animal类

class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}

2.创建Dog实体类，并继承Animal类

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void watchHouse() {  
        System.out.println("看家");  
    }  
}

步骤三：演示

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat();  
        a.eat(); 				// 调用的是 Cat 的 eat

        // 向下转型 
        Cat c = (Cat)a;       
        c.catchMouse(); 		// 调用的是 Cat 的 catchMouse
    }  
}

10.6.7.5转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型 
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。

10.6.7.6instanceof关键字（重点）

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型 
如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型 
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

10.6.7.7instanceof新特性

JDK14的时候提出了新特性，把判断和强转合并成了一行

//新特性
//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d
//如果不是，则不强转，结果直接是false
if(a instanceof Dog d){
    d.lookHome();
}else if(a instanceof Cat c){
    c.catchMouse();
}else{
    System.out.println("没有这个类型，无法转换");
}

11.抽象类

笔记小结：

概述：

定义：没有方法体的方法称为抽象方法，包含抽象方法的类就是抽象类
抽象方法：没有方法体的方法
// 抽象方法
public abstract void abstractMethod();
抽象类：包含抽象方法的类
public abstract class AbstractClass {
    // 抽象方法
    public abstract void abstractMethod();
}
注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

abstract介绍

使用
// 被继承
特征：

抽象类得到了拥有抽象方法的能力，也就是说有了自己的一套规范
抽象类失去了创建对象的能力，也就是说不能创建对象

细节：

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错
抽象类存在的意义是为了被子类继承

意义：抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义

抽象类和接口区别，主要在于构造函数、成员变量、继承关系（单继承，多实现）

11.1概述

11.1.1定义

Java抽象类（Abstract Class）是一种特殊的类，它不能被实例化，只能被继承。抽象类用于定义一些基本行为，而具体的行为由其子类来实现。

11.1.2抽象方法

没有方法体的方法，也就是没有"{ }"的方法

11.1.3抽象类

包含抽象方法的类

11.1abstract关键字

11.1.1abstract含义

abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

11.1.2抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

基本用例：

/\* 格式：
修饰符 abstract 返回值类型 方法名 (参数列表)；\*/
public abstract void run()；

11.1.3抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

/\* 格式：
abstract class 类名字 { 
 
} \*/
public abstract class Animal {
    public abstract void run()；
}

11.2基本用例

要求：继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。

// 父类,抽象类
abstract class Employee {
	private String id;
	private String name;
	private double salary;
	
	public Employee() {
	}
	
	public Employee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	// 抽象方法
	// 抽象方法必须要放在抽象类中
	abstract public void work();
}

// 定义一个子类继承抽象类
class Manager extends Employee {
	public Manager() {
	}
	public Manager(String id, String name, double salary) {
		super(id, name, salary);
	}
	// 2.重写父类的抽象方法
	@Override
	public void work() {
		System.out.println("管理其他人");
	}
}

// 定义一个子类继承抽象类
class Cook extends Employee {
	public Cook() {
	}
	public Cook(String id, String name, double salary) {
		super(id, name, salary);
	}
	@Override
	public void work() {
		System.out.println("厨师炒菜多加点盐...");
	}
}

// 测试类
public class Demo10 {
	public static void main(String[] args) {
		// 创建抽象类,抽象类不能创建对象
		// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
// Employee e = new Employee();
// e.work();
		
		// 3.创建子类
		Manager m = new Manager();
		m.work();
		
		Cook c = new Cook("ap002", "库克", 1);
		c.work();
	}
}

说明：

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

11.3特征

抽象类的特征总结起来可以说是 有得有失

有得：抽象类得到了拥有抽象方法的能力。

有失：抽象类失去了创建对象的能力。

其他成员（构造方法，实例方法，静态方法等）抽象类都是具备的。

11.4细节

不需要背，只要当idea报错之后，知道如何修改即可。

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

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

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

抽象类存在的意义是为了被子类继承。

理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

11.5意义

抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义。抽象类可以强制让子类，一定要按照规定的格式进行重写

11.6.抽象类和接口的区别

	抽象类	接口
方法实现	可以有实现的方法和非抽象方法	只有方法签名，无方法实现
构造函数	可以有构造函数	无法定义构造函数
成员变量	可以有成员变量	只能定义常量，无成员变量
继承关系	子类只能继承一个抽象类	类可以实现多个接口
功能实现	提供对类的部分实现	定义契约和行为规范

12.接口

笔记小结：

概述

含义：接口是一种规范或契约，它只定义了方法签名、常量以及嵌套类型的声明，没有方法实现或属性
格式：
//接口的定义格式：
interface 接口名称{
    // 抽象方法
}
// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”
特点：

抽象方法：会自动加上public abstract修饰
常量：会自动加上 public static final修饰

基本实现

实现方式：使用 implements关键字
格式：
/\*\*接口的实现：
 在Java中接口是被实现的，实现接口的类称为实现类。
 实现类的格式:\*/
class 类名 implements 接口1,接口2,接口3...{
}
要求：接口体现的是一种规范，接口对实现类是一种强制性的约束。需要强制重写或定义为抽象类

接口与接口的多继承

含义：一个接口可以继承另一个或多个接口，这被称为接口的多继承
格式：
public interface SportMan extends Law , Abc {
    void run();
}
补充：接口和类之间的关系

类和类是继承关系，只能单继承，不能多继承
类与接口是实现关系，可以单实现，还可以多实现
接口与接口是继承关系，可以单继承，还可以多继承

JDK中接口新增：

JDK7以前：接口中只能定义抽象方法。
JDK8以后：新增默认方法（default method）
格式：public default 返回值类型 方法名(参数列表) {   }
// 例如
public default void show(){
    System.out.println("InterA接口中的默认方法 ---- show");
}
特点：

默认方法不是抽象方法，所以不强制被重写
解决接口升级的问题

注意：

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public可以省略,static不能省略

JDK9以后：新增private修饰符

格式：
- 格式 : private返回值类型方法名(参数列表){}
- 范例: private void show() { }

- 格式: private static返回值类型方法名(参数列表){}
- 范例: private static void method(){ }
接口的多态

含义：当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态

接口的细节

实现类可以同时继承A类也可以实现接口，不过需要实现所有方法
实现类可以同时继承抽象类也可以实现接口，不过需要重写所有方法
实现类实现了两个接口，且两个接口存在相同抽象方法，此时只需重写一次
当实现了接口，子类实现类中的方法跟父类方法同名是，看需求选择重写
做空重写：只需要重写实现类中的部分接口，可先创建类进行重写，在将此类继承，实现部分

12.1概述

12.1.1定义

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的

12.1.2格式

//接口的定义格式：
interface 接口名称{
    // 抽象方法
}

// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

12.1.3特点

在JDK7，包括JDK7之前，接口中的只有包含：抽象方法和常量

12.1.3.1抽象方法

注意：接口中的抽象方法默认会自动加上public abstract修饰，程序员无需自己手写！！
按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。

12.1.3.2常量

在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。

12.2基本用例

public interface InterF {
    // 抽象方法！
    // public abstract void run();
    void run();

    // public abstract String getName();
    String getName();

    // public abstract int add(int a , int b);
    int add(int a , int b);


    // 它的最终写法是：
    // public static final int AGE = 12 ;
    int AGE  = 12; //常量
    String SCHOOL\_NAME = "黑马程序员";

}

12.3基本的实现

12.3.1概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

12.3.2格式

/\*\*接口的实现：
 在Java中接口是被实现的，实现接口的类称为实现类。
 实现类的格式:\*/
class 类名 implements 接口1,接口2,接口3...{

}

12.3.3要求和意义

必须重写实现的全部接口中所有抽象方法。
如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范。

12.3.4案例-基本实现

假如我们定义一个运动员的接口（规范），代码如下：

/\*\*
 接口：接口体现的是规范。
 \* \*/
public interface SportMan {
    void run(); // 抽象方法，跑步。
    void law(); // 抽象方法，遵守法律。
    String compittion(String project);  // 抽象方法，比赛。
}

接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：

package com.itheima._03接口的实现;
/\*\*
 \* 接口的实现：
 \* 在Java中接口是被实现的，实现接口的类称为实现类。
 \* 实现类的格式:
 \* class 类名 implements 接口1,接口2,接口3...{
 \*
 \*
 \* }
 \* \*/
public class PingPongMan  implements SportMan {
    @Override
    public void run() {
        System.out.println("乒乓球运动员稍微跑一下！！");
    }

    @Override
    public void law() {
        System.out.println("乒乓球运动员守法！");
    }

    @Override
    public String compittion(String project) {
        return "参加"+project+"得金牌！";
    }
}

测试代码：

public class TestMain {
    public static void main(String[] args) {
        // 创建实现类对象。
        PingPongMan zjk = new PingPongMan();
        zjk.run();
        zjk.law();
        System.out.println(zjk.compittion("全球乒乓球比赛"));

    }
}

12.3.5案例-多实现

类与接口之间的关系是多实现的，一个类可以同时实现多个接口。

首先我们先定义两个接口，代码如下：

/\*\* 法律规范：接口\*/
public interface Law {
    void rule();
}

/\*\* 这一个运动员的规范：接口\*/
public interface SportMan {
    void run();
}

然后定义一个实现类：

/\*\*
 \* Java中接口是可以被多实现的：
 \* 一个类可以实现多个接口: Law, SportMan
 \*
 \* \*/
public class JumpMan implements Law ,SportMan {
    @Override
    public void rule() {
        System.out.println("尊长守法");
    }

    @Override
    public void run() {
        System.out.println("训练跑步！");
    }
}

说明：

从上面可以看出类与接口之间是可以多实现的，我们可以理解成实现多个规范，这是合理的

12.3接口与接口的多继承

Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口

注意：

类与接口是实现关系
接口与接口是继承关系

接口继承接口就是把其他接口的抽象方法与本接口进行了合并。

案例演示：

public interface Abc {
    void go();
    void test();
}

/\*\* 法律规范：接口\*/
public interface Law {
    void rule();
    void test();
}

 \*
 \*  总结：
 \*     接口与类之间是多实现的。
 \*     接口与接口之间是多继承的。
 \* \*/
public interface SportMan extends Law , Abc {
    void run();
}

12.4JDK8以后接口中新增的方法

允许在接口中定义默认方法，需要使用关键字default修饰

作用：解决接口升级的问题

接口中默认方法的定义格式:
- 格式: public default返回值类型方法名(参数列表){}
- 范例:public default void show(){ }
接口中默认方法的注意事项:
- 默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
- public可以省略，default不能省略
- 如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

示例：

public interface InterA {
     /\*接口中默认方法的定义格式：
 格式：public default 返回值类型 方法名(参数列表) { }

 接口中默认方法的注意事项：
 1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
 2.public可以省略，default不能省略
 3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写\*/


    public abstract void method();

    public default void show(){
        System.out.println("InterA接口中的默认方法 ---- show");
    }
}

接口中，静态的关键字可以不能省略。

接口中，静态的关键字修饰可以又方法体

接口中，静态的关键字是为了解决接口升级的问题

允许在接口中定义定义静态方法，需要用static修饰
接口中静态方法的定义格式:
- 格式: public static返回值类型方法名(参数列表){}
- 范例:public static void show(){ }
接口中静态方法的注意事项:
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略,static不能省略

示例：

在接口中，被static修饰的方法，不能被重写，可以直接调用

重写（子类把从父类继承下来的虚方法表里面的方法进行覆盖了，这才叫重写。）

12.5JDK9新增的方法

基本用例

/\*格式：
private返回值类型方法名(参数列表){} \*/
private void show() { }

/\*格式：
 private static返回值类型方法名(参数列表){} \*/
private static void method(){ }

12.6接口的应用

12.6.1接口的灵活使用

接口代表规则，是行为的抽象。想要让哪个类拥有一个行为，就让这个类实现对应的接口就可以了

若想让某种javaBean实现某种功能，则实现某种接口即可

12.6.2接口的多态

当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态。

说明：

如果一个方法中，当参数为接口时，那么在调用方法时就可传递这个接口的所有实现类对象

基本用例：

public class Main {
    public static void main(String[] args) {
        test(new IHomeServiceImpl());
    }
    private static void test(IHomeService IHomeService){
        IHomeServiceImpl home1= (IHomeServiceImpl) IHomeService;
        home1.test();
    }

说明：

IHomeService为接口，那么当这个接口需要什么对象时，new相应对象即可拿到这个接口对应的实现类对象

12.7适配器设计模式

请查看接口的细节第5个

12.8接口的细节

关于接口的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

当两个接口中存在相同抽象方法的时候，该怎么办？

只要重写一次即可。此时重写的方法，既表示重写1接口的，也表示重写2接口的。

实现类能不能继承A类的时候，同时实现其他接口呢？

继承的父类，就好比是亲爸爸一样
实现的接口，就好比是干爹一样
可以继承一个类的同时，再实现多个接口，只不过，要把接口里面所有的抽象方法，全部实现。

实现类能不能继承一个抽象类的时候，同时实现其他接口呢？

实现类可以继承一个抽象类的同时，再实现其他多个接口，只不过要把里面所有的抽象方法全部重写。

实现类Zi，实现了一个接口，还继承了一个Fu类。假设在接口中有一个方法，父类中也有一个相同的方法。子类如何操作呢？

处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。
处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。

如果一个接口中，有10个抽象方法，但是我在实现类中，只需要用其中一个，该怎么办?（重点）

可以在接口跟实现类中间，新建一个中间类（适配器类）
让这个适配器类去实现接口，对接口里面的所有的方法做空重写。
让子类继承这个适配器类，想要用到哪个方法，就重写哪个方法。
因为中间类没有什么实际的意义，所以一般会把中间类定义为抽象的，不让外界创建对象

13.枚举

笔记小结：

含义：它是一种特殊的数据类型，用于定义一组固定的常量
普通枚举常量

enum Weekday {
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

带有参数的枚举常量

enum DayOfWeek {
    MONDAY(1), TUESDAY(2), WEDNESDAY(3), THURSDAY(4), FRIDAY(5), SATURDAY(6), SUNDAY(7);
    private int value;
    DayOfWeek(int value) {
        this.value = value;
    }
    public int getValue() {
        return this.value;

实现接口的枚举常量

public enum BasicOperation implements Operation {
    PLUS("+") {
        public int apply(int x, int y) { return x + y; }
    }

    private final String symbol;

    BasicOperation(String symbol) {
             this.symbol = symbol;
    }
}

匿名内部类的方式

enum Operation {
    PLUS {
        public int apply(int x, int y) {
            return x + y;
        }
    }
    public abstract int apply(int x, int y);
}

13.1概述

Java中枚举是一种特殊的数据类型，用于定义一组固定的常量。枚举类型定义了一个枚举集合，可以在其中定义枚举常量，并且可以通过名称来访问它们。枚举在Java中是一个独立的类，可以包含属性、方法和构造函数等元素

枚举常量通常用于表示一组有限的可能取值，例如一周中的星期几、一年中的季节、颜色等等。使用枚举类型可以提高代码的可读性、可维护性和可扩展性

13.2基本用例

步骤一：定义枚举

创建枚举Weekday类

enum Weekday {
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

说明：

常量的定义用，作为分隔符进行分割

步骤二：演示

// 调用
Weekday today = Weekday.MONDAY;

说明：

调用的方式类跟静态常量的调用方法相同

13.3枚举常量

/\* 格式
enum 枚举名 {
 枚举常量1，枚举常量2，……
} \*/
enum Weekday {
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

// 使用
Weekday today = Weekday.MONDAY;
System.out.println(day); // 输出 MONDAY

13.4带有参数的枚举常量

/\* 格式 
enum 枚举名 {
 枚举常量1（值），枚举常量2（值），……
} \*/
enum DayOfWeek {
    MONDAY(1), TUESDAY(2), WEDNESDAY(3), THURSDAY(4), FRIDAY(5), SATURDAY(6), SUNDAY(7);
    private int value;
    DayOfWeek(int value) {
        this.value = value;
    }
    public int getValue() {
        return this.value;
    }
}
// 使用
DayOfWeek day = DayOfWeek.MONDAY;
int value = day.getValue();
System.out.println("Today is " + day + ", value is " + value);// 输出Today is MONDAY, value is 1

13.5实现接口的枚举常量

/\* 格式 
public interface Operation {
 int apply(int x, int y);
} \*/

public enum BasicOperation implements Operation {
    PLUS("+") {
        public int apply(int x, int y) { return x + y; }
    },
    MINUS("-") {
        public int apply(int x, int y) { return x - y; }
    },
    TIMES("\*") {
        public int apply(int x, int y) { return x \* y; }
    },
    DIVIDE("/") {
        public int apply(int x, int y) { return x / y; }
    };
    
    private final String symbol;

    BasicOperation(String symbol) {
        this.symbol = symbol;
    }

    @Override public String toString() {
        return symbol;
    }
}

// 使用
int result = BasicOperation.PLUS.apply(1, 2);  // 3

13.6匿名内部类的方式

// 例如
enum Operation {
    PLUS {
        public int apply(int x, int y) {
            return x + y;
        }
    },
    MINUS {
        public int apply(int x, int y) {
            return x - y;
        }
    },
    TIMES {
        public int apply(int x, int y) {
            return x \* y;
        }
    },
    DIVIDE {
        public int apply(int x, int y) {
            return x / y;
        }
    };

    public abstract int apply(int x, int y);
}

// 使用
int result = Operation.PLUS.apply(1, 2) // 返回值为3

14.常用类

笔记小结：

String、StringBuilder、StringJoiner类，见各个小节
字符串原理：请参见字符串原理小节内容。
注意：不断的使用String s = “常量”进行字符串拼接会消耗大量的堆内存空间，建议使用StringJoiner类进行字符串的拼接

14.1String类

笔记小结：

概述：Java 程序中所有的双引号字符串，都是 String 类的对象。String对象不需要导包
特点：

不可变性：频繁修改字符串的操作会导致内存占用和性能问题，因为频繁创建String对象并进行重新赋值
线程安全性：多个线程可以同时访问同一个String对象，而不会出现线程安全问题
存储在常量池中：Java中有一个字符串常量池，用于存储字符串常量

构造方法
String()
String(char[] chs)
String(byte[] bys)
String s = “常量”
构造方法创建对象与直接赋值区别
创建对象：不存在复用，对象每new一次就会在内存中开辟一个新的空间
直接赋值：存在复用，若对象的值是常量池中已存在的，则JVM不会在堆内存中开辟新的空间
字符串比较
== 的作用：基本数据类型比较值，引用数据类型比较地址值
equals方法的作用：比较字符串内容是否相同
equalsIgnoreCase方法的作用：比较字符串内容是否相同，不区分大小写
案例：
手机号屏蔽：字符.substring()
敏感词替换：字符串.replace（）

14.1.1概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

14.1.2特点

不可变性：String对象一旦创建，其内容不可变。这意味着当对一个String对象进行修改时，实际上是创建了一个新的String对象，并将原对象的内容复制到新对象中。因此，频繁修改字符串的操作会导致内存占用和性能问题
线程安全性：由于String对象不可变，所以多个线程可以同时访问同一个String对象，而不会出现线程安全问题
存储在常量池中：Java中有一个字符串常量池，用于存储字符串常量。当创建一个字符串时，如果该字符串已经存在于常量池中，则返回常量池中的字符串对象，否则创建一个新的对象并添加到常量池中
支持操作符+和+=：可以通过+和+=操作符将两个字符串连接起来，形成一个新的字符串。但是需要注意的是，每次使用这些操作符都会创建一个新的String对象
支持Unicode编码：String类中的字符编码采用Unicode编码，这使得String可以支持多种语言和字符集
支持常用的字符串操作：String类提供了许多常用的字符串操作，例如字符串比较、查找、替换、切割、大小写转换等

14.1.3构造方法

常用的构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

示例代码

public class StringDemo01 {
    public static void main(String[] args) {
        //public String()：创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

        //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String s = “abc”： 直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

说明：

字符数组常用在更换某个字符，此时需要构造方法
字节数组常用在把字节信息进行转换，此时需要构造方法

14.1.4构造和直接赋值方式创建对象区别

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

说明：

不存在复用，因为每次new出来的对象会在内存中开辟一个新的空间

直接赋值方式创建

以“ ”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

说明：

当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在。若不存在，则创建新的、若存在则复用

14.1.5字符串的比较

14.1.5.1==号的作用

比较基本数据类型：比较的是具体的值
比较引用数据类型：比较的是对象地址值

14.1.5.2equals方法的作用

方法介绍

public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写

基本用例

public class StringDemo02 {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串对象地址是否相同
        System.out.println(s1 == s2); // false
        System.out.println(s1 == s3); // false
        System.out.println(s3 == s4); // true
        System.out.println("--------");

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // true
        System.out.println(s3.equals(s4)); // true
    }
}

14.1.5.3equalsIgnoreCase方法的作用

equalsIgnoreCase 是 Java 中的一个字符串方法，用于比较两个字符串是否相等，但忽略它们的大小写。它与 equals 方法类似，但不考虑大小写的区别。

方法介绍：

public boolean equalsIgnoreCase(String anotherString)

14.1.5案例—手机号屏蔽

说明：

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽

代码实现：

public class Test8手机号屏蔽 {
    public static void main(String[] args) {
        /\*以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
 最终效果为：131\*\*\*\*9468\*/

        //1.键盘录入一个手机号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号码");
        String phoneNumber = sc.next();//13112349408

        //2.截取手机号码中的前三位
        String star = phoneNumber.substring(0, 3);

        //3.截取手机号码中的最后四位
        //此时我用substring方法，是用1个参数的，还是两个参数的？1个参数的会更好
        //因为现在我要截取到最后，所以建议使用1个参数的。
        String end = phoneNumber.substring(7);

        //4.拼接
        String result = star + "\*\*\*\*" + end;

        System.out.println(result);

    }
}

补充：在 Java 中，substring 是字符串类中的一个方法，用于截取一个字符串的子串

这个方法有两种不同的用法：

截取从指定位置开始到字符串末尾的子串：
public String substring(int beginIndex)
其中，beginIndex 表示截取子串的起始位置。返回从 beginIndex 开始到字符串末尾的子串。

例如：
rustCopy codeString str = "Hello, world!";
String substr = str.substring(7);  // 截取 "world!"
System.out.println(substr);
输出结果为：
world!
截取从指定位置开始到指定位置结束的子串：
public String substring(int beginIndex, int endIndex)
其中，beginIndex 和 endIndex 分别表示截取子串的起始位置和结束位置。返回从 beginIndex 开始到 endIndex - 1 结束的子串。

例如：
rustCopy codeString str = "Hello, world!";
String substr = str.substring(7, 12);  // 截取 "world"
System.out.println(substr);
输出结果为：
world
需要注意的是，substring 方法返回的是一个新的字符串，而不是在原字符串上进行修改。如果 beginIndex 或 endIndex 超出了字符串的范围，会抛出 IndexOutOfBoundsException 异常。

14.1.6案例—敏感词替换

需求1：键盘录入一个字符串，如果字符串中包含（TMD），则使用***替换

public class Test9敏感词替换 {
    public static void main(String[] args) {
        //1.定义一个变量表示骂人的话
        String talk = "后裔你玩什么啊，TMD";


        //2.把这句话中的敏感词进行替换
        String result = talk.replace("TMD", "\*\*\*");

        //3.打印
        System.out.println(talk);
        System.out.println(result);
    }
}

需求2：如果要替换的敏感词比较多怎么办？

public class Test10多个敏感词替换 {
    public static void main(String[] args) {
        //实际开发中，敏感词会有很多很多

        //1.先键盘录入要说的话
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要说的话");
        String talk = sc.next();//后裔你玩什么啊，TMD,GDX,ctmd,ZZ

        //2.定义一个数组用来存多个敏感词
        String[] arr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};

        //3.把说的话中所有的敏感词都替换为\*\*\*

        for (int i = 0; i < arr.length; i++) {
            //i 索引
            //arr[i] 元素 --- 敏感词
            talk = talk.replace(arr[i],"\*\*\*");
        }

        //4.打印结果
        System.out.println(talk);//后裔你玩什么啊，\*\*\*,\*\*\*,\*\*\*,\*\*\*

    }
}

补充：在 Java 中，replace 是字符串类中的一个方法，用于替换一个字符串中的某些字符或子串。****

这个方法有两种不同的用法：

用新的字符串替换掉所有的旧字符串：
 public String replace(CharSequence target, CharSequence replacement)
其中，target 表示要被替换的旧字符串，replacement 表示用于替换的新字符串。返回一个新的字符串，其中所有的 target 都被替换成了 replacement。

例如：
 rustCopy codeString str = "Hello, world!";
String newStr = str.replace("o", "0");  // 替换所有的 "o" 为 "0"
System.out.println(newStr);
输出结果为：
 Hell0, w0rld!
用新的字符串替换掉某个位置开始的一段子串：
 public String replace(int startIndex, int endIndex, String newStr)
其中，startIndex 和 endIndex 分别表示要被替换的子串的起始位置和结束位置（不包括 endIndex 所在的字符），newStr 表示用于替换的新字符串。返回一个新的字符串，其中从 startIndex 开始到 endIndex - 1 结束的子串都被替换成了 newStr。

例如：
 rustCopy codeString str = "Hello, world!";
String newStr = str.replace(7, 12, "JAVA");  // 替换 "world" 为 "JAVA"
System.out.println(newStr);
输出结果为：
 Hello, JAVA!
需要注意的是，replace 方法返回的是一个新的字符串，而不是在原字符串上进行修改。如果 startIndex 或 endIndex 超出了字符串的范围，会抛出 IndexOutOfBoundsException 异常。

14.2StringBuilder类

笔记小结：

概述：可以看成是一个容器，创建之后里面的内容是可变的。
常用方法：append（）、length（）、reverse（）、toString（）
链式编程：

含义：对StringBuilder对象进行方法连续操作
格式：
StringBuilder sb = new StringBuilder();
sb.append("aaa").append("bbb").append("ccc").append("ddd");

14.2.1概述

StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。当我们在拼接字符串和反转字符串的时候会使用到

14.2.2成员方法

14.2.3基本用例-基本使用

public class StringBuilderDemo3 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder("abc");

        //2.添加元素
        /\*sb.append(1);
 sb.append(2.3);
 sb.append(true);\*/

        //反转
        sb.reverse();

        //获取长度
        int len = sb.length();
        System.out.println(len);


        //打印
        //普及：
        //因为StringBuilder是Java已经写好的类
        //java在底层对他做了一些特殊处理。
        //打印对象不是地址值而是属性值。
        System.out.println(sb);
    }
}

14.2.4链式编程

public class StringBuilderDemo4 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder();

        //2.添加字符串
        sb.append("aaa").append("bbb").append("ccc").append("ddd");

        System.out.println(sb);//aaabbbcccddd

        //3.再把StringBuilder变回字符串
        String str = sb.toString();
        System.out.println(str);//aaabbbcccddd

    }
}

注意：

需要用tostring将它变为字符串，因为此时为StringBuilder容器而不是字符串

14.3StringJoiner类

笔记小结：

概述：可以看成是一个容器，创建之后里面的内容是可变的。
构造方法：

StringJoiner（间隔符号）
StringJoiner（间隔符号，开始符号，结束符号）

常用方法：

add()
length()
toString()

14.3.1概述

StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。
JDK8出现的

14.3.2构造方法

14.3.3成员方法

14.3.4基本用例-基本使用

//1.创建一个对象，并指定中间的间隔符号
StringJoiner sj = new StringJoiner("---");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
//3.打印结果
System.out.println(sj);//aaa---bbb---ccc

//1.创建对象
StringJoiner sj = new StringJoiner(", ","[","]");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
int len = sj.length();
System.out.println(len);//15
//3.打印
System.out.println(sj);//[aaa, bbb, ccc]
String str = sj.toString();
System.out.println(str);//[aaa, bbb, ccc]

14.4字符串原理（重点）

说明：

详细视频讲解：https://www.bilibili.com/video/BV17F411T7Ao/?p=107

14.4.1扩展底层原理1:字符串存储的内存原理

直接赋值会复用字符串常量池中的
new出来不会复用，而是开辟一个新的空间

14.4.2扩展底层原理2:==号比较的到底是什么?

基本数据类型比较数据值
引用数据类型比较地址值

14.4.3扩展底层原理3:字符串拼接的底层原理

如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。
如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。

常量拼接

变量拼接

说明：

会非常的消耗堆内存，一个加号会在堆中创建两个对象

说明：JDK8之后将字符串拼接进行了优化处理

在 JDK8 中，Java 对字符串拼接进行了优化处理。在之前的版本中，字符串拼接通常会使用 + 运算符，这会创建大量的临时字符串对象，导致内存的浪费和垃圾回收的频繁发生，降低程序的性能。
为了解决这个问题，JDK8 中引入了新的字符串拼接方式，即使用 StringBuilder 类或 StringJoiner 类进行拼接。这些类在内部使用可变长度的字符数组来存储字符串，可以避免创建大量的临时字符串对象，提高了程序的性能和效率。

例如，以下代码使用 StringBuilder 类进行字符串拼接：
String name = "John";
int age = 30;
String city = "New York";

String message = new StringBuilder("My name is ")
.append(name)
.append(", I am ")
.append(age)
.append(" years old, and I live in ")
.append(city)
.toString();

System.out.println(message);
输出结果为：
My name is John, I am 30 years old, and I live in New York
需要注意的是，这种优化并不意味着在所有情况下都应该使用 StringBuilder 或 StringJoiner 类进行字符串拼接。在一些简单的情况下，直接使用 + 运算符可能更加方便和易读。开发者应该根据具体情况选择合适的方式进行字符串拼接。

14.4.4扩展底层原理4:StringBuilder提高效率原理图

所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存

说明：

StringBuilder是一个内容可变的容器

14.4.5扩展底层原理5：StringBuilder源码分析

默认创建一个长度为16的字节数组
添加的内容长度小于16，直接存
添加的内容大于16会扩容（原来的容量*2+2)
如果扩容之后还不够，以实际长度为准

说明：

StrinBuilder会创建默认为16的字节数组

15.内部类

笔记小结：

概述

定义：定义在另一个类中的类
作用：实现更好的封装性，内部的事务脱离外部的事务无法使用

分类：
成员内部类，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
局部内部类，类定义在方法内
匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。
成员内部类：请见成员内部类小节
静态内部类：请见成员内部类小节
局部内部类：请见成员内部类小节
匿名内部类：请见成员内部类小节。只使用一次类时，可以使用匿名内部类

15.1概述

15.1.1定义

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。

Java内部类是定义在另一个类中的类，它可以访问包含它的外部类的所有成员和方法，包括私有成员和方法。

15.1.2作用

一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用

人里面有一颗心脏。
汽车内部有一个发动机。
为了实现更好的封装性。

15.2分类

成员内部类，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
局部内部类，类定义在方法内
匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

15.3成员内部类

笔记小结：

特点：无static修饰的内部类，属于外部类对象
使用：
// 前提需要new对象 
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类
获取内部类对象方式

外部直接创建成员内部类的对象
  外部类.内部类 变量 = new 外部类（）.new 内部类（）;
在外部类中定义一个方法提供内部类的对象
  public class Outer {
    String name;
    private class Inner{
        static int a = 10;
    }
    public Inner getInstance(){
        return new Inner();
    }
}
细节：

成员内部类可以被一些修饰符所修饰，例如： private，默认，protected等
在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量
创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值

内存图：

方法区中的字节码文件，会加载外部内字节码文件和内部类的字节码文件，它是两个独立的字节码文件

2. 当new Inner（）时会在堆内存中记录隐藏的this，而这个this是外部类的地址
3. 补充：a，就近原则、this.a，是内部类中的a、Outer.this.a，是外部类中的a

15.3.1特点

无static修饰的内部类，属于外部类对象的。
宿主：外部类对象。

15.3.2使用格式

 // 前提是new对象
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

15.3.3获取成员内部类对象

方式一：外部直接创建成员内部类的对象

/\* 格式：
 外部类.内部类 变量 = new 外部类（）.new 内部类（）;\*/
public class Test {
    public static void main(String[] args) {
        // 宿主：外部类对象。
       // Outer out = new Outer();
        // 创建内部类对象。
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}

class Outer {
    // 成员内部类，属于外部类对象的。
    // 拓展：成员内部类不能定义静态成员。
    public class Inner{
        // 这里面的东西与类是完全一样的。
        public void method(){
            System.out.println("内部类中的方法被调用了");
        }
    }
}

方式二：在外部类中定义一个方法提供内部类的对象

public class Outer {
    String name;
    private class Inner{
        static int a = 10;
    }
    public Inner getInstance(){
        return new Inner();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        System.out.println(o.getInstance());


    }
}

说明：

当成员内部类被private修饰时。在外部类编写方法，对外提供内部类对象
当成员内部类被非私有修饰时，直接创建对象。Outer.Inner oi = new Outer().new Inner();

15.3.4细节

编写成员内部类的注意点：

成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见"成员内部类"的内存图）

详解：

内部类被private修饰，外界无法直接获取内部类的对象，只能通过“成员内部类”中的方式二获取内部类的对象
被其他权限修饰符修饰的内部类一般“成员内部类”中的方式一直接获取内部类的对象
内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。
内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

15.3.5内存图（重点）

说明：

方法区中的字节码文件，会加载外部内字节码文件和内部类的字节码文件，它是两个独立的字节码文件

当new Inner（）时会在堆内存中记录隐藏的this，而这个this是外部类的地址
补充：a，就近原则、this.a，是内部类中的a、Outer.this.a，是外部类中的a

15.3.6案例–面试题

注意：

内部类访问外部类对象的格式是：外部类名.this

public class Test {
    public static void main(String[] args) {
        Outer.inner oi = new Outer().new inner();
        oi.method();
    }
}

class Outer {	// 外部类
    private int a = 30;

    // 在成员位置定义一个类
    class inner {
        private int a = 20;

        public void method() {
            int a = 10;
            System.out.println(???);	// 10 答案：a
            System.out.println(???);	// 20 答案：this.a
            System.out.println(???);	// 30 答案：Outer.this.a
        }
    }
}

说明：

外部类成员变量和内部类成员变量重名时，在内部类如何访问?使用System.out.println(outer.this.变量名);

15.4静态内部类

笔记小结：

特点：有static修饰，属于外部类本身的
使用：
外部类名.内部类名.方法名();  
获取内部类对象方式
外部类.内部类  变量 = new  外部类.内部类构造器;

15.4.1特点

静态内部类是一种特殊的成员内部类。
有static修饰，属于外部类本身的。

总结：

静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。

补充：

静态内部类可以直接访问外部类的静态成员。
静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。
静态内部类中没有隐含的Outer.this。

15.4.2使用格式

外部类名.内部类名.方法名();

15.4.3获取成员内部类对象

/\* 格式：
 外部类.内部类 变量 = new 外部类.内部类构造器; \*/
// 外部类：Outer01
class Outer01{
    private static  String sc_name = "黑马程序";
    // 内部类: Inner01
    public static class Inner01{
        // 这里面的东西与类是完全一样的。
        private String name;
        public Inner01(String name) {
            this.name = name;
        }
        public void showName(){
            System.out.println(this.name);
            // 拓展:静态内部类可以直接访问外部类的静态成员。
            System.out.println(sc_name);
        }
    }
}

public class InnerClassDemo01 {
    public static void main(String[] args) {
        // 创建静态内部类对象。
        // 外部类.内部类 变量 = new 外部类.内部类构造器;
        Outer01.Inner01 in  = new Outer01.Inner01("张三");
        in.showName();
    }
}

说明：

注意区分成员内部类的创建方式 Outer.inner oi = new Outer().new inner();

15.5局部内部类

笔记小结：

特点：定义在方法中的类
使用格式

 class 外部类名 {
	数据类型 变量名;

	修饰符 返回值类型 方法名(参数列表) {
    		// …
		class 内部类 {
			// 成员变量
			// 成员方法
		}
	}
}

15.5.1特点

局部内部类 ：定义在方法中的类

15.5.2使用格式

class 外部类名 {
	数据类型 变量名;
	
	修饰符 返回值类型 方法名(参数列表) {
		// …
		class 内部类 {
			// 成员变量
			// 成员方法
		}
	}
}

15.6匿名内部类（重点）

笔记小结：

特点：

定义一个没有名字的内部类
这个类实现了父类，或者父类接口
匿名内部类会创建这个没有名字的类的对象

使用格式：new 接口或者 new 父类
new 父类名或者接口名(){
  // 方法重写
  @Override 
  public void method() {
      // 执行语句
  }
};
使用方式
new 父类或方法后直接.调用
  new Swim() {
    @Override
    public void swimming() {
        System.out.println("自由泳...");
    }
}.swimming();
new 父类或方法后直接赋值
  // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
    @Override
    public void swimming() {
        System.out.println("蛙泳...");
    }
};
s2.swimming();
意义：定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码

匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类了。

15.6.1特点

定义一个没有名字的内部类
这个类实现了父类，或者父类接口
匿名内部类会创建这个没有名字的类的对象

15.6.2使用格式

前提：

匿名内部类必须继承一个父类或者实现一个父接口

new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {
        // 执行语句
    }
};

注意：

使用前提，要么继承父类，要么实现接口

15.6.3获取匿名内部类

概述：

1.直接new接口

new Swim() {
    @Override
    public void swimming() {
        System.out.println("自由泳...");
    }
}.swimming();

2.重写子类方法

// 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
    @Override
    public void swimming() {
        System.out.println("蛙泳...");
    }
};

基本用例：

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
		new Swim() {
			@Override
			public void swimming() {
				System.out.println("自由泳...");
			}
		}.swimming();

        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };

        s2.swimming();
        s2.swimming();
    }
}

15.6.4应用场景

之前我们使用接口时，似乎得做如下几步操作：

定义子类
重写接口中的方法
创建子类对象
调用重写后的方法

interface Swim {
    public abstract void swimming();
}

// 1. 定义接口的实现类
class Student implements Swim {
    // 2. 重写抽象方法
    @Override
    public void swimming() {
        System.out.println("狗刨式...");
    }
}

public class Test {
    public static void main(String[] args) {
        // 3. 创建实现类对象
        Student s = new Student();
        // 4. 调用方法
        s.swimming();
    }
}

现在：通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 普通方式传入对象
        // 创建实现类对象
        Student s = new Student();
        
        goSwimming(s);
        // 匿名内部类使用场景:作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);

        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });

        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }

    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}

15.6.5意义

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

16.包装类

笔记小结：

概述：

定义：每个基本数据类型都有一个对应的包装类，这些包装类提供了一些有用的方法
作用：包装类是一种用来将基本数据类型（例如int，char，float等）转换为对象类型的类

方法：

将基本数据类型转换为对象类型：valueOf（int）、valueOf（string）
进制转换：tobinarystring(int i)、tooctalstring(int i)、toHexstring(int i)
解析为包装类：parseXXX(string s)

装箱与拆箱：基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“
自动装箱与自动拆箱：注意，从JDK5以后，将自动完成拆箱与装箱。我们在使用时，必要时需要类型判断
基本类型与字符串之间的转换：

基本类型 —>String：XXX.valueOf( )
// 例如
String s2 = String.valueOf(123);
String —>基本类型：XXX.praseXXX( )
// 例如
int y = Integer.parseInt("123");

16.1概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

16.2包装类方法

例如：Interger类

Integer类概述

包装一个对象中的原始类型 int 的值

Integer类构造方法及静态方法

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回保存指定String值的 Integer 对象
static string tobinarystring(int i)	得到二进制
static string tooctalstring(int i)	得到八进制
static string toHexstring(int i)	得到十六进制
static int parseInt(string s)	将字符串类型的整数转成int类型的整数

示例代码

//public Integer(int value)：根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(100);
System.out.println(i1);

//public Integer(String s)：根据 String 值创建 Integer 对象(过时)
Integer i2 = new Integer("100");
//Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("--------");

//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);

//public static Integer valueOf(String s)：返回保存指定String值的Integer对象 
Integer i4 = Integer.valueOf("100");
System.out.println(i4);


/\*
 public static string tobinarystring(int i) 得到二进制
 public static string tooctalstring(int i) 得到八进制
 public static string toHexstring(int i) 得到十六进制
 public static int parseInt(string s) 将字符串类型的整数转成int类型的整数
 \*/

//1.把整数转成二进制，十六进制
String str1 = Integer.toBinaryString(100);
System.out.println(str1);//1100100

//2.把整数转成八进制
String str2 = Integer.toOctalString(100);
System.out.println(str2);//144

//3.把整数转成十六进制
String str3 = Integer.toHexString(100);
System.out.println(str3);//64

//4.将字符串类型的整数转成int类型的整数
//强类型语言:每种数据在java中都有各自的数据类型
//在计算的时候，如果不是同一种数据类型，是无法直接计算的。
int i = Integer.parseInt("123");
System.out.println(i);
System.out.println(i + 1);//124
//细节1:
//在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
//细节2:
//8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
String str = "true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);

16.3装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

补充：为什么需要拆箱与包箱

基本类型在内存中占据固定大小的空间，而引用类型在内存中只存储指向对象的引用

16.4自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如:

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

16.5基本类型与字符串之间的转换

16.5.1基本类型转换为String

转换方式
- 方式一：直接在数字后加一个空字符串
- 方式二：通过String类静态方法valueOf()
示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}

16.5.2String转换为基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

转换方式
- 方式一：先将字符串数字转成Integer，再调用valueOf()方法
- 方式二：通过Integer静态方法parseInt()进行转换
示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2: 
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

注意：

如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

16.5.3底层原理

建议：获取Integer对象的时候不要自己new，而是采取直接赋值或者静态方法valueOf的方式

因为在实际开发中，-128~127之间的数据，用的比较多。如果每次使用都是new对象，那么太浪费内存了。

所以，提前把这个范围之内的每一个数据都创建好对象，如果要用到了不会创建新的，而是返回已经创建好的对象。

//1.利用构造方法获取Integer的对象(JDK5以前的方式)
/\*Integer i1 = new Integer(1);
 Integer i2 = new Integer("1");
 System.out.println(i1);
 System.out.println(i2);\*/

//2.利用静态方法获取Integer的对象(JDK5以前的方式)
Integer i3 = Integer.valueOf(123);
Integer i4 = Integer.valueOf("123");
Integer i5 = Integer.valueOf("123", 8);

System.out.println(i3);
System.out.println(i4);
System.out.println(i5);

//3.这两种方式获取对象的区别(掌握)
//底层原理：
//因为在实际开发中，-128~127之间的数据，用的比较多。
//如果每次使用都是new对象，那么太浪费内存了
//所以，提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的，而是返回已经创建好的对象。
Integer i6 = Integer.valueOf(127);
Integer i7 = Integer.valueOf(127);
System.out.println(i6 == i7);//true

Integer i8 = Integer.valueOf(128);
Integer i9 = Integer.valueOf(128);
System.out.println(i8 == i9);//false

//因为看到了new关键字，在Java中，每一次new都是创建了一个新的对象
//所以下面的两个对象都是new出来，地址值不一样。
/\*Integer i10 = new Integer(127);
 Integer i11 = new Integer(127);
 System.out.println(i10 == i11);

 Integer i12 = new Integer(128);
 Integer i13 = new Integer(128);
 System.out.println(i12 == i13);\*/

17.常用API

笔记小结：见各个小结

17.1API帮助文档

笔记小结：

概述：API，简称应用程序编程接口。简单说就是JDK中提供的功能类

17.1.1概述

API (Application Programming Interface) ：应用程序编程接口。指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

17.1.2使用

步骤一：打开

打开帮助文档

步骤二：索引

1.找到索引选项卡中的输入框

2.在输入框中输入Random

步骤三：介绍

1.看类在哪个包下

2.看类的描述

3.看构造方法

4.看成员方法

17.2Math类

笔记小结：

概述：使用Math类完成基本的数学运算
方法

public static int abs(int a)					// 返回参数的绝对值
public static double ceil(double a)				// 返回大于或等于参数的最小整数
public static double floor(double a)			// 返回小于或等于参数的最大整数
public static int round(float a)				// 按照四舍五入返回最接近参数的int类型的值
public static int max(int a,int b)				// 获取两个int值中的较大值
public static int min(int a,int b)				// 获取两个int值中的较小值
public static double pow (double a,double b)	// 计算a的b次幂的值
public static double random()					// 返回一个[0.0,1.0)的随机值

17.2.1概述

Math类包含执行基本数字运算的方法，我们可以使用Math类完成基本的数学运算

17.2.2常用成员方法

public static int abs(int a)					// 返回参数的绝对值
public static double ceil(double a)				// 返回大于或等于参数的最小整数
public static double floor(double a)			// 返回小于或等于参数的最大整数
public static int round(float a)				// 按照四舍五入返回最接近参数的int类型的值
public static int max(int a,int b)				// 获取两个int值中的较大值
public static int min(int a,int b)				// 获取两个int值中的较小值
public static double pow (double a,double b)	// 计算a的b次幂的值
public static double random()					// 返回一个[0.0,1.0)的随机值

17.2.3基本用例

public class MathDemo01 {

    public static void main(String[] args) {

        // public static int abs(int a) 返回参数的绝对值
        System.out.println("-2的绝对值为：" + Math.abs(-2));
        System.out.println("2的绝对值为：" + Math.abs(2));

        // public static double ceil(double a) 返回大于或等于参数的最小整数
        System.out.println("大于或等于23.45的最小整数位：" + Math.ceil(23.45));
        System.out.println("大于或等于-23.45的最小整数位：" + Math.ceil(-23.45));

        // public static double floor(double a) 返回小于或等于参数的最大整数
        System.out.println("小于或等于23.45的最大整数位：" + Math.floor(23.45));
        System.out.println("小于或等于-23.45的最大整数位：" + Math.floor(-23.45));

        // public static int round(float a) 按照四舍五入返回最接近参数的int
        System.out.println("23.45四舍五入的结果为：" + Math.round(23.45));
        System.out.println("23.55四舍五入的结果为：" + Math.round(23.55));

        // public static int max(int a,int b) 返回两个int值中的较大值
        System.out.println("23和45的最大值为: " + Math.max(23, 45));

        // public static int min(int a,int b) 返回两个int值中的较小值
        System.out.println("12和34的最小值为: " + Math.min(12 , 34));

        // public static double pow (double a,double b)返回a的b次幂的值
        System.out.println("2的3次幂计算结果为: " + Math.pow(2,3));

        // public static double random()返回值为double的正值，[0.0,1.0)
        System.out.println("获取到的0-1之间的随机数为: " + Math.random());
    }

}

/\*
\* 
 -2的绝对值为：2
 2的绝对值为：2
 大于或等于23.45的最小整数位：24.0
 大于或等于-23.45的最小整数位：-23.0
 小于或等于23.45的最大整数位：23.0
 小于或等于-23.45的最大整数位：-24.0
 23.45四舍五入的结果为：23
 23.55四舍五入的结果为：24
 23和45的最大值为: 45
 12和34的最小值为: 12
 2的3次幂计算结果为: 8.0
 获取到的0-1之间的随机数为: 0.7322484131745958
\* \*/

17.3System类

笔记小结：

概述：包含了系统操作的一些常用的方法
常用成员方法

public static long currentTimeMillis()			// 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）
public static void exit(int status)				// 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出
public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length); // 进行数值元素copy

17.3.1概述

System类所在包为java.lang包，因此在使用的时候不需要进行导包。并且System类被final修饰了，因此该类是不能被继承的。

System包含了系统操作的一些常用的方法。比如获取当前时间所对应的毫秒值，再比如终止当前JVM等等。

17.3.2常用成员方法

public static long currentTimeMillis()			// 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）
public static void exit(int status)				// 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出
public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length); // 进行数值元素copy

17.3.3基本用例

public class SystemDemo01 {

    public static void main(String[] args) {

        // 获取当前时间所对应的毫秒值
        long millis = System.currentTimeMillis();

        // 输出结果
        System.out.println("当前时间所对应的毫秒值为：" + millis);

    }

}

public class SystemDemo01 {

    public static void main(String[] args) {
        
        // 输出
        System.out.println("程序开始执行了.....");
        
        // 终止JVM
        System.exit(0);
        
        // 输出
        System.out.println("程序终止了..........");
        
    }
    
}

public class SystemDemo01 {

    public static void main(String[] args) {

        // 定义源数组
        int[] srcArray = {23 , 45 , 67 , 89 , 14 , 56 } ;

        // 定义目标数组
        int[] desArray = new int[10] ;

        // 进行数组元素的copy: 把srcArray数组中从0索引开始的3个元素，从desArray数组中的1索引开始复制过去
        System.arraycopy(srcArray , 0 , desArray , 1 , 3);

        // 遍历目标数组
        for(int x = 0 ; x < desArray.length ; x++) {
            if(x != desArray.length - 1) {
                System.out.print(desArray[x] + ", ");
            }else {
                System.out.println(desArray[x]);
            }

        }

    }

}

17.4Runtime类

笔记小结：

概述：Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息
常用成员方法：

public static Runtime getRuntime()		//当前系统的运行环境对象
public void exit(int status)			//停止虚拟机
public int availableProcessors()		//获得CPU的线程数
public long maxMemory()				    //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory()				//JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory()				//JVM剩余内存大小（单位byte）
public Process exec(String command) 	//运行cmd命令

17.4.1概述

Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息

17.4.2常用成员方法

public static Runtime getRuntime()		//当前系统的运行环境对象
public void exit(int status)			//停止虚拟机
public int availableProcessors()		//获得CPU的线程数
public long maxMemory()				    //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory()				//JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory()				//JVM剩余内存大小（单位byte）
public Process exec(String command) 	//运行cmd命令

17.4.3基本用例

public class RunTimeDemo1 {
    public static void main(String[] args) throws IOException {
        /\*
 public static Runtime getRuntime() 当前系统的运行环境对象
 public void exit(int status) 停止虚拟机
 public int availableProcessors() 获得CPU的线程数
 public long maxMemory() JVM能从系统中获取总内存大小(单位byte)
 public long totalMemory() JVM已经从系统中获取总内存大小(单位byte)
 public long freeMemory() JVM剩余内存大小(单位byte)
 public Process exec(string command) 运行cmd命令
 \*/

        //1.获取Runtime的对象
        //Runtime r1 =Runtime.getRuntime();

        //2.exit 停止虚拟机
        //Runtime.getRuntime().exit(0);
        //System.out.println("看看我执行了吗?");


        //3.获得CPU的线程数
        System.out.println(Runtime.getRuntime().availableProcessors());//8
        //4.总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//4064
        //5.已经获取的总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//254
        //6.剩余内存大小
        System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//251

        //7.运行cmd命令
        //shutdown :关机
        //加上参数才能执行
        //-s :默认在1分钟之后关机
        //-s -t 指定时间 : 指定关机时间
        //-a :取消关机操作
        //-r: 关机并重启
        Runtime.getRuntime().exec("shutdown -s -t 3600");


    }
}

17.5Object类（重点）

笔记小结：

概述：所有类都直接或者间接的继承自该类
常用成员方法：

public String toString()				//返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)		//比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()    			//对象克隆

使用：请查看各小节

17.5.1概述

Object类所在包是java.lang包。Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类；换句话说，该类所具备的方法，其他所有类都继承了。

17.5.2常用成员方法

public String toString()				//返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)		//比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()    			//对象克隆

17.5.3基本用例

常见方法介绍

我们要学习的Object类中的常见方法如下所示：

public String toString()				//返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)		//比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()    			//对象克隆

案例演示

接下来我们就来通过一些案例演示一下这些方法的特点。

案例-演示toString方法

笔记小结

在通过输出语句输出一个对象时，默认调用的就是toString()方法
输出地址值一般没有意义，我们可以通过重写toString方法去输出对应的成员变量信息（快捷键：atl + insert ，空白处右键 -> Generate -> 选择toString）
toString方法的作用：以良好的格式，更方便的展示对象中的属性值
一般情况下Jdk所提供的类都会重写Object类中的toString方法

实现步骤：

创建一个学生类，提供两个成员变量（name ， age）；并且提供对应的无参构造方法和有参构造方法以及get/set方法
创建一个测试类（ObjectDemo01），在测试类的main方法中去创建学生对象，然后调用该对象的toString方法获取该对象的字符串表现形式，并将结果进行输出

如下所示：

Student类

public class Student {

    private String name ;       // 姓名
    private String age ;        // 年龄

    // 无参构造方法和有参构造方法以及get和set方法略
    ...
        
}

ObjectDemo01测试类

public class ObjectDemo01 {

    public static void main(String[] args) {

        // 创建学生对象
        Student s1 = new Student("itheima" , "14") ;

        // 调用toString方法获取s1对象的字符串表现形式
        String result1 = s1.toString();

        // 输出结果
        System.out.println("s1对象的字符串表现形式为：" + result1);

    }

}

运行程序进行测试，控制台输出结果如下所示：

s1对象的字符串表现形式为：com.itheima.api.system.demo04.Student@3f3afe78

为什么控制台输出的结果为：com.itheima.api.system.demo04.Student@3f3afe78；此时我们可以查看一下Object类中toString方法的源码，如下所示：

public String toString() {		// Object类中toString方法的源码定义
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

其中getClass().getName()对应的结果就是：com.itheima.api.system.demo04.Student；Integer.toHexString(hashCode())对应的结果就是3f3afe78。

我们常常将"com.itheima.api.system.demo04.Student@3f3afe78"这一部分称之为对象的内存地址值。但是一般情况下获取对象的内存地址值没有太大的意义。获取对象的成员变量的字符串拼接形式才

算有意义，怎么实现呢？此时我们就需要在Student类中重写Object的toString方法。我们可以通过idea开发工具进行实现，具体步骤如下所示：

在空白处使用快捷键：alt + insert。此时会弹出如下的对话框

1576055135105

选择toString，此时会弹出如下的对话框

1576055198877

同时选择name和age属性，点击OK。此时就会完成toString方法的重写，代码如下所示：

@Override
public String toString() {
    return "Student{" +
        "name='" + name + '\'' +
        ", age='" + age + '\'' +
        '}';
}

这段代码就是把Student类中的成员变量进行了字符串的拼接。重写完毕以后，再次运行程序，控制台输出结果如下所示：

s1对象的字符串表现形式为：Student{name='itheima', age='14'}

此时我们就可以清楚的查看Student的成员变量值，因此重写toString方法的意义就是以良好的格式，更方便的展示对象中的属性值

我们再来查看一下如下代码的输出：

// 创建学生对象
Student s1 = new Student("itheima" , "14") ;

// 直接输出对象s1
System.out.println(s1);

运行程序进行测试，控制台输出结果如下所示：

Student{name='itheima', age='14'}

我们可以看到和刚才的输出结果是一致的。那么此时也就证明直接输出一个对象，那么会默认调用对象的toString方法，因此如上代码的等同于如下代码：

// 创建学生对象
Student s1 = new Student("itheima" , "14") ;

// 调用s1的toString方法，把结果进行输出
System.out.println(s1.toString());

因此后期为了方便进行测试，我们常常是通过输出语句直接输出一个对象的名称。

小结：

在通过输出语句输出一个对象时，默认调用的就是toString()方法
输出地址值一般没有意义，我们可以通过重写toString方法去输出对应的成员变量信息（快捷键：atl + insert ，空白处右键 -> Generate -> 选择toString）
toString方法的作用：以良好的格式，更方便的展示对象中的属性值
一般情况下Jdk所提供的类都会重写Object类中的toString方法

案例-演示equals方法

笔记小结

默认情况下equals方法比较的是对象的地址值
比较对象的地址值是没有意义的，因此一般情况下我们都会重写Object类中的equals方法

实现步骤：

在测试类（ObjectDemo02）的main方法中，创建两个学生对象，然后比较两个对象是否相同

代码如下所示：

public class ObjectDemo02 {

    public static void main(String[] args) {

        // 创建两个学生对象
        Student s1 = new Student("itheima" , "14") ;
        Student s2 = new Student("itheima" , "14") ;

        // 比较两个对象是否相等
        System.out.println(s1 == s2);

    }

}

运行程序进行测试，控制台的输出结果如下所示：

false

因为"=="号比较的是对象的地址值，而我们通过new关键字创建了两个对象，它们的地址值是不相同的。因此比较结果就是false。

我们尝试调用Object类中的equals方法进行比较，代码如下所示：

// 调用equals方法比较两个对象是否相等
boolean result = s1.equals(s2);

// 输出结果
System.out.println(result);

运行程序进行测试，控制台的输出结果为：

false

为什么结果还是false呢？我们可以查看一下Object类中equals方法的源码，如下所示：

public boolean equals(Object obj) {		// Object类中的equals方法的源码
    return (this == obj);
}

通过源码我们可以发现默认情况下equals方法比较的也是对象的地址值。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；

那么要比较对象的属性，我们就需要在Student类中重写Object类中的equals方法。equals方法的重写，我们也可以使用idea开发工具完成，具体的操作如下所示：

在空白处使用快捷键：alt + insert。此时会弹出如下的对话框

1576056718392

选择equals() and hashCode()方法，此时会弹出如下的对话框

1576057779458

点击next，会弹出如下对话框：

1576057813175

选择neme和age属性点击next，此时就会弹出如下对话框：

1576057892814

取消name和age属性（因为此时选择的是在生成hashCode方法时所涉及到的属性，关于hashCode方法后期再做重点介绍），点击Finish完成生成操作。生成的equals方法和hashCode方法如下：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return Objects.equals(name, student.name) && Objects.equals(age, student.age);	// 比较的是对象的name属性值和age属性值
}

@Override
public int hashCode() {
    return 0;
}

hashCode方法我们暂时使用不到，可以将hashCode方法删除。重写完毕以后运行程序进行测试，控制台输出结果如下所示：

true

此时equals方法比较的是对象的成员变量值，而s1和s2两个对象的成员变量值都是相同的。因此比较完毕以后的结果就是true。

小结：

默认情况下equals方法比较的是对象的地址值
比较对象的地址值是没有意义的，因此一般情况下我们都会重写Object类中的equals方法

案例-对象克隆

笔记小结：

浅克隆：

含义：浅克隆是指在克隆对象时，只复制对象本身和其中的基本类型数据，而不复制对象中引用类型的数据，此时复制出来的对象与原对象共享引用类型数据所在的地址。
特点：当原对象中引用类型数据发生改变时，复制出来的对象也会发生变化。

深克隆：

含义：在克隆对象时，不仅复制对象本身和其中的基本类型数据，还要对对象中的引用类型数据进行递归复制，以确保复制出来的对象与原对象的所有数据完全独立，互不影响
特点：可以保证克隆出来的对象与原对象完全独立，互不影响

注意：深克隆会比浅克隆更加耗费时间和资源，但可以保证克隆出来的对象与原对象完全独立，互不影响。而浅克隆虽然速度快，但是容易出现数据共享的问题，需要特别注意。

把A对象的属性值完全拷贝给B对象，也叫对象拷贝,对象复制

对象克隆的分类：

深克隆
浅克隆

浅克隆：

不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来

基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。

Object类默认的是浅克隆

深克隆：

基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的

代码实现：

package com.itheima.a04objectdemo;

public class ObjectDemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // protected object clone(int a) 对象克隆 

        //1.先创建一个对象
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
        User u1 = new User(1, "zhangsan", "1234qwer", "girl11", data);

        //2.克隆对象
        //细节:
        //方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。
        //书写细节:
        //1.重写Object中的clone方法
        //2.让javabean类实现Cloneable接口
        //3.创建原对象并调用clone就可以了
        //User u2 =(User)u1.clone();

        //验证一件事情：Object中的克隆是浅克隆
        //想要进行深克隆，就需要重写clone方法并修改里面的方法体
        //int[] arr = u1.getData();
        //arr[0] = 100;

        //System.out.println(u1);
        //System.out.println(u2);


        //以后一般会用第三方工具进行克隆
        //1.第三方写的代码导入到项目中
        //2.编写代码
        //Gson gson =new Gson();
        //把对象变成一个字符串
        //String s=gson.toJson(u1);
        //再把字符串变回对象就可以了
        //User user =gson.fromJson(s, User.class);

        //int[] arr=u1.getData();
        //arr[0] = 100;

        //打印对象
        //System.out.println(user);

    }
}

package com.itheima.a04objectdemo;

import java.util.StringJoiner;



//Cloneable
//如果一个接口里面没有抽象方法
//表示当前的接口是一个标记性接口
//现在Cloneable表示一旦实现了，那么当前类的对象就可以被克降
//如果没有实现，当前类的对象就不能克隆
public class User implements Cloneable {
    private int id;
    private String username;
    private String password;
    private String path;
    private int[] data;




    public User() {
    }

    public User(int id, String username, String password, String path, int[] data) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.data = data;
    }

    /\*\*
 \* 获取
 \*
 \* @return id
 \*/
    public int getId() {
        return id;
    }

    /\*\*
 \* 设置
 \*
 \* @param id
 \*/
    public void setId(int id) {
        this.id = id;
    }

    /\*\*
 \* 获取
 \*
 \* @return username
 \*/
    public String getUsername() {
        return username;
    }

    /\*\*
 \* 设置
 \*
 \* @param username
 \*/
    public void setUsername(String username) {
        this.username = username;
    }

    /\*\*
 \* 获取
 \*
 \* @return password
 \*/
    public String getPassword() {
        return password;
    }

    /\*\*
 \* 设置
 \*
 \* @param password
 \*/
    public void setPassword(String password) {
        this.password = password;
    }

    /\*\*
 \* 获取
 \*
 \* @return path
 \*/
    public String getPath() {
        return path;
    }

    /\*\*
 \* 设置
 \*
 \* @param path
 \*/
    public void setPath(String path) {
        this.path = path;
    }

    /\*\*
 \* 获取
 \*
 \* @return data
 \*/
    public int[] getData() {
        return data;
    }

    /\*\*
 \* 设置
 \*
 \* @param data
 \*/
    public void setData(int[] data) {
        this.data = data;
    }

    public String toString() {
        return "角色编号为：" + id + "，用户名为：" + username + "密码为：" + password + ", 游戏图片为:" + path + ", 进度:" + arrToString();
    }


    public String arrToString() {
        StringJoiner sj = new StringJoiner(", ", "[", "]");

        for (int i = 0; i < data.length; i++) {
            sj.add(data[i] + "");
        }
        return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。

        //先把被克隆对象中的数组获取出来
        int[] data = this.data;
        //创建新的数组
        int[] newData =new int[data.length];
        //拷贝数组中的数据
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //调用父类中的方法克隆对象
            User u=(User)super.clone();
        //因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
        u.data =newData;
        return u;
    }
}

17.6Objects类

笔记小结：

概述：用于操作对象
方法：

// objects是一个对象工具类，提供了一些操作对象的方法
equals(对象1，对象2):先做非空判断，比较两个对象
isNull(对象):判断对象是否为空
nonNull(对象):判断对象是否不是空

17.6.1概述

java.util.Objects 是 Java 7 中新增的一个工具类，包含了一些常用的静态方法，主要用于操作对象

17.6.2常用成员方法

// objects是一个对象工具类，提供了一些操作对象的方法
equals(对象1，对象2):先做非空判断，比较两个对象
isNull(对象):判断对象是否为空
nonNull(对象):判断对象是否不是空

17.7BigInteger类

笔记小结：

概述：获取一个随机的大整数。获取一个指定的大整数，可以超出long的取值范围
字符串中的数字必须是整数。字符串中的数字必须要跟进制吻合
使用细节：

静态方法获取BigInteger的对象，内部有优化
在内部对常用的数字: -16 ~ 16 进行了优化
提前把-16~16 先创建好BigInteger的对象，如果多次获取不会重新创建新的

17.7.1概述

平时在存储整数的时候，Java中默认是int类型，int类型有取值范围：-2147483648 ~ 2147483647。

说明：

如果数字过大，我们可以使用long类型，但是如果long类型也表示不下怎么办呢？

就需要用到BigInteger，可以理解为：大的整数。

有多大呢？理论上最大到42亿的21亿次方

基本上在内存撑爆之前，都无法达到这个上限。

BigInteger所在包是在java.math包下，因此在使用的时候就需要进行导包。我们可以使用BigInteger类进行大整数的计算

17.7.2常用成员方法

参考资料：

常用API-07-BigInteger基本使用和原理解析_哔哩哔哩_bilibili

17.7.2.1构造方法

public BigInteger(int num, Random rnd) 		//获取随机大整数，范围：[0 ~ 2的num次方-1]
public BigInteger(String val) 				//获取指定的大整数
public BigInteger(String val, int radix) 	//获取指定进制的大整数
    
// 下面这个不是构造，而是一个静态方法获取BigInteger对象
public static BigInteger valueOf(long val) 	//静态方法获取BigInteger的对象，内部有优化

小结：

如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
如果BigInteger表示的超出long的范围，可以用构造方法获取。
对象一旦创建，BigInteger内部记录的值不能发生改变。
只要进行计算都会产生一个新的BigInteger对象

17.7.2.2成员方法

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类型整数，超出范围数据有误

17.7.3基本用例

package com.itheima.a06bigintegerdemo;

import java.math.BigInteger;

public class BigIntegerDemo1 {
    public static void main(String[] args) {
        /\*
 public BigInteger(int num, Random rnd) 获取随机大整数，范围:[0~ 2的num次方-11
 public BigInteger(String val) 获取指定的大整数
 public BigInteger(String val, int radix) 获取指定进制的大整数

 public static BigInteger valueOf(long val) 静态方法获取BigInteger的对象，内部有优化

 细节:
 对象一旦创建里面的数据不能发生改变。
 \*/


        //1.获取一个随机的大整数
        /\* Random r=new Random();
 for (int i = e; i < 100; i++) {
 BigInteger bd1 = new BigInteger(4,r);
 System.out.println(bd1);//[@ ~ 15]}
 }
 \*/

        //2.获取一个指定的大整数，可以超出long的取值范围
        //细节:字符串中必须是整数，否则会报错
        /\* BigInteger bd2 = new BigInteger("1.1");
 System.out.println(bd2);
 \*/

        /\*
 BigInteger bd3 = new BigInteger("abc");
 System.out.println(bd3);
 \*/

        //3.获取指定进制的大整数
        //细节:
        //1.字符串中的数字必须是整数
        //2.字符串中的数字必须要跟进制吻合。
        //比如二进制中，那么只能写日和1，写其他的就报错。
        BigInteger bd4 = new BigInteger("123", 2);
        System.out.println(bd4);

        //4.静态方法获取BigInteger的对象，内部有优化
        //细节:
        //1.能表示范围比较小，只能在long的取值范围之内，如果超出long的范围就不行了。
        //2.在内部对常用的数字: -16 ~ 16 进行了优化。
        // 提前把-16~16 先创建好BigInteger的对象，如果多次获取不会重新创建新的。
        BigInteger bd5 = BigInteger.valueOf(16);
        BigInteger bd6 = BigInteger.valueOf(16);
        System.out.println(bd5 == bd6);//true


        BigInteger bd7 = BigInteger.valueOf(17);
        BigInteger bd8 = BigInteger.valueOf(17);
        System.out.println(bd7 == bd8);//false


        //5.对象一旦创建内部的数据不能发生改变
        BigInteger bd9 =BigInteger.valueOf(1);
        BigInteger bd10 =BigInteger.valueOf(2);
        //此时，不会修改参与计算的BigInteger对象中的借，而是产生了一个新的BigInteger对象记录
        BigInteger result=bd9.add(bd10);
        System.out.println(result);//3

    }
}

package com.itheima.a06bigintegerdemo;

import java.math.BigInteger;

public class BigIntegerDemo2 {
    public static void main(String[] args) {
        /\*
 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类型整数，超出范围数据有误
 \*/

        //1.创建两个BigInteger对象
        BigInteger bd1 = BigInteger.valueOf(10);
        BigInteger bd2 = BigInteger.valueOf(5);

        //2.加法
        BigInteger bd3 = bd1.add(bd2);
        System.out.println(bd3);

        //3.除法，获取商和余数
        BigInteger[] arr = bd1.divideAndRemainder(bd2);
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        //4.比较是否相同
        boolean result = bd1.equals(bd2);
        System.out.println(result);

        //5.次幂
        BigInteger bd4 = bd1.pow(2);
        System.out.println(bd4);

        //6.max
        BigInteger bd5 = bd1.max(bd2);


        //7.转为int类型整数，超出范围数据有误
        /\* BigInteger bd6 = BigInteger.valueOf(2147483647L);
 int i = bd6.intValue();
 System.out.println(i);
 \*/

        BigInteger bd6 = BigInteger.valueOf(200);
        double v = bd6.doubleValue();
        System.out.println(v);//200.0
    }
}

17.7.4底层原理

对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。

数组中最多能存储元素个数：21亿多

数组中每一位能表示的数字：42亿多

理论上，BigInteger能表示的最大数字为：42亿的21亿次方。

但是还没到这个数字，电脑的内存就会撑爆，所以一般认为BigInteger是无限的。

存储方式如图所示：

17.8BigDecimal类

笔记小结：

概述：表示较大的小数和解决小数运算精度失真问题
获取对象：

BigDecimal bd1 = new BigDecimal(“较大的小数”);
BigDecimal bd2 = BigDecimal.valueof(0.1);

操作：

加: add
减: subtract
乘:multiply
除:divide （四舍五入: RoundingMode.HALF_UP)

17.8.1概述

首先我们来分析一下如下程序的执行结果：

public class BigDecimalDemo01 {

    public static void main(String[] args) {
        System.out.println(0.09 + 0.01);
    }

}

这段代码比较简单，就是计算0.09和0.01之和，并且将其结果在控制台进行输出。那么按照我们的想法在控制台输出的结果应该为0.1。那么实际的运行结果是什么呢？我们来运行一下程序，控制台的输出

结果如下所示：

0.09999999999999999


# 最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份**Java核心架构笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

**中高级开发必知必会：**

![](https://img-blog.csdnimg.cn/img_convert/c99620e01dbf1207360b6c17766c7605.webp?x-oss-process=image/format,png)

Integer;

public class BigIntegerDemo1 {
    public static void main(String[] args) {
        /\*
 public BigInteger(int num, Random rnd) 获取随机大整数，范围:[0~ 2的num次方-11
 public BigInteger(String val) 获取指定的大整数
 public BigInteger(String val, int radix) 获取指定进制的大整数

 public static BigInteger valueOf(long val) 静态方法获取BigInteger的对象，内部有优化

 细节:
 对象一旦创建里面的数据不能发生改变。
 \*/


        //1.获取一个随机的大整数
        /\* Random r=new Random();
 for (int i = e; i < 100; i++) {
 BigInteger bd1 = new BigInteger(4,r);
 System.out.println(bd1);//[@ ~ 15]}
 }
 \*/

        //2.获取一个指定的大整数，可以超出long的取值范围
        //细节:字符串中必须是整数，否则会报错
        /\* BigInteger bd2 = new BigInteger("1.1");
 System.out.println(bd2);
 \*/

        /\*
 BigInteger bd3 = new BigInteger("abc");
 System.out.println(bd3);
 \*/

        //3.获取指定进制的大整数
        //细节:
        //1.字符串中的数字必须是整数
        //2.字符串中的数字必须要跟进制吻合。
        //比如二进制中，那么只能写日和1，写其他的就报错。
        BigInteger bd4 = new BigInteger("123", 2);
        System.out.println(bd4);

        //4.静态方法获取BigInteger的对象，内部有优化
        //细节:
        //1.能表示范围比较小，只能在long的取值范围之内，如果超出long的范围就不行了。
        //2.在内部对常用的数字: -16 ~ 16 进行了优化。
        // 提前把-16~16 先创建好BigInteger的对象，如果多次获取不会重新创建新的。
        BigInteger bd5 = BigInteger.valueOf(16);
        BigInteger bd6 = BigInteger.valueOf(16);
        System.out.println(bd5 == bd6);//true


        BigInteger bd7 = BigInteger.valueOf(17);
        BigInteger bd8 = BigInteger.valueOf(17);
        System.out.println(bd7 == bd8);//false


        //5.对象一旦创建内部的数据不能发生改变
        BigInteger bd9 =BigInteger.valueOf(1);
        BigInteger bd10 =BigInteger.valueOf(2);
        //此时，不会修改参与计算的BigInteger对象中的借，而是产生了一个新的BigInteger对象记录
        BigInteger result=bd9.add(bd10);
        System.out.println(result);//3

    }
}

package com.itheima.a06bigintegerdemo;

import java.math.BigInteger;

public class BigIntegerDemo2 {
    public static void main(String[] args) {
        /\*
 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类型整数，超出范围数据有误
 \*/

        //1.创建两个BigInteger对象
        BigInteger bd1 = BigInteger.valueOf(10);
        BigInteger bd2 = BigInteger.valueOf(5);

        //2.加法
        BigInteger bd3 = bd1.add(bd2);
        System.out.println(bd3);

        //3.除法，获取商和余数
        BigInteger[] arr = bd1.divideAndRemainder(bd2);
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        //4.比较是否相同
        boolean result = bd1.equals(bd2);
        System.out.println(result);

        //5.次幂
        BigInteger bd4 = bd1.pow(2);
        System.out.println(bd4);

        //6.max
        BigInteger bd5 = bd1.max(bd2);


        //7.转为int类型整数，超出范围数据有误
        /\* BigInteger bd6 = BigInteger.valueOf(2147483647L);
 int i = bd6.intValue();
 System.out.println(i);
 \*/

        BigInteger bd6 = BigInteger.valueOf(200);
        double v = bd6.doubleValue();
        System.out.println(v);//200.0
    }
}

17.7.4底层原理

数组中最多能存储元素个数：21亿多

数组中每一位能表示的数字：42亿多

理论上，BigInteger能表示的最大数字为：42亿的21亿次方。

但是还没到这个数字，电脑的内存就会撑爆，所以一般认为BigInteger是无限的。

存储方式如图所示：

17.8BigDecimal类

笔记小结：

概述：表示较大的小数和解决小数运算精度失真问题
获取对象：

BigDecimal bd1 = new BigDecimal(“较大的小数”);
BigDecimal bd2 = BigDecimal.valueof(0.1);

操作：

加: add
减: subtract
乘:multiply
除:divide （四舍五入: RoundingMode.HALF_UP)

17.8.1概述

首先我们来分析一下如下程序的执行结果：

public class BigDecimalDemo01 {

    public static void main(String[] args) {
        System.out.println(0.09 + 0.01);
    }

}

结果如下所示：

0.09999999999999999


# 最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份**Java核心架构笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

**中高级开发必知必会：**

[外链图片转存中...(img-rtW9eR4m-1714196599415)]

> **本文已被[CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/topics/618154847)收录**

2401_84023683

关注

15
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
学习笔记：黑马程序员Java-中级篇（第二部分）

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。回顾基本数据类型转换自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14 多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。
复制链接

扫一扫