用Java和Python模仿Kotlin构建器

最新推荐文章于 2024-05-05 08:25:48 发布

dnc8371

最新推荐文章于 2024-05-05 08:25:48 发布

阅读量132

点赞数

文章标签： python java 编程语言 javascript 人工智能 ViewUI

介绍

Kotlin可能现在是我最喜欢的语言，并且它可能提供的最酷的功能之一是基于几个功能构建的类型安全的生成器（稍后解释）。我发现自己真的很想在其他两种主要语言（Java和Python）中使用此功能。本文解释了我认为与使用这些语言的类型安全的构建器最接近的东西。

Kotlin

首先，我需要说明Kotlin进行类型安全的构建器的能力。要快速了解这些构建器的含义，您应该查看有关它们的页面。在本文中，我们将实现其html构建器的一小部分。

Kotlin创建类型安全的构建器的能力归功于许多小功能。第一个是lambda语法； {param, list -> block.of.code()} 。如果lambda的参数为零，则可以忽略参数列表和箭头。当它只有一个参数时，也是如此，因为该参数被隐式称为it 。例如， {doSomethingWith(it)}是合法的lambda，假设doSomethingWith()接受的对象与传递给lambda的对象的类型相同。

下一个功能是如何将lambda传递给函数。如果最后一个参数是lambda，则可以在函数调用的括号后传递该参数。例如， myFunc(arg1){lambdaArg()} 。如果lambda是唯一的参数，则可以完全忽略括号： aFunc{lambdaArg()} 。这使您可以定义看起来像语言功能的功能。如果不是因为保留了这些关键字，就可以从技术上定义自己的if-else块或任何循环。

接下来是扩展方法，您可以定义像它们一样工作的lambda。扩展方法是为接口类之外的类或接口定义的新方法。例如，您可以为String类创建新的方法。实际上，它们只是静态方法，它们采用其所针对类型的隐式第一个参数。在Kotlin代码中，第一个参数分配给this标识符， this标识符隐式使用，就像在实际方法中一样。

您也可以定义像扩展方法一样工作的lambda（ SomeClass.() -> Unit而不是(SomeClass) -> Unit ），以便在lambda内部，您可以调用对象而无需显式引用它。

所有这些功能，再加上非常好的类型推断，共同构成了一种功能，可以从使用扩展lambda的函数中创建类型安全的构建器。因此，我们可以这样写：

html {
   head {
      title("A Title")
   }
   body {
      p = "paragraph"
      p = "'nother one"
      p = "last paragraph"
   }
}

要返回Html包含对象Head和Body ，将Head包含Title与文字，“A标题”。 Body包含3个Paragraphs 。

您可能会注意到title和[p]的定义方式不同。它可能会是聪明有title使用=语法代替p ，但p展示了这些建设者如何素材可以是优于title 。我用Python做过类似的事情，因为它也支持属性。

让我们看一下允许创建这些对象的Kotlin代码

fun html(htmlBuilder: Html.() -> Unit): Html {
   val html = Html()
   html.htmlBuilder()
   return html
}

class Html {
   private var head: Head? = null
   private var body: Body? = null

   fun head(headBuilder: Head.() -> Unit) {
      head = Head()
      head?.headBuilder()
   }

   fun body(bodyBuilder: Body.() -> Unit) {
      body = Body()
      body?.bodyBuilder()
   }
}

我们从Html类和用于启动构建器的html()函数开始。 html函数不是必需的，因为该代码可以用作Html构造函数，但是它使我们能够使构造函数保持简单，并且所有函数都小写而不违反命名约定。

您会注意到，实际上一切都还很短。只有html函数是3行，这仅仅是因为它必须在最后返回结果。如果我们在Html上使用构造函数，那么它将只有htmlBuilder() 。

这里的Head及Title 。

class Head {
   private var title: Title? = null

   fun title(text: String) {
      title = Title(text)
   }
}


class Title (private val text: String) { }

进行得还不错。 Title不需要构建器，因为它仅包含文本。如果不是因为需要一些更复杂的构建机制，我实际上会让Head只握住String本身，而不是创建Title类和对象。

class Body {
   private val paragraphs: ArrayList<Paragraph> = ArrayList()

   var p: String
      private get() = null!!
      set(value) {
         paragraphs.add(Paragraph(value))
      }
}
 

class Paragraph (private val text: String) { }

这是真正有趣的事情。与使用Title方法不同，我们没有使用p()方法，而是使用p的setter来将Paragraph对象添加到列表中。在这种情况下，它不是最直观的。它只是在这里向您展示如何利用这些构建者来发挥创造力。

还要记住，这些类只是构建器类，因此允许它们是有状态的。应该有一个build()方法，该方法递归地调用所有封闭对象的build()方法，以创建一个不错的，不变的对象。

Java

在Java中，您几乎可以创建完全相同的类，除了生成器看起来不那么干净之外，因为它没有上面的所有可爱功能。因此，首先开始，这是构建器代码的最终外观。

html(html -> {
   html.head(head ->
      head.title("A Title")
   );
   ht.body(body -> {
      body.p("paragraph");
      body.p("'nother one");
      body.p("last paragraph");
   });
});

这是接近的建设者语法，你可以在Java中获得。请注意， title()和p()的调用方式没有什么区别，因为Java不提供任何类似于属性的构造。另外，请注意，您需要为所有内容起一个名字。使用隐式this ，您必须编写类似于hd.title(...)而不仅仅是title(...) ，这甚至没有提到我们必须为lambda定义参数列表这一事实。

您还可以做其他几件事，但更糟糕的是，第一件事就是使用常规代码：

Html html = new Html();
   Head head = html.head();
      head.title("A Title");
   Body body = html.body();
      body.p("paragraph");
      body.p("'nother one");
      body.p("last paragraph");

这并不可怕，但是由于缺少完整类型推断（我必须指定head和body属于其各自的类型），它最终变得相对冗长（由于没有括号，所以多余的制表符纯粹是为了外观）用过的。我想到的另一种方法将在Python版本之后显示，因为它试图复制该版本。

因此，让我们看一下代码：

public class Html {
   public static Html html(Consumer<Html> htmlBuilder)
   {
      Html html = new Html();
      htmlBuilder.accept(html);
      return html;
   }

   private Head head = null;
   private Body body = null;

   public void head(Consumer<Head> headBuilder) {
      head = new Head();
      headBuilder.accept(head);
   }

   public void body(Consumer<Body> bodyBuilder) {
      body = new Body();
      bodyBuilder.accept(body);
   }
}

这与直接移植到Java一样直接。 html()函数已作为静态方法移入Html类，因为它必须放在 Java中。我们使用了Consumer<Html> ，因为这是Java与我们想要的lambda最为接近的东西。

这里是Head和Title ：

public class Head { 
   private Title title = null;

   public void title(String text) {
      title = new Title(text);
   }
}


public class Title {
   private final String text;

   public Title(String text) {
      this.text = text;
   }
}

这里没有太多注意事项。这可能与您的期望有关。现在以“ Body Paragraph结束。

public class Body {
   private final List paragraphs = new ArrayList<>();

   public void p(String text) {
      paragraphs.add(new Paragraph(text));
   }
}
 

public class Paragraph {
   private final String text;

   public Paragraph(String text) {
      this.text = text;
   }
}

几乎感觉像不值得编写这些类，不是吗，它们是如此简单。请记住，这是准构建器部分。同样，此代码实际上并不包含用于构建实际的，不变的DOM树的功能。

这就是构建Java版本所需要的。除了一些语法上的冗长之外，用Java创建比使用Kotlin几乎容易得多，因为没有任何其他功能可以考虑和使用：P

Python

试图找出一种在Python中执行类似操作的方法，这使我很幸运地看到了一个视频，该视频展示了使用上下文管理器（ with语句）的新颖（但不直观）的方法。 Python中的问题在于，lambda只允许具有单个表达式或语句。上下文管理器通过有效地允许您在可以在上下文管理器内使用的条目上返回一个对象（或不返回任何对象），从而允许（非常有限的）方式绕过单行lambda，就像在lambda内一样。

因此，例如，构建器在Python中如下所示：

myhtml = Html()
with myhtml as html:
    with html.head() as head:
        head.title("A Title")
    with html.body() as body:
        body.p = "paragraph"
        body.p = "'nother one"
        body.p = "last paragraph"

这实际上看起来像是浪费，因为这几乎可以很容易地写成以下内容：

html = Html()
head = html.head()
head.title("A Title")
body = html.body()
body.p = "paragraph"
body.p = "'nother one"
body.p = "last paragraph"

with块的最大好处是缩进，因为Python由于在花括号上使用缩进，因此具有缩进限制。为此，上下文管理器可能值得。但是，在向您展示了用Python制作这些代码所需的基本代码之后，我还将在书中谈到另一个好处：

class Html:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        return False

    def head(self):
        self._head = Head()
        return self._head

    def body(self):
        self._body = Body()
        return self._body

在这里，你可以看到Html类具有所需的__enter__()和__exit__()方法是一个上下文管理器。他们几乎什么也不做； __enter__()仅返回self ，而__exit__()只是表示它__exit__()可能传入的任何异常__exit__() head()和body()方法几乎可以满足您现在的期望。 Head和Body也是上下文管理器类型的假设。

class Head:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        return False

    def title(self, text):
        self._title = Title(text)
 

class Title:
    def __init__(self, text):
        self.text = text
 

class Body:
    p = property()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        return False

    @p.setter
    def p(self, text):
        if not hasattr(self, 'paragraphs'):
            self.paragraphs = []
        self.paragraphs.append(Paragraph(text))


class Paragraph:
    def __init__(self, text):
        self.text = text

唯一值得关注的新事物是在Body中为其p标签使用了property 。幸运的是，我们并不需要对干将property ，我们需要有返回小号None ，就像在Kotlin。

好的，现在我们来看一个有趣的，不太明显的原因，在这种情况下使用上下文管理器会有所帮助。在Java和Kotlin中，我们最终需要对build()方法进行一次额外的调用（或者让html()函数为我们完成），并让它最后一次全部进行递归遍历照顾它。使用上下文管理器， __enter__() __exit__() __enter__()和__exit__()方法可以在进入时传递对象的生成器版本，然后在退出时进行构建。这意味着构建器的每个中间阶段在退出时已经包含完整构建的版本。

实际上，将头缠绕起来可能有点困难。这是一个使用Html ， HtmlBuilder和Head进行部分实现的示例：

class Html:
    def __enter__(self):
        self._builder = HtmlBuilder()
        return self._builder

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.head = self._builder._head
        self.body = self._builder._body
        del self._builder
        return False


class HtmlBuilder:
    def head(self):
        self._head = Head()
        return self._head

    def body(self):
        ...


class Head:
    def __enter__(self):
        self._builder = HeadBuilder()
        return self._builder

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.title = self._builder._title
        del self._builder
        return False

在这里， Html对象的__enter__()方法创建并保存一个生成器，然后将其返回。在__exit__() ，它从存储在构建器中的值构建自身，并从自身中删除构建器。一经考虑，至少对于我来说，可能会认为存储在构建器上的对象不是完成的对象，而是完成的对象。使用HtmlBuilder的head()方法和Head的实现可以看到，builder对象上的方法返回带有其自己的__exit__() __enter__()和__exit__()方法的适当类，这些类也将保证其正确构建。使用此设置，调用代码实际上仍然与第一次相同。

最后一件事：既然我们知道可以使用上下文管理器来执行此操作，那么您可能会认为Java的try资源管理器实际上可以正常工作。而且你会是对的。实际上，它的最终语法（除了随机try关键字之外）也比lambda版本更干净。调用时，资源管理器的版本如下所示：

Html html = Html();
try(html) {
   try(Head head = html.head()) {
      head.title("A Title");
   }
   try(Body body = html.body()) {
      body.p("paragraph");
      body.p("'nother one");
      body.p("last paragraph");
   }
}

在这一点上，我将留给您尝试并弄清楚如何实现它。提示：我认为它不能像Python构建的第二个版本那样工作，它会随其构建。我认为此Java版本代码中的所有内容都需要构建器，直到最后，您在html上调用build()方法以创建真实版本。

奥托罗

天哪，这东西最终有点长，不是吗？我希望您能从此练习中获得一些乐趣，因为我不确定它的实际用途（除了了解您可以使用上下文管理器模拟0或1参数lambda外，还可以。

可悲的是，我从来没有像在Kotlin网站的示例中那样谈论添加其他参数，例如在函数调用中分配类，id等。 Kotlin还具有其他功能，可以使它真正干净和容易，但是本文显然没有足够的空间。下周我会解决。

谢谢阅读！

注意：截至昨天，所有编辑已完成。从这里开始，我“只是”需要设计一个我有想法的封面；获取所有印刷版和电子书版的格式；编写附录（大部分只是本书中的代码片段的集合，充实了更多内容）；并完成GitHub存储库的编写，该库将具有所有超级有用的类和函数，可更快，更轻松且更少的问题来构建自己的描述符。我希望所有这些工作都能在夏季结束之前完成，但希望能早日完成。我的生活将变得更加忙碌，所以我不知道我能花多少时间来完成所有这些工作。

翻译自: https://www.javacodegeeks.com/2016/01/mimicking-kotlin-builders-java-python.html

dnc8371

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
用Java和Python模仿Kotlin构建器

介绍 Kotlin可能现在是我最喜欢的语言，并且它可能提供的最酷的功能之一是基于几个功能构建的类型安全的生成器（稍后解释）。我发现自己真的很想在其他两种主要语言（Java和Python）中使用此功能。本文解释了我认为与使用这些语言的类型安全的构建器最接近的东西。 Kotlin 首先，我需要说明Kotlin进行类型安全的构建器的能力。要快速了解这些构建器的含义，您应该查看有关它们的页...
复制链接

扫一扫