面向对象进阶：包、权限修饰符、抽象类、接口

目录

 Java面向对象进阶

 包（Package）

 常量

 枚举（Enum）

抽象类

 多态

---

 Java面向对象进阶

在本篇博客中，我们将深入探讨Java的高级面向对象概念，包括包、权限修饰符、抽象类、接口、常量、枚举和多态。每个主题都会通过代码示例来帮助理解这些概念。

 包（Package）

包是用于将类进行分门别类管理的结构，类似于文件夹，便于程序的管理和维护。

 创建包

包的语法格式如下：

```java
package com.company.project;
```

- 包语句必须位于文件的第一行。
- 通常使用IDE工具（如IntelliJ IDEA）创建包。

 导入包

- 相同包下的类可以直接访问。
- 不同包下的类需要导入包才能使用。

```java
import com.company.project.ClassName;
```

 示例

```java
package com.example.model;

public class Student {
    // 类的定义
}
```

权限修饰符

权限修饰符用于控制类成员的访问范围。Java提供了四种权限修饰符：`private`、默认（无修饰符）、`protected` 和 `public`。

权限修饰符的作用范围

| 修饰符   | 同一类中 | 同一包中 | 子类中 | 无关类中 |
|----------|----------|----------|--------|----------|
| private  | √        |          |        |          |
| 默认     | √        | √        |        |          |
| protected| √        | √        | √      |          |
| public   | √        | √        | √      | √        |

 示例

```java
public class Person {
    private String name; // 私有成员
    String address; // 默认成员
    protected int age; // 受保护成员
    public void display() { // 公共方法
        System.out.println("Name: " + name);
    }
}
```

 final关键字

`final`关键字用于修饰类、方法和变量。

 final的作用

- **修饰类**：类不能被继承。
- **修饰方法**：方法不能被重写。
- **修饰变量**：变量在第一次赋值后不能被重新赋值。

 示例

```java
public final class Constants {
    public static final double PI = 3.14159;
}

public class Circle {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public final double calculateArea() {
        return Constants.PI * radius * radius;
    }
}

```

 常量

常量是用`public static final`修饰的成员变量，通常用于记录系统的配置数据。

 示例

```java
public class Config {
    public static final String APP_NAME = "MyApp";
    public static final int MAX_USERS = 1000;
}
```

 枚举（Enum）

枚举是一种特殊的Java类型，表示一组固定的常量。用于信息标志和分类。

### 定义枚举

```java
public enum Direction {
    NORTH, SOUTH, EAST, WEST;
}

```

### 示例

```java
public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

public class Main {
    public static void main(String[] args) {
        for (Season season : Season.values()) {
            System.out.println(season);
        }
    }
}
```

抽象类

抽象类是不能实例化的类，用于定义子类的公共行为。

### 抽象类和抽象方法

- **抽象类**：使用`abstract`关键字定义。
- **抽象方法**：只有方法签名，没有方法体，必须在子类中实现。

 示例

```java
public abstract class Animal {
    public abstract void sound();
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.sound();
    }
}

```

 多态

多态是指一个对象可以有多种形态，通常指父类引用指向子类对象。

 多态的实现

- **方法调用**：编译时看左边（父类），运行时看右边（子类）。
- **变量调用**：编译和运行都看左边（父类）。

### 示例

```java
public class Animal {
    public void move() {
        System.out.println("Animal moves");
    }
}

public class Cat extends Animal {
    @Override
    public void move() {
        System.out.println("Cat moves silently");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.move();  // 输出：Cat moves silently
    }
}
```

 类型转换

在多态中，有时候需要进行类型转换以使用子类的特有方法。

 类型转换

- **自动类型转换**：子类对象可以自动转换为父类类型。
- **强制类型转换**：需要显式转换语法。

 示例

```java
Animal animal = new Cat();
if (animal instanceof Cat) {
    Cat cat = (Cat) animal; // 强制类型转换
    cat.move();
}
```

通过这些示例，我们了解了Java的高级面向对象编程概念及其应用，希望这对您的学习和开发有所帮助！

--- 

如果有任何问题或需要进一步的帮助，请随时提出！