11.java面向对象

面向对象思想概述

概述

面向对象编程（Object-Oriented Programming，OOP）是一种软件设计和编程的方法。在面向对象的编程范式中，程序被组织为对象的集合，每个对象都有自己的状态和行为，并且能够与其他对象进行交互，面向对象编程的优势在于提高代码的可维护性、可重用性和可扩展性。它通过模块化和抽象化的方式更好地反映了现实世界中的问题，使得软件开发更加灵活和易于理解。

面向过程和面向对象的区别

面向过程编程和面向对象编程是两种不同的编程范式，它们在设计和组织代码的方式上有一些关键区别。

1. 核心思想：

   • 面向过程： 以过程或函数为中心，程序被看作一系列的步骤或操作。重点是对数据的处理。
   • 面向对象： 以对象为中心，程序被组织为一组相互作用的对象。重点是对象的状态和行为。

2. 数据和函数：

   • 面向过程： 数据和函数是分离的，函数对数据进行操作。
   • 面向对象： 数据和函数被封装在对象内部，对象通过方法（对象的函数）来操作数据。

3. 封装性：

   • 面向过程： 缺乏封装性，数据和函数可能散布在不同的地方。
   • 面向对象： 具有封装性，对象内部的实现细节被隐藏，只暴露必要的接口。

4. 继承：

   • 面向过程： 不直接支持继承。
   • 面向对象： 支持继承，通过继承可以重用和扩展已有的类。

5. 多态性：

   • 面向过程： 不直接支持多态。
   • 面向对象： 支持多态，同一种操作可以作用于不同的对象，产生不同的结果。

6. 适用场景：

   • 面向过程： 适合简单、线性的任务，如脚本编程。
   • 面向对象： 适合大型、复杂的系统，更容易扩展和维护。

总的来说，面向过程更注重操作序列和流程，而面向对象更注重事物的抽象和模型。选择使用哪种编程范式通常取决于问题的性质和程序的规模。
明白了，让我们通过一个中文的例子来说明面向过程和面向对象的区别。

面向过程：

假设我们要描述制作面条的过程：

1. 准备材料
2. 煮水
3. 放入面条
4. 煮熟
5. 捞出，加入调料

过程：
准备材料
煮水
放入面条
煮熟
捞出，加入调料

面向对象：

现在，我们通过面向对象的方式描述：

对象：面条
属性：材料、状态
方法：
  - 煮水()
  - 放入面条()
  - 煮熟()
  - 加入调料()

在这个例子中，我们把面条看作一个对象，对象有属性（材料、状态）和方法（煮水、放入面条、煮熟、加入调料）。通过对象的方法来执行操作，而不是简单地按照步骤执行过程。

这展示了面向对象的方式更注重于事物的抽象和模型，将属性和方法封装在对象内部。而面向过程更着重于描述一系列步骤或过程。

类和对象

类是一种抽象的概念，描述了一类对象的共同特征；而对象是这个类的具体实例，具有实际的属性和行为。类和对象是面向对象编程的基础，通过它们可以更好地组织和抽象程序的结构。

1. 类（Class）：

   • 定义： 类是一种抽象数据类型，用于描述具有相同属性和方法的对象的集合。
   • 作用： 类定义了对象的模板，包含属性和方法的描述。

2. 对象（Object）：

   • 定义： 对象是类的实例，是具体存在的数据结构，具有类定义的属性和方法。
   • 作用： 每个对象都有自己的状态（属性）和行为（方法），是类的具体实现。

在Java中，类的定义包括类的声明和类体两个部分。以下是一个简单的Java类定义的基本结构：

// 类的声明
public class ClassName {
    // 成员变量（属性）
    private dataType attributeName;  // 例如：private int age;

    // 构造方法（Constructor）
    public ClassName(parameters) {
        // 构造方法的初始化代码
    }

    // 成员方法（方法）
    public returnType methodName(parameters) {
        // 方法的实现代码
    }

    // 其他成员变量和方法...

}

在Java中，类的访问机制通过访问修饰符（access modifier）来实现，主要有以下四种访问修饰符：

1. public（公有的）：

   • 类、成员变量和方法声明为public可以被任何其他类访问。
   • 示例：public class MyClass { ... }

2. private（私有的）：

   • 类的私有成员（私有变量和私有方法）只能在类的内部访问，外部无法直接访问。
   • 示例：private int myVariable;

3. protected（受保护的）：

   • 类的protected成员可以被类本身、同一包内的类以及其子类访问。
   • 示例：protected void myMethod() { ... }

4. default（默认的，无修饰符）：

   • 类、成员变量和方法如果没有使用public、private或protected修饰符，默认为包内可见。
   • 示例：class MyDefaultClass { ... }

这些访问修饰符可以应用于类的成员变量、构造方法和成员方法。在类的内部，可以访问该类的所有成员，而在类的外部，访问权限由成员的访问修饰符决定。

// 类的访问修饰符示例
public class MyClass {
    public int publicVariable;
    private int privateVariable;
    protected int protectedVariable;
    int defaultVariable;  // 默认为包内可见

    // 构造方法
    public MyClass() {
        // 在类的内部，可以访问所有成员
        publicVariable = 1;
        privateVariable = 2;
        protectedVariable = 3;
        defaultVariable = 4;
    }

    // 成员方法
    public void publicMethod() {
        // 在类的内部，可以访问所有成员
        publicVariable = 1;
        privateVariable = 2;
        protectedVariable = 3;
        defaultVariable = 4;
    }
}

在这个示例中，MyClass 类包含了不同访问修饰符的成员变量和方法。在类的内部，可以自由访问所有成员；而在类的外部，访问权限受到访问修饰符的限制。
解释每个部分：

• 类的声明： 使用 class 关键字声明一个类，后面跟着类名。类名的首字母通常大写。

• 成员变量（属性）： 定义类的属性，即成员变量。可以使用访问修饰符（如 private、public）来控制成员变量的访问权限。

• 构造方法（Constructor）： 构造方法是一个特殊的方法，用于初始化对象。构造方法的名字必须与类名相同，没有返回类型，可以带有参数。

• 成员方法（方法）： 定义类的行为，即成员方法。同样，可以使用访问修饰符来控制方法的访问权限。

以下是一个简单的Java类定义的示例：

public class Car {
    // 成员变量
    private String brand;
    private int year;

    // 构造方法
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    // 成员方法
    public void start() {
        System.out.println("The car is starting.");
    }

    // 其他成员变量和方法...
}

这个例子定义了一个名为 Car 的类，包含了品牌（brand）和生产年份（year）两个成员变量，以及一个构造方法和一个启动方法。

对象定义

在Java中，要使用一个类的对象，需要进行两个步骤：对象的创建和对象的使用。

1. 对象的创建：

使用 new 关键字和类的构造方法来创建对象。构造方法用于初始化对象的属性。

// 创建Car类的对象
Car myCar = new Car("Toyota", 2022);

在这里，Car 是一个类名，myCar 是对象的引用变量，通过 new Car("Toyota", 2022) 创建了一个 Car 类的对象。该对象通过构造方法初始化了品牌为 “Toyota”，生产年份为 2022。

2. 对象的使用：

创建对象后，可以使用对象的引用变量来调用类中定义的成员变量和方法。

// 访问对象的成员变量
System.out.println("Brand: " + myCar.brand);
System.out.println("Year: " + myCar.year);

// 调用对象的方法
myCar.start();

在这里，我们通过 myCar 引用变量访问了对象的成员变量 brand 和 year，并调用了对象的方法 start()。

完整的示例代码：

public class Car {
    private String brand;
    private int year;

    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public void start() {
        System.out.println("The car is starting.");
    }

    public static void main(String[] args) {
        // 创建Car类的对象
        Car myCar = new Car("Toyota", 2022);

        // 访问对象的成员变量
        System.out.println("Brand: " + myCar.brand);
        System.out.println("Year: " + myCar.year);

        // 调用对象的方法
        myCar.start();
    }
}

在上述代码中，main 方法是Java程序的入口点，通过创建对象并使用对象的成员进行了演示。

匿名对象

在Java中，匿名对象是指没有明确赋值给任何变量，且没有被指定引用的对象。匿名对象通常在创建对象的同时调用其方法或执行某些操作，而不保留对对象的引用。

示例：

public class MyClass {
    public void displayMessage(String message) {
        System.out.println(message);
    }

    public static void main(String[] args) {
        // 创建匿名对象并调用方法
        new MyClass().displayMessage("Hello, I am an anonymous object.");

        // 没有保留对匿名对象的引用
        // 无法再次使用该对象
    }
}

在上述示例中，MyClass 类包含一个 displayMessage 方法，用于显示传入的消息。在 main 方法中，通过 new MyClass().displayMessage("Hello, I am an anonymous object."); 创建了一个匿名对象，并直接调用了其 displayMessage 方法，而不保留对该对象的引用。

使用匿名对象的场景通常是在某个方法只需一次调用时，不需要保留对对象的引用。匿名对象的生命周期仅限于当前语句块，一旦执行完毕，对象就会被销毁。

关键字 package 和 import

package

在Java中，package 是一个关键字，用于声明一个包（package）。包是一种用于组织和管理类文件的机制，它可以包含多个相关的类和子包。package 关键字用于指定一个类所属的包。

语法：

package package_name;

• package_name 是包的名称，按照惯例，包名是小写字母，并用点（.）分隔子包。例如：com.example.myapp。

示例：

// 声明一个包
package com.example.myapp;

// 定义一个类
public class MyClass {
    // 类的成员和方法
}

在这个示例中，MyClass 类被声明在 com.example.myapp 包中。包名通常反映了类所在的项目或组织的结构。

包的作用包括：

1. 组织和管理代码： 将相关的类组织在同一个包中，使代码更加结构化和可维护。

2. 命名空间管理： 避免类名冲突，不同包中的类可以有相同的类名，通过包名进行区分。

3. 访问控制： 包也影响了类的访问权限，类的成员可以设置为包私有（默认）、公有、受保护等。

在Java中，一个源文件通常以 package 声明开始，后面紧跟着 import 语句（用于导入其他包的类），然后是类的定义。

java 常用的包

Java中有许多主要的标准包，它们提供了丰富的类库和功能，用于支持各种类型的应用程序开发。以下是一些主要的Java包：

1. java.lang： 包含Java的核心类，如基本数据类型的包装类、字符串、异常处理、线程等。这个包中的类是自动导入的，无需显式导入。

2. java.util： 提供了集合框架、日期和时间工具、随机数生成器等实用工具类。

3. java.io： 包含用于输入和输出的类，支持文件操作、流处理等。

4. java.net： 提供了用于网络编程的类，包括Socket、ServerSocket等。

5. java.awt： Abstract Window Toolkit，提供用于创建图形用户界面（GUI）的类。

6. javax.swing： 提供了用于创建更丰富的GUI应用程序的类，建立在java.awt之上。

7. java.sql： 提供了与数据库交互的类，包括对JDBC（Java Database Connectivity）的支持。

8. java.math： 包含对任意精度整数和小数进行操作的类。

9. java.security： 提供了有关安全性的类，包括加密、数字签名等。

10. java.text： 提供了用于处理文本、日期和数字格式化的类。

11. java.nio： 提供了用于非阻塞I/O和新的文件I/O（NIO）的类。

12. java.applet： 包含Applet类，用于创建Java小程序，尽管现代Java应用更倾向于使用Swing或JavaFX。

这些包构成了Java标准库的一部分，开发者可以使用它们来加速应用程序的开发，而不必从头开始实现所有功能。在实际的Java开发中，根据应用程序的需求，可能还需要使用其他第三方库或框架。

import

在Java中，import 是一个关键字，用于导入其他包中的类、接口或枚举。通过使用 import 关键字，可以在代码中引用其他包的成员，避免写出完整的类路径。

语法：

import package_name.ClassName;

• package_name 是包的名称。
• ClassName 是要导入的类、接口或枚举的名称。

示例：

// 导入java.util包中的ArrayList类
import java.util.ArrayList;

// 使用ArrayList类
public class Example {
    public static void main(String[] args) {
        ArrayList<String> myList = new ArrayList<>();
        myList.add("Java");
        myList.add("Programming");

        System.out.println(myList);
    }
}

在这个示例中，通过 import java.util.ArrayList; 导入了 java.util 包中的 ArrayList 类，使得在代码中可以直接使用 ArrayList 而不必写出完整的路径。

注意事项：

1. import 语句通常出现在源文件的开头，位于包声明之后，类声明之前。

2. 可以使用通配符 * 导入整个包下的所有类，但在大型项目中通常建议只导入需要使用的类，以避免命名冲突和提高代码的可读性。

// 导入java.util包下的所有类
import java.util.*;

import 关键字是Java语言中一种方便的机制，使得在代码中使用其他包的类更加简洁和方便。

类的成员之一：属性

类的属性（成员变量）是描述类的特征或状态的变量。它们表示了类的数据成员，用于存储对象的状态信息。属性可以是基本数据类型（如整数、浮点数、字符等）或其他类的对象。

定义属性的语法：

[访问修饰符] 数据类型 属性名;

• 访问修饰符： 定义属性的访问权限，可以是 public、private、protected 或默认（无修饰符）。
• 数据类型： 属性的数据类型，可以是基本数据类型或其他类的类型。
• 属性名： 属性的名称，用于在类中标识该属性。

示例：

public class Car {
    // 属性声明
    private String brand;  // 品牌
    private int year;       // 生产年份
    public double price;   // 价格

    // 构造方法
    public Car(String brand, int year, double price) {
        // 构造方法初始化属性
        this.brand = brand;
        this.year = year;
        this.price = price;
    }

    // 其他成员方法...
}

在这个示例中，Car 类包含了三个属性：brand、year 和 price。这些属性用于描述汽车的品牌、生产年份和价格。属性通常被设置为私有（private），并通过构造方法或其他成员方法进行初始化和访问，以实现封装的概念。

访问属性的方式：

在类的内部，可以直接访问属性。在类的外部，通常使用公有的成员方法来访问和修改属性，以维护封装性。

// 在类的外部访问属性的例子
public class Main {
    public static void main(String[] args) {
        // 创建Car对象
        Car myCar = new Car("Toyota", 2022, 25000.0);

        // 访问属性
        System.out.println("Brand: " + myCar.brand);
        System.out.println("Year: " + myCar.year);
        System.out.println("Price: " + myCar.price);
    }
}

这个例子中，通过创建 Car 对象并使用对象的引用变量访问属性，展示了在类的外部如何访问属性。

成员变量和局部变量

成员变量和局部变量是两种不同类型的变量，它们在Java中具有一些关键的区别：

成员变量：

1. 作用域： 成员变量的作用域是整个类，可以在类的任何地方被访问，包括构造方法、成员方法、初始化块等。

2. 生命周期： 成员变量的生命周期与对象的生命周期相同。它们在对象创建时被创建，在对象销毁时被销毁。

3. 初始化（Initialization）： 成员变量可以有默认值，如果没有显式初始化，它们将被赋予默认值。数值类型的默认值是0，布尔类型的默认值是false，对象类型的默认值是null。成员变量可以通过构造方法、初始化块或直接赋值语句进行初始化。

   public class MyClass {
       // 默认值分别为 0, null, false
       private int intValue;
       private String stringValue;
       private boolean booleanValue;
   
       // 构造方法进行初始化
       public MyClass() {
           intValue = 42;
           stringValue = "Hello";
           booleanValue = true;
       }
   }
   

4. 可访问性： 成员变量可以具有不同的访问修饰符，例如 public、private、protected 或默认（无修饰符）。这影响了成员变量的可见性和访问权限。

5. 存储位置： 成员变量存储在对象的内存空间中，每个对象都有一份独立的成员变量副本。

public class MyClass {
    // 成员变量
    private int memberVar;

    // 构造方法
    public MyClass(int value) {
        // 成员变量初始化
        memberVar = value;
    }

    // 成员方法
    public void displayVar() {
        System.out.println("Member Variable: " + memberVar);
    }
}

局部变量：

1. 作用域： 局部变量的作用域限定在声明它的块内，包括方法、构造方法、初始化块等。

2. 生命周期： 局部变量的生命周期仅限于声明它的块。当块执行完毕时，局部变量的内存被释放。

3. 初始化： 局部变量没有默认值，必须在使用之前进行显式初始化。

4. 可访问性： 局部变量只能在声明它的块内访问，对于外部块是不可见的。

5. 存储位置： 局部变量通常存储在栈内存中。

public class MyClass {
    // 成员方法
    public void exampleMethod() {
        // 局部变量
        int localVar = 42;
        System.out.println("Local Variable: " + localVar);
    }
}

总体而言，成员变量用于表示对象的状态，而局部变量用于暂时存储在方法或块中的临时数据。

类外访问成员变量

在Java中，成员变量可以通过对象的引用进行访问。访问成员变量的方式取决于成员变量的访问修饰符（public、private、protected 或默认）。以下是一些常见的情况：

1. 公有成员变量（public member variable）： 可以在类的外部直接通过对象引用访问。

   public class MyClass {
       public int publicVar;
   
       // 其他类或方法中的访问
       public static void main(String[] args) {
           MyClass myObject = new MyClass();
           myObject.publicVar = 42;  // 直接访问公有成员变量
           System.out.println(myObject.publicVar);
       }
   }
   

2. 私有成员变量（private member variable）： 私有成员变量在类的外部不能直接访问。通常通过公有的成员方法提供间接访问。

   public class MyClass {
       private int privateVar;
   
       // 提供公有方法来访问私有成员变量
       public int getPrivateVar() {
           return privateVar;
       }
   
       public void setPrivateVar(int value) {
           privateVar = value;
       }
   
       // 其他类或方法中的访问
       public static void main(String[] args) {
           MyClass myObject = new MyClass();
           myObject.setPrivateVar(42);  // 通过公有方法设置私有成员变量的值
           System.out.println(myObject.getPrivateVar());  // 通过公有方法获取私有成员变量的值
       }
   }
   

3. 受保护成员变量（protected member variable）和默认成员变量（package-private member variable）： 受保护和默认访问级别的成员变量在类的外部的包相关性和继承关系中有不同的访问权限。通常，也通过提供公有的成员方法来进行访问。

总之，成员变量的访问权限受到其访问修饰符的影响，而在类的外部通常通过提供公有的成员方法来实现对成员变量的访问。

实例变量内存分析

1. 物理硬件上的存储：

在物理硬件层面，Java对象被存储在计算机的内存中。每个对象在内存中都占据一块连续的内存空间，该空间包括对象的头部信息和成员变量的存储区域。

• 对象头部信息： 包含对象的标记、类型信息、同步锁等。这部分信息由JVM管理，通常占用一定的字节。

• 成员变量存储区域： 包括实例变量以及可能的填充字节。实例变量的存储顺序与其在类中的声明顺序一致。

2. JVM上的存储：

JVM负责Java程序的运行和内存管理。Java中的对象在JVM中被创建、初始化和垃圾回收。

• 堆内存（Heap Memory）： 对象通常存储在堆内存中。堆内存是由JVM管理的内存池，用于存放所有创建的对象。每个对象在堆内存中都有一个唯一的地址。

• 实例变量的内存分配： 每个实例变量在对象的内存布局中占用一定的空间。基本数据类型的实例变量直接存储其值，而引用类型的实例变量存储的是引用地址。

• 栈内存（Stack Memory）： 局部变量和对象引用通常存储在栈内存中。栈内存是用于存储方法调用、局部变量和操作数栈的内存区域。

• 寄存器（Registers）： 一些局部变量和引用可能存储在CPU寄存器中，以提高访问速度。

总体过程：

1. 对象创建： 当通过 new 关键字创建一个对象时，JVM会在堆内存中分配一块空间，该空间用于存储对象的实例变量。

2. 实例变量初始化： 构造方法负责对实例变量进行初始化。这包括给实例变量赋初值，构造方法中的初始化块执行等。

3. 对象的生命周期： 对象的生命周期从创建到垃圾回收结束。在此期间，实例变量的值可能会发生变化。

4. 内存释放： 当对象不再被引用时，JVM的垃圾回收机制会回收对象所占用的堆内存，并释放相应的资源。

实例变量是存储在对象内存中的成员变量，每个对象都有一份独立的实例变量副本。让我们通过一个简单的内存分析来了解实例变量的存储情况：

考虑以下Java类：

public class MyClass {
    // 实例变量
    private int instanceVar1;
    private String instanceVar2;

    // 构造方法
    public MyClass(int value, String str) {
        // 实例变量初始化
        this.instanceVar1 = value;
        this.instanceVar2 = str;
    }

    // 其他成员方法...
}

现在，让我们创建一个 MyClass 的对象并分析其内存结构：

public class MemoryAnalysis {
    public static void main(String[] args) {
        // 创建对象
        MyClass myObject = new MyClass(42, "Hello");

        // 对象的内存结构
        // myObject -> |-------------------------|
        //              | instanceVar1: 42        |
        //              | instanceVar2: "Hello"   |
        //              |-------------------------|
    }
}

在这个示例中，我们创建了一个 MyClass 的对象 myObject。该对象在内存中占用一块连续的空间，其中包含了实例变量 instanceVar1 和 instanceVar2 的值。每个实例对象都有自己的实例变量副本，它们的值可以独立设置和访问。

值得注意的是，this 关键字用于区分实例变量和构造方法的参数，确保正确地引用实例变量。在构造方法中，通过 this.instanceVar1 和 this.instanceVar2 对实例变量进行初始化。在其他成员方法中，同样可以使用 this 来引用实例变量。

这种内存结构的设计允许每个对象拥有自己的状态，而实例变量的值则在对象的整个生命周期内存在。每个对象都有独立的实例变量，使得面向对象编程中的封装和对象的独立性成为可能。
从物理硬件和Java虚拟机（JVM）的角度，我们可以分析对象和实例变量的存储方式。

类的成员之二：方法

方法是类中的成员之一，用于定义类的行为和功能。方法定义了类可以执行的操作。以下是关于方法的一些重要概念：

方法的定义：

在Java中，方法由方法名、返回类型、参数列表和方法体组成。方法的定义形式如下：

[访问修饰符] 返回类型 方法名(参数列表) {
    // 方法体
    // 可以包含一系列的语句
    return 返回值; // 如果方法有返回值的话
}

• 访问修饰符： 定义方法的访问权限，可以是 public、private、protected 或默认（无修饰符）。
• 返回类型： 指定方法返回值的类型，如果方法不返回任何值，可以使用 void。
• 方法名： 方法的名称，用于在其他地方调用该方法。
• 参数列表： 方法可以接收输入参数，参数列表定义了输入参数的类型和名称。
• 方法体： 包含方法执行的一系列语句，定义了方法的具体功能。
• 返回值： 如果方法有返回值，使用 return 语句返回相应的值。

方法的调用：

在类的外部或类的内部的其他方法中，可以通过对象的引用调用方法。方法调用的一般形式如下：

对象引用.方法名(参数列表);

示例：

public class Calculator {
    // 方法定义
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    public void displayResult(int result) {
        System.out.println("Result: " + result);
    }

    // 其他成员方法...
}

public class Main {
    public static void main(String[] args) {
        // 创建Calculator对象
        Calculator myCalculator = new Calculator();

        // 调用方法
        int sum = myCalculator.add(5, 7);
        myCalculator.displayResult(sum);
    }
}

在这个示例中，Calculator 类包含了两个方法：add 和 displayResult。add 方法接收两个整数参数并返回它们的和，displayResult 方法用于显示计算结果。在 Main 类中，通过创建 Calculator 对象并调用其方法来演示方法的使用。

方法是面向对象编程中实现封装和抽象的重要手段，它们允许将代码组织成可重用的单元，提高代码的可读性和可维护性。

方法内存分析

方法调用的内存分析涉及到栈内存和堆内存的使用。以下是一个简单的方法调用的内存分析过程：

假设有如下的类：

public class Example {
    private int result;

    public int add(int num1, int num2) {
        result = num1 + num2;
        return result;
    }
}

1. 创建对象：

首先，需要创建一个 Example 对象。对象会被分配在堆内存中。

Example myObject = new Example();

堆内存:
|---------------------|
|       myObject      |
|---------------------|
|      result: 0      |
|---------------------|

2. 方法调用：

调用对象上的 add 方法，传递参数并执行方法体。方法调用会导致栈内存的使用。

int sum = myObject.add(5, 7);

栈内存:
|---------------------|
|        add()        |
|---------------------|
|   num1: 5            |
|   num2: 7            |
|---------------------|
|   result: (unchanged)|
|---------------------|

在栈内存中，创建了一个帧（frame）用于存储方法调用的局部变量和执行过程中的状态。这个帧包含了方法的参数 num1 和 num2，以及方法内部的局部变量。

3. 方法执行：

方法开始执行，计算 num1 + num2 的结果，并将结果存储在对象的 result 成员变量中。

栈内存:
|---------------------|
|        add()        |
|---------------------|
|   num1: 5            |
|   num2: 7            |
|---------------------|
|   result: 12         |
|---------------------|

4. 方法返回：

方法执行完成后，返回值（结果）被传递回调用方。此时栈帧被销毁。

栈内存: (空)

5. 对象状态更新：

在堆内存中，对象的状态已经被更新，result 成员变量的值变为 12。

堆内存:
|---------------------|
|       myObject      |
|---------------------|
|      result: 12     |
|---------------------|

这个简单的示例描述了方法调用时栈内存和堆内存的基本过程。栈内存用于存储方法调用的局部变量和执行状态，而堆内存用于存储对象的实例变量。方法的执行过程包括参数传递、局部变量的分配和更新对象的状态。

练习

当然，下面是几个关于方法和实例的练习题，每个问题后面都有答案和简要解释：

练习题 1：

public class Rectangle {
    private int length;
    private int width;

    // 构造方法
    public Rectangle(int l, int w) {
        length = l;
        width = w;
    }

    // 计算矩形的面积
    public int calculateArea() {
        return length * width;
    }

    public static void main(String[] args) {
        // 创建矩形对象
        Rectangle myRectangle = new Rectangle(5, 10);

        // 调用方法计算面积
        int area = myRectangle.calculateArea();

        // 输出面积
        System.out.println("Area of the rectangle: " + area);
    }
}

问题： 以上代码定义了一个 Rectangle 类，包含了计算矩形面积的方法。在 main 方法中创建一个矩形对象，调用方法计算并输出面积。预测输出结果是什么？

答案： 预测输出结果是 “Area of the rectangle: 50”。

练习题 2：

public class Circle {
    private double radius;

    // 构造方法
    public Circle(double r) {
        radius = r;
    }

    // 计算圆的面积
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    public static void main(String[] args) {
        // 创建圆对象
        Circle myCircle = new Circle(3.5);

        // 调用方法计算面积
        double area = myCircle.calculateArea();

        // 输出面积
        System.out.println("Area of the circle: " + area);
    }
}

问题： 以上代码定义了一个 Circle 类，包含了计算圆面积的方法。在 main 方法中创建一个圆对象，调用方法计算并输出面积。预测输出结果是什么？

答案： 预测输出结果是 “Area of the circle: 38.484209”（保留小数点后6位）。

练习题 3：

public class Student {
    private String name;
    private int age;

    // 构造方法
    public Student(String n, int a) {
        name = n;
        age = a;
    }

    // 显示学生信息
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    public static void main(String[] args) {
        // 创建学生对象
        Student myStudent = new Student("Alice", 20);

        // 调用方法显示信息
        myStudent.displayInfo();
    }
}

问题： 以上代码定义了一个 Student 类，包含了显示学生信息的方法。在 main 方法中创建一个学生对象，调用方法显示学生信息。预测输出结果是什么？

答案： 预测输出结果是：

Name: Alice
Age: 20

可变参数

在Java中，可变参数是一种允许方法接受不定数量参数的特性。这是通过在方法的参数列表中使用省略号 ... 来实现的。可变参数允许方法接受任意数量相同类型的参数，这些参数被封装成一个数组。

以下是Java中使用可变参数的基本语法：

public returnType methodName(Type... paramName) {
    // 方法体
}

其中：

• returnType 是方法的返回类型。
• methodName 是方法的名称。
• Type 是可变参数的类型。
• paramName 是可变参数的名称。

以下是一个简单的例子：

public class VariableArgumentsExample {
    // 使用可变参数计算整数的总和
    public static int calculateSum(int... numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }

    public static void main(String[] args) {
        // 调用方法，传递不定数量的参数
        int sum1 = calculateSum(1, 2, 3, 4, 5);
        int sum2 = calculateSum(10, 20, 30);

        // 输出结果
        System.out.println("Sum 1: " + sum1);
        System.out.println("Sum 2: " + sum2);
    }
}

在这个例子中，calculateSum 方法使用了可变参数，可以接受不定数量的整数参数。在 main 方法中，我们演示了如何传递不同数量的参数给这个方法，并输出了计算的结果。

注意事项：

• 可变参数必须是方法参数列表的最后一个参数。
• 在方法内部，可变参数被视为数组，可以通过数组的方式进行访问。
• 调用时可以传递任意数量的参数，甚至可以传递零个参数。

使用可变参数可以让方法更加灵活，适应不同数量的输入参数。

方法重载

方法重载是指在同一个类中可以定义多个方法，它们具有相同的名称但有不同的参数列表。方法重载使得在调用方法时，根据传递的参数类型和数量的不同，可以选择调用适当版本的方法。

以下是方法重载的基本规则：

1. 方法名称必须相同。
2. 参数列表必须不同，包括参数的数量、类型或顺序。
3. 返回类型可以相同也可以不同。

以下是一个简单的例子：

public class OverloadExample {
    // 重载方法，接受两个整数参数
    public int add(int a, int b) {
        return a + b;
    }

    // 重载方法，接受三个整数参数
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 重载方法，接受两个 double 类型参数
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        OverloadExample calculator = new OverloadExample();

        // 调用不同版本的 add 方法
        int result1 = calculator.add(5, 10);
        int result2 = calculator.add(5, 10, 15);
        double result3 = calculator.add(3.5, 2.5);

        // 输出结果
        System.out.println("Result 1: " + result1);
        System.out.println("Result 2: " + result2);
        System.out.println("Result 3: " + result3);
    }
}

在这个例子中，OverloadExample 类定义了三个版本的 add 方法，它们具有相同的名称但有不同的参数列表。通过传递不同数量和类型的参数，我们可以选择调用适当版本的方法。

方法重载提供了更灵活的方法调用方式，使得我们可以使用相同的方法名称来处理不同的输入情况。在实际编码中，方法重载常用于提供一组相关但参数不同的功能。

当涉及到方法重载的练习时，通常可以设计一组方法，要求学习者理解方法重载的规则。以下是一些练习题及其答案：

练习题 1：

设计一个类 MathOperations，其中包含多个方法用于执行基本数学运算。包括：

1. add 方法，接受两个整数参数，返回它们的和。
2. add 方法的重载，接受三个整数参数，返回它们的和。
3. multiply 方法，接受两个 double 参数，返回它们的乘积。
4. multiply 方法的重载，接受三个 double 参数，返回它们的乘积。

答案 1：

public class MathOperations {
    // 方法重载 - add
    public int add(int a, int b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 方法重载 - multiply
    public double multiply(double a, double b) {
        return a * b;
    }

    public double multiply(double a, double b, double c) {
        return a * b * c;
    }
}

练习题 2：

设计一个类 StringProcessor，其中包含多个方法用于处理字符串。包括：

1. concatenate 方法，接受两个字符串参数，返回它们的连接结果。
2. concatenate 方法的重载，接受三个字符串参数，返回它们的连接结果。
3. reverse 方法，接受一个字符串参数，返回它的反转结果。

答案 2：

public class StringProcessor {
    // 方法重载 - concatenate
    public String concatenate(String str1, String str2) {
        return str1 + str2;
    }

    public String concatenate(String str1, String str2, String str3) {
        return str1 + str2 + str3;
    }

    // 方法 - reverse
    public String reverse(String str) {
        return new StringBuilder(str).reverse().toString();
    }
}

这些练习可以帮助理解方法重载的概念，以及如何在类中设计具有相同名称但不同参数的方法。通过调用这些方法并观察结果，可以更好地理解方法重载的使用场景。

参数传递

Java 的方法调用采用值传递的机制，不论是基本数据类型还是引用数据类型。但在引用数据类型的情况下，传递的是引用的值（对象的地址值），这可能引起一些混淆。

1. 基本数据类型的值传递：

对于基本数据类型（如int、double等），方法得到的是实际参数值的一个拷贝，而不是原始参数的引用。因此，在方法内部修改参数的值不会影响原始变量的值。

public class ValuePassingExample {
    public static void main(String[] args) {
        int x = 10;
        System.out.println("Before method call: x = " + x);

        // 调用方法
        modifyValue(x);

        System.out.println("After method call: x = " + x);
    }

    // 修改值的方法
    public static void modifyValue(int value) {
        System.out.println("Inside method: value = " + value);
        value = 20;  // 修改方法内部的值
        System.out.println("Inside method after modification: value = " + value);
    }
}

上述代码中，modifyValue 方法的修改不会影响到原始变量 x 的值。

2. 引用数据类型的值传递：

对于引用数据类型（如对象），传递的是引用的值，即对象的地址值。尽管传递的是引用的值，但方法内部对引用的操作不能修改原始引用指向的对象的地址。

public class ReferencePassingExample {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        System.out.println("Before method call: " + person.getName());

        // 调用方法
        modifyReference(person);

        System.out.println("After method call: " + person.getName());
    }

    // 修改引用的方法
    public static void modifyReference(Person p) {
        System.out.println("Inside method: " + p.getName());
        p.setName("Bob");  // 修改引用指向的对象的值
        System.out.println("Inside method after modification: " + p.getName());
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

在上述代码中，modifyReference 方法修改了引用指向的对象的值，而不是引用本身。因此，原始引用 person 仍然指向同一个对象，但对象的内部状态发生了变化。

总体而言，Java 中的方法调用都是按值传递的，这一点对于基本数据类型和引用数据类型都适用。对于引用数据类型，传递的是引用的值，但无法通过方法内部的操作修改原始引用指向的对象的地址。

类的成员之三：构造器

构造器（Constructor）是Java类的一种特殊方法，用于在对象创建时进行初始化。构造器的名称与类名相同，没有返回类型，且不能被显式调用，而是在创建对象时自动调用。

构造器的主要作用是初始化对象的状态，为对象的属性赋初值，以确保对象在被创建时处于一个合理的初始状态。每次创建对象时，都会调用相应类的构造器。

在Java中，构造器分为两种主要类型：

1. 无参构造器（默认构造器）：

如果在类中没有显式定义构造器，Java会默认提供一个无参构造器。这个构造器不接受任何参数，通常用于初始化对象的默认值。

public class MyClass {
    // 无参构造器（默认构造器）
    public MyClass() {
        // 初始化对象的默认值
    }
}

2. 有参构造器：

有参构造器接受一定数量的参数，并根据这些参数对对象进行初始化。通过有参构造器，可以在创建对象时指定不同的初始化值。

public class Person {
    private String name;
    private int age;

    // 有参构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 其他方法
    // ...
}

在这个例子中，Person 类包含了一个有参构造器，用于在创建 Person 对象时初始化 name 和 age 属性。

构造器的特点：

• 构造器的名称与类名相同。
• 构造器没有返回类型，即使是 void 也不能显式声明。
• 构造器在创建对象时自动调用，不能手动调用。
• 可以定义多个构造器，形成构造器的重载。

构造器的重载：

构造器可以像普通方法一样进行重载，即在同一个类中定义多个具有不同参数列表的构造器。通过构造器的重载，可以提供多种不同的初始化方式。

public class Student {
    private String name;
    private int age;
    private String major;

    // 无参构造器
    public Student() {
        // 初始化默认值
    }

    // 有参构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 有参构造器的重载
    public Student(String name, int age, String major) {
        this.name = name;
        this.age = age;
        this.major = major;
    }

    // 其他方法
    // ...
}

在这个例子中，Student 类定义了三个构造器，分别用于无参初始化、带两个参数初始化和带三个参数初始化。通过构造器的重载，可以根据需要选择不同的初始化方式。

递归

递归是一种在方法内部调用自身的编程技巧。在Java中，递归是通过在方法体内调用方法本身来实现的。递归通常用于解决可以被分解成相似子问题的问题，每次递归调用都将问题规模缩小，最终达到基本情况的解决。

以下是一个简单的递归示例，计算阶乘：

public class RecursionExample {
    public static void main(String[] args) {
        int n = 5;
        int factorial = calculateFactorial(n);
        System.out.println("Factorial of " + n + " is: " + factorial);
    }

    // 递归计算阶乘
    public static int calculateFactorial(int num) {
        if (num == 0 || num == 1) {
            return 1; // 基本情况：0的阶乘和1的阶乘均为1
        } else {
            return num * calculateFactorial(num - 1); // 递归调用
        }
    }
}

在这个例子中，calculateFactorial 方法递归地调用自身，计算给定数的阶乘。当 num 等于0或1时，递归停止，返回1。否则，递归调用 calculateFactorial(num - 1)，直到达到基本情况。

递归需要满足以下条件：

1. 基本情况： 必须有一个或多个基本情况，递归调用会在基本情况下终止，防止无限递归。
2. 问题规模缩小： 每次递归调用都应该使问题的规模减小，逐渐接近基本情况。

递归的优点是它可以使代码更简洁和易读，但需要小心处理，避免无限递归或性能问题。递归的缺点之一是可能导致栈溢出，因为每个递归调用都会占用栈空间。在实践中，对于某些问题，迭代（循环）的解决方案可能更有效。
当涉及到递归的题目时，通常涉及解决可以被分解为相似子问题的问题。以下是一些递归题目及其答案：

递归题目 ：

计算给定数字的阶乘。阶乘的定义是：n! = n * (n-1) * (n-2) * … * 1。

答案 ：

public class Factorial {
    public static void main(String[] args) {
        int n = 5;
        int result = factorial(n);
        System.out.println("Factorial of " + n + " is: " + result);
    }

    public static int factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
}

递归题目：

反转字符串。编写一个递归函数，将输入的字符串反转。

答案 3：

public class StringReverse {
    public static void main(String[] args) {
        String input = "Hello";
        String result = reverseString(input);
        System.out.println("Reversed string: " + result);
    }

    public static String reverseString(String str) {
        if (str.isEmpty()) {
            return str;
        } else {
            return reverseString(str.substring(1)) + str.charAt(0);
        }
    }
}

这些题目涵盖了递归在不同类型问题中的应用，包括数学计算、字符串处理等。递归的关键是定义好基本情况和递归调用的规则，确保递归能够在基本情况下终止。

面向对象-封装

封装是面向对象编程中的一个重要概念，它指的是将一个对象的状态（属性）和行为（方法）封装在一起，并对外部提供一定的访问和操作权限。封装的目的是为了隐藏对象的内部实现细节，提供一种清晰的接口供其他对象使用，并防止外部直接访问对象的内部状态。

在Java中，封装可以通过以下方式实现：

1. 私有属性（Private Fields）： 将类的属性声明为私有的，只能在类的内部访问。

2. 公共方法（Public Methods）： 提供公共方法用于访问和修改私有属性。这些方法被称为 getter 和 setter 方法。

下面是一个简单的例子，演示了如何使用封装：

public class Person {
    // 私有属性
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法（getter 和 setter）
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }
    }

    // 其他方法
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

在这个例子中，Person 类的属性 name 和 age 被声明为私有的，外部无法直接访问它们。通过提供公共的 getter 和 setter 方法，可以对这些属性进行访问和修改。在 setter 方法中，可以添加一些逻辑来验证属性的值是否合法。

使用封装的好处包括：

• 安全性： 隐藏对象的内部实现，防止不合理的直接访问和修改。
• 灵活性： 可以通过公共方法来控制属性的访问和修改，可以在方法中添加逻辑。
• 模块化： 可以更容易地理解和维护代码，因为对象的内部实现细节被封装在一起。

封装是面向对象编程的三大特征之一，另外两个是继承和多态。

面向对象-继承

继承是面向对象编程中的一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。继承创建了一种层次关系，使得子类可以重用父类的代码，并且可以在不修改父类的情况下添加新的功能。

在Java中，使用关键字 extends 实现继承。子类继承了父类的成员，包括字段和方法。以下是一个简单的继承的例子：

// 父类
class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类继承父类
class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类的构造器
    }

    // 子类可以继承父类的方法
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        // 创建子类对象
        Dog myDog = new Dog("Buddy");

        // 调用父类的方法
        myDog.eat();

        // 调用子类自己的方法
        myDog.bark();
    }
}

在这个例子中，Dog 类继承了 Animal 类。子类 Dog 拥有父类 Animal 的属性 name 和方法 eat，并且可以添加自己的方法 bark。在子类的构造器中，使用 super(name) 调用了父类的构造器，以初始化继承的属性。

当一个类继承另一个类时，子类（派生类）会继承父类（基类）的成员变量和成员方法。以下是关于继承中的成员变量、成员方法、单继承和构造方法的详细说明：

1. 成员变量的继承：

子类继承父类的成员变量，包括父类中声明的所有字段。子类可以直接访问父类的非私有字段。如果子类中声明了与父类相同名称的字段，子类的字段会隐藏父类的字段，这称为字段的遮蔽（hiding）。

// 父类
class Animal {
    String name = "Animal";
    private int age = 5;
}

// 子类
class Dog extends Animal {
    String breed = "Labrador";
    // 子类中的name字段遮蔽了父类中的name字段
    String name = "Dog";

    public void display() {
        System.out.println("Name: " + name); // Dog
        System.out.println("Breed: " + breed); // Labrador
        System.out.println("Parent Name: " + super.name); // Animal
    }
}

2. 成员方法的继承：

子类继承父类的成员方法。子类可以直接调用父类的方法，也可以重写（覆盖）父类的方法。重写时，子类的方法应该具有相同的方法签名（方法名称、参数列表、返回类型）。通过使用 super 关键字，子类可以调用父类的方法。

// 父类
class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类
class Dog extends Animal {
    // 重写父类的eat方法
    @Override
    public void eat() {
        System.out.println("Dog is eating dog food.");
        // 调用父类的eat方法
        super.eat();
    }
}

3. 单继承：

Java是一种单继承语言，一个类只能直接继承一个类。这意味着一个子类只能有一个直接的父类。这种设计决策有助于避免多继承引发的一些问题，如菱形继承问题。如果一个类需要继承多个类的功能，可以通过接口、组合等方式来实现。

class A {}
class B extends A {} // 合法，B继承A
// class C extends A, B {} // 非法，Java不支持多继承

4. 构造方法的继承：

构造方法不会被继承，但在创建子类对象时，会调用父类的构造方法以完成父类的初始化。子类的构造方法可以通过 super() 调用父类的构造方法，以确保父类的初始化得以执行。

// 父类
class Animal {
    public Animal() {
        System.out.println("Animal constructor");
    }
}

// 子类
class Dog extends Animal {
    public Dog() {
        super(); // 调用父类的构造方法
        System.out.println("Dog constructor");
    }
}

在上述例子中，当创建 Dog 对象时，会先调用父类 Animal 的构造方法，然后再调用子类 Dog 的构造方法。

继承是面向对象编程的核心特性之一，它提供了一种代码重用和扩展的机制。合理使用继承能够使代码更加灵活、可维护，并提高代码的复用性。

面向对象-多态

多态是面向对象编程中的一个重要概念，它允许使用基类的引用来引用派生类的对象，以实现动态绑定。多态有助于编写灵活、可扩展和可维护的代码。

1. 多态的基本概念：

多态表示同一个方法名可以在不同的类中有不同的实现，即相同的接口可以有多种不同的形态。在Java中，多态可以通过继承和接口实现。

2. 多态的实现：

在Java中，多态主要通过两种方式实现：

a. 方法重写（Override）：

子类可以重写（覆盖）父类的方法，以提供自己的实现。父类的引用可以指向子类的对象，通过这个引用调用的方法会调用子类的实现。

// 父类
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 多态：父类引用指向子类对象
        animal.makeSound(); // 调用子类的实现
    }
}

b. 接口（Interface）：

通过接口，一个类可以实现多个接口，从而表现出不同的形态。接口定义了一组抽象方法，而实现接口的类必须提供这些方法的具体实现。

// 接口
interface Soundable {
    void makeSound();
}

// 实现接口的类
class Dog implements Soundable {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

// 另一个实现接口的类
class Cat implements Soundable {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Soundable soundable1 = new Dog(); // 多态：接口引用指向实现类对象
        Soundable soundable2 = new Cat(); // 多态：接口引用指向实现类对象

        soundable1.makeSound(); // 调用Dog的实现
        soundable2.makeSound(); // 调用Cat的实现
    }
}

3. 多态的优点：

• 代码灵活性： 通过多态，可以使用通用的接口引用来引用不同的对象，使代码更加灵活和可扩展。
• 代码可读性： 多态可以提高代码的可读性和可维护性，因为不同的实现可以通过相同的接口进行访问。
• 统一的接口： 多态使得可以定义统一的接口，不同的子类提供各自的实现。

4. 多态的运行时动态绑定：

在多态中，方法调用是在运行时动态绑定的。即在编译时确定调用的方法名和参数类型，而在运行时确定具体调用的方法实现。这使得程序在运行时能够适应对象的实际类型。

Animal animal = new Dog(); // 多态：父类引用指向子类对象
animal.makeSound(); // 调用Dog的实现，而不是Animal的实现

这种运行时动态绑定的机制使得多态成为面向对象编程中一个强大的特性，它提高了代码的灵活性和可维护性。

关键字 static

static 是Java中的关键字，它可以用于修饰类的成员（字段、方法、内部类），以表示这些成员是与类本身相关，而不是与类的实例对象相关。以下是关于 static 关键字的详细解释：

1. 静态成员变量（Static Fields）：

静态成员变量属于类，而不是属于类的实例对象。所有该类的实例对象共享同一个静态成员变量。

public class MyClass {
    // 静态成员变量
    static int count;

    public MyClass() {
        // 构造方法中可以访问静态成员变量
        count++;
    }
}

2. 静态方法（Static Methods）：

静态方法属于类，不依赖于类的实例对象。可以直接通过类名调用静态方法，而无需创建类的实例。

public class MathUtils {
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
}

// 调用静态方法
int result = MathUtils.add(3, 5);

3. 静态块（Static Blocks）：

静态块是在类加载时执行的代码块，用于进行一些静态成员变量的初始化或其他静态操作。

public class MyClass {
    // 静态块
    static {
        System.out.println("Static block is executed.");
    }
}

4. 静态内部类（Static Inner Classes）：

静态内部类是声明为静态的内部类，它与外部类的实例对象无关，可以直接通过外部类的类名访问。

public class OuterClass {
    // 静态内部类
    static class InnerClass {
        // ...
    }
}

5. 静态导入（Static Import）：

静态导入允许在不指定类名的情况下直接使用类的静态成员。通过 import static 关键字实现。

import static java.lang.Math.*;

public class MathExample {
    public static void main(String[] args) {
        // 不需要使用Math前缀
        double result = sqrt(16);
        System.out.println(result);
    }
}

6. 静态关键字的特点：

• 静态成员属于类，不依赖于类的实例对象。
• 静态成员可以通过类名直接访问。
• 静态成员在类加载时初始化。
• 静态方法不能访问非静态成员，只能访问静态成员。
• 静态方法中不能使用 this 关键字，因为没有实例对象。
• 静态块在类加载时执行，仅执行一次。

static 关键字的使用使得某些成员与类本身关联，而不是与类的实例对象关联。这在一些工具类、常量等场景下非常有用。但应当谨慎使用静态，因为它可能导致全局状态，影响代码的可维护性和测试性。

单例

单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点。单例模式在整个应用程序中共享相同的实例，这对于管理共享资源、全局配置和避免重复创建相同对象的开销非常有用。

在Java中，实现单例模式的方式有多种，下面介绍两种常见的实现方法：

1. 饿汉式单例模式：

在类加载时就创建实例，保证了线程安全。适用于实例创建开销不大、占用内存小的情况。

public class SingletonEager {
    // 在类加载时就创建实例
    private static final SingletonEager instance = new SingletonEager();

    // 私有构造方法，防止外部实例化
    private SingletonEager() {}

    // 全局访问点
    public static SingletonEager getInstance() {
        return instance;
    }
}

2. 懒汉式单例模式：

在需要使用时才创建实例，通过双重检查锁定（Double-Checked Locking）保证了线程安全。适用于实例创建开销较大、占用内存较多的情况。

public class SingletonLazy {
    // 声明但不初始化
    private static SingletonLazy instance;

    // 私有构造方法，防止外部实例化
    private SingletonLazy() {}

    // 双重检查锁定，保证线程安全
    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

使用示例：

public class SingletonExample {
    public static void main(String[] args) {
        // 饿汉式单例模式
        SingletonEager eagerInstance1 = SingletonEager.getInstance();
        SingletonEager eagerInstance2 = SingletonEager.getInstance();
        System.out.println(eagerInstance1 == eagerInstance2); // true

        // 懒汉式单例模式
        SingletonLazy lazyInstance1 = SingletonLazy.getInstance();
        SingletonLazy lazyInstance2 = SingletonLazy.getInstance();
        System.out.println(lazyInstance1 == lazyInstance2); // true
    }
}

在上述示例中，创建了两个单例类的实例，并通过比较它们的引用地址来验证它们是否相同。单例模式的实现方式取决于具体的需求和性能要求，选择适合场景的实现方式。

关键字 native

native 是Java中的一个关键字，它用于表示一个方法是由非Java语言（通常是由C或C++编写）实现的，并且该方法的具体实现是在外部的原生代码中。使用 native 关键字的方法在Java中只有方法签名，而具体的实现在外部。

通常，使用 native 关键字的场景包括：

1. 与底层系统交互： 通过调用外部库或操作系统提供的功能。
2. 性能优化： 对于一些性能敏感的任务，通过使用本地方法可以提高执行效率。

以下是一个使用 native 关键字的简单示例：

public class NativeExample {
    // 使用native关键字声明的本地方法
    public native void callNativeMethod();

    // 加载动态链接库
    static {
        System.loadLibrary("NativeLibrary");
    }

    public static void main(String[] args) {
        NativeExample example = new NativeExample();
        example.callNativeMethod();
    }
}

在这个例子中，callNativeMethod 方法被声明为本地方法，具体的实现将在外部的动态链接库（例如，名为 “NativeLibrary” 的库）中提供。在类加载时，通过 System.loadLibrary 加载动态链接库。

实际的本地方法的实现会在原生代码中，例如C或C++中。以下是一个简单的C语言实现的本地方法示例：

#include 
#include 

JNIEXPORT void JNICALL Java_NativeExample_callNativeMethod(JNIEnv *env, jobject obj) {
    printf("This is a native method implementation.\n");
}

在这个C代码中，Java_NativeExample_callNativeMethod 是Java中 callNativeMethod 方法的实际实现。这个函数由Java的JNI（Java Native Interface）调用。实际的JNI调用在原生代码和Java代码之间提供了桥梁。

使用 native 关键字需要谨慎，因为它引入了与Java平台无关的原生代码，可能导致一些跨平台兼容性和可维护性的问题。

关键字 final

final 是Java中的一个关键字，它可以用于修饰类、方法和变量，具有不同的含义和用途。

1. 修饰类：

当一个类被声明为 final 时，表示该类不能被继承，即它是不可扩展的。

final class FinalClass {
    // ...
}

2. 修饰方法：

当一个方法被声明为 final 时，表示该方法不能被子类重写，即它是不可覆盖的。

class ParentClass {
    // final方法
    final void finalMethod() {
        // ...
    }
}

class ChildClass extends ParentClass {
    // 无法重写final方法，会编译报错
    // void finalMethod() { }
}

3. 修饰变量：

a. 修饰成员变量：

当一个成员变量被声明为 final 时，表示该变量的值只能被赋值一次，一旦被赋值后就不可再修改。通常用于定义常量。

class MyClass {
    // final成员变量
    final int constantValue = 10;

    // ...
}

b. 修饰局部变量：

当一个局部变量被声明为 final 时，表示该变量的值不能被修改，一旦被赋值后就不可再修改。常用于匿名内部类中。

public void exampleMethod() {
    final int localVar = 5;

    // localVar不能被修改
    // localVar = 10; // 编译错误

    // 匿名内部类中使用final变量
    Runnable myRunnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(localVar);
        }
    };
}

特点和用途：

• 不可变性： final 修饰的类、方法、变量都具有不可变性，这有助于提高代码的安全性和可靠性。
• 性能优化： 编译器和运行时环境可能通过 final 修饰来进行一些优化，例如内联（inlining）。
• 约定： 使用 final 可以约定某些编码规范，例如常量的命名习惯、方法不可覆盖等。

需要注意的是，final 不同于 static。final 表示不可变性，而 static 表示共享性。在一些情况下，final 和 static 可以一起使用，例如声明一个静态不可变的常量。

object类的使用

Object 类是Java中所有类的根类，也是Java中的基本类之一。所有类都直接或间接地继承自 Object 类。Object 类中定义了一些通用的方法，这些方法在所有对象中都可用。以下是一些常见的 Object 类的方法和用法：

1. toString() 方法：

toString() 方法返回对象的字符串表示。在 Object 类中，默认的 toString() 方法返回一个由类名和对象的哈希码组成的字符串。在自定义类中，通常可以重写 toString() 方法，以返回更有意义的对象描述。

public class MyClass {
    private int value;

    public MyClass(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "value=" + value +
                '}';
    }
}

public class ObjectExample {
    public static void main(String[] args) {
        MyClass obj = new MyClass(42);
        System.out.println(obj.toString()); // 输出自定义的toString()结果
    }
}

2. quals() 方法：

equals() 方法用于比较两个对象是否相等。在 Object 类中，equals() 方法默认比较的是对象的引用地址，即两个对象在内存中是否是同一个对象。在自定义类中，通常需要重写 equals() 方法，以提供自定义的相等比较逻辑。

public class Person {
    private String name;
    private int age;

    // 构造方法等省略

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
}

public class ObjectExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Alice", 25);

        System.out.println(person1.equals(person2)); // true，因为重写了equals方法
    }
}

3. hashCode() 方法：

hashCode() 方法返回对象的哈希码，用于支持哈希表等数据结构。在 Object 类中，hashCode() 方法默认返回对象的内存地址的哈希码。在自定义类中，通常需要重写 hashCode() 方法，以提供自定义的哈希码逻辑。

public class Person {
    private String name;
    private int age;

    // 构造方法等省略

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class ObjectExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        System.out.println(person.hashCode()); // 输出自定义的hashCode()结果
    }
}

4. getClass() 方法：

getClass() 方法返回对象的运行时类。在多态的情况下，可以使用 getClass() 方法获取对象的真实类型。

public class ObjectExample {
    public static void main(String[] args) {
        Object obj = "Hello";
        System.out.println(obj.getClass()); // 输出class java.lang.String
    }
}

5. notify() 和 notifyAll() 方法：

这两个方法用于实现线程间的通信。在多线程环境下，可以使用 wait()、notify() 和 notifyAll() 方法来实现线程的等待和唤醒。

以上是一些常见的 Object 类的方法和用法，这些方法在Java中提供了一些通用的功能，可用于自定义类的实现。当自定义类需要具有一些通用的行为时，可以考虑继承 Object 类并重写其中的方法。

抽象类

在Java中，抽象类（Abstract Class）是一种不能实例化的类，用于作为其他类的父类。抽象类可以包含抽象方法，这些方法只有声明而没有具体实现，需要子类去实现。抽象类的定义使用 abstract 关键字。

以下是关于Java抽象类的一些重要概念和用法：

1. 抽象类的定义：

// 抽象类的定义
abstract class Shape {
    // 抽象方法
    abstract void draw();

    // 普通方法
    void display() {
        System.out.println("Displaying shape");
    }
}

2. 抽象方法：

抽象方法是一种没有实现体的方法，只有方法的声明。子类必须实现抽象方法。

abstract class Animal {
    abstract void makeSound();
}

3. 抽象类的继承：

子类继承抽象类，需要实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。

// 具体的子类
class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing Circle");
    }
}

4. 抽象类的实例化：

抽象类不能直接实例化，但可以通过其子类实例化。

Shape shape = new Circle();
shape.draw();     // 调用子类实现的draw()方法
shape.display();  // 调用抽象类的普通方法

5. 抽象类的构造方法：

抽象类可以有构造方法，它在子类实例化时被调用。抽象类的构造方法主要用于初始化抽象类的成员。

abstract class Vehicle {
    String type;

    // 抽象类的构造方法
    public Vehicle(String type) {
        this.type = type;
    }

    // 抽象方法
    abstract void start();

    void displayType() {
        System.out.println("Vehicle type: " + type);
    }
}

6. 抽象类与接口的区别：

• 抽象类可以有构造方法，而接口不能有构造方法。
• 一个类只能继承一个抽象类，但可以实现多个接口。
• 抽象类可以有实例变量，而接口只能有常量。
• 抽象类的方法可以有访问修饰符，而接口的方法默认是 public。
• 抽象类可以包含普通方法的实现，而接口中的方法都是抽象的。

抽象类提供了一种在类的层次结构中表示通用行为和属性的机制，同时也约束了子类的实现。在设计中，抽象类通常用于表示一类具有共同特征的对象，而抽象方法则要求子类提供具体实现。

接口

在Java中，接口（Interface）是一种抽象类型，它定义了一组抽象方法，但没有具体的实现。接口是实现多继承的一种方式，一个类可以实现多个接口。接口的定义使用 interface 关键字。

以下是关于Java接口的一些重要概念和用法：
Java 8及之后的版本中，接口中的抽象方法可以省略 abstract 关键字，因为接口中的方法默认就是抽象的。在接口中声明方法时，可以直接写方法签名而不需要加上 abstract 关键字。

// Java 8及之后的版本，接口中的抽象方法可以省略abstract关键字
interface MyInterface {
    void abstractMethod();
}

这样的写法仍然定义了一个抽象方法，实现该接口的类必须提供对 abstractMethod 的具体实现。在这种情况下，编译器会将该方法默认视为抽象方法。在较早的Java版本中，接口中的抽象方法必须显式使用 abstract 关键字，但现代Java语法简化了这一点。

1. 接口的定义：

// 接口的定义
public interface Drawable {
    // 抽象方法
    void draw();

    // 默认方法（Java 8引入）
    default void display() {
        System.out.println("Displaying shape");
    }

    // 静态方法（Java 8引入）
    static void printInfo() {
        System.out.println("Interface Drawable");
    }
}

2. 接口的实现：

一个类可以通过 implements 关键字实现一个或多个接口，并提供接口中定义的抽象方法的具体实现。

// 实现接口
public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

3. 接口的多继承：

一个类可以实现多个接口，通过逗号分隔。

public class Square implements Drawable, Rotatable {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }

    @Override
    public void rotate() {
        System.out.println("Rotating Square");
    }
}

4. 接口的默认方法：

在Java 8中引入了默认方法，允许在接口中提供方法的默认实现。实现接口的类可以选择使用默认实现，也可以选择重写默认方法。

// 接口中的默认方法
public interface Drawable {
    void draw();

    default void display() {
        System.out.println("Displaying shape");
    }
}

5. 接口的静态方法：

在Java 8中引入了静态方法，允许在接口中提供静态方法。通过接口名调用静态方法。

// 接口中的静态方法
public interface Drawable {
    void draw();

    static void printInfo() {
        System.out.println("Interface Drawable");
    }
}

6. 接口与抽象类的区别：

• 接口中的方法都是抽象的，而抽象类可以包含抽象方法和具体方法。
• 一个类可以实现多个接口，但只能继承一个抽象类。
• 接口中的变量默认是 public static final 类型，即常量。
• 接口中的方法默认是 public abstract 类型，可以使用 default 关键字提供默认实现。
• 抽象类可以有构造方法，而接口不能有构造方法。

接口在Java中用于定义一组相关的抽象方法，以便多个类实现这些方法并提供各自的具体实现。它是实现多继承的一种机制，能够提高代码的灵活性和可维护性。

7.问题

当一个类同时面临继承和实现多个类或接口中存在相同方法名的情况，可以通过以下两种方式解决：

1. 继承中的方法重写：

class ParentClassA {
    void commonMethod() {
        System.out.println("Implementation in ParentClassA");
    }
}

class ParentClassB {
    void commonMethod() {
        System.out.println("Implementation in ParentClassB");
    }
}

class ChildClass extends ParentClassA, ParentClassB {
    // 需要在子类中重写commonMethod方法，选择性地调用某个父类的方法
    @Override
    void commonMethod() {
        super.commonMethod(); // 调用ParentClassA或ParentClassB的方法
    }
}

2. 实现多个接口中的方法重写：

interface InterfaceA {
    default void commonMethod() {
        System.out.println("Implementation in InterfaceA");
    }
}

interface InterfaceB {
    default void commonMethod() {
        System.out.println("Implementation in InterfaceB");
    }
}

class MyClass implements InterfaceA, InterfaceB {
    // 在实现类中重写commonMethod方法，选择性地调用某个接口的方法
    @Override
    public void commonMethod() {
        InterfaceA.super.commonMethod(); // 调用InterfaceA的方法
        // 或者
        InterfaceB.super.commonMethod(); // 调用InterfaceB的方法
    }
}

这两种方式都是为了解决方法的重名问题。在继承的情况下，需要在子类中重写方法，并使用 super 关键字选择性地调用某个父类的方法。在实现多个接口的情况下，需要在实现类中重写方法，并使用接口名明确指定调用哪个接口的方法。根据具体情况，选择合适的方法来解决方法的重名，以确保代码的清晰性和可维护性。

8.常用接口

在Java中，有许多常用的接口，它们提供了标准化的方法来实现各种功能。以下是一些常见的接口及其用途：

1. Runnable 接口：

   • 用途： 用于实现多线程。包含一个 run 方法，线程执行的代码就在这个方法中。

   class MyRunnable implements Runnable {
       @Override
       public void run() {
           // 线程执行的代码
       }
   }
   

2. Callable 接口：

   • 用途： 与 Runnable 类似，也是为了实现多线程，但与之不同的是，Callable 的 call 方法可以返回结果，并且可以抛出异常。

   class MyCallable implements Callable<Integer> {
       @Override
       public Integer call() throws Exception {
           // 线程执行的代码，返回结果
           return 42;
       }
   }
   

3. Comparator 接口：

   • 用途： 用于对象比较。通过实现 Comparator 接口，可以定义对象之间的比较规则。

   class MyComparator implements Comparator<String> {
       @Override
       public int compare(String s1, String s2) {
           // 自定义比较规则
           return s1.compareTo(s2);
       }
   }
   

4. EventListener 接口：

   • 用途： 是事件处理机制的基础。实现该接口的类可以监听某个特定类型的事件。

   class MyListener implements EventListener {
       // 处理事件的方法
       public void handleEvent(MyEvent event) {
           // 处理事件的逻辑
       }
   }
   

5. Observer 接口：

   • 用途： 是观察者模式的实现。实现该接口的类可以注册为观察者，接收被观察者的通知。

   class MyObserver implements Observer {
       @Override
       public void update(Observable o, Object arg) {
           // 处理被观察者通知的逻辑
       }
   }
   

6. List 接口：

   • 用途： 是集合框架中的一种。实现该接口的类表示一个有序的集合，常见的实现类包括 ArrayList 和 LinkedList。

   List<String> myList = new ArrayList<>();
   myList.add("Item 1");
   myList.add("Item 2");
   

这些接口都是Java标准库中提供的，通过实现这些接口，可以利用Java的标准化机制来实现不同的功能，例如多线程、事件处理、集合操作等。在实际开发中，了解和熟练使用这些常见接口是很重要的。

包装类

包装类（Wrapper Classes）是一组用于将基本数据类型转换为对象的类。在Java中，基本数据类型（如int、double、char等）是非对象的，无法直接参与面向对象的操作。为了弥补这个缺陷，Java提供了相应的包装类，每个基本数据类型都有对应的包装类。

下面是每种基本数据类型及其对应的包装类：

1. 整数类型：

   • byte 对应 Byte
   • short 对应 Short
   • int 对应 Integer
   • long 对应 Long

2. 浮点类型：

   • float 对应 Float
   • double 对应 Double

3. 字符类型：

   • char 对应 Character

4. 布尔类型：

   • boolean 对应 Boolean

用法示例：

转换（装箱与拆箱）：

// 装箱：基本数据类型转换为包装类
int intValue = 42;
Integer integerValue = Integer.valueOf(intValue);

// 拆箱：包装类转换为基本数据类型
int result = integerValue.intValue();

字符串到包装类的转换：

String strValue = "123";
int intValueFromString = Integer.parseInt(strValue);

包装类到字符串的转换：

Integer integerValue = 42;
String strFromInteger = integerValue.toString();

自动装箱与拆箱：

Integer autoBoxedValue = 42;  // 自动装箱
int unboxedValue = autoBoxedValue;  // 自动拆箱

判断两个包装类是否相等：

Boolean bool1 = true;
Boolean bool2 = true;
if (bool1.equals(bool2)) {
    System.out.println("Equal");
}

这些包装类在处理基本数据类型时提供了更多的功能和灵活性。装箱和拆箱使得在基本数据类型和包装类之间进行转换更加方便。例如，可以将包装类作为集合的元素，也可以方便地将基本数据类型转换为字符串。

内部类

在Java中，内部类是定义在其他类内部的类。内部类可以访问包含它的外部类的成员，包括私有成员。Java的内部类分为以下几种类型：

1. 成员内部类（Member Inner Class）：

   • 成员内部类是定义在外部类中的类，它可以访问外部类的所有成员，包括私有成员。

   public class OuterClass {
       private int outerField;
   
       public class InnerClass {
           public void innerMethod() {
               System.out.println("Accessing outerField: " + outerField);
           }
       }
   }
   

2. 局部内部类（Local Inner Class）：

   • 局部内部类定义在方法或代码块内部，只在定义它的方法或代码块中可见。

   public class OuterClass {
       public void outerMethod() {
           int localVar = 42;
   
           class LocalInnerClass {
               public void innerMethod() {
                   System.out.println("Local variable: " + localVar);
               }
           }
   
           LocalInnerClass localInner = new LocalInnerClass();
           localInner.innerMethod();
       }
   }
   

3. 匿名内部类（Anonymous Inner Class）：

   • 匿名内部类是没有名字的局部内部类，通常用于创建实现某个接口或继承某个类的对象。

   interface MyInterface {
       void myMethod();
   }
   
   public class OuterClass {
       public void createAnonymousInner() {
           MyInterface myObject = new MyInterface() {
               @Override
               public void myMethod() {
                   System.out.println("Anonymous Inner Class");
               }
           };
   
           myObject.myMethod();
       }
   }
   

4. 静态嵌套类（Static Nested Class）：

   • 静态嵌套类是使用 static 关键字修饰的内部类，它与外部类之间的关系更像是普通的类和类之间的关系。

   public class OuterClass {
       private static int staticOuterField;
   
       public static class StaticNestedClass {
           public void nestedMethod() {
               System.out.println("Accessing staticOuterField: " + staticOuterField);
           }
       }
   }
   

匿名内部类可以通过 new 关键字实例化，这是因为匿名内部类本质上是一个实现了某个接口或继承了某个类的子类，并且它在实例化的同时提供了实现。

当你使用匿名内部类时，实际上是在创建一个继承了某个类或实现了某个接口的匿名子类的对象。这个匿名子类没有显式的类名，它直接在实例化的地方定义了类的实现，因此称为匿名内部类。

以下是一个使用匿名内部类的例子：

interface MyInterface {
    void myMethod();
}

public class MyClass {
    public static void main(String[] args) {
        // 使用匿名内部类实现MyInterface接口
        MyInterface myObject = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Implementation of myMethod in anonymous inner class");
            }
        };

        // 调用接口中的方法
        myObject.myMethod();
    }
}

在上面的例子中，MyInterface 是一个接口，通过匿名内部类实现了该接口。在实例化的同时提供了对 myMethod 方法的实现。虽然没有显式地命名这个类，但它仍然是一个具有实现的类，可以通过 new 关键字实例化并使用。

匿名内部类的优点是可以在使用的地方直接实现接口或继承类，避免了单独创建一个具体类的繁琐过程，使代码更为简洁。

内部类的使用可以带来更好的封装和组织代码的能力，同时可以访问外部类的私有成员。不同类型的内部类有不同的使用场景，根据需要选择合适的内部类类型。