问题[oop](coding)

我正在学习 Fortran 的面向对象编程。我好奇，当编译时参数的类型未知时，重载类型绑定过程有什么意义。

让我一步一步解释我的问题（这些程序只是为了提高我的 Fortran 技能的例子）

第一个程序：类型绑定过程的重载

module my_mod

  implicit none
  
  type :: my_type_t
    character(len=128) :: my_text
  contains
    procedure :: integer_print, real_print
    generic :: my_print => integer_print, real_print
  end type my_type_t
  
  contains
  
  subroutine integer_print(this, my_int)
    class(my_type_t), intent(in) :: this
    integer, intent(in) :: my_int
    write (*,"(a,a,i0)") trim(this%my_text),' integer ', my_int
  end subroutine integer_print
  
  subroutine real_print(this, my_real)
    class(my_type_t), intent(in) :: this
    real, intent(in) :: my_real
    write (*,"(a,a,f0.3)") trim(this%my_text),' real ', my_real
  end subroutine real_print

end module my_mod

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  my_var%my_text = "Hello"
  
  call my_var%my_print(10)
  call my_var%my_print(9.9)

end program my_pgm

它给出了预期的结果。使用integer_print或real_print，取决于参数的类型my_print（整数或实数）。

第二个程序（或者应该写成步骤）：使用了一个抽象类型，并且有两个派生类型：my_int_t和my_real_t。它与第一个例子非常相似。但是，使用了两种类型：一个用于整数，另一个用于实数。

module my_mod

  implicit none
  
  type, abstract :: my_abstract_t
  end type  my_abstract_t
  
  type, extends(my_abstract_t) :: my_int_t
    integer :: an_integer
  end type my_int_t
  
  type, extends(my_abstract_t) :: my_real_t
    real :: a_real
  end type my_real_t
  
  type :: my_type_t
    character(len=128) :: my_text
  contains
    procedure :: integer_print, real_print
    generic :: my_print => integer_print, real_print
  end type my_type_t
  
  contains
  
  subroutine integer_print(this, my_int)
    class(my_type_t), intent(in) :: this
    type(my_int_t), intent(in) :: my_int
    write (*,"(a,a,i0)") trim(this%my_text),' integer ', my_int%an_integer
  end subroutine integer_print
  
  subroutine real_print(this, my_real)
    class(my_type_t), intent(in) :: this
    type(my_real_t), intent(in) :: my_real
    write (*,"(a,a,f0.3)") trim(this%my_text),' real ', my_real%a_real
  end subroutine real_print

end module my_mod

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  type(my_int_t) :: my_int
  type(my_real_t) :: my_real
  
  my_var%my_text = "Hello"
  
  my_int%an_integer = 10
  my_real%a_real = 9.9
  
  call my_var%my_print(my_int)
  call my_var%my_print(my_real)

end program my_pgm

my_int和的类型my_real在编译类型时是已知的，因此输出是正确的。并且my_var%my_print(...)无论变量类型是什么（my_int_t或my_real_t），都会使用相同的调用，就像第一个示例中那样。

但是，现在这是我的问题。

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  class(my_abstract_t), allocatable :: my_number
  
  allocate(my_int_t::my_number)
  ! or allocate(my_real_t::my_number)
  
  my_var%my_text = "Hello"

  select type (my_number)
  type is (my_int_t)
      my_number%an_integer = 10
  type is (my_real_t)
      my_number%a_real = 9.9
  end select
  
  select type (my_number)
  type is (my_int_t)
      call my_var%my_print(my_number)
  type is (my_real_t)
      call my_var%my_print(my_number)
  end select

end program my_pgm

的类型my_number在编译时是未知的。因此，我必须使用一段我认为非常多余的代码：

  select type (my_number)
  type is (my_int_t)
      call my_var%my_print(my_number)
  type is (my_real_t)
      call my_var%my_print(my_number)
  end select

我本来希望只写一行 : ，call my_var%my_print(...)就像第一和第二个例子一样。我是不是应该得出结论，在第三个例子中，过程重载并不重要，最好直接在块中使用integer_printand ？还是有什么我没理解的地方？real_printselect type

编辑1

按照 Francescalus 的注释，如果我理解正确的话，我的确无法避免select type阻塞。因此，我按照以下方式修改了程序。

module my_mod

  implicit none
  
  type, abstract :: my_abstract_t
  end type  my_abstract_t
  
  type, extends(my_abstract_t) :: my_int_t
    integer :: an_integer
  end type my_int_t
  
  type, extends(my_abstract_t) :: my_real_t
    real :: a_real
  end type my_real_t
  
  type :: my_type_t
    character(len=128) :: my_text
  contains
    procedure, private :: real_print, integer_print
    procedure, public :: my_print
  end type my_type_t
  
  contains
  
  subroutine integer_print(this, my_int)
    class(my_type_t), intent(in) :: this
    type(my_int_t), intent(in) :: my_int
    write (*,"(a,a,i0)") trim(this%my_text),' integer ', my_int%an_integer
  end subroutine integer_print
  
  subroutine real_print(this, my_real)
    class(my_type_t), intent(in) :: this
    type(my_real_t), intent(in) :: my_real
    write (*,"(a,a,f0.3)") trim(this%my_text),' real ', my_real%a_real
  end subroutine real_print
  
  subroutine my_print(this,my_number)
    class(my_type_t), intent(in) :: this
    class(my_abstract_t), intent(in) :: my_number
    
    select type (my_number)
    type is (my_int_t)
        call this%integer_print(my_number)
    type is (my_real_t)
        call this%real_print(my_number)
    end select
    
  end subroutine my_print
    

end module my_mod

program my_pgm

  use my_mod
  implicit none
  
  type(my_type_t) :: my_var
  class(my_abstract_t), allocatable :: my_number1, my_number2
  
  my_number1 = my_int_t(an_integer = 10)
  my_number2 = my_real_t(a_real = 9.9)
  
  my_var%my_text = "Hello"

  call my_var%my_print(my_number1)
  call my_var%my_print(my_number2)
  
end program my_pgm

任何评论都将受到欢迎。

里氏替换原则指出，如果用子类替换超类（解释），那么一段代码应该仍然正确。我不明白的是，我们为什么要关心这个属性？它能让我们的代码更可重用、更灵活或更易于维护吗？

在解释替换属性的相关性时，我希望提供一个遵循该原则和违反该原则的代码示例。

假设我们想模拟不同种类的食物：披萨和馅饼。披萨和馅饼都有一种配料，但它们的配料不同。

我们实现一个抽象类Baked，以及两个具体类Pizza和Pie。我们还实现一个抽象类Topping，以及两个具体类PizzaTopping和PieTopping。

根据定义， 的任何具体实现都Baked必须具有Topping，因此Baked应具有 类型的属性Topping。此外，此特定的 topping 属性应为PizzaTopping中的类型Pizza，并且PieTopping中的类型Pie。

如果我正确理解了前面的答案，那么在这种情况下 LSP 就会被违反，因为如果我们抛开抽象的事实Baked，就有可能实例化Baked持有 的 a ，但如果我们用PieTopping替换，这是不可能的。BakedPizza

我的问题是：有没有办法在不违反 LSP 的情况下实现这个模型？

我希望能对如何正确实现“组合优于继承”进行一些澄清。我认为我已经掌握了理论，但在实践中我很难理解它如何不会导致代码重复。

我有以下示例（它是 Java）：假设我们有一个抽象动物类：

abstract class Animal {
    protected void eat() {
        // Common eating implementation
    }

    protected void sleep() {
        // Common sleeping implementation
    }
}

我们想要建造飞行和游泳的动物。我知道，遵循 LSP 的最佳方法是为每个接口提供接口：

interface Flyer {
    void fly();
}

interface Swimmer {
    void swim();
}

那么我们就会有

class Salmon extends Animal implements Swimmer {
    @Override
    public void swim() {
        // Swim implementation
    }
}

class Sparrow extends Animal implements Flyer {
    @Override
    public void fly() {
        // Fly implementation
    }
}

但随后我们得到了一个新的要求，即Magpie它的飞行方式与麻雀相同。我们将创建一个类，与 a 没有太大不同Sparrow：

class Magpie extends Animal implements Flyer {
    @Override
    public void fly() {
        // Same exact fly implementation as Sparrow.fly
    }
}

出于本练习的目的，想象一下，苍蝇的实现非常复杂，包括数据库集成、日志记录等。这会导致大量重复的代码，如果我们添加更多的鸟或鱼，我们甚至需要重复代码更远。

还有一个想法是为相同类型的传单创建一个抽象类，例如

abstract class FlyingBird extends Animal implements Flyer

并在那里有通用的实现，但是如果我们需要创建其中一些并且有一只动物需要扩展其中两个怎么办？这是一个滑坡...

有什么办法可以避免这种情况吗？或者我在某个地方遗漏了标记？

在某些来源（例如Martin Fowler 的原始文章）中，没有写到方法将返回相同的对象，并且示例中的方法返回不同的对象，但在某些来源（较新）中，例如维基百科，则写到方法将返回相同的对象，哪个是对的？