10、Java基础篇——面向对象进阶（多态&包&final&权限修饰符）

1、多态

多态是面向对象编程中的一个重要概念，它表示同样的方法在不同的对象上有不同的表现形式。它可以以不同的形式呈现，包括重载、覆盖和转换。

多态的使用场景： 当一个类需要被多个其他类继承，而这些子类又需要改变某个方法的行为时，可以使用多态来实现。另外，在实现接口、虚函数和抽象类的时候，也都会应用到多态。

多态的定义和前提： 多态是一种静态语法现象，它的运行时行为是基于对象的动态绑定。前提是存在继承或实现关系，并且重写了父类或接口中的方法。

多态的运行特点： 多态的运行特点包括以下几点：1）程序在运行时才能确定具体调用哪个方法；2）多个子类对象调用的是同一个父类方法，但得到的结果可能不同；3）可以通过父类引用指向子类对象，从而实现类型的隐藏和替换。

多态的弊端： 多态虽然可以实现灵活的程序设计，但同时也会带来一些问题，比如因为运行时绑定导致程序运行效率较低，以及容易出现类型转换和参数传递的问题。

//父类Animal
public class Animal {
    public void cry() {
        System.out.println("动物在叫");
    }
}

//子类Dog
public class Dog extends Animal {
    public void cry() {
        System.out.println("狗在汪汪叫");
    }
}

//子类Cat
public class Cat extends Animal {
    public void cry() {
        System.out.println("猫在喵喵叫");
    }
}

//测试类
public class TestPolymorphism {
    public static void main(String[] args) {
        Animal animal1 = new Animal();
        Animal animal2 = new Dog();
        Animal animal3 = new Cat();

        animal1.cry();// 动物在叫
        animal2.cry();// 狗在汪汪叫
        animal3.cry();// 猫在喵喵叫
    }
}

2、包

包是Java中用来管理类的一种机制，它可以将相关的类组织起来，提高程序结构的清晰度和可维护性。

（1）包的定义：

包是一组相互关联的类和接口的集合，它们存储在同一个文件夹或目录中，使用包名来区分不同的包，避免了命名冲突。

（2）导包：

在使用其他包中的类时需要进行导包，即通过import语句引入指定包的类，从而可以直接使用该类。

//com.example包中的HelloWorld类
package com.example;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

//导入com.example包中的HelloWorld类
import com.example.HelloWorld;

public class TestPackage {
    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();
        hello.main(new String[]{});
    }
}

3、权限修饰符

权限修饰符是Java中用来限制类、变量和方法的访问权限的关键字，包括public、private、protected和默认。

（1）权限修饰符的定义和使用：

权限修饰符用来设置类、变量和方法的访问级别。不同的访问级别决定了它们可以被哪些部分的代码访问。

（2）不同权限的访问能力：

public： 可以被任何代码访问。
private： 只能被本类中的代码访问。
protected： 可以被本类及其子类和同一个包中的代码访问。
默认： 可以被同一个包中的代码访问。

//Person类
package com.example;

public class Person {
    public String name;     // 公有变量
    private int age;        // 私有变量
    protected String gender;// 受保护变量

    public Person() {
        this.name = "Tom";
        this.age = 20;
        this.gender = "Male";
    }

    public void sayHello() {
        System.out.println("Hello, I'm a person.");
    }

    private void talkAge() {
        System.out.println("My age is " + age);
    }

    protected void talkGender() {
        System.out.println("My gender is " + gender);
    }
}

//Student类继承Person类
package com.example;

public class Student extends Person {
    public Student() {
        super();
    }

    public void study() {
        System.out.println("I'm studying.");
    }

    public static void main(String[] args) {
        Student student = new Student();

        System.out.println(student.name);       // public变量可以被访问
        student.sayHello();                     // public方法可以被访问
        //System.out.println(student.age);         // 私有变量不能被访问
        //student.talkAge();                       // 私有方法不能被访问
        System.out.println(student.gender);     // 受保护变量可以被访问
        student.talkGender();                   // 受保护方法可以被访问
    }
}

4、final关键字

final是Java中的一个关键字，它可以用来修饰类、方法和变量。使用final关键字可以使类、方法和变量成为不可修改的常量。

（1）final关键字的概述：

final是Java中的一个关键字，用于修饰类、方法和变量，使它们成为不可修改的常量。

（2）final关键字的使用方式：

final修饰类：表示该类不可被继承。
final修饰方法：表示该方法不可被子类重写。

//父类Animal
public class Animal {
    public final void cry() {
        System.out.println("动物在叫");
    }
}

//子类Dog，继承自Animal类
public class Dog extends Animal {
    public void cry() { //编译错误，无法覆盖父类中的final方法
        System.out.println("狗在汪汪叫");
    }
}

final修饰变量：表示该变量不能被重新赋值。

public class TestFinal {
    public static void main(String[] args) {
        final double PI = 3.1415926;
        //PI = 5.0; //编译错误，PI是常量，不可重新赋值
        System.out.println(PI);
    }
}

修饰局部变量

public class TestFinal {
    public static void main(String[] args) {
        final int num;
        num = 100; //正确，num是局部变量，只要在声明之后就可以赋值
        //num = 200; //编译错误，num已经被赋初值，不能再次赋值
        System.out.println(num);
    }
}

以上就是Java面向对象进阶（多态&包&final&权限修饰符）的全部内容，作者能力有限，如果不足请及时指出。