java基础知识回顾（二）

二、方法、类、对象、this和static

（二）、类

1.类和对象的概念

• 类：类是一种抽象的数据类型，用于定义对象的结构和行为。它包含属性（成员变量）和方法。

• 对象：对象是类的实例，是类的具体表现形式。通过对象可以访问类的属性和方法。

2.类的发现和设计

• 发现类：在分析问题时，识别出具有相同属性和行为的实体，将这些实体抽象为类。

• 设计类：确定类的属性和方法，设计类的结构，使其能够满足问题的需求。

3.类的定义

• 语法：修饰符 class 类名 { 成员变量; 成员方法; }

• 示例

public class Person {
    // 成员变量
    private String name;
    private int age;
    // 成员方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return this.age;
    }
}

4.对象的创建

• 语法：类名 对象名 = new 类名();

• 示例

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

5.对象的使用

• 访问属性和方法

  • 语法：对象名.属性名 或 对象名.方法名()

  • 示例

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(20);
        System.out.println(person.getName() + "，年龄：" + person.getAge());
    }
}

（三）、this 和 static

1.this 是什么

• this：this 是一个关键字，用于引用当前对象。它可以在类的实例方法和构造方法中使用，指向调用该方法或构造方法的对象。

2.this 在实例方法中的使用

• 作用：用于区分同名的成员变量和局部变量。

• 示例

public class Person {
    private String name;
    public void setName(String name) {
        this.name = name; // 使用 this 区分成员变量和局部变量
    }
}

3.this 在构造方法中的使用

• 作用：用于调用本类的其他构造方法。

• 示例

public class Person {
    private String name;
    private int age;
    public Person() {
        this("未知", 0); 
        // 调用本类的另一个构造方法
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4.static 概述

• static：static 是一个关键字，用于修饰类的成员变量、成员方法和代码块。被 static 修饰的成员属于类本身，而不是类的某个对象。

5.静态变量

• 概念：静态变量属于类，所有对象共享同一个静态变量。

• 语法：static 数据类型 变量名;

• 示例

public class Person {
    private String name;
    private int age;
    public static int count = 0; // 静态变量
    public Person() {
        count++;
    }
}
public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
        System.out.println(Person.count); // 输出 2
    }
}

6.静态代码块

• 概念：静态代码块在类加载时执行一次，用于初始化静态变量。

• 语法：static { 代码块; }

• 示例

java复制

public class Person {
    public static int count;
    static {
        count = 100; // 初始化静态变量
    }
}
public class Main {
    public static void main(String[] args) {
        System.out.println(Person.count); // 输出 100
    }
}

7.静态方法

• 概念：静态方法属于类，可以通过类名直接调用，也可以通过对象调用。

• 语法：static 返回类型 方法名(参数列表) { 方法体; }

• 示例

public class Person {
    public static void printMessage(String message) {
        System.out.println(message);
    }
}
public class Main {
    public static void main(String[] args) {
        Person.printMessage("Hello, World!"); // 通过类名调用
        Person person = new Person();
        person.printMessage("Hello, World!"); // 通过对象调用
    }
}

三、封装、继承和多态三大特点

（一）封装

封装是将类的成员变量和成员方法封装在一起，隐藏类的内部实现细节，只暴露必要的接口给外部使用。

public class Person {
    // 私有成员变量
    private String name;
    private int age;
    // 公有方法，用于访问和修改成员变量
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setAge(int age) {
        this.age = age;
    }public int getAge() {
        return this.age;
    }
}
public class Main {
     public static void main(String[] args) {
         Person person = new Person();
         person.setName("张三");
         person.setAge(20);System.out.println(person.getName() + "，年龄：" + person.getAge());
     }
}

（二）继承

继承是一种代码复用的机制，子类可以继承父类的属性和方法。

// 父类
public class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}
// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println("狗叫");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自父类的方法
        dog.bark(); // 子类自己的方法
    }
}

（三）Override（方法覆盖）

一、方法覆盖的概念

方法覆盖（Override）是指在子类中重新定义父类中同名且同参数的方法。通过方法覆盖，子类可以提供特定的实现，从而覆盖父类的默认行为。

二、方法覆盖的规则

（一）方法名和参数列表必须完全相同

子类方法的名称和参数列表必须与父类被覆盖的方法完全一致，包括参数的类型、顺序和数量。

（二）返回类型必须相同或兼容

子类方法的返回类型必须与父类被覆盖的方法相同，或者返回类型的子类（协变返回类型）。

（三）访问权限不能更严格

子类方法的访问权限不能比父类被覆盖的方法更严格。例如，如果父类方法是 public，子类方法不能是 protected 或 private。

（四）不能覆盖父类的私有方法

父类的私有方法不能被子类覆盖，因为子类无法访问父类的私有方法。

（五）不能覆盖父类的静态方法

父类的静态方法不能被子类覆盖，但可以被隐藏（通过定义同名同参数的静态方法）。

（六）异常声明可以不同

子类方法可以声明比父类方法更宽松的异常，或者不声明任何异常。

三、方法覆盖的示例

（一）基本覆盖

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗叫");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // 输出 "狗叫"
    }
}

（二）协变返回类型

class Animal {
    public Animal getAnimal() {
        return this;
    }
}
class Dog extends Animal {
    @Override
    public Dog getAnimal() {
        return this;
    }
}
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog dog2 = dog.getAnimal(); // 返回 Dog 类型
    }
}

（三）异常声明

class Animal {
    public void makeSound() throws Exception {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() throws ArithmeticException { 
        // 更具体的异常
        System.out.println("狗叫");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        try {
            animal.makeSound();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、方法覆盖与多态

方法覆盖是实现多态的关键机制。通过方法覆盖，可以实现“一个接口，多种实现”，即通过父类的引用调用子类的方法。

（一）多态示例

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗叫");
    }
}
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫叫");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        animal1.makeSound(); // 输出 "狗叫"
        Animal animal2 = new Cat();
        animal2.makeSound(); // 输出 "猫叫"
    }
}

五、方法覆盖与方法隐藏

（一）方法隐藏

如果子类定义了一个与父类同名且同参数的静态方法，那么子类的方法会隐藏父类的方法，而不是覆盖。

（二）示例

class Animal {
    public static void makeSound() {
        System.out.println("动物发出声音");
    }
}
class Dog extends Animal {
    public static void makeSound() {
        System.out.println("狗叫");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal.makeSound(); // 输出 "动物发出声音"
        Dog.makeSound(); // 输出 "狗叫"
    }
}

六、注意事项

（一）@Override 注解

在覆盖父类方法时，建议使用 @Override 注解。它可以帮助编译器检查方法是否正确覆盖了父类的方法，避免拼写错误或其他问题。

（二）final 方法

如果父类方法被声明为 final，则子类不能覆盖该方法。

（三）abstract 方法‘

如果父类方法被声明为 abstract，则子类必须覆盖该方法，除非子类本身也是 abstract 类。

七、总结

方法覆盖是面向对象编程中的一个重要概念，它允许子类提供特定的实现，从而覆盖父类的默认行为。通过方法覆盖，可以实现多态，提高代码的灵活性和可扩展性。在使用方法覆盖时，需要注意方法覆盖的规则，避免常见的错误。

（四）多态

多态是指同一个接口或父类可以被不同的子类实现或继承，调用时根据实际对象的类型动态调用相应的方法。

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}// 子类 1
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗叫");
    }
}// 子类 2
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫叫");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        animal1.makeSound(); // 输出 "狗叫"
        Animal animal2 = new Cat();
        animal2.makeSound(); // 输出 "猫叫"
    }
}

在多态中，animal1 和 animal2 都是 Animal 类型的引用，但实际指向的对象分别是 Dog 和 Cat，调用 makeSound 方法时会根据实际对象的类型动态调用相应的方法，这就是多态的体现。