六、java中的类和对象

类和对象

  • 六、类和对象
    • 1. 类
      • 1.1 类的组成
      • 1.2 类的定义
    • 2. 对象
      • 2.1 创建对象
      • 2.2 调用对象
    • 3. 成员变量和局部变量
      • 3.1 成员变量
      • 3.2 局部变量
      • 3.3 区别
    • 4. this关键字
    • 5. 构造方法
      • 5.1 格式
      • 5.2 特点
      • 5.3 注意事项
    • 6. 标准类(JavaBean类)

六、类和对象

1. 类

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

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

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

1.1 类的组成

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

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

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

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

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

例如,定义一个类名为`Car`的类:
`public class Car {}`
  1. 成员变量:成员变量也称为属性,用于描述类中的数据。

成员变量的定义通常放置在类的开头部分,可以添加修饰符(如publicprivateprotected等),用于控制变量的访问权限。

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

`public class Car { private String brand; private String color; }`
  1. 方法:方法包含一些语句块,用于执行特定操作。

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

例如,定义一个`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类有两个成员变量:nameagename被声明为私有的,只能在类内部访问和修改,而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()方法有三个局部变量:xyz。它们只能在calculate()方法内访问和使用。z变量是这两个局部变量的乘积,它存储了计算的结果,并在打印出来后就被销毁了。

3.3 区别

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

  1. 位置和作用域:

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

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

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

    • 成员变量:可以使用访问修饰符,例如publicprivate等,来控制它们的可见性和访问权限。
    • 局部变量:它们的可见性限于定义它们的方法或代码块,因此不需要访问修饰符。
  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类有两个成员变量xy,以及一个setX()方法用于设置成员变量x的值。calculate()方法定义了一个局部变量z,用于存储xy的乘积结果。在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可以将该方法的参数与成员变量区分开来。

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

例如:

public class Example {
    private String name;

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

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

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

  1. 用于返回当前对象的引用:
    • 当方法需要返回当前对象的引用时,可以使用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. 构造方法的创建
  • 如果没有定义构造方法,系统将给出一个默认的无参数构造方法

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

  1. 构造方法的重载
  • 如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法

示例代码:

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等则不是。

你可能感兴趣的:(Java,java,开发语言)