类和对象

类和对象

什么是类

在面向对象编程（OOP）中，类（Class）是一个蓝图或模板，它定义了一组具有相同属性（变量）和行为（函数或方法）的对象的结构。类是创建对象的基础，对象则是类的实例。

public class Car(){
    //属性
    private String color;
    private int speed;

    // 构造函数
public Car(String color) {
    this.color = color;
    this.speed = 0; // 初始速度为0
}

    // 方法
public void start() {
    speed = 10; // 假设启动时速度为10
}

public void stop() {
    speed = 0; // 停止时速度为0
}

public void accelerate(int increment) {
    speed += increment; // 增加速度
}

   // Getter和Setter方法
public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
}

public int getSpeed() {
    return speed;
}


}

什么是对象

对象是类的实例

1. 具体化：对象是现实世界中某些事物的抽象表示，比如一个Car对象可以代表一个具体的汽车。
2. 状态：对象包含数据，这些数据定义了对象的当前状态。这些数据通常存储在对象的属性或字段中。
3. 行为：对象可以执行操作，这些操作通常通过对象的方法或函数来实现。
4. 唯一性：每个对象都有其唯一性，即使两个对象属于同一个类，它们也可以有不同的状态。
5. 封装：对象封装了自己的数据和行为，隐藏了内部的实现细节，只通过方法暴露操作接口。
6. 交互：对象之间可以相互交互，通过发送消息来调用彼此的方法。
7. 继承：对象可以是另一个对象的子类，继承父类的属性和方法。
8. 多态：对象可以表现出多种形式，通过重载和重写方法，同一个接口可以有多种不同的实现。

创建对象的过程通常称为实例化

// 创建Car类的一个对象
Car myCar = new Car("Red");
//myCar是Car类的一个实例，它有自己的状态（颜色为"Red"，速度为0），并且可以执行start等行为。

获取对象的方法

1. 直接访问：

   • 如果对象的属性或方法是公开的（使用public访问修饰符），可以直接通过对象实例访问它们。

     public class MyClass {
         public int value = 10;
         public void display() {
             System.out.println("Value is " + value);
         }
     }
     
     MyClass obj = new MyClass();
     int val = obj.value; // 直接访问属性
     obj.display(); // 直接调用方法
     

2. 通过Getter和Setter方法：

   • 对于私有属性，通常通过公共的Getter和Setter方法来访问和修改。

     private int value;
     
     public int getValue() {
         return value;
     }
     
     public void setValue(int value) {
         this.value = value;
     }
     

3. 构造方法：

   • 构造方法用于在创建对象时初始化对象的状态。

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

4. 方法调用：

   • 对象的方法可以通过对象实例来调用，无论这些方法是实例方法还是静态方法。

     obj.instanceMethod(); // 调用实例方法
     MyClass.staticMethod(); // 调用静态方法
     

5. 通过数组或集合：

   • 如果对象存储在数组或集合中，可以通过索引或迭代器来访问它们。

     MyClass[] objects = new MyClass[10];
     objects[0] = new MyClass();
     // 或者使用集合框架中的迭代器
     List<MyClass> list = new ArrayList<>();
     list.add(new MyClass());
     for (MyClass item : list) {
         item.someMethod();
     }
     

6. 通过反射：

   • Java的反射API允许在运行时动态地发现和操作对象的属性和方法。

     Class<?> clazz = obj.getClass();
     Method method = clazz.getMethod("someMethod");
     method.invoke(obj);
     

7. 通过序列化：

   • 对象可以被序列化成字节流，之后可以被反序列化回对象。

     ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("file.obj"));
     out.writeObject(obj);
     // ...
     ObjectInputStream in = new ObjectInputStream(new FileInputStream("file.obj"));
     MyClass deserializedObj = (MyClass) in.readObject();
     

8. 通过克隆：

   • 对象可以通过克隆技术创建一个副本，这通常通过实现Cloneable接口和重写clone()方法来实现。

     obj.clone(); // 创建对象的副本
     

9. 通过代理模式：

   • 代理模式允许通过代理对象来访问目标对象的方法，可以在调用前后添加额外的处理逻辑。

     MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
             MyInterface.class.getClassLoader(),
             new Class[] { MyInterface.class },
             new InvocationHandler() {
                 @Override
                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                     // 调用目标对象的方法
                     return method.invoke(target, args);
                 }
             }
     );