JAVA类和对象

一、类与对象基础

1. 类与对象定义

• 类：对象的模板，定义对象的属性（成员变量）和行为（方法）。

  public class Dog {
      String name;    // 属性
      public void eat() { ... } // 行为
  }

• 对象：类的实例，通过 new 关键字创建。

  Dog dog = new Dog(); // 实例化对象

2. 对象实例化过程

• 步骤：

  1. 内存分配：在堆内存中为对象分配空间。

  2. 初始化成员变量：赋予默认值（如 int 为 0，对象为 null）。

  3. 调用构造方法：显式初始化成员变量。

---

二、成员访问与 this 关键字

1. 成员访问

• 通过对象引用访问成员：

  
  dog.name = "小黑"; // 访问属性
  dog.eat();        // 调用方法

2. this 关键字

• 作用：

  • 区分成员变量与局部变量（同名时）。

  • 访问当前对象的成员或调用其他构造方法。

• 示例：

  public class Dog {
      private String name;
      public Dog(String name) {
          this.name = name; // this 绑定成员变量
      }
  }

---

三、构造方法

1. 定义与规则

• 方法名与类名相同，无返回值，用于初始化对象。

• 默认构造方法：若未显式定义，Java 自动提供无参构造方法。

• 构造方法重载：通过不同参数列表定义多个构造方法。

  
  public Dog() { ... }                 // 无参构造
  public Dog(String name) { ... }      // 有参构造

2. 构造方法调用链

• 使用 this() 调用其他构造方法（需在方法首行）：

  public Dog() {
      this("未知"); // 调用有参构造
  }

---

四、封装与权限修饰符

1. 封装原则

• 隐藏实现细节，通过 private 保护成员变量，提供 public 的 getter/setter。

  public class Student {
      private int age;
      public int getAge() { return age; }
      public void setAge(int age) { 
          if (age > 0) this.age = age; 
      }
  }

2. 权限修饰符

修饰符	类内	同包	子类	其他包
public	✔️	✔️	✔️	✔️
protected	✔️	✔️	✔️	❌
默认	✔️	✔️	❌	❌
private	✔️	❌	❌	❌

---

五、静态成员

1. 静态变量

• 属于类而非对象，所有对象共享，通过类名直接访问。

  public class Student {
      static String school = "坤坤大学"; 
  }
  Student.school = "成都大学"; // 修改影响所有对象

2. 静态方法

• 只能访问静态成员，不能使用 this。

  public static void printSchool() {
      System.out.println(school); // 正确
      // System.out.println(name); // 错误（非静态）
  }

---

六、继承与多态

1. 继承（Inheritance）

• 子类继承父类属性和方法，实现代码复用。

  class Animal { void eat() { ... } }
  class Dog extends Animal { ... }

2. 多态（Polymorphism）

• 编译时多态：方法重载（同名方法，参数不同）。

• 运行时多态：方法重写（子类覆盖父类方法）。

  Animal animal = new Dog(); // 向上转型
  animal.eat(); // 调用 Dog 类的 eat()

---

七、抽象类与接口

1. 抽象类（Abstract Class）

• 可包含抽象方法（无实现）和具体方法。

  abstract class Animal {
      abstract void sound(); // 抽象方法
      void sleep() { ... }   // 具体方法
  }

2. 接口（Interface）

• Java 8+ 支持默认方法和静态方法。

  interface Runnable {
      void run();                // 抽象方法
      default void log() { ... } // 默认方法
  }

---

八、内部类

1. 成员内部类

• 依赖外部类对象，可访问外部类所有成员。

  class Outer {
      class Inner { ... }
  }
  Outer.Inner inner = new Outer().new Inner();

2. 匿名内部类

• 直接实现接口或继承类，无需显式定义类名。

  Runnable r = new Runnable() {
      @Override
      public void run() { ... }
  };

---

九、关键补充

1. 对象内存模型

• 成员变量存储在堆内存，方法存储在方法区，所有对象共享方法代码。

2. 包与导入

• 使用 package 定义包，import 导入其他包的类。

  package com.example;
  import java.util.List;

3. final 关键字

• 修饰类（不可继承）、方法（不可重写）、变量（常量）。

---

总结图示

    A[类] --> B[对象]
    A --> C[成员变量]
    A --> D[成员方法]
    A --> E[构造方法]
    C --> F[静态变量]
    D --> G[静态方法]
    A --> H[继承]
    H --> I[多态]
    A --> J[内部类]
    J --> K[成员内部类]
    J --> L[匿名内部类]

可通过实际编码练习（如设计类、实现封装、继承与多态等）深化理解！