暑假Java知识点回顾：类与对象知识总结

面向对象

基础语法

程序结构、打印语句、输入语句、数据类型与变量、运算符、条件判断语句、循环语句、数组。

java 复制代码

public class HelloWorld {
    public static void main(String[] args) {
        // 打印语句
        System.out.println("Hello, World!");

        // 输入语句
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入姓名：");
        String name = scanner.nextLine();

        // 数据类型与变量
        int age = 18;
        double score = 95.5;
        boolean isPass = true;

        // 运算符
        int sum = age + 2;
        boolean isAdult = age >= 18;

        // 条件判断语句
        if (isAdult) {
            System.out.println(name + " 已成年");
        } else {
            System.out.println(name + " 未成年");
        }

        // 循环语句
        for (int i = 0; i < 3; i++) {
            System.out.println("第 " + (i + 1) + " 次循环");
        }

        // 数组
        int[] scores = {90, 85, 95};
        System.out.println("第一个成绩：" + scores[0]);
    }
}

类与对象

类与对象的概念

类的定义
属性定义
方法定义：参数、返回值
类创建对象
对象名调用对象的属性
对象名调用方法执行

封装

类的格式，系统中使用的类都是有封装的。

一个类包含哪些内容

面向对象的成员

属性：使用对象变量名调用
方法：使用对象变量名调用

构造方法

格式：没有返回值结构，且方法名是类名的方法 public 类名(){}
创建对象的时候调用 new 类名()
作用：用于对象创建时的初始化（属性的初始化和方法初始化调用）
构造方法的重载：重载方法，一个类中可以定义多个同名的方法，要求参数不一致

构造代码块

{} 也是在对象创建时执行，也可以做一些初始化操作。

静态资源

static 关键字修饰的成员属于类本身，与具体的对象实例无关，因此可以直接通过类名调用，无需先创建对象。它的核心特性是唯一性：无论创建多少个对象，静态成员在内存中只有一份，被所有对象共享。

静态属性：在内存中只存在一份，所有对象共享同一份数据，通过类名直接调用，例如 类名.属性名
静态方法：通过类名直接调用，例如 类名.方法名()；由于静态方法不依赖对象，因此不能直接使用本类中的实例属性或实例方法（即对象成员部分）
静态代码块：在类被加载时执行，且只会执行唯一的一次，常用于完成一些全局性的初始化操作，例如加载配置文件、初始化数据库连接等### 访问权限修饰符
public：修饰类、属性、方法，表示权限是公开的，在项目中都可以调用
private：私有的，只能修饰类中的成员，权限是只能在本类中访问
protected：只能在同一个包下和子类中访问
缺省不写：类中缺省不写，同一个包下；接口中缺省不写，默认 public

继承与多态

继承的语法（extends）

继承是面向对象的重要特性，子类通过 extends 关键字继承父类的属性和方法，实现代码复用。

java 复制代码

class Animal {
    String name;

    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println(name + " 正在汪汪叫");
    }
}

方法重写（@Override）

子类可以重写父类的方法，使用 @Override 注解标记，表示该方法是对父类方法的重写。

java 复制代码

class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("狗在汪汪叫");
    }
}

多态的实现

多态是指同一个方法调用，在不同对象上表现出不同的行为。核心是父类引用指向子类对象。

java 复制代码

Animal animal = new Dog();  // 父类引用指向子类对象
animal.sound();             // 实际调用的是 Dog 类重写后的方法

继承与多态实战示例

下面通过一个完整的 Java 示例，演示继承的语法、方法重写以及多态的实现。

java 复制代码

// 父类：动物
class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    // 父类方法：发出声音
    public void sound() {
        System.out.println(name + " 发出声音");
    }

    // 父类方法：吃东西
    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
}

// 子类：狗，继承 Animal
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    // 重写父类的 sound 方法
    @Override
    public void sound() {
        System.out.println(name + " 汪汪叫");
    }

    // 子类特有方法
    public void guard() {
        System.out.println(name + " 正在看家");
    }
}

// 子类：猫，继承 Animal
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    // 重写父类的 sound 方法
    @Override
    public void sound() {
        System.out.println(name + " 喵喵叫");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        // 父类引用指向子类对象（多态）
        Animal dog = new Dog("旺财");
        Animal cat = new Cat("咪咪");

        // 调用重写后的方法
        dog.sound();
        cat.sound();

        // 调用父类中未重写的方法
        dog.eat();
        cat.eat();

        // 子类特有方法需要通过子类类型调用
        Dog realDog = new Dog("大黄");
        realDog.guard();
    }
}

运行结果：

text 复制代码

旺财 汪汪叫
咪咪 喵喵叫
旺财 正在吃东西
咪咪 正在吃东西
大黄 正在看家

通过这个示例可以看到：子类通过 extends 继承父类的属性和方法，实现代码复用；通过 @Override 重写父类方法，让不同子类表现出不同的行为；多态让父类引用可以指向任意子类对象，使代码更加灵活和可扩展。

封装

封：使用受限制的权限修饰符修饰属性或者方法，使得这个类的对象不能直接调用这个属性赋值，不能直接调用方法执行。比如使用 private
装：提供一套公开的访问方式
- 给属性赋值：setter 方法
  java 复制代码
```
public void set属性名(参数) {
    this.属性名 = 参数;
}
```
- 获取属性的值：getter 方法
  java 复制代码
```
public 数据类型 get属性名() {
    return 属性;
}
```

封装实战示例

下面通过一个完整的 Java 示例，演示 private 属性、setter/getter 方法、构造方法重载以及静态方法调用的实际使用场景。

java 复制代码

public class Student {
    // private 属性：外部不能直接访问
    private String name;
    private int age;

    // 构造方法重载一：无参构造
    public Student() {
        System.out.println("调用无参构造方法");
    }

    // 构造方法重载二：带两个参数
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("调用带参构造方法");
    }

    // setter 方法：给属性赋值
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0 || age > 150) {
            System.out.println("年龄不合法，拒绝赋值");
            return;
        }
        this.age = age;
    }

    // getter 方法：获取属性的值
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 静态方法：类名直接调用
    public static void showSchool() {
        System.out.println("学校：某某大学");
    }

    // 普通方法：展示学生信息
    public void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }

    public static void main(String[] args) {
        // 通过无参构造创建对象，再使用 setter 赋值
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(20);
        s1.showInfo();

        // 通过带参构造创建对象，直接初始化属性
        Student s2 = new Student("李四", 22);
        s2.showInfo();

        // 非法年龄赋值会被拦截
        s2.setAge(200);

        // 静态方法通过类名直接调用
        Student.showSchool();
    }
}

运行结果：

text 复制代码

调用无参构造方法
姓名：张三，年龄：20
调用带参构造方法
姓名：李四，年龄：22
年龄不合法，拒绝赋值
学校：某某大学

通过这个示例可以看到：外部无法直接访问 private 属性，只能通过 setter/getter 方法读写，从而在赋值时加入校验逻辑，保证数据安全；构造方法重载让对象创建更灵活；静态方法则无需创建对象即可通过类名调用。

总结

代码格式更加规范，可读性更好
数据的安全性更好
读写分离