面向对象继承，多态，接口以及final关键字0125

一、继承

Java 继承是面向对象编程的重要概念之一，它允许子类（派生类）继承父类（基类）的属性和方法，从而实现代码的重用和扩展。

在 Java 中，继承通过 extends 关键字来实现。子类通过 extends 关键字继承父类的属性和方法，同时还可以添加自己的属性和方法。子类可以调用父类中的公有（public）和受保护（protected）属性和方法，但不能直接访问父类的私有（private）属性和方法。

下面是一个简单的 Java 继承示例：

public class Animal { 
public String name; 


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


public void eat() { 
System.out.println(name + " is eating."); 
} 
} 


public class Dog extends Animal { 
public Dog(String name) { 
super(name); 
} 


public void bark() { 
System.out.println(getName() + " is barking."); 
} 
}

在这个示例中，Animal 类是一个基类，它有一个公有属性 name 和一个公有方法 eat()。Dog 类是一个派生类，它继承了 Animal 类的属性和方法，并添加了一个自己的方法 bark()。

在 Dog 类的构造函数中，通过 super() 方法调用了父类的构造函数，从而初始化了 name 属性。在 bark() 方法中，通过 getName() 方法获取了父类的 name 属性，并输出了狗在叫的信息。

需要注意的是，Java 只支持单继承，即一个类只能继承一个父类。但是，Java 支持接口的多继承，即一个类可以实现多个接口。此外，Java 还提供了默认方法（default method）和静态方法（static method）等特性，以进一步扩展继承的功能。

总的来说，Java 继承是实现代码重用和扩展的重要手段，它可以让子类继承父类的属性和方法，并在子类中添加新的属性和方法，从而实现更加灵活和高效的编程。

 二、多态

Java 多态是面向对象编程的三大特性之一（另外两个是封装和继承），它允许不同类的对象对同一消息做出不同的响应。多态性使得代码更加通用和灵活，因为它可以消除代码中对具体类名的硬编码引用，代之以在运行时确定对象的实际类型。

Java 多态主要体现在以下几个方面：

1. 方法重载（Overloading）：在同一个类中，方法名相同但参数列表不同（参数类型、参数个数或参数顺序不同）的方法称为重载方法。重载是多态的一种静态形式，它在编译时就能确定具体调用哪个方法。

2. 方法重写（Overriding）：在子类中定义一个与父类中同名、同参数列表的方法，并且访问修饰符不能比父类中被重写的方法的访问修饰符更严格（但可以更宽松）。重写是多态的动态形式，它在运行时根据对象的实际类型来确定调用哪个方法。

3. 对象的多态性：父类引用变量可以引用子类对象。当使用父类引用调用被子类重写的方法时，Java 虚拟机会在运行时确定对象的实际类型，并调用相应子类的方法。这就是动态绑定或后期绑定。

4. 接口的多态性：接口引用变量可以引用实现该接口的任何类的对象。通过接口引用调用方法时，Java 虚拟机会在运行时确定对象的实际类型，并调用相应实现类的方法。

5. 类型检查和类型转换：Java 提供了 instanceof 关键字来检查一个对象是否是指定类型的实例，以及类型转换来在类型之间转换对象的引用。

6. 构造方法的多态性：虽然构造方法本身不支持多态（因为构造方法不能被继承），但是可以通过工厂方法或构造器引用来实现构造方法的多态性。

这里是一个简单的例子，演示了Java中方法重写的多态性：

public class Animal { 
public void makeSound() { 
System.out.println("The animal makes a sound"); 
} 
} 


public class Dog extends Animal { 
@Override 
public void makeSound() { 
System.out.println("The dog barks"); 
} 
} 


public class Cat extends Animal { 
@Override 
public void makeSound() { 
System.out.println("The cat meows"); 
} 
} 


public class Main { 
public static void main(String[] args) { 
Animal myAnimal = new Animal(); 
Animal myDog = new Dog(); 
Animal myCat = new Cat(); 


myAnimal.makeSound(); // 输出 "The animal makes a sound" 
myDog.makeSound(); // 输出 "The dog barks" 
myCat.makeSound(); // 输出 "The cat meows" 
} 
}

在这个例子中，Animal 类有一个 makeSound 方法，Dog 和 Cat 类分别重写了这个方法。在 main 方法中，我们使用 Animal 类型的引用来指向不同实际类型的对象，并调用 makeSound 方法。Java 虚拟机在运行时根据实际对象的类型来决定调用哪个版本的 makeSound 方法，从而展示了多态的行为。

  三、接口

在Java中，接口（Interface）是一种特殊的类型，用于定义一组抽象的方法（没有实现的方法体），这些方法可以由任何类或其他接口实现。接口提供了一种方式来确保类遵循某种特定的协议，或者说是一种约定，使得不同的类可以以相同的方式被使用。

接口定义了一个公共的行为规范，但不关心具体的实现细节。通过实现一个接口，一个类承诺提供接口中声明的所有方法的具体实现。这使得代码更加模块化，提高了代码的可重用性和可维护性。

接口在Java中通过interface关键字来定义，并且可以包含常量和抽象方法的声明。从Java 8开始，接口还可以包含默认方法（default methods）和静态方法（static methods），以及私有方法（从Java 9开始）。

下面是一个简单的Java接口示例：

// 定义一个接口 
public interface Animal { 
// 常量声明（public static final，但这些修饰符在接口中是隐式的） 
int LEGS = 4; 


// 抽象方法声明（public abstract，但这些修饰符在接口中也是隐式的） 
void eat(); 
void sleep(); 


// 从Java 8开始，接口可以包含默认方法 
default void breathe() { 
System.out.println("The animal breathes"); 
} 


// 从Java 8开始，接口也可以包含静态方法 
static int getNumberOfLegs() { 
return LEGS; 
} 
} 


// 一个类实现接口 
public class Dog implements Animal { 
// 实现接口中的抽象方法 
@Override 
public void eat() { 
System.out.println("The dog eats"); 
} 


@Override 
public void sleep() { 
System.out.println("The dog sleeps"); 
} 


// Dog类继承了breathe默认方法，但也可以选择重写它 
// 如果不重写，那么调用Dog类的breathe方法时会执行Animal接口中的默认实现 
} 


// 使用接口的示例 
public class Main { 
public static void main(String[] args) { 
Dog myDog = new Dog(); 
myDog.eat(); 
myDog.sleep(); 
myDog.breathe(); // 调用的是Animal接口中的默认方法 
System.out.println("An animal has " + Animal.getNumberOfLegs() + " legs"); 
} 
}

在这个例子中，Animal 是一个接口，它定义了两个抽象方法 eat 和 sleep，以及一个默认方法 breathe 和一个静态方法 getNumberOfLegs。Dog 类实现了 Animal 接口，并提供了 eat 和 sleep 方法的具体实现。当我们在 Main 类的 main 方法中创建 Dog 类的对象并调用这些方法时，Java 虚拟机会根据 Dog 类的实现来执行这些方法。同时，由于 Dog 类没有提供 breathe 方法的实现，它将继承并使用 Animal 接口中的默认实现。

  四、final关键字

final是Java中的一个关键字，它可以用来修饰类、方法和变量（包括成员变量、局部变量、静态变量和形参）。final关键字的主要作用是表示“最终的”，即不可变的。以下是final关键字的具体用法和含义：

1. 修饰类：当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类被声明为final，那么其他任何类都不能继承这个类。例如，Java中的String类就是一个final类，不能被继承。

2. 修饰方法：当一个方法被final修饰时，表示这个方法不能被重写（Override）。也就是说，如果一个类的方法被声明为final，那么子类就不能覆盖这个方法。这常用于设计模式中，确保某些重要方法的行为不会被子类改变。

3. 修饰变量：这里的变量可以是类的成员变量、局部变量、静态变量和形参。

   • 成员变量：如果成员变量被final修饰，那么这个变量就是一个常量，一旦被赋值后就不能再改变它的值。这里需要注意的是，对于引用类型的变量，final修饰的是引用本身，而不是引用指向的对象。即你不能让这个引用指向另一个对象，但你可以改变引用指向对象的内容。
   • 局部变量：final修饰的局部变量也必须在声明时赋值，而且只能赋值一次，之后就不能再改变它的值。
   • 静态变量：final修饰的静态变量通常用作常量，这种常量的命名规范是所有字母都大写，多个单词之间用下划线_连接。
   • 形参：final修饰的形参表明这个形参是一个常量，在方法体内不能改变它的值。

使用final关键字的好处包括：

• 提高性能：对于不可变类，它们的对象在创建后就不会再改变，这有助于减少程序运行时的错误，并且有可能提高程序的性能（例如，Java中的String类就是一个不可变类）。
• 提高安全性：通过final关键字，可以确保某些重要的类、方法或变量不会被错误地修改或覆盖，从而提高程序的安全性。
• 提高可读性：使用final关键字可以使代码更容易理解，因为它明确表示了某些东西是不应该被改变的。