chapter06 面向对象基础 知识点Note

---

前言

`
面向对象封装

面向对象是软件开发中的一种编程风格 和 开发范式， 除了面向对象 ，还有面向过程， 指令式编程 和函数式编程

接触最多的还是面向过程 (POP)和面向对象(OOP)

面向过程 : 如果某个过程的实现代码重复出现 可以将过程抽取为一个函数 可以简化冗余代码 以函数为组织单位 执行者思维

面向对象 : 关注焦点是类 将事物的属性特征 行为特征抽象出来 用类来表示 属性 和 方法

以类为组织单位 每个事物都具备自己的属性和行为功能 设计者思维

宏观上面向对象 微观上面向过程

Java类及类的成员 属性 方法 构造器 代码块 内部类

面向对象特征 封装 继承 多态

其他关键字 this super package import static final interface abstract

什么是类？ 具有相同特征的事物的抽象描述

什么是对象？ 实际存在的事物个体

重点 类的成员设计(属性field 行为-方法method)

对象.属性 对象.方法

1 创建类 设计内部属性 方法

2 创建类的对象

3 通过对象 调用内部属性方法

面向对象（Object-Oriented）是一种以对象为基础，通过封装、继承和多态等特性来组织和设计程序的编程范式。它将问题看作是由一组相互作用的对象所组成，每个对象都有自己的状态（属性）和行为（方法）。面向对象编程的主要思想是将现实世界中的事物抽象成对象，通过定义对象之间的关系和交互来解决问题。面向对象的编程语言有Java、C++、Python等。

在Java中，封装是面向对象编程中的一种基本概念，指的是将数据和方法包装在类中，并保护数据不被直接访问。封装的主要目的是隐藏数据和方法的具体实现，使得它们对外只暴露必要的接口，从而提高代码的安全性和可维护性。

封装通常通过使用访问修饰符来实现。Java中的访问修饰符有4种，分别是：public、protected、默认（无修饰符）和private。它们分别表示不同的访问级别，具体如下：

• public：公开级别，可以被任何类直接访问。
• protected：受保护级别，在同一包内或者子类中可访问。
• 默认（缺省）：同一包内可访问，不加修饰符则表示默认级别。
• private：私有级别，在本类中可访问，其他类不能访问。

在Java中，我们可以将变量和方法设置为不同的访问修饰符来实现封装。
例如，将变量设置为 private 修饰符，就能够保护其不被直接访问和修改。
而将方法设置为 public 或者 protected 修饰符，则能够为外部提供一个可访
问的接口

public class Person {
    private String name; // 姓名，私有级别
    private int age; // 年龄，私有级别

    public void setName(String name) { // 设置姓名，公开级别
        this.name = name;
    }

    public String getName() { // 获取姓名，公开级别
        return this.name;
    }

    public void setAge(int age) { // 设置年龄，公开级别
        // 检查参数的合法性
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            System.out.println("年龄必须在0~150之间！");
        }
    }

    public int getAge() { // 获取年龄，公开级别
        return this.age;
    }
}

在上述代码中，我们定义了一个名为 Person 的类，其中包含了私有变量 name 和 age。这些变量被设置为私有级别，保护其不被外部直接访问。

然后，我们为外部提供了公开的方法 setName()、getName()、setAge() 和 getAge()，以便于对 name 和 age 进行获取或修改。这些方法都被设置为公开级别，能够被外部直接访问。

在 setAge() 方法中，我们还进行了参数合法性的检查，确保传入的参数在合法范围内。

通过这样的方式，我们就能够实现对变量和方法的封装。这样一来，外部的类只能通过公开的方法来访问和修改 name 和 age，从而保证了数据的安全性和可维护性。

在Java中，我们通常将实例变量（成员变量）声明为私有（private），而将方法声明为公有（public）。这样的设计符合面向对象编程的封装原则。

将实例变量声明为私有的主要目的是保护数据的安全性。私有变量只能在类的内部访问，其他类无法直接访问和修改私有变量。为了访问或修改私有变量，我们需要提供公有的访问器（getter）和修改器（setter）方法。通过公有方法来操作私有变量，可以实现对变量的控制，例如对输入数据的验证、限制或计算等。

将方法声明为公有的主要目的是供外部类或对象调用。公有方法是类对外部的接口，也称为公有接口（public interface）。其他类或对象通过调用公有方法来与当前类进行交互，获取所需的信息或执行特定的操作。公有方法应当提供明确的功能，并且按照设计意图进行操作，以确保类的正确使用。

以下是一个示例代码，展示了如何将实例变量声明为私有，同时提供公有的访问器和修改器方法：

public class Person {
    private String name; // 姓名，私有变量

    public void setName(String name) { // 设置姓名，公有方法
        this.name = name;
    }

    public String getName() { // 获取姓名，公有方法
        return this.name;
    }
}

在上述代码中，name 变量被声明为私有变量，外部类无法直接访问。通过提供公有的 setName() 和 getName() 方法，外部类可以通过调用这些方法来设置和获取 name 变量的值。

这种设计可以保护 name 数据的安全性，只允许通过公有方法来进行操作。

需要注意的是，并非所有的变量和方法都需要设置为私有或公有。根据具体的需求和设计原则，有些变量和方法也可以设置为受保护（protected）、默认（无修饰符）等其他访问修饰符，以实现更合理的封装和访问控制。

Java语言的基本元素 类（class）和对象（Object）

类抽象概念 的集合 对象 实体实例

---

类的设计 属性和行为

属性 变量variable 行为 方法method

类的定义 使用关键字 class

[修饰符] class 类名{
    属性声明;
    方法声明;
}

对象的创建 使用new

//把创建的对象用一个引用数据类型的变量保存起来，这样就可以反复使用这个对象了
类名 对象名 = new 类名();
new 类名()//也称为匿名对象
class PersonTest{
    public static void main(String[] args){
        //创建Person类的对象
        Person per = new Person();
        //创建Dog类的对象
        Dog dog = new Dog();
    }
}

对象调用属性或方法

使用" 对象名.属性 " 或 " 对象名.方法 "的方式访问对象成员（包括属性和方法）

//声明Animal类
public class Animal { //动物类
    public int legs;
    public void eat() {
        System.out.println("Eating.");
    }
    public void move() {
        System.out.println("Move.");
    }
}

//声明测试类
public class AnimalTest {
    public static void main(String args[]) {
        //创建对象
        Animal xb = new Animal();
        xb.legs = 4;//访问属性
        System.out.println(xb.legs);
        xb.eat();//访问实例方法
        xb.move();//访问实例方法
    }
}

栈里存变量名

堆里存值

在Java中，栈（Stack）和堆（Heap）都是用于存储数据的内存区域，但它们有不同的特点和存储内容。

1. 栈（Stack）：
   • 栈是一种用于管理方法调用和局部变量的内存区域。
   • 在栈中存储的是基本数据类型的变量和对象的引用。
   • 存储在栈中的数据具有固定大小和短生命周期。
   • 当一个方法被调用时，会在栈上创建一个称为栈帧（Stack Frame）的数据结构，用于保存方法的参数、局部变量和程序执行点等信息。
   • 方法的执行过程中，栈会按照先进后出（FILO）的方式进行操作。
2. 堆（Heap）：
   • 堆是用于动态分配内存的内存区域。
   • 在堆中存储的是对象和数组等引用类型的数据。
   • 存储在堆中的数据具有灵活的大小和长生命周期。
   • 所有通过 new 关键字创建的对象都会分配在堆上，并且可以通过对象的引用在程序的不同部分进行访问。
   • 堆的内存空间由垃圾回收器负责回收释放。

需要注意的是，栈和堆并不是Java内存模型的全部，还包括方法区（Method Area）、运行时常量池（Runtime Constant Pool）等部分。栈和堆在内存管理和数据访问方式上有所不同，了解它们的特点有助于编写高效、安全的Java程序。

匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

如：new Person().shout();

使用情况

如果一个对象只需要进行一次方法调用，那么就可以使用匿名对象。

我们经常将匿名对象作为实参传递给一个方法调用

对象的内存解析 （堆 栈 方法区）

堆（Heap） ：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

栈（Stack） ：是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首址）。 方法执行完，自动释放。

方法区（Method Area） ：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

堆：凡是new出来的结构(对象、数组)都放在堆空间中。对象的属性存放在堆空间中。

创建一个类的多个对象（比如p1、p2），则每个对象都拥有当前类的一套"副本"（即属性）。当通过一个对象修改其属性时，不会影响其它对象此属性的值。不同间对象修改 并不影响

当声明一个新的变量使用现有的对象进行赋值时（比如p3 = p1），此时并没有在堆空间中创建新的对象。而是两个变量共同指向了堆空间中同一个对象。当通过一个对象修改属性时，会影响另外一个对象对此属性的调用。 对象赋值 浅拷贝

对象名中存储的是对象地址 对象名存放在栈里 对象实例属性存放在堆里

类、数组都是引用数据类型，引用数据类型的变量中存储的是对象的地址，或者说指向堆中对象的首地址。

栈内存主要用于存储基本数据类型的值和引用类型的地址。 当创建一个对象时，它会被分配在堆内存中，并且在栈内存中分配一个变量或属性来存储对该对象的引用。这个变量或属性中存储的是指向该对象的地址。可以将这个变量或属性称为“引用”。

具体来说：

1. 对象本身 和对象内属性存储在堆内存中。

2. 变量或属性（引用）存储在栈内存中。

3. 栈内存中的变量或属性保存了指向堆内存中对象的内存地址。

类的成员之一 变量(属性) field

声明成员变量

基本数据类型 byte char int short long boolean double float

引用数据类型

[修饰符1] class 类名{
    [修饰符2] 数据类型 成员变量名 [= 初始化值];
}

public class Person{
    private int age; //声明private变量 age
    public String name = “Lila”; //声明public变量 name
}

位置要求：必须在类中，方法外

修饰符(暂不考虑)

常用的权限修饰符有：private、缺省、protected、public

其他修饰符：static、final

数据类型

任何基本数据类型(如int、Boolean) 或 任何引用数据类型。

成员变量名

属于标识符，符合命名规则和规范即可。

初始化值

根据情况，可以显式赋值；也可以不赋值，使用默认值

成员变量和局部变量

方法体外 类体内声明的变量称为成员变量

方法体内部位置 类体内声明的变量称为局部变量 ( 方法内)

其中，static可以将成员变量分为两大类，静态变量和非静态变量。其中静态变量又称为类变量，static修饰变量时 用该类创造的所有对象共用此变量的唯一值

static double salary = 10000;public class Employee {
    String name;
    int age;
    int id;
    static double salary = 10000;

    MyDate birthday;
}

public class MyDate {
    int year;
    int month;
    int day;
}

非静态变量又称为实例变量或者属性。

局部变量 （方法内变量） 则是分为形参方法局部变量 代码块局部变量

即成员变量 （静态变量和非静态变量） 局部变量 （形参方法局部变量和 代码块局部变量）

成员变量 与 局部变量 的对比

相同点

变量声明的格式相同： 数据类型 变量名 = 初始化值

变量必须先声明、后初始化、再使用。

变量都有其对应的作用域。只在其作用域内是有效的

不同点

1、声明位置和方式 （1）实例变量：在类中方法外 （2）局部变量：在方法体{}中或方法的形参列表、代码块中

2、在内存中存储的位置不同 （1）实例变量-属性-成员变量：堆 （2）局部变量：栈

3、生命周期

（1）实例变量：和对象的生命周期一样，随着对象的创建而存在，随着对象被GC回收而消亡， 而且每一个对象的实例变量是独立的。 （2）局部变量：和方法调用的生命周期一样，每一次方法被调用而在存在，随着方法执行的结束而消亡， 而且每一次方法调用都是独立。

4、作用域

（1）实例变量：通过对象就可以使用，本类中直接调用，其他类中“对象.实例变量”

（2）局部变量：出了作用域就不能使用

5、修饰符（后面来讲） 属性可以用 修饰符修饰 局部变量不能用任何权限修饰符修饰

（1）实例变量：public,protected,private,final,volatile,transient等

（2）局部变量：final

6、默认值 （1）实例变量：有默认值 （2）局部变量：没有，必须手动初始化。其中的形参比较特殊，靠实参给它初始化

类的成员之二 方法 method

方法 是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为 函数 或 过程 。

将功能封装为方法的目的是，可以 实现代码重用，减少冗余，简化代码

Java里的方法 不能独立存在 ，所有的方法必须定义在类里。

举例1：Math.random()的random()方法

Math.sqrt(x)的sqrt(x)方法

System.out.println(x)的println(x)方法

new Scanner(System.in).nextInt()的nextInt()方法

Arrays类中的binarySearch()方法、sort()方法、equals()方法

方法的声明

[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]{
    方法体的功能代码
}
public void setAge(int i) { //声明方法setAge
    age = i; //将参数i的值赋给类的成员变量age
}

一个完整的方法 = 方法头 + 方法体。

方法头就是 [修饰符] 返回值类型 方法名([形参列表])[throws 异常列表] ，也称为 方法签名 。通

常调用方法时只需要关注方法头就可以，从方法头可以看出这个方法的功能和调用格式。

方法体就是方法被调用后要执行的代码。对于调用者来说，不了解方法体如何实现的，并不影响方

法的使用。

2方法头可能包含5个部分

修饰符：可选的。方法的修饰符也有很多，例如：public、protected、private、static、abstract、

native、final、synchronized等，后面会一一学习。

其中，权限修饰符有public、protected、private。在讲封装性之前，我们先默认使用pulbic修

饰方法。

其中，根据是否有static，可以将方法分为静态方法和非静态方法。其中静态方法又称为类方

法，非静态方法又称为实例方法。咱们在讲static前先学习实例方法。

返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者。

无返回值，则声明：void

有返回值，则声明出返回值类型（可以是任意类型）。与方法体中“ return 返回值 ”搭配使

用

方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”

形参列表：表示完成方法体功能时需要外部提供的数据列表。可以包含零个，一个或多个参数

public class Person{
    private int age;
    public int getAge() { //声明方法getAge()
        return age;
    }
    public void setAge(int i) { //声明方法setAge
        age = i; //将参数i的值赋给类的成员变量age
    }
}
[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]{
    方法体的功能代码
}无论是否有参数，()不能省略

如果有参数，每一个参数都要指定数据类型和参数名，多个参数之间使用逗号分隔，例如：

一个参数： (数据类型 参数名)

二个参数： (数据类型1 参数1, 数据类型2 参数2)

参数的类型可以是基本数据类型、引用数据类型

throws 异常列表：可选，在【第09章-异常处理】章节再讲

**3方法体：**方法体必须有{}括起来，在{}中编写完成方法功能的代码

4关于方法体中return语句的说明：

return语句的作用是结束方法的执行，并将方法的结果返回去如果返回值类型不是void，方法体中必须保证一定有 return 返回值; 语句，并且要求该返回值结果的类型与声明的返回值类型一致或兼容。

如果返回值类型为void时，方法体中可以没有return语句，如果要用return语句提前结束方法的执行，那么return后面不能跟返回值，直接写return ; 就可以。return语句后面就不能再写其他代码了，否则会报错：Unreachable code

调用实例方法

（1）必须先声明后使用，且方法必须定义在类的内部

（2）调用一次就执行一次，不调用不执行。

（3）方法中可以调用类中的方法或属性，不可以在方法内部定义方法。
类中可以有多个方法 但方法不能嵌套方法 类中可以嵌套类 （内部类） 可以在方法中定义局部类 只能在该方法内部创建和使用

类{
    方法1(){
    }
    方法2(){
    }
}

public class Outer {
    public void outerMethod() {
        class LocalClass {
            public void localMethod() {
                System.out.println("Local Class");
            }
        }
        LocalClass local = new LocalClass();
        local.localMethod();
    }
}

return在方法中的作用：

作用1：结束一个方法

作用2：结束一个方法的同时，可以返回数据给方法的调用者

注意点：在return关键字的直接后面不能声明执行语句

方法调用内存解析

方法 没有被调用 的时候，都在 方法区 中的字节码文件(.class)中存储。

方法 被调用 的时候，需要进入到 栈内存 中运行。方法每调用一次就会在栈中有一个 入栈 动作，即

给当前方法开辟一块独立的内存区域，用于存储当前方法的局部变量的值。

当方法执行结束后，会释放该内存，称为 出栈 ，如果方法有返回值，就会把结果返回调用处，如

果没有返回值，就直接结束，回到调用处继续执行下一条指令。

栈结构：先进后出，后进先出

非static方法调用时需先new对象 同一类时 new当前类对象

对象数组

数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用类型中的类时，我们称为对象数组。

对象数组，首先要创建数组对象本身，即确定数组的长度，然后再创建每一个元素对象，如果不创建，数组的元素的默认值就是 null ，所以很容易出现 空指针异常NullPointerException 。

public class Rectangle {
    double length;
    double width;
    public double area(){//面积
        return length * width;
    }
    public double perimeter(){//周长
        return 2 * (length + width);
    }
    public String getInfo(){
        return "长：" + length +
            "，宽：" + width +
            "，面积：" + area() +
            "，周长：" + perimeter();
    }
}
public class ObjectArrayTest {
    public static void main(String[] args) {
        //声明并创建一个长度为3的矩形对象数组
        Rectangle[] array = new Rectangle[3];
        //创建3个矩形对象，并为对象的实例变量赋值，
        //3个矩形对象的长分别是10,20,30
        //3个矩形对象的宽分别是5,15,25
        //调用矩形对象的getInfo()返回对象信息后输出
        for (int i = 0; i < array.length; i++) {
            //创建矩形对象
            array[i] = new Rectangle();
            //为矩形对象的成员变量赋值
            array[i].length = (i+1) * 10;
            array[i].width = (2*i+1) * 5;
            //获取并输出对象数组中对象的信息
            System.out.println(array[i].getInfo());
        }
    }
}

方法重载 overload

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可。

参数列表不同，意味着参数个数或参数类型的不同

JVM通过方法的参数列表，调用匹配的方法。

先找个数、类型最匹配的 再找个数和类型可以兼容的，如果同时多个方法可以兼容将会报错

两同一不同： 同一类下 相同方法名 不同参数列表 形参顺序不同也算 修饰符无关

//返回两个整数的和
public int add(int x,int y){
    return x+y;
}
//返回三个整数的和
public int add(int x,int y,int z){
    return x+y+z;
}
//返回两个小数的和
public double add(double x,double y){
    return x+y;
}

// println方法重载

int[] arr = new int[]{1,2,3};
System.out.println(arr); //地址值

char[] arr1 = new char[]{'a','b','c'};
System.out.println(arr1); // abc

boolean[] arr2 = new boolean[]{true,false,true};
System.out.println(arr2); // 地址值

可变个数的形参 语法糖

方法名(参数的类型名 ...参数名)
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String...books);

\1. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

\2. 可变个数形参的方法与同名的方法之间，彼此构成重载

\3. 可变参数方法的使用与方法参数部分使用数组是一致的，二者不能同时声明，否则报错。

\4. 方法的参数部分有可变形参，需要放在形参声明的最后

\5. 在一个方法的形参中，最多只能声明一个可变个数的形参# 对象的内存解析 （堆 栈 方法区）

// 求n个整数的和
public class NumberTools {
    public int total(int[] nums){
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
    public int sum(int... nums){
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
}

public class TestVarParam {
    public static void main(String[] args) {
        NumberTools tools = new NumberTools();
        System.out.println(tools.sum());//0个实参
        System.out.println(tools.sum(5));//1个实参
        System.out.println(tools.sum(5,6,2,4));//4个实参
        System.out.println(tools.sum(new int[]{5,6,2,4}));//传入数组实参
        System.out.println("------------------------------------");
        System.out.println(tools.total(new int[]{}));//0个元素的数组
        System.out.println(tools.total(new int[]{5}));//1个元素的数组
        System.out.println(tools.total(new int[]{5,6,2,4}));//传入数组实参
    }
}

public class StringContact {
    public static void main(String[] args) {
        /**
         * 对n个字符串进行拼接 每个字符用某字符分割 如果没传入字符 返回空字符串
         */
        StringContact sc = new StringContact();

        String result = sc.concat("-","Hello","Java");
        System.out.println("最后结果为"+ result);
    }

    public String concat(String operator, String ...strs){
        String result = "";

        for (int i =0; i< strs.length;i++){
            if(i ==0){
                result += strs[i];
            }else {
                result += (operator + strs[i]);
            }
        }
        return result;
    }
}

方法的值传递机制

对于方法内声明的局部变量 出现赋值操作

如果是基本数据类型变量 将该变量保存的数据值传递出去 改变数据 不会影响元数据

如果是引用数据类型变量 将此变量保存的地址值传递出去 改变数据 改变原数据

实参给形参赋值过程

如果形参是基本数据类型变量 将实参保存的数据值 赋给形参

如果形参是引用数据类型变量 将实参保存的地址值 赋给形参

public class ValueTransfer {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        ValueTransfer valueTransfer = new
                ValueTransfer();

        System.out.println("m:" + m + ", n: " + n);

        //m++;  11 20
        valueTransfer.method1(m); //10 20

        System.out.println("m:" + m + ", n: " + n);

        valueTransfer.swap(m, n);
        //swap内部形参交互 不影响原数据
        System.out.println("m:" + m + ", n: " + n); // 10, 20

        Person p = new Person();
        p.age = 10;
        valueTransfer.method2(p);

        System.out.println(p.age); //11

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

        arr2[0] = 10;
        System.out.println(arr[0]); // 10

        Order order = new Order();
        order.orderId = 1001;

        Order order2 = order;

        order2.orderId = 1002;
        System.out.println(order.orderId);

    }
    public void method1(int m) {
        m++;
    }
    public void method2(Person p) {
        p.age++;
    }
    public void swap(int m, int n) {
        int temp = m;
        m = n;
        n = temp;
        System.out.println("swap内部 m: "+m + ",n:" + n); //20 10
    }
}
class Order {
    int orderId;
}

传递对象

public class PassObject {
    public static void main(String[] args) {
        //方法内部可以调用方法 但不能方法内部定义方法
        PassObject passObject = new PassObject();

        Circle circle = new Circle();
        passObject.printArea(circle, 5);

        System.out.println("当前半径值 " + circle.radius);
    }

    public void printArea(Circle c, int time) {
        System.out.println("Radius\t\tArea");

        for (int i = 1; i <= time; i++) {
            c.radius = i;
            System.out.println(c.radius + "\t\t\t" + c.getArea());
        }
    }
}

// 对数组进行排序操作 可以指明排序方式 由大到小  由小到大
public class ArraySortImprove {
    public static void main(String[] args) {
        int[] arr = new int[]{34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};

        //Arrays.sort(arr);
        ArraySortImprove arraySortImprove = new ArraySortImprove();
        arraySortImprove.BubbleSort(arr,"desc"); //空指针异常

        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序
     * @param arr
     */
    public void BubbleSort(int[] arr){
        for (int j = 0; j < arr.length - 1; j++) {
            //    执行一轮 找出最大的数
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    //交换
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
    }

    /**
     * 冒泡排序优化
     * @param arr
     * @param sortMethod  asc 升序  desc 降序
     */
    public void BubbleSort(int[] arr,String sortMethod){
        //if(sortMethod.equals("asc")){
        if("asc".equals(sortMethod)){ // 避免空指针异常可以将常量值放前面进行equals
            for (int j = 0; j < arr.length - 1; j++) {
                //    执行一轮 找出最大的数
                for (int i = 0; i < arr.length - 1 - j; i++) {
                    if (arr[i] > arr[i + 1]) {
                        //交换
                        int temp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = temp;
                    }
                }
            }
        }else if("desc".equals(sortMethod)){
            for (int j = 0; j < arr.length - 1; j++) {
                //    执行一轮 找出最大的数
                for (int i = 0; i < arr.length - 1 - j; i++) {
                    if (arr[i] < arr[i + 1]) {
                        交换
                        //int temp = arr[i];
                        //arr[i] = arr[i + 1];
                        //arr[i + 1] = temp;
                        //swap(arr[i],arr[i+1]);
                        swap(arr,i,i+1);
                    }
                }
            }
        }else{
         System.out.println("输入的排序方法有误");
        }
    }

    /**
     * 形参交互 不会影响原数组数据
     * @param i
     * @param j
     */
    public void swap(int i, int j){
        int temp = i;
        i =j;
        j = temp;
    }

    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

记录 对数组值交互抽离方法 统一采用

public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

递归

方法自己调用自己的现象就称为递归。

**递归的分类 ** 直接递归、间接递归。

直接递归：方法自身调用自己。

间接递归：可以理解为A()方法调用B()方法，B()方法调用C()方法，C()方法调用A()方法。

递归方法包含了一种 隐式的循环 。递归方法会 重复执行 某段代码，但这种重复执行无须循环控制。

递归一定要向 已知方向 递归，否则这种递归就变成了无穷递归，停不下来，类似于 死循环 。最终发生 栈内存溢出 。

递归需要有结束条件

public class Recurision {
    public static void main(String[] args) {
        Recurision recurision = new Recurision();
        int sum = recurision.sum(100);
        System.out.println("总和" + sum);
    }

    /**
     * 计算 1-100内自然数总和
     */
    public int sum(int num){
        if(num == 1){
            return 1;
        }else {
            return sum(num -1) + num;
        }
    }
}

关键字package import

package 顶层包名.子包名 ;

包可以包含类和子包，划分 项目层次 ，便于管理

帮助 管理大型软件 系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式

解决 类命名冲突 的问题 控制 访问权限

一个源文件只能有一个声明包的package语句

package语句作为Java源文件的第一条语句出现。若缺省该语句，则指定为无名包。

包名，属于标识符，满足标识符命名的规则和规范（全部小写）、见名知意

包通常使用所在公司域名的倒置：com.atguigu.xxx。 大家取包名时不要使用" java.xx "包

包对应于文件系统的目录，package语句中用 “.” 来指明包(目录)的层次，每.一次就表示一层文件目录。

同一个包下可以声明多个结构（类、接口），但是不能定义同名的结构（类、接口）。不同的包下 可以定义同名的结构（类、接口）

全类名 java.util.Date date = new java.util.Date(1234L)

视图层包名 view. 控制层包名 controller. 模型层 model.

jdk中常见的包

java.lang ----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能

java.net ----包含执行与网络相关的操作的类和接口。 java.io ----包含能提供多种输入/输出功能的类。

java.util ----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

java.text ----包含了一些java格式化相关的类 java.sql ----包含了java进行JDBC数据库编程的相关类/接口

java.awt ----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

MVC设计模式

MVC设计模式将整个程序分为三个层次： 视图模型(Viewer)层 ， 控制器(Controller)层 ，与 数据模型

(Model)层 。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵

活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

视图层viewer：显示数据,为用户提供使用界面，与用户直接进行交互。
    >相关工具类 view.utils
    >自定义view view.ui
控制层controller：解析用户请求，处理业务逻辑，给予用户响应
    >应用界面相关 controller.activity
    >存放fragment controller.fragment
    >显示列表的适配器 controller.adapter
    >服务相关的 controller.service
    >抽取的基类 controller.base
模型层model：主要承载数据、处理数据
    >数据对象封装 model.bean/domain
    >数据库操作类 model.dao
    >数据库 model.db

思考 MVC模式 区分与 前端 Vue框架的 MVVM模式

import导入

import 包名.类名;

import语句，声明在包的声明和类的声明之间。如果需要导入多个类或接口，那么就并列显式多个import语句即可

如果使用 a.* 导入结构，表示可以导入a包下的所有的结构。举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。

如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。如果已经导入java.a包下的类，那么如果需要使用a包的子包下的类的话，仍然需要导入。

如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类。（了解） import static 组合的使用：调用指定类或接口下的静态的属性或方法

面向对象特征之一 封装

面向对象的开发原则要遵循“ 高内聚、低耦合

高内聚、低耦合是软件工程中的概念，也是UNIX 操作系统设计的经典原则。

内聚，指一个模块内各个元素彼此结合的紧密程度；耦合指一个软件结构内不同模块之间互连程度的度量。

内聚意味着重用和独立，耦合意味着多米诺效应牵一发动全身。

高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合 ：仅暴露少量的方法给外部使用，尽量方便外部调用。

JAVA实现数据封装是控制类或成员的可见性范围。这就需要依赖访问控制修饰符，也称为权限修饰符来控制。

public private 缺省 protected

修饰符 本类内部 缺省、 private 。具体访问范围如下：

修饰符	本类内部	本包内	其他包非子类	其他包非子类
private	√	×	×	×
缺省	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

开发中，一般成员实例变量都习惯使用private修饰，再提供相应的public权限的get/set方法访问。

类只能使用 public 缺省修饰

类的内部成员 方法 变量可以采用4种权限修饰

封装性的体现

场景1：私有化(private)类的属性，提供公共(public)的get和set方法，对此属性进行获取或修改
场景2：将类中不需要对外暴露的方法，设置为private.
场景3：单例模式中构造器private的了，避免在类的外部创建实例。（放到static关键字后讲）

对于final的实例变量，不提供set()方法。（后面final关键字的时候讲）对于static final的成员变量，习惯上使用public修饰。

idea 快捷生成getter setter alt + insert

下面实现封装一个实体类 也即是下一个知识点 构造器

/**
 * @author Admin
 * @title: Book
 * @projectName MyDemo
 * @description: Book
 * @date 2024/8/3 21:45
 */
public class Book {
    private String bookName;
    private String author;
    private double price;

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

public class BookTest {
    public static void main(String[] args) {
        Book book = new Book();
        book.setBookName("在人间");
        book.setAuthor("大仲马");
        book.setPrice(30);

        System.out.println(book);
    }
}

类的成员之三 构造器

我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻

烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢？

可以，Java给我们提供了 构造器（Constructor) ，也称为 构造方法 。

构造器作用

作用1：搭配new关键字，创建类的对象
作用2：在创建对象的同时，可以给对象的相关属性赋值

构造器的使用说明

构造器一般分为 有参构造 无参构造

构造器声明的格式：权限修饰符 类名(形参列表){}
创建类以后，在没有显示提供任何构造器的情况下，系统会默认提供一个空参的构造器，且构造器的权限
与类声明的权限相同。
一旦类中显示声明了构造器，则系统不再提供默认的空参的构造器。
一个类中可以声明多个构造器，彼此之间构成重载。

new对象，并在new对象的时候为实例变量赋值。

举例：Person p = new Person(“Peter”,15) ;

[修饰符] class 类名{
    [修饰符] 构造器名(){
        // 实例初始化代码  无参构造
    }
    [修饰符] 构造器名(参数列表){
        // 实例初始化代码  有参构造
    }
}

构造器和方法的区别

构造器（Constructor）和方法（Method）在Java中有一些区别。

1. 名称：构造器的名称必须与类名完全相同，而方法可以有任意合法的标识符作为名称。
2. 返回类型：构造器没有返回类型，包括 void。而方法必须定义返回类型，如果没有具体返回值，可以使用 void 表示。
3. 调用方式：构造器在创建对象时自动调用，用于初始化对象的成员变量和状态。每次创建对象时都会调用构造器。而方法需要通过对象或类来调用。
4. 用途：构造器用于创建和初始化对象，它们负责初始化对象的状态。方法用于执行特定的操作或计算，并且可以被对象或类调用。
5. 构造器重载：一个类可以有多个构造器，它们的参数列表不同，从而可以在创建对象时提供不同的初始化方式。这被称为构造器重载。方法也可以进行重载，但重载的方法必须具有不同的参数列表。
6. 继承和重写：当一个类继承自父类时，它将继承父类的构造器。子类可以通过 super() 关键字调用父类的构造器，并根据需要添加额外的初始化代码。而方法可以在子类中重写（覆盖）父类中的方法。

总结起来，构造器用于创建和初始化对象，没有返回类型，命名与类名相同，通过 new 关键字自动调用。而方法用于执行操作或计算，有返回类型，可以是任意合法的标识符，需要通过对象或类来调用。

\1. 当我们没有显式的声明类中的构造器时，系统会默认提供一个无参的构造器并且该构造器的修饰符默认与类的修饰符相同

\2. 当我们显式的定义类的构造器以后，系统就不再提供默认的无参的构造器了。

\3. 在类中，至少会存在一个构造器。

\4. 构造器是可以重载的。

1. 在类的属性中，可以有哪些位置给属性赋值？
   ① 默认初始化；
   ② 显式初始化；
   ③ 构造器中初始化；

---

④ 通过"对象.方法"的方式赋值；
⑤ 通过"对象.属性"的方式赋值；

2. 这些位置执行的先后顺序是怎样？
   ① - ② - ③ - ④/⑤

JavaBean

JavaBean是一种Java语言写成的可重用组件

所谓JavaBean，是指符合如下标准的Java类：

类是公共的 有一个无参的公共的构造器

有属性，且有对应的get、set方法

JavaBean 在 Spring框架中会大量使用 理解面向对象编程思想

UML类图

UML 类图 +表示public -表示private #表示protected 若方法有下划线表示构造器

描述软件模型 架构

常用的UML工具软件有 PowerDesinger 、 Rose 和 Enterprise Architect 。

UML工具软件不仅可以绘制软件开发中所需的各种图表，还可以生成对应的源代码。

+表示 public 类型， - 表示 private 类型，#表示protected类型

方法的写法: 方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型

斜体表示抽象方法或类。

---