编程语言的一些特性

文章时效性提示

这是一篇发布于 388 天前的文章，部分信息可能已发生改变，请注意甄别。

学习到C#,Kotlin或者Dart这种特性多、语法糖不少的编程语言之后,就会出现一些新的问题,这里不定期更新一下学到的语法糖.特别说一下,在某些开发者眼里,C#,Kotlin,Go,Rust,Dart是 Most Popular New Programming Languages,都在不同程度上提升了开发效率和性能.

委托

委托Delegation本来算是一种设计思想,在C#和Kotlin这些语言里有专门的实现方式.

.NET 中,委托具有以下特点。

• 委托类似于 C++函数指针,但与指针不同的是,委托是完全面向对象的、安全的数据类型。
• 委托允许将方法作为参数进行传递。
• 委托可用于定义回调方法。
• 委托可以把多个方法连接在一起,这样在触发事件时,可同时启动多个事件处理程序。

有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承，它还使我们可以模拟mixin。

class RealPrinter { // the "delegate"
    void print() { 
      System.out.print("something"); 
    }
}

class Printer { // the "delegator"
    RealPrinter p = new RealPrinter(); // create the delegate 
    void print() { 
      p.print(); // delegation
    } 
}

public class Main {
    // to the outside world it looks like Printer actually prints.
    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print();
    }
}

interface I {
    void f();
    void g();
}

class A implements I {
    public void f() { System.out.println("A: doing f()"); }
    public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
    public void f() { System.out.println("B: doing f()"); }
    public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
    // delegation
    I i = new A();

    public void f() { i.f(); }
    public void g() { i.g(); }

    // normal attributes
    public void toA() { i = new A(); }
    public void toB() { i = new B(); }
}


public class Main {
    public static void main(String[] args) {
        C c = new C();
        c.f();     // output: A: doing f()
        c.g();     // output: A: doing g()
        c.toB();
        c.f();     // output: B: doing f()
        c.g();     // output: B: doing g()
    }
}

Java本身没有委托设计.而在C#中使用delegate可以使用定义委托赋值方法,作为参数或者多播、匿名委托

using System;

// 定义一个委托类型
delegate void PrintDelegate(string message);

class Program
{
    static void Main(string[] args)
    {
        // 创建委托实例并关联一个方法
        PrintDelegate printDelegate = PrintMessage;
        
        // 使用委托调用方法
        printDelegate("Hello, C#!");
    }
    
    static void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }
}
using System;

delegate int CalculationDelegate(int x, int y);

class Program
{
    static void Main(string[] args)
    {
        // 调用方法，传递委托作为参数
        int result = Calculate(5, 3, AddNumbers);
        Console.WriteLine(result);
    }
    
    static int Calculate(int x, int y, CalculationDelegate calculation)
    {
        return calculation(x, y);
    }
    
    static int AddNumbers(int x, int y)
    {
        return x + y;
    }
}
using System;

delegate void PrintDelegate(string message);

class Program
{
    static void Main(string[] args)
    {
        // 创建多播委托
        PrintDelegate printDelegate = PrintMessage1;
        printDelegate += PrintMessage2;
        
        // 调用多播委托，会依次执行所有关联的方法
        printDelegate("Hello, C#!");
    }
    
    static void PrintMessage1(string message)
    {
        Console.WriteLine("Message 1: " + message);
    }
    
    static void PrintMessage2(string message)
    {
        Console.WriteLine("Message 2: " + message);
    }
}
using System;

delegate int CalculationDelegate(int x, int y);

class Program
{
    static void Main(string[] args)
    {
        // 使用匿名委托定义和调用方法
        CalculationDelegate calculation = delegate(int x, int y)
        {
            return x + y;
        };
        
        int result = calculation(5, 3);
        Console.WriteLine(result);
        
        // 使用 Lambda 表达式定义和调用方法
        CalculationDelegate calculation2 = (x, y) => x + y;
        
        int result2 = calculation2(5, 3);
        Console.WriteLine(result2);
    }
}

上面的代码类似定义方法的原型.

而在Kotlin中有类委托和属性委托.

类委托允许一个类将其接口的实现委托给另一个类。通过在类定义中使用 by 关键字，可以将接口的实现委托给另一个对象。被委托的对象必须实现相应的接口。

属性委托允许我们将属性的读取和写入操作委托给其他对象。Kotlin 提供了一些内置的委托，例如 Lazy、Observable 和 NotNull 等。此外，我们还可以自定义属性委托.

interface Sound {
    fun makeSound()
}

class CatSound : Sound {
    override fun makeSound() {
        println("Meow!")
    }
}

class Animal(sound: Sound) : Sound by sound

fun main() {
    val catSound = CatSound()
    val animal = Animal(catSound)
    animal.makeSound() // 输出 "Meow!"
}

class Example {
    var property: String by CustomDelegate()
}

class CustomDelegate {
    private var value: String = ""

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("Getting property value: $value")
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
        println("Setting property value: $newValue")
        value = newValue
    }
}

fun main() {
    val example = Example()
    example.property = "Hello, Kotlin!" // 输出 "Setting property value: Hello, Kotlin!"
    println(example.property) // 输出 "Getting property value: Hello, Kotlin!"
}