类和对象
类和对象
1. 类
类是一种定义代码的结构，包含属性和方法的模板,用于描述代码中的对象。
类可以看作是一个模板或者蓝图，它定义了对象的属性和方法。
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
1.1 类的组成
类的组成是由属性和行为两部分组成
- 属性：在类中通过成员变量来体现（类中方法外的变量）
- 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
一个类通常由以下部分组成：
- 类名：类名是类的名称，我们可以使用任何标识符作为类名。
类名应符合Java编码规范，通常以大写字母开头。
例如，定义一个类名为`Car`的类：
`public class Car {}`
- 成员变量：成员变量也称为属性，用于描述类中的数据。
成员变量的定义通常放置在类的开头部分，可以添加修饰符（如public、private、protected等），用于控制变量的访问权限。
例如，定义一个Car类，包含品牌和颜色两个成员变量：
`public class Car { private String brand; private String color; }`
- 方法：方法包含一些语句块，用于执行特定操作。
方法通常用于操作类中的数据（成员变量），为成员变量赋值或取值，并将结果返回。方法也可以添加修饰符（如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 类的定义
类的定义步骤：
- 定义类
- 编写类的成员变量
- 编写类的成员方法
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中使用的变量类型，它们具有以下几个主要区别：
-
位置和作用域：
- 成员变量：定义在类中但在方法之外。它们属于对象，可以在整个类中的方法中访问，包括构造函数。成员变量的作用域是整个类。
- 局部变量：定义在方法中，或者在代码块（如 if 语句块或循环语句块）中。它们只能在它们所属的方法或代码块中访问，作用域限于定义它们的方法或代码块。
-
生命周期：
- 成员变量：它们的生命周期与对象的生命周期相同。当对象被创建时，成员变量被分配内存空间，直到对象被销毁，内存才会被释放。
- 局部变量：它们在定义时被分配内存空间，并在其所属的方法或代码块执行期间存在。当方法或代码块执行完毕时，局部变量的内存空间会被释放。
-
默认值：
- 成员变量：如果没有显式初始化，成员变量会被赋予默认值。数值类型的默认值是0，布尔类型的默认值是false，引用类型的默认值是null。
- 局部变量：局部变量在使用之前必须显式初始化，否则编译器会报错。
-
访问修饰符：
- 成员变量：可以使用访问修饰符，例如
public、private等，来控制它们的可见性和访问权限。 - 局部变量：它们的可见性限于定义它们的方法或代码块，因此不需要访问修饰符。
- 成员变量：可以使用访问修饰符，例如
-
存储位置：
- 成员变量：存储在对象内存中，并且每个对象都有其自己的成员变量。
- 局部变量：存储在每个线程的栈内存中，并且每次方法调用或代码块执行时都会创建一个新的局部变量。
下面是一个综合示例，展示了成员变量和局部变量的不同用法：
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关键字时，它通常用于以下情况中：
- 用于区分局部变量和成员变量：
- 当方法内部的局部变量和成员变量同名时，使用
this关键字，使编译器就能知道引用哪一个变量了。
- 当方法内部的局部变量和成员变量同名时，使用
例如：
public class Example {
private String name;
public void setName(String name) {
this.name = name; // 使用 this 来区分成员变量和方法参数
}
}
在上面的代码中，变量
name既是成员变量，也是方法setName()的参数。使用this可以将该方法的参数与成员变量区分开来。
- 用于在构造器中调用其他的构造器：
- 当一个类有多个构造器时，可以使用
this关键字来调用其他的构造器。这可以避免代码重复，同时确保所有构造器都执行到相同的初始化步骤。
- 当一个类有多个构造器时，可以使用
例如：
public class Example {
private String name;
public Example() {
this("John Doe"); // 调用带参构造器
}
public Example(String name) {
this.name = name;
}
}
在上面的代码中，我们定义了两个构造器，一个是默认构造器，另一个是带有一个参数的构造器。通过使用
this关键字来调用另一个构造器，我们只需要在一个构造器中执行初始化步骤即可。
- 用于返回当前对象的引用：
- 当方法需要返回当前对象的引用时，可以使用
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中的构造方法有以下特点：
- 构造方法的名称必须与类名完全相同，包括大小写。
- 构造方法没有返回类型，包括
void。 - 构造方法可以有参数，也可以没有参数。如果没有显式定义构造方法，则会有一个默认构造方法，它不带参数。
- 如果一个类有多个构造方法，它们之间必须具有不同的参数列表，否则将会出现编译错误。
- 在构造方法中，可以使用
this关键字来调用本类的另一个构造方法，使用super关键字来调用父类的构造方法。
5.3 注意事项
- 构造方法的创建
-
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
-
如果定义了构造方法，系统将不再提供默认的构造方法
- 构造方法的重载
- 如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
示例代码：
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类需要满足以下要求：
-
私有的成员变量：JavaBean类中的成员变量必须是私有的，以确保对数据的封装性。
-
公共的getter/setter方法：JavaBean类中必须定义公共的getter/setter方法，以便外部访问成员变量。这些方法应该遵循标准的命名规范。
-
无参数的构造函数：JavaBean类必须提供一个无参数的构造函数，以便在使用某些框架（如Java标准的JavaBeans框架）时能够正确地初始化JavaBean对象。
-
可以包含其他有参构造函数：JavaBean类可以包含其他有参数的构造函数，但必须同时提供无参数的构造函数。
-
遵循JavaBean命名规范：JavaBean类的名称应该遵循JavaBean约定，即类名是一个或多个单词，每个单词的第一个字母大写，并且不包含下划线。例如，Person、Order等类名是合法的JavaBean类名，而person、Order_detail等则不是。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
