六、java中的类和对象

六、类和对象

1. 类

类是一种定义代码的结构，包含属性和方法的模板,用于描述代码中的对象。

类可以看作是一个模板或者蓝图，它定义了对象的属性和方法。

类是对象的数据类型，类是具有相同属性和行为的一组对象的集合

1.1 类的组成

类的组成是由属性和行为两部分组成

• 属性：在类中通过成员变量来体现（类中方法外的变量）
• 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

一个类通常由以下部分组成：

1. 类名：类名是类的名称，我们可以使用任何标识符作为类名。

类名应符合Java编码规范，通常以大写字母开头。

例如，定义一个类名为`Car`的类：

`public class Car {}`

2. 成员变量：成员变量也称为属性，用于描述类中的数据。

成员变量的定义通常放置在类的开头部分，可以添加修饰符（如public、private、protected等），用于控制变量的访问权限。

例如，定义一个Car类，包含品牌和颜色两个成员变量：

`public class Car { private String brand; private String color; }`

3. 方法：方法包含一些语句块，用于执行特定操作。

方法通常用于操作类中的数据（成员变量），为成员变量赋值或取值，并将结果返回。方法也可以添加修饰符（如public、private、protected等），用于控制方法的访问权限。

例如，定义一个`Car`类，包含加速和刹车两个方法：

public class Car {
    private String brand;
    private String color;
    private int speed;

    public void accelerate(int increment) {
        speed += increment;
    }

    public void brake(int decrement) {
        speed -= decrement;
    }
}

在这个例子中，`accelerate()`和`brake()`是方法，它们用于加速和刹车操作。

`brand`、`color`和`speed`是成员变量，用于描述车辆的品牌、颜色和速度。

1.2 类的定义

类的定义步骤：

1. 定义类
2. 编写类的成员变量
3. 编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}

例如：

/*
    手机类：
        类名：
        手机(Phone)

        成员变量：
        品牌(brand)
        价格(price)

        成员方法：
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

2. 对象

对象是类的实例，存储在内存中,它是类定义的抽象描述在内存中的实际具体化的一个个体。

2.1 创建对象

我们通过实例化（即创建）类来创建对象。

• 使用new关键字来创建一个类的对象。

   类名 对象名 = new 类名();
  

例如，创建一个Car对象：

Car myCar = new Car();

这行代码创建了一个`Car`类的对象，并将其赋给变量`myCar`。

当执行该语句时，将会向操作系统请求一块内存空间，该空间用于存储新创建的`Car`对象。

完成创建后，系统会返回指向该对象的引用（地址），并将其存储在变量`myCar`中。

2.2 调用对象

• 调用成员的格式：
  • 对象名.成员变量
  • 对象名.成员方法();

示例代码：

/*
    创建对象
        格式：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class HuaWeiPhone{
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "华为";
        p.price = 3999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

• 通过引用变量来访问和操作对象。

例如，可以使用.（点）操作符来获取或修改对象的属性或调用对象的方法。

myCar.accelerate(10);  // 将车速增加10

在这个例子中，我们使用myCar.accelerate(10)调用Car类中的accelerate()方法，并将参数10传递给该方法。这个方法将把车速增加10。

3. 成员变量和局部变量

在Java中，变量可以分为成员变量和局部变量。

3.1 成员变量

成员变量是定义在类中，方法之外的变量。

它们的生命周期和对象一样长，并且可以被类中的所有方法访问，因此也称作“对象属性”。

成员变量需要使用访问修饰符来修饰其可见性。

通常，成员变量也需要初始化，否则将默认为其类型的默认值（例如，数值类型默认为0，布尔类型默认为false，对象类型默认为null）。

下面是一个示例：

public class Person {
    private String name; // 私有成员变量，只能在类中访问

    public int age; // 公有成员变量，可以在类外部访问

    // 构造函数，初始化成员变量
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 对象方法，访问和修改成员变量
    public void sayHello() {
        System.out.println("My name is " + name + ", and I am " + age + " years old.");
    }
}

在这个例子中，Person类有两个成员变量：name和age。name被声明为私有的，只能在类内部访问和修改，而age被声明为公有的，可以在类外部访问和修改。Person类还包含一个构造函数，用于初始化这两个成员变量。

3.2 局部变量

局部变量是在方法或代码块中定义的变量，只有在它们的作用域内访问和使用它们。

它们的生命周期只在方法或代码块中，在方法或代码块的结束时它们会被销毁。

局部变量不需要使用访问修饰符来管理可见性。

下面是一个示例：

public void calculate() {
    int x = 5; // 局部变量
    int y = 10; // 局部变量
    int z = x * y; // 局部变量，计算结果

    System.out.println("The result is " + z);
}

在这个例子中，calculate()方法有三个局部变量：x、y和z。它们只能在calculate()方法内访问和使用。z变量是这两个局部变量的乘积，它存储了计算的结果，并在打印出来后就被销毁了。

3.3 区别

成员变量和局部变量是两种在Java中使用的变量类型，它们具有以下几个主要区别：

1. 位置和作用域：

   • 成员变量：定义在类中但在方法之外。它们属于对象，可以在整个类中的方法中访问，包括构造函数。成员变量的作用域是整个类。
   • 局部变量：定义在方法中，或者在代码块（如 if 语句块或循环语句块）中。它们只能在它们所属的方法或代码块中访问，作用域限于定义它们的方法或代码块。

2. 生命周期：

   • 成员变量：它们的生命周期与对象的生命周期相同。当对象被创建时，成员变量被分配内存空间，直到对象被销毁，内存才会被释放。
   • 局部变量：它们在定义时被分配内存空间，并在其所属的方法或代码块执行期间存在。当方法或代码块执行完毕时，局部变量的内存空间会被释放。

3. 默认值：

   • 成员变量：如果没有显式初始化，成员变量会被赋予默认值。数值类型的默认值是0，布尔类型的默认值是false，引用类型的默认值是null。
   • 局部变量：局部变量在使用之前必须显式初始化，否则编译器会报错。

4. 访问修饰符：

   • 成员变量：可以使用访问修饰符，例如public、private等，来控制它们的可见性和访问权限。
   • 局部变量：它们的可见性限于定义它们的方法或代码块，因此不需要访问修饰符。

5. 存储位置：

   • 成员变量：存储在对象内存中，并且每个对象都有其自己的成员变量。
   • 局部变量：存储在每个线程的栈内存中，并且每次方法调用或代码块执行时都会创建一个新的局部变量。

下面是一个综合示例，展示了成员变量和局部变量的不同用法：

public class Example {
    private int x; // 成员变量
    private int y; // 成员变量

    public void setX(int x) {
        this.x = x; // 为成员变量x赋值
    }

    public void calculate() {
        int z = x * y; // 计算结果存储在局部变量z中
        System.out.println("The result is " + z);
    }

    public static void main(String[] args) {
        Example example = new Example();
        example.setX(5);
        example.y = 10; // 直接为成员变量赋值

        example.calculate(); // 计算结果并打印
    }
}

在这个例子中，Example类有两个成员变量x和y，以及一个setX()方法用于设置成员变量x的值。calculate()方法定义了一个局部变量z，用于存储x和y的乘积结果。在main()方法中，我们创建了Example类的一个新实例，为成员变量x设置了值，直接为成员变量y赋值，然后调用calculate()方法来计算结果并打印。

4. this关键字

在Java中，this关键字是一个引用，它指向当前对象，即正在执行方法的对象。

当我们使用this关键字时，它通常用于以下情况中：

1. 用于区分局部变量和成员变量：
   • 当方法内部的局部变量和成员变量同名时，使用this关键字，使编译器就能知道引用哪一个变量了。

例如：

public class Example {
    private String name;

    public void setName(String name) {
        this.name = name; // 使用 this 来区分成员变量和方法参数
    }
}

在上面的代码中，变量name既是成员变量，也是方法setName()的参数。使用this可以将该方法的参数与成员变量区分开来。

2. 用于在构造器中调用其他的构造器：
   • 当一个类有多个构造器时，可以使用this关键字来调用其他的构造器。这可以避免代码重复，同时确保所有构造器都执行到相同的初始化步骤。

例如：

public class Example {
    private String name;

    public Example() {
        this("John Doe"); // 调用带参构造器
    }

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

在上面的代码中，我们定义了两个构造器，一个是默认构造器，另一个是带有一个参数的构造器。通过使用this关键字来调用另一个构造器，我们只需要在一个构造器中执行初始化步骤即可。

3. 用于返回当前对象的引用：
   • 当方法需要返回当前对象的引用时，可以使用this关键字。（链式编程中很常见）

例如：

public class Example {
    private int count;

    public Example increment() {
        count++;
        return this; // 返回当前对象
    }

    public int getCount() {
        return count;
    }
}

在上面的代码中，方法increment()返回当前对象的引用。这意味着可以使用链式语法来执行多次调用。

5. 构造方法

在Java中，构造方法是一种特殊的方法，用于创建和初始化对象。它们具有与类名相同的名称，并且没有返回类型。

5.1 格式

• 格式：

  public class 类名{

      修饰符 类名( 参数 ) {
    
      }
  

  }

• 功能：主要是完成对象数据的初始化

• 示例代码：

class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

5.2 特点

Java中的构造方法有以下特点：

1. 构造方法的名称必须与类名完全相同，包括大小写。
2. 构造方法没有返回类型，包括void。
3. 构造方法可以有参数，也可以没有参数。如果没有显式定义构造方法，则会有一个默认构造方法，它不带参数。
4. 如果一个类有多个构造方法，它们之间必须具有不同的参数列表，否则将会出现编译错误。
5. 在构造方法中，可以使用this关键字来调用本类的另一个构造方法，使用super关键字来调用父类的构造方法。

5.3 注意事项

1. 构造方法的创建

• 如果没有定义构造方法，系统将给出一个默认的无参数构造方法

• 如果定义了构造方法，系统将不再提供默认的构造方法

2. 构造方法的重载

• 如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

示例代码：

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

    public Person() {
        // 默认构造方法
    }

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

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

    // 使用this关键字调用另一个构造方法
    public Person(int age) {
        this("Unknown", age);
    }

    // 使用super关键字调用父类的构造方法
    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }
}

6. 标准类（JavaBean类）

JavaBean是一种符合特定规范的Java类，用于在Java中表示一些特定实体。

JavaBean类包含一些私有的成员变量、公共的getter/setter方法和零个或多个构造函数。

标准的JavaBean类需要满足以下要求：

1. 私有的成员变量：JavaBean类中的成员变量必须是私有的，以确保对数据的封装性。

2. 公共的getter/setter方法：JavaBean类中必须定义公共的getter/setter方法，以便外部访问成员变量。这些方法应该遵循标准的命名规范。

3. 无参数的构造函数：JavaBean类必须提供一个无参数的构造函数，以便在使用某些框架（如Java标准的JavaBeans框架）时能够正确地初始化JavaBean对象。

4. 可以包含其他有参构造函数：JavaBean类可以包含其他有参数的构造函数，但必须同时提供无参数的构造函数。

5. 遵循JavaBean命名规范：JavaBean类的名称应该遵循JavaBean约定，即类名是一个或多个单词，每个单词的第一个字母大写，并且不包含下划线。例如，Person、Order等类名是合法的JavaBean类名，而person、Order_detail等则不是。