04_面向对象

面向对象

创建与使用对象

// 定义Student类
class Student {
    String name;
    int age;
    int studentId;

    public void get() {
        System.out.println("姓名：" + name + " 年龄：" + age + " 学号：" + studentId);
    }
}

// 定义HelloWorld类
public class HelloWorld {
    // 程序入口 main
    public static void main(String[] args) {

        Student obj = new Student();  // 创建对象
        obj.get();  // null, 0, 0

        // 修改对象的属性值
        obj.name = "Peter";
        obj.age = 16;
        obj.studentId = 1024255;
        obj.get();  // Peter, 16, 1024255
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

注意事项

• 类名建议使用英文，首字母大写，满足驼峰模式，例如：Student、Human
• 类中定义的变量也称为成员变量（对象的属性），类中定义的方法也称为成员方法（对象的行为）
• 在定义类的时候，成员变量本身存在默认值，一般情况下没必要自己去赋予初始值，除非有特殊需要
• 一个代码文件中，可以写多个 class 类，但是只能有一个类可以使用 public 装饰，且被 public 装饰的类名必须成为该代码文件的文件名
• 如果某对象没有一个变量去引用它，则该对象无法被操作了，该对象会成为所谓的垃圾对象
• Java 存在自动垃圾回收机制，会自动清除掉垃圾对象，我们不用太担心

面向对象的其他知识

• this : 主要用于解决变量名称冲突问题

  public class HelloWorld {
      public static void main(String[] args) {
  
          Student obj = new Student();
          System.out.println("姓名：" + obj.name + " 年龄：" + obj.age + " 学号：" + obj.studentId);
  
          obj.setAttr("Gogo", 33, 1024255);
          System.out.println("姓名：" + obj.name + " 年龄：" + obj.age + " 学号：" + obj.studentId);
          // 运行结果:
          // 姓名：null 年龄：0 学号：0
          // 姓名：Gogo 年龄：33 学号：1024255
      }
  }
  
  class Student {
      String name;
      int age;
      int studentId;
  
      public void setAttr(String name, int age, int studentId) {
          this.name = name;
          this.age = age;
          this.studentId = studentId;
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25

• 构造器

  • 构造器特点：创建对象时，对象会去调用构造器
  • 常见应用场景：创建对象时，同时完成对对象成员变量（属性）的初始化赋值
  • 注意事项：
    • 类在设计时，如果不写构造器，Java 是会为类自动生成一个无参构造器的
    • 一旦定义了有参构造器，Java 就不会帮我们的类自动生成无参构造器了，此时就建议自己手写一个无参构造器，然后在那里放着，以免日后需要使用到无参构造器，却又没有自动生成。

  public class HelloWorld {
      public static void main(String[] args) {
  
          Student obj = new Student("Peter", 20, 1024255);
          System.out.println("姓名：" + obj.name + " 年龄：" + obj.age + " 学号：" + obj.studentId);
          // 运行结果:
          // 含参构造器被触发执行了
          // 姓名：Peter 年龄：20 学号：1024255
      }
  }
  
  class Student {
      String name;
      int age;
      int studentId;
  
      // （无参）构造器  [支持重载]
      public Student() {
          System.out.println("无参构造器被触发执行了");
      }
  
      // （含参）构造器  [支持重载]
      public Student(String name, int age, int studentId) {
          System.out.println("含参构造器被触发执行了");
          this.name = name;
          this.age = age;
          this.studentId = studentId;
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29

• 三大特征

  • 封装 ( 合理隐藏，合理暴露 )

    • 公开成员：可以使用 public 进行修饰
    • 隐藏成员：可以使用 private 进行修饰

    public class HelloWorld {
        public static void main(String[] args) {
            People jack = new People(29);
            System.out.println(jack.getAge());  // 29
            jack.setAge(56);
            System.out.println(jack.getAge());  // 56
            jack.setAge(-1); // Error! The age is incorrect!
        }
    }
    
    class People {
        private int age;  // 禁止直接访问与修改age
    
        public People(int age) {
            this.age = age;
        }
    
        // 对外提供访问、修改 age 的方法
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            if (age > 0 && age <= 120) {
                this.age = age;
            } else {
                System.out.println("Error! The age is incorrect!");
            }
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30

  • 继承：Java 基础阶段不作介绍

  • 多态：Java 基础阶段不作介绍