第六章（抽象类，接口，多态，类的高级特性）

一.抽象类

在Java中，抽象类是一种特殊的类，它不能被实例化。抽象类通常用作其他类的基类，定义公共接口，这个接口可以被其他具体的类实现。抽象类可以包含抽象方法和非抽象方法。

特点：

1. 抽象方法：抽象类可以包含抽象方法和非抽象方法。抽象方法是一个只有声明没有实现的方法。抽象方法没有方法体，只有声明，在声明后面有分号。在Java中，一个类如果包含抽象方法，那么这个类必须被声明为抽象类。
2. 抽象类不能被实例化：因为抽象类是不完整的，所以不能被实例化。只有当子类继承了抽象类并实现了所有的抽象方法后，才能创建子类的实例。
3. 抽象类可以有构造器：抽象类可以有构造器，供子类实例化时调用。
4. 抽象类可以有非抽象方法：抽象类可以有非抽象方法，供子类直接使用。
5. 抽象类可以被子类继承：抽象类可以被子类继承，子类可以使用抽象类中的非抽象方法，也可以实现抽象类中的抽象方法。

用法：

在面向对象的设计中，当我们需要定义一个接口，这个接口包含一些方法，这些方法可以被其他类实现，但是我们又不希望这个接口被直接实例化，那么我们可以使用抽象类。例如：

public abstract class AbstractClass {  
    //抽象方法  
    public abstract void abstractMethod();  
  
    //非抽象方法  
    public void normalMethod() {  
        System.out.println("This is a normal method.");  
    }  
}

在这个例子中，AbstractClass是一个抽象类，它包含一个抽象方法abstractMethod()和一个非抽象方法normalMethod()。我们不能直接实例化AbstractClass，但是我们可以创建一个AbstractClass的子类，并在子类中实现abstractMethod()。例如：

public class ConcreteClass extends AbstractClass {  
    //实现父类的抽象方法  
    public void abstractMethod() {  
        System.out.println("This is an implementation of abstract method.");  
    }  
}

在这个例子中，ConcreteClass继承了AbstractClass，并实现了abstractMethod()。现在我们可以实例化ConcreteClass并调用它的方法：

public class Main {  
    public static void main(String[] args) {  
        ConcreteClass cc = new ConcreteClass();  
        cc.abstractMethod();  //输出: This is an implementation of abstract method.  
        cc.normalMethod();  //输出: This is a normal method.  
    }  
}

二.接口

在Java中，接口是一种定义方法签名但不包含方法实现的蓝图。它是一个完全抽象的类，可以拥有抽象方法和常量。接口提供了一种规范，描述了类应该具有哪些方法和常量。

接口的意义在于提供了一种标准，使得不同的类可以按照同样的方式进行处理。通过接口，可以实现多态性，即一个对象可以引用多种实际类型。此外，接口还可以提高代码的可读性和可维护性，因为接口定义了一种规范，使得其他开发人员可以更容易地理解代码。

使用接口的方法如下：

1.定义接口：使用interface关键字定义一个接口，并定义其中的方法和常量。

public interface MyInterface {  
    void myMethod();  
    int MY_CONSTANT = 100;  
}

2.实现接口：使用implements关键字实现接口中定义的方法和常量。

public class MyClass implements MyInterface {  
    public void myMethod() {  
        // 实现方法逻辑  
    }  
}

3.使用接口：通过实现接口，可以实现多态性，即一个对象可以引用多种实际类型。

MyInterface obj = new MyClass();  
obj.myMethod(); // 调用 MyClass 中的 myMethod 方法

三.多态

在Java中，多态是指一个对象可以引用多种实际类型。它是面向对象编程的三大特性之一，包括封装和继承。多态的意义在于提高了程序的扩展性和复用性，使得代码更加灵活和易于维护。

多态的使用方法如下：

1.定义一个父类和一个子类，子类继承父类并覆盖父类中的方法。

class Animal {  
    public void makeSound() {  
        System.out.println("Animal is making a sound");  
    }  
}  
  
class Dog extends Animal {  
    public void makeSound() {  
        System.out.println("Dog is barking");  
    }  
}

2.创建一个父类对象，并将其子类对象赋值给该父类对象。

Animal animal = new Dog();

3.调用该父类对象的方法，实际上会调用子类中的方法。

animal.makeSound(); // 输出 "Dog is barking"

在这个例子中，我们创建了一个Animal类型的对象，并将其Dog类型的对象赋值给了该Animal类型的对象。当我们调用该Animal对象的makeSound方法时，实际上会调用Dog类中的makeSound方法，因为Dog类覆盖了Animal类中的makeSound方法。这就是多态的实现过程。

四.类的高级特性

Java中的类的高级特性包括Static修饰符、Final修饰符和代码块。下面是它们的概念、意义和使用方法：

1. Static修饰符：

   • 概念：Static修饰符表示一个成员（变量或方法）属于类本身，而不是类的实例。
   • 意义：使用Static修饰符可以使类的成员不依赖于类的实例，而是与类本身相关联。这样，即使没有创建类的实例，也可以访问这些成员。
   • 使用方法：在定义类的成员时，使用Static关键字来修饰它。例如：

   • java`public class MyClass {  
         static int count = 0; // 静态变量  
         static void incrementCount() { // 静态方法  
             count++;  
         }  
     }`

2.Final修饰符：

• 概念：Final修饰符表示一个成员（变量、方法或类）不能被改变或继承。
• 意义：使用Final修饰符可以提高代码的可读性和安全性。对于变量，Final修饰符表示它是一个常量，不能被重新赋值。对于方法，Final修饰符表示它不能被重写。对于类，Final修饰符表示它不能被继承。
• 使用方法：在定义类的成员或类时，使用Final关键字来修饰它。例如：

java`public final class MyClass {  
    final int value = 100; // 常量变量  
    final void printValue() { // 常量方法  
        System.out.println(value);  
    }  
}`

 

3.代码块：

• 概念：代码块是在类中定义的一段代码，用于执行某些特定的操作。
• 意义：代码块可以用于执行一些初始化或清理操作，例如初始化静态变量或执行一些特定的逻辑。
• 使用方法：在类中定义代码块，可以放在类中的任何位置。代码块使用大括号 {} 来包裹。例如：

  java`public class MyClass {  
      static {  
          // 静态代码块，用于初始化静态变量或执行其他操作  
          count = 0;  
      }  
        
      {  
          // 实例代码块，用于初始化实例变量或执行其他操作  
          value = 100;  
      }  
        
      public void printValue() {  
          System.out.println(value);  
      }  
  }`  
  ```注意，静态代码块在类加载时执行一次，而实例代码块在每次创建类的实例时执行一次。