写习惯了就好，你还没有上知乎问为什么他们要写后缀……

我觉得这也就是习惯问题，好像之前 ML 什么的都是这么写来着……
一般来说好像喜欢项目定义语法结构前缀关键字的人会夸赞它定义更明确（因为开头是固定的关键字比如 var val fun constructor）、允许考虑标识符的名字多于类型（这样可能有助于你起好名字）、在隐式类型的时候（比如 type inference, gradual typing）方便不少（因为此时类型不必显式写出，C# 和 Java 10 那个 var 又显得不够好看）
喜欢 R fn(T x) {...} 这种的喜欢说它简洁、突出最终值的类型这个重点

使用的类型签名看起来像是这样，以下程序构筑使用了变量右值（value）、左值（一般是 variable）和子程序，多态是简单的函数重载 (overloading)
调戏结果 撸猫（猫 小猫） {...}
调戏结果 撸猫（波斯猫 小猫） {...} 这是 C、C++、Java

程序 撸猫（猫：猫）：调戏结果 {...}
程序 撸猫（猫：波斯猫）：调戏结果 {...} 这是 Kotlin、Rust、Swift、Python 什么的

typealias Sound = String
abstract class Noisable(private val noise: Sound) {
  fun makeNoise(): Unit = println(noise)
}
data class 猫(val name: String, val isMale: Bool): Noisable("Meow")

这个时候，Kotlin 使用 <:> 显然会比沿用 extends 要好。

其实也未必不可以用 extends 什么的，不过 Kotlin 的 <:> 语法实质上不能完全和 Java 的 extends 划等号，因为

+ 这个语法还被用来 val dict: MutableMap<Char, Char> = mutableMapOf() — 这个例子的代码风格好像是不被 Kotlin 推荐的
+ Generic（也就是 OOP 的 Parametric polymorphism，参数化多态，也是 Kotlin 完胜 Java 的地方之一，因为它有比 Java8-11 都强多了的泛型推导） 的 upper-bound（类型参数的继承序(order) 上界）
也是使用 ParamizedType<WTF: Type> 这种语法指定的，虽然 Kotlin 不一定把这个东西叫成 upper-bound aka. ubound，不过 Java 里都叫 Type wildcard capture<? super T>
类型『上』界可以认为是命题 (? > T)… 此处 ? 这个未知类型要『大于』T，也就是说是 T 的 subtype 才能被视为可接受的类型参数，Scala 里这种约束叫 [+T]。
比如 Kolin 里一个 mutableListOf(1) as ArrayList<*> （K2JVM 里是一个 typealias 定义的）的继承关系看起来是这样（虽然看起来 T? 不像是个『简单』类型……）：

Any? Any
List<*>? List<*>
MutableList<*>? MutableList<*>
ArrayList<*>? ArrayList<*>

这里每一个第 n+1 的项目，都比上一项『大』，而且这个关系具有传递性(transitive)即 (Number: Any) => (1 is Number) => (1 is Any), 不过不像 T: Comparable<T> 的 cmp 它不具有反对称性(asymmetric)…… 呃不反对称与否我不清楚
Any? 是 Kotlin 的顶类型，所有类型都大于它（是它的子类型），Kotlin 里的 <in T> 在 T 是 Any? 的时候，所有接受 T 的函数相当于要求对应位置为 capture<? super Object> 类型，当然这不是很科学的设计，但也能用（我不是指型变性(variance)，它是很科学的，尤其在 Scala 和 Kotlin 里非常好用，毕竟你还是希望有一些只能接受『更小』类型的『值需求』位置）
Nothing 是 Kotlin 的底类型(bottom type)，所有类型都小于它（这个类型是不能被 typealias 的，由此你可以注意到 Kotlin 设计是的确很细腻）
<out T> 在 T 是 Nothing 的时候，也相当于所有返回 T 的子过程或者说行为、方法(behavior, method) 要求 capture<? extends Void>
当然这不科学，因为没有类型比 Nothing 更大，不过 Nothing 也是任何类型的子类型，而且上面的 Void 应该说是 Nothing? 这个类型，看作实例值的集合它只有一种可能：null, Java 的那个版本是 final 并且 private Void(){} 隐藏架构器的版本，所以它是没有实例的类型。
Kotlin 里的 <*> 是基于 PECS(producer-extends, consumer-super; 或者说生产者-协变, 接受者-逆变) 原则生产消费者模型类型安全的，所以 Map<*, *> 的意思是 Map<? super Nothing, ? extends (Any?)>

也算是支持 subtyping 的类型系统里强化其 completeness （也就是降低假阳性 False positive 的概率，对应的是假阴性 False negative 的 soundness，即允许不一致的类型通过）的一种方案，毕竟你甚至可以 println(System.exit(1)), 从类型安全的角度看这是没有任何毛病的（虽然 Java 里没有返回值就是没有返回值，你不能用 void 去 call println; 或者更准确的说法是 System.exit: (I)V 没有返回值）

不过 Kotlin 首先是多个函数类型 (in T) -> out R, 而且这个还和 fun... 比较对称
如果要和 Java 对称的话，函数的类型只能写的和 C 一样丑：
调戏结果(*)(波斯猫 猫);
我觉得这实在不能和『好看』扯上半点关系…… wtf

其实构造函数本身，如果你结合 Kotlin 1.3 和 Java8 来比较、加上倾向杂交一点而不是 Kotlin 式 OOP+FP 多范式的 Rust 什么的，就会发现它也就是个不良的封装而已

为什么一定要 call super 在加不一致的语法糖（Kotlin 里只要父类，当然不是接口实现全部加上无参 superclass constructor 的括号）什么的呢？Kotlin 里把类的 constructor 进一步独立出来，要求所有特化类的 parent 数据依赖都在语法结构层次上直接提供，又重构了一大堆包括 static 换 companion object 的操作，Kotlin 比 Java 更像 OOP 一些了，毕竟重要的东西应该写明显一点嘛

不过对我来说，好像觉得本来就是应该像 Kotlin 这样做的一样，Java 的抽象程度还是不够，何必要函数呢？难道更多时候不是一个表达式就够了么？

Rust 的就是没有专门的构造函数，用的是类似 Json 语法的 struct initializer，不过也是不难看的
毕竟 Rust 不是面向对象的编程语言，即便偶尔可以用一点点多态（trait 什么的）也不能说是特别能使用 subtyping 的主