这种对Java的添加会很难实现吗？

我经常希望能够正确地修饰java类，即为它们添加行为。我知道ruby中的mixin，我知道它们可能会变得非常混乱

我提出了这样一种语言结构的理论观点：

package org.test.decorator;

public decorator ListPatch<E> extends List<E> {
    public E last() {
        return this.get(this.size() - 1);
    }
}

List<String> list = new List<String>();
list.Add("test");
Console.WriteLine(list.Last());

我对编译器没有太多的了解，所以我想知道这样的事情是否可能。如果这真的是一个进步的话。

当然，这是可能的

Scala编译成字节码（并且具有从Scala类到字节码类的相当直接的映射）并支持混合的事实证明了这一点

下面是示例代码在Scala语法中的外观：

class ListTest {

    // ...

}

trait ListPatch {
    def last {
        // ...
    }
}

object Main {
    def main(args: Array[String]) {
        val list = new ListTest() with ListPatch;
        list.add("test")
        println(list.last)
    }
}

Scala通过添加一个A腋生类

Main$$anon$1

来编译它，该类由

ListTest

和

ListPatch

组成

Java开发人员的座右铭一直是（而且很可能永远是）“如果有疑问，就把它排除在外”

相关问题：

当然，这是可能的
Scala编译成字节码（并且具有从Scala类到字节码类的相当直接的映射）并支持混合的事实证明了这一点
下面是示例代码在Scala语法中的外观：

class ListTest {

    // ...

}

trait ListPatch {
    def last {
        // ...
    }
}

object Main {
    def main(args: Array[String]) {
        val list = new ListTest() with ListPatch;
        list.add("test")
        println(list.last)
    }
}

Scala通过添加一个A腋生类

Main$$anon$1

来编译它，该类由

ListTest

和

ListPatch

组成
Java开发人员的座右铭一直是（而且很可能永远是）“如果有疑问，就把它排除在外”
相关问题：
---

这并不是你问题的答案，但你可以通过控制反转/依赖注入来解决这个问题（就像你在代码中做的那样）
基本上：

---

不要使用“new ArrayList（）”而是使用诸如“injector.new（ArrayList.class）”之类的工厂。此注入器现在可以重写所需的类并返回一个对象，该对象扩展了用您的方法修饰的ArrayList。
这并不是您问题的答案，但您可以通过控制反转/依赖项注入来解决此问题（就像您在代码中所做的那样）
基本上：

---

不要使用“new ArrayList（）”而是使用诸如“injector.new（ArrayList.class）”之类的工厂。这个注入器现在可以重写所需的类并返回一个对象，该对象扩展了用您的方法修饰的ArrayList。
您的想法听起来很像
扩展方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型
在C#中，您可以将示例编写为：

public static class ListExtensions
{
    public E Last(this List<E> list)
    {
        return list[list.Count - 1];
    }
}

公共静态类ListExtensions
{
公共E最后（此列表）
{
返回列表[list.Count-1]；
}
}

像这样使用它：

package org.test.decorator;

public decorator ListPatch<E> extends List<E> {
    public E last() {
        return this.get(this.size() - 1);
    }
}

List<String> list = new List<String>();
list.Add("test");
Console.WriteLine(list.Last());

List List=新列表（）；
列表。添加（“测试”）；
Console.WriteLine（list.Last（））；

因此，从设计的角度来看，它当然可以被设计和添加。但是，在向现有语言添加内容时，还有其他一些需要考虑的因素，例如语法冲突、向后兼容性、边缘情况、设计和编码的成本以及它提供的好处

---

Eric Lippert在C#中有（扩展方法的自然扩展），在第二部分中，他强调了影响产品X为什么没有特性Y？的一些方面，我相信这也适用于Java及其开发。
你的想法听起来很像
扩展方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型
在C#中，您可以将示例编写为：

public static class ListExtensions
{
    public E Last(this List<E> list)
    {
        return list[list.Count - 1];
    }
}

公共静态类ListExtensions
{
公共E最后（此列表）
{
返回列表[list.Count-1]；
}
}

像这样使用它：

package org.test.decorator;

public decorator ListPatch<E> extends List<E> {
    public E last() {
        return this.get(this.size() - 1);
    }
}

List<String> list = new List<String>();
list.Add("test");
Console.WriteLine(list.Last());

List List=新列表（）；
列表。添加（“测试”）；
Console.WriteLine（list.Last（））；

因此，从设计的角度来看，它当然可以被设计和添加。但是，在向现有语言添加内容时，还有其他一些需要考虑的因素，例如语法冲突、向后兼容性、边缘情况、设计和编码的成本以及它提供的好处

---

Eric Lippert在C#中有（扩展方法的自然扩展），在第二部分中，他强调了影响产品X为什么没有特性Y？的一些方面，我相信这也适用于Java及其开发。
，这里有一篇2000年的文章：你的第一个任务是提出一个严格的、不含糊的定义，它涵盖了所有的情况，并且没有破坏语言中的任何其他东西。我想你会发现这部分任务本身就够艰巨的了。好吧，这里有一篇2000年的文章：你的第一个任务是提出一个严格的、不含糊的定义，涵盖所有情况，并且不破坏语言中的任何其他内容。我想你会发现这部分任务本身就够艰巨的了。没错，这是缺点。但是由于某些原因，类通常是最终的。但是变量的类型将是'List'，因此这个新的子类方法将不可用。正确，这是缺点。但是由于某些原因，类通常是最终的。但是变量的类型将是'List'，因此这个新的子类方法将不可用。