9、Java基础篇——面向对象进阶（static&继承）

1、如何定义类

我们在这里复习一下之前讲过的类、封装、构造方法等内容。在Java中，通过关键字"class"来定义类。类是对象的模板，用于定义对象的属性和行为。

public class Dog {
    // 属性（成员变量）
    String name;
    int age;
    
    // 方法（成员方法）
    public void bark() {
        System.out.println("汪汪！");
    }
}

2、如何通过类创建对象

通过使用关键字"new"，可以根据类创建对象。对象是类的实例，可以访问类中定义的属性和方法。

public class Main {
    public static void main(String[] args) {
        // 创建Dog类的对象
        Dog myDog = new Dog();
        
        // 访问对象的属性和方法
        myDog.name = "旺财";
        myDog.age = 3;
        myDog.bark();
    }
}

3、封装的步骤实现

封装是面向对象编程的重要原则之一，它用于隐藏对象的内部实现细节，并通过公共方法来访问和操作对象的数据。

封装的步骤如下：

将类的属性设置为私有（private）访问权限。
提供公共（public）的getter和setter方法来访问和修改属性值。

public class Dog {
    private String name;
    private int age;
    
    // getter方法
    public String getName() {
        return name;
    }
    
    // setter方法
    public void setName(String newName) {
        name = newName;
    }
    
    // getter方法
    public int getAge() {
        return age;
    }
    
    // setter方法
    public void setAge(int newAge) {
        if (newAge >= 0) {
            age = newAge;
        }
    }
}

4、构造方法

构造方法是用于创建对象时进行初始化的特殊方法。它具有与类名相同的名称，并且没有返回类型。构造方法可以重载，即可以定义多个不同参数的构造方法。

public class Student {
    private String name;
    private int age;
    
    // 无参构造方法
    public Student() {
        name = "Unknown";
        age = 0;
    }
    
    // 带参构造方法
    public Student(String newName, int newAge) {
        name = newName;
        age = newAge;
    }
    
    // getter和setter方法
    // ...
}

public class Main {
    public static void main(String[] args) {
        // 创建Student对象
        Student student1 = new Student(); // 使用无参构造方法
        Student student2 = new Student("Alice", 20); // 使用带参构造方法
        
        // 访问对象的属性值
        System.out.println(student1.getName()); // 输出："Unknown"
        System.out.println(student2.getName()); // 输出："Alice"
    }
}

5、this关键字的作用

（1）用于普通的getter与setter方法：

public class Person {
    private String name;
    
    public String getName() {
        return this.name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

（2）用于构造方法中：

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

6、static关键字

static关键字用于修饰类的成员（方法和变量），表示这些成员属于类本身而不是实例。可以直接通过类名访问静态成员，而无需创建对象。

public class MathUtils {
    public static int sum(int a, int b) {
        return a + b;
    }
    
    public static final double PI = 3.14159;
}

7、继承

继承是面向对象编程的重要概念之一，它允许一个类从另一个类派生出来，并继承其属性和方法。被继承的类称为父类或超类，继承的类称为子类或派生类。

（1）继承的格式：

public class Animal { // 父类
    public void eat() {
        System.out.println("动物正在吃食物");
    }
}

public class Dog extends Animal { // 子类
    public void bark() {
        System.out.println("汪汪！");
    }
}

（2）子类不能继承的内容：

子类不能继承父类中声明为私有（private）的属性和方法。

public class Animal {
    private String name;
    
    private void privateMethod() {
        System.out.println("这是父类的私有方法");
    }
}

public class Dog extends Animal {
    public void accessPrivateMethod() {
        // 无法访问父类的私有方法privateMethod()
        // privateMethod();  // 编译错误
    }
}

（3）继承后的特点—成员变量：

子类继承了父类的成员变量，可以直接访问父类的非私有成员变量，也可以通过super关键字访问父类的成员变量。

public class Animal {
    public String name;
    protected int age;
    private String color;
}

public class Dog extends Animal {
    public void printInformation() {
        System.out.println("姓名：" + name);  // 可以直接访问父类的非私有成员变量name
        System.out.println("年龄：" + age);   // 可以直接访问父类的受保护成员变量age
        //System.out.println("颜色：" + color); // 无法直接访问父类的私有成员变量color
    }
}

（4）继承后的特点—成员方法：

子类继承了父类的成员方法，可以直接调用父类的非私有方法，也可以通过super关键字调用父类的方法。

public class Animal {
    public void eat() {
        System.out.println("动物正在吃食物");
    }
    
    protected void sleep() {
        System.out.println("动物正在睡觉");
    }
    
    private void run() {
        System.out.println("动物在奔跑");
    }
}

public class Dog extends Animal {
    public void play() {
        System.out.println("狗正在玩耍");
    }
    
    public void sleepAndRun() {
        sleep();  // 可以直接调用父类的受保护方法sleep()
        //run();    // 无法直接调用父类的私有方法run()
    }
}

8、方法重写

方法重写是指子类重新定义父类中已经存在的方法。在子类中重写的方法具有相同的名称、参数列表和返回类型。

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

public class Cat extends Animal {
    @Override
    // @Override重写注解,这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
    public void makeSound() {
        System.out.println("猫发出喵喵的声音");
    }
}

9、继承后的特点—构造方法

子类在实例化时，会自动调用父类的无参构造方法。如果父类没有无参构造方法并且定义了带参数的构造方法，子类需要使用super关键字来显式调用父类的构造方法。

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

public class Dog extends Animal {
    private int age;
    
    public Dog(String name, int age) {
        super(name); // 调用父类的带参数构造方法
        this.age = age;
    }
}

以上就是Java面向对象进阶（static&继承）的全部内容，作者能力有限，如果不足请及时指出。