【Java】面向对象04-类类型和接口类型

4 类类型和接口类型

4.1 定义类、实例方法、实例变量、类方法、类变量，使用恰当的、语法允许的修饰符（比如public、final、static、abstract等等），能够清楚准确阐述单独修饰符和联合

当我们在Java中定义类时，可以使用各种修饰符来指定类的性质和访问级别。以下是关于类、实例方法、实例变量、类方法和类变量的一些基本概念以及可能使用的修饰符：

1. 类定义：

   java

   [修饰符] class ClassName {
       // 类体
   }
   

   • 修饰符：可以是 public、abstract、final 等。

2. 实例方法：

   java

   [修饰符] returnType methodName([参数列表]) {
       // 方法体
   }
   

   • 修饰符：可以是 public、private、protected、static、final 等。
   • 返回类型(returnType)：方法返回的数据类型。
   • 方法名(methodName)：方法的名称。
   • 参数列表：方法的输入参数。

3. 实例变量：

   java

   [修饰符] dataType variableName;
   

   • 修饰符：可以是 public、private、protected、static、final 等。
   • 数据类型(dataType)：变量的数据类型。
   • 变量名(variableName)：变量的名称。

4. 类方法（静态方法）：

   java

   [修饰符] static returnType methodName([参数列表]) {
       // 方法体
   }
   

   • 修饰符：可以是 public、private、protected、static、final 等。
   • 返回类型(returnType)：方法返回的数据类型。
   • 方法名(methodName)：方法的名称。
   • 参数列表：方法的输入参数。

5. 类变量（静态变量）：

   java

   [修饰符] static dataType variableName;
   

   • 修饰符：可以是 public、private、protected、static、final 等。
   • 数据类型(dataType)：变量的数据类型。
   • 变量名(variableName)：变量的名称。

修饰符的组合可以根据需要使用，例如：

• 如果你希望一个类的实例变量对所有类都可见，可以使用 public 修饰符。
• 如果你希望一个方法可以在没有创建对象的情况下被调用，可以使用 static 修饰符。
• 如果你希望一个变量的值在被创建对象后不能被修改，可以使用 final 修饰符等。

需要注意的是，这些修饰符的使用要根据具体的需求和设计原则，灵活运用以达到合适的封装和访问控制。

4.2 修饰符的意义，以及在修饰符限定的声明条款上建立的包之间的关系所带来的影响

修饰符在Java中用于限定类、方法、变量等声明的属性和行为。它们控制了对这些声明的访问级别、性质和行为。以下是一些常见的修饰符及其意义：

1. public： 可以被任何其他类访问。是最广泛的访问级别。
2. private： 只能在声明它的类内部访问。用于实现封装。
3. protected： 对于同一包内的类和所有子类可见。用于实现继承。
4. default (package-private)： 在同一包内可见，不使用任何修饰符。不同包的类无法访问。

对于方法，还有一些其他的修饰符：

1. static： 静态方法或变量，属于类而不是实例。可以通过类名直接调用，而不需要实例化对象。
2. final： 表示最终的、不可修改的。对于类，表示该类不能被继承；对于方法，表示方法不能被重写；对于变量，表示变量是一个常量。
3. abstract： 用于声明抽象类或抽象方法。抽象类不能被实例化，而抽象方法必须在子类中被实现。

修饰符的选择影响了代码的可维护性、安全性和可读性。合适的修饰符能够提供适当的封装，防止未经授权的访问，同时也使得代码更容易理解和维护。

在建立包之间的关系方面，修饰符的选择直接影响了不同包中的类、方法和变量是否可以被访问。例如：

• 如果一个类使用了 public 修饰符，那么它可以被其他包中的类直接访问。
• 如果一个类使用了 default 修饰符，那么它只能被同一包中的类访问。
• 如果一个变量使用了 private 修饰符，那么它只能在声明它的类内部访问。

在设计Java应用程序时，良好的包管理和修饰符的使用能够提高代码的模块化性、安全性和可维护性。开发者应该根据项目的需求和设计目标，选择合适的修饰符以及包的组织结构。

4.3 掌握访问控制修饰符

在Java中，访问控制修饰符用于控制类、方法、变量等成员的可见性和访问权限。Java提供了四种访问控制修饰符：

1. public：

   • 意义： 公共访问级别，对所有类可见。
   • 应用场景： 适用于希望成员能够被所有类访问的情况。

2. private：

   • 意义： 私有访问级别，只在声明它的类内部可见。
   • 应用场景： 适用于实现封装，限制对类的内部细节的直接访问，提高安全性。

3. protected：

   • 意义： 受保护访问级别，对同一包内的类和所有子类可见。
   • 应用场景： 适用于希望在继承层次结构中提供对成员的访问权限，但不希望公开给所有类。

4. default (package-private)：

   • 意义： 包（包括子包）内可见，不使用任何修饰符时默认的访问级别。
   • 应用场景： 适用于将成员限制在同一包内，不对外公开。

如何掌握访问控制修饰符：

1. 理解各个修饰符的含义：

   • 了解 public 表示公共访问，对所有类可见。
   • 了解 private 表示私有访问，只在声明类内部可见。
   • 了解 protected 表示受保护访问，对同一包内的类和所有子类可见。
   • 了解默认（无修饰符）表示包内可见。

2. 应用场景：

   • 理解在不同场景下选择不同的访问修饰符的原因。
   • 了解如何使用修饰符来实现封装、继承和模块化。

3. 掌握修饰符的组合：

   • 熟悉在类、方法、变量上可以组合使用多个修饰符，如 public static、 private final等。

4. 实践和案例分析：

   • 编写一些简单的类和方法，尝试使用不同的访问修饰符，理解其影响。
   • 分析现有的Java库和框架中的类和方法，看看它们是如何使用访问修饰符的。

5. 深入理解面向对象概念：

   • 理解访问修饰符与面向对象编程中的封装、继承和多态的关系。

掌握访问控制修饰符是Java程序设计中的基础之一，有助于编写清晰、安全和易维护的代码。通过实际练习和深入理解，可以更好地运用这些概念来设计和构建Java应用程序。

4.4 掌握构造方法的创建，包括无参构造

构造方法是一种特殊类型的方法，用于在创建对象时执行必要的初始化操作。在Java中，构造方法的名称与类名相同，没有返回类型，并且可以有不同的参数列表。其中，无参构造方法是一种没有参数的构造方法。

创建有参构造方法：

有参构造方法通常用于接受参数，并根据这些参数对对象进行初始化。以下是创建有参构造方法的基本步骤：

java

public class MyClass {
    // 实例变量
    private int myField;

    // 有参构造方法
    public MyClass(int initialValue) {
        this.myField = initialValue;
    }

    // 其他方法和代码...
}

在这个例子中， MyClass 类有一个私有的实例变量 myField，并且有一个有参构造方法，该构造方法接受一个整数参数 initialValue，并将其赋值给实例变量 myField。

创建无参构造方法：

如果没有为类显式定义构造方法，Java会提供一个默认的无参构造方法。但是，如果你显式定义了任何构造方法（无论是有参还是无参），默认的无参构造方法就不再被提供。因此，如果你需要无参构造方法，你需要显式定义它。

以下是创建无参构造方法的示例：

java

public class MyClass {
    // 实例变量
    private int myField;

    // 有参构造方法
    public MyClass(int initialValue) {
        this.myField = initialValue;
    }

    // 无参构造方法
    public MyClass() {
        // 可以在这里进行默认初始化，或者留空
    }

    // 其他方法和代码...
}

在这个例子中， MyClass 类有一个有参构造方法和一个无参构造方法。无参构造方法可以执行默认的初始化操作，或者留空，具体取决于你的需求。

通过提供不同的构造方法，你可以根据实际情况选择性地初始化对象的属性。这使得你的类更加灵活，能够适应不同的使用场景。

4.5 掌握this关键字、super关键字的使用

在Java中， this 和 super 是两个关键字，用于在类的方法中引用当前对象或其父类对象。

1. this 关键字：

• 用途： this 用于引用当前对象，即正在执行代码的对象。它可以用于解决实例变量和局部变量之间的命名冲突，也可以在构造方法中调用另一个构造方法。

a. 解决变量命名冲突：

java

public class MyClass {
    private int myField;

    public void setMyField(int myField) {
        this.myField = myField; // 使用this关键字区分实例变量和方法参数
    }
}

b. 在构造方法中调用另一个构造方法：

java

public class MyClass {
    private int myField;

    // 有参构造方法
    public MyClass(int myField) {
        this.myField = myField;
    }

    // 无参构造方法，调用有参构造方法进行初始化
    public MyClass() {
        this(0); // 调用有参构造方法
    }
}

2. super 关键字：

• 用途： super 用于引用父类的对象或调用父类的方法。它主要用于解决子类和父类之间的成员变量或方法的命名冲突，以及在子类构造方法中调用父类的构造方法。

a. 调用父类方法：

java

public class ParentClass {
    public void display() {
        System.out.println("This is from the parent class.");
    }
}

public class ChildClass extends ParentClass {
    public void display() {
        super.display(); // 调用父类的display方法
        System.out.println("This is from the child class.");
    }
}

b. 在子类构造方法中调用父类构造方法：

java

public class ParentClass {
    private int parentField;

    public ParentClass(int parentField) {
        this.parentField = parentField;
    }
}

public class ChildClass extends ParentClass {
    private int childField;

    public ChildClass(int parentField, int childField) {
        super(parentField); // 调用父类的构造方法
        this.childField = childField;
    }
}

这样， super 和 this 关键字提供了一种清晰的方式来引用对象，解决了变量和方法的命名冲突，并且在构造方法中使用它们可以确保正确地初始化对象的状态。

4.6 定义类的继承，子类和父类之间的关系，数据成员的继承（可能包含隐藏），实例方法的继承（可能包含了覆盖）

继承是面向对象编程中的一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。这建立了子类和父类之间的关系，使得代码的重用性和可维护性增强。

1. 定义类的继承：

在Java中，通过使用 extends 关键字可以实现类的继承。以下是一个简单的例子：

java

// 父类
class Animal {
    String name;

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

    public void makeSound() {
        System.out.println("Some generic sound");
    }
}

// 子类继承自父类
class Dog extends Animal {
    // 子类可以有自己的数据成员

    public Dog(String name) {
        super(name); // 调用父类的构造方法
    }

    // 子类可以覆盖父类的方法
    @Override
    public void makeSound() {
        System.out.println("Bark! Bark!");
    }

    // 子类可以有自己的方法
    public void wagTail() {
        System.out.println("Tail is wagging.");
    }
}

在这个例子中， Dog 类继承自 Animal 类。 Dog 类拥有自己的数据成员（例如， wagTail 方法），同时也继承了 Animal 类的数据成员和方法（例如， name 和 makeSound 方法）。子类可以根据需要添加新的数据成员和方法，也可以覆盖父类的方法。

2. 数据成员的继承：

子类会继承父类的数据成员，但有一点需要注意，即子类不能访问父类中声明为私有的成员（private）。子类可以访问父类的公有（public）和受保护（protected）成员。

java

class Animal {
    private String privateField = "I am private";
    public String publicField = "I am public";
    protected String protectedField = "I am protected";
}

class Dog extends Animal {
    public void printFields() {
        // 在子类中访问继承的成员
        // privateField 不可访问，会导致编译错误
        System.out.println(publicField);
        System.out.println(protectedField);
    }
}

3. 实例方法的继承（包含覆盖）：

子类会继承父类的实例方法，可以选择性地覆盖这些方法。覆盖是指在子类中重新定义与父类中具有相同签名（方法名、参数列表和返回类型）的方法。

java

class Animal {
    public void makeSound() {
        System.out.println("Some generic sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark! Bark!");
    }
}

在这个例子中， Dog 类覆盖了 Animal 类中的 makeSound 方法。当通过 Dog 类的对象调用 makeSound 方法时，将执行 Dog 类中的方法而不是父类中的方法。

总体而言，继承是面向对象编程中的重要概念，它提供了一种有效的代码复用和扩展的机制。然而，使用继承时需要小心，以避免滥用和深度继承链带来的复杂性。

4.7 类的toString方法的使用

在Java中， toString 是 Object类中的一个方法，它被设计用于返回对象的字符串表示。默认情况下， Object类的 toString 方法返回一个字符串，其中包含类的名称，紧跟着 “@” 符号，以及对象的哈希码。

java

public class MyClass {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(obj.toString()); // 默认的toString方法输出：类名@哈希码
    }
}

然而，通常情况下，我们会在自定义类中覆盖 toString 方法，以便提供有关对象内容更有用的信息。以下是一个示例：

java

public class Person {
    private String name;
    private int age;

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

    // 覆盖toString方法，提供有用的对象信息
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }

    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        System.out.println(person.toString()); // 输出：Person{name='Alice', age=25}
    }
}

在这个例子中，通过覆盖 toString 方法，我们定义了一个自定义的字符串表示形式，它包含了 Person 对象的关键信息。

使用 toString 方法的好处在于，在调试和日志记录中，可以更轻松地输出有关对象状态的信息，而无需手动构建字符串。此外，当你打印对象时（例如使用 System.out.println），实际上调用了对象的 toString 方法。

在实际开发中，如果你想要输出自定义对象的信息，覆盖 toString 方法是一个很好的实践，它能够提高代码的可读性和调试效率。

4.8 定义接口类型，类类型和接口类型之间的区别，以及接口类型的使用意义

在Java中，类类型和接口类型是两种不同的概念。让我们分别讨论它们之间的区别，并深入了解接口类型的定义和使用。

类类型（Class Type）：

• 定义： 类类型是指通过类定义的数据类型。类是面向对象编程中的基本概念，它可以包含数据成员和方法。对象是类的实例。

• 示例：

  java

  public class Car {
      private String brand;
      private String model;
  
      public Car(String brand, String model) {
          this.brand = brand;
          this.model = model;
      }
  
      // 其他方法和代码...
  }
  
  // 创建Car类的对象
  Car myCar = new Car("Toyota", "Camry");
  

接口类型（Interface Type）：

• 定义： 接口类型是一种抽象类型，它定义了一组方法的签名，但不提供方法的实现。类通过实现接口来提供方法的具体实现。接口可以包含常量（静态常量）和默认方法（具有默认实现的方法）。

• 示例：

  java

  public interface Vehicle {
      void start();
  
      void stop();
  }
  
  // 类实现接口
  public class Car implements Vehicle {
      @Override
      public void start() {
          System.out.println("Car is starting...");
      }
  
      @Override
      public void stop() {
          System.out.println("Car is stopping...");
      }
  
      // 其他方法和代码...
  }
  

类型之间的区别：

1. 继承关系： 类型之间的主要区别在于继承。类通过继承关系构建，一个类可以继承另一个类，而接口通过实现关系构建，一个类可以实现多个接口。

2. 多继承： 类在Java中是单继承的，即一个类只能直接继承一个父类。但是，一个类可以实现多个接口，实现了接口的类可以获得接口定义的多个方法。

接口类型的使用意义：

1. 实现多态： 接口提供了一种实现多态的方式。不同的类可以实现相同的接口，从而允许它们以相似的方式被处理。

2. 解耦合： 接口可以用于将抽象与实现分离，从而减少类之间的耦合度。一个类通过实现接口，而不是继承特定的类，使得代码更加灵活和可扩展。

3. 组织代码： 接口可以用于组织代码结构，使得代码更加清晰和模块化。接口提供了一种约定，要求实现类必须提供指定的方法。

4. 约定编程： 接口可以用于制定编程规范，让不同的类都遵循相同的接口，以确保一致性和可维护性。

总的来说，接口类型在Java中具有重要的作用，它提供了一种实现多态、解耦合、组织代码和约定编程的机制，使得代码更加灵活、清晰和易于维护。