要定义一个类，需使用class关键字并设计属性和方法；创建对象使用new关键字；构造方法用于初始化对象；封装、继承、多态是面向对象三大特性；成员变量属于对象，局部变量在方法内有效；static成员属于类且被所有对象共享。1. 定义类时使用public class 类名 {}结构，包含属性和方法；2. 创建对象通过类名 变量名 = new 类名()实现；3. 构造方法与类同名，用于初始化属性；4. 封装隐藏内部细节，继承实现代码复用，多态允许父类引用指向子类对象；5. 成员变量在类中声明，局部变量在方法中声明且必须初始化；6. static变量和方法属于类，可通过类名调用，静态方法只能访问静态成员。掌握这些概念是java面向对象编程的基础。
Java中，定义类就像制定蓝图，而创建对象则是根据蓝图建造实实在在的房屋。类定义了对象的属性和行为，对象则是类的具体实例。
定义类和创建对象是Java面向对象编程的基石。
如何用Java定义一个类？
定义一个类，你需要用到
class关键字。想象一下，你要设计一个“汽车”类。你需要考虑汽车有哪些属性（颜色、品牌、型号）和行为（启动、加速、刹车）。
立即学习“Java免费学习笔记（深入）”；
public class Car {
// 属性（成员变量）
String color;
String brand;
String model;
// 行为（方法）
public void start() {
System.out.println("汽车启动了！");
}
public void accelerate() {
System.out.println("汽车加速了！");
}
public void brake() {
System.out.println("汽车刹车了！");
}
}这段代码定义了一个名为
Car的类，它有
color、
brand和
model三个属性，以及
start、
accelerate和
brake三个方法。注意，
public关键字表示这个类和它的成员可以被其他类访问。如果省略，则默认为包访问权限。
如何在Java中创建对象？
有了类这个蓝图，就可以创建具体的汽车对象了。使用
new关键字来创建对象。
public class Main {
public static void main(String[] args) {
// 创建一个Car对象
Car myCar = new Car();
// 设置对象的属性
myCar.color = "红色";
myCar.brand = "宝马";
myCar.model = "X5";
// 调用对象的方法
myCar.start();
myCar.accelerate();
// 打印汽车的信息
System.out.println("我的汽车是：" + myCar.color + " " + myCar.brand + " " + myCar.model);
}
}这段代码首先创建了一个
Car类的对象
myCar。然后，通过
.运算符来访问对象的属性，并设置了颜色、品牌和型号。最后，调用了
start和
accelerate方法，并打印了汽车的信息。 关键点在于
new Car()，它在内存中开辟了一块空间，用来存储
Car对象的属性和方法。
构造方法的作用是什么？
构造方法是一种特殊的方法，用于在创建对象时初始化对象的状态。它与类同名，没有返回值。
public class Car {
String color;
String brand;
String model;
// 构造方法
public Car(String color, String brand, String model) {
this.color = color;
this.brand = brand;
this.model = model;
}
public void start() {
System.out.println("汽车启动了！");
}
public void accelerate() {
System.out.println("汽车加速了！");
}
public void brake() {
System.out.println("汽车刹车了！");
}
}public class Main {
public static void main(String[] args) {
// 使用构造方法创建Car对象
Car myCar = new Car("红色", "宝马", "X5");
myCar.start();
myCar.accelerate();
System.out.println("我的汽车是：" + myCar.color + " " + myCar.brand + " " + myCar.model);
}
}在这个例子中，
Car类定义了一个带有三个参数的构造方法。在创建对象时，可以直接传入颜色、品牌和型号，而不需要单独设置。
this关键字用于区分成员变量和局部变量。
如何理解封装、继承和多态？
封装、继承和多态是面向对象编程的三大特性。
- 封装：将数据和行为绑定在一起，并隐藏对象的内部实现细节，只对外提供公共接口。例如，汽车类封装了颜色、品牌、型号等属性，以及启动、加速、刹车等方法。用户只需要调用这些方法，而不需要了解汽车内部的具体工作原理。
-
继承：允许一个类（子类）继承另一个类（父类）的属性和方法。例如，可以创建一个
ElectricCar
类，继承Car
类，并添加电池容量等属性。这样，ElectricCar
类就拥有了Car
类的所有属性和方法，同时还可以添加自己的特性。 -
多态：允许使用父类的引用指向子类的对象。例如，可以创建一个
Vehicle
接口，Car
类和ElectricCar
类都实现这个接口。然后，可以使用Vehicle
类型的引用指向Car
对象或ElectricCar
对象。这样，就可以使用统一的方式来操作不同类型的车辆。
interface Vehicle {
void start();
}
class Car implements Vehicle {
@Override
public void start() {
System.out.println("汽车启动");
}
}
class ElectricCar implements Vehicle {
@Override
public void start() {
System.out.println("电动汽车启动");
}
}
public class Main {
public static void main(String[] args) {
Vehicle car = new Car();
Vehicle electricCar = new ElectricCar();
car.start(); // 输出：汽车启动
electricCar.start(); // 输出：电动汽车启动
}
}多态使得代码更加灵活和可扩展。
成员变量和局部变量有什么区别？
成员变量是在类中定义的变量，也称为实例变量。它们属于对象，每个对象都有一份自己的成员变量。局部变量是在方法中定义的变量。它们只在方法内部有效，方法执行完毕后，局部变量就会被销毁。
public class Example {
// 成员变量
int x;
public void method() {
// 局部变量
int y = 10;
System.out.println("局部变量 y: " + y);
System.out.println("成员变量 x: " + x);
}
public static void main(String[] args) {
Example example = new Example();
example.x = 5; // 设置成员变量
example.method();
}
}成员变量可以在类的任何地方访问，而局部变量只能在定义它的方法内部访问。成员变量有默认值（例如，int类型的默认值为0），而局部变量必须在使用前显式地初始化。
如何使用static关键字？
static关键字用于声明静态成员，静态成员属于类，而不是对象。静态成员变量在所有对象之间共享，静态方法可以通过类名直接调用，而不需要创建对象。
public class Counter {
static int count = 0; // 静态变量
public Counter() {
count++; // 每次创建对象，count加1
}
public static int getCount() { // 静态方法
return count;
}
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
Counter c3 = new Counter();
System.out.println("对象数量: " + Counter.getCount()); // 输出：对象数量: 3
}
}在这个例子中，
count是一个静态变量，它记录了创建了多少个
Counter对象。
getCount是一个静态方法，它可以返回
count的值。 注意，静态方法只能访问静态成员，不能直接访问非静态成员。
掌握这些基础操作，你就可以开始使用Java进行面向对象编程了。记住，实践是最好的老师。多写代码，多思考，你就能更好地理解面向对象编程的思想。
