类和对象

类和对象

什么是类

在面向对象编程(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);
                  }
              }
      );
      
posted @ 2024-08-06 10:59  糊涂图-4060  阅读(30)  评论(0)    收藏  举报