如何创建引用另一对象参数的变量？类属性动态比较咨询

1. 如何创建一个引用另一对象参数的变量？ #

如果你想创建一个能动态指向对象某个属性/参数的变量，**函数式接口（或委托）**是最优雅的解决方案。它本质上是把“获取属性值”的逻辑封装成一个可复用的变量，相当于给对象属性加了一个“引用指针”。

举个具体的例子（以C#和Java为例，其他语言逻辑类似）：

C# 示例 #

// 假设你的自定义类
public class MyClass {
    public int Int1 { get; set; }
    public string StringProp { get; set; }
}

// 创建引用Int1属性的变量，用Func<MyClass, int>委托
Func<MyClass, int> intPropertyRef = mc => mc.Int1;
// 引用StringProp的变量
Func<MyClass, string> stringPropertyRef = mc => mc.StringProp;

// 使用时，传入对象实例就能获取对应属性值
MyClass instance = new MyClass { Int1 = 10, StringProp = "test" };
int intVal = intPropertyRef(instance); // 得到10
string strVal = stringPropertyRef(instance); // 得到"test"

Java 示例 #

class MyClass {
    private int int1;
    private String stringProp;
    
    // 构造器、getter方法
    public int getInt1() { return int1; }
    public String getStringProp() { return stringProp; }
}

// 用Function接口创建属性引用
Function<MyClass, Integer> intPropertyRef = MyClass::getInt1;
Function<MyClass, String> stringPropertyRef = MyClass::getStringProp;

// 使用
MyClass instance = new MyClass();
instance.setInt1(10);
instance.setStringProp("test");
int intVal = intPropertyRef.apply(instance); // 得到10
String strVal = stringPropertyRef.apply(instance); // 得到"test"

这种方式类型安全，编译时就能检查属性是否存在，而且比反射性能更优。

2. 优化自定义类属性比较的switch实现 #

你当前用switch+字符串参数的方式确实存在不少痛点：硬编码字符串容易出错、代码冗余、扩展性差（加新属性就要修改switch分支）。最优的解决方案是结合上面提到的函数式接口/委托，直接把“属性选择逻辑”作为参数传入比较方法，彻底干掉switch。

优化后的实现（C#） #

public class MyClass {
    public int Int1 { get; set; }
    public int Int2 { get; set; }
    public double DoubleProp { get; set; }
}

// 通用比较方法，接受属性选择器作为参数
public void CompareAndOperate(MyClass myClass1, MyClass myClass2, Func<MyClass, IComparable> propertySelector) {
    var val1 = propertySelector(myClass1);
    var val2 = propertySelector(myClass2);
    
    if (val1.CompareTo(val2) < 0) {
        // 执行你的操作逻辑
        Console.WriteLine("第一个实例的属性值更小");
    }
}

// 调用方式，直接传入属性选择器
CompareAndOperate(obj1, obj2, mc => mc.Int1);
CompareAndOperate(obj1, obj2, mc => mc.Int2);
CompareAndOperate(obj1, obj2, mc => mc.DoubleProp);

优化后的实现（Java） #

class MyClass {
    private int int1;
    private int int2;
    private double doubleProp;
    
    // 构造器、getter方法
    public int getInt1() { return int1; }
    public int getInt2() { return int2; }
    public double getDoubleProp() { return doubleProp; }
}

// 泛型比较方法，支持所有可比较类型
public <T extends Comparable<T>> void compareAndOperate(MyClass myClass1, MyClass myClass2, Function<MyClass, T> propertySelector) {
    T val1 = propertySelector.apply(myClass1);
    T val2 = propertySelector.apply(myClass2);
    
    if (val1.compareTo(val2) < 0) {
        // 执行你的操作逻辑
        System.out.println("第一个实例的属性值更小");
    }
}

// 调用方式
compareAndOperate(obj1, obj2, MyClass::getInt1);
compareAndOperate(obj1, obj2, MyClass::getInt2);
compareAndOperate(obj1, obj2, MyClass::getDoubleProp);

为什么这比switch更好？ #

• 编译时安全：如果属性名写错，编译器直接报错，不会等到运行时才发现问题
• 代码简洁：去掉了冗长的switch分支，逻辑更清晰
• 扩展性强：新增属性时，完全不需要修改比较方法，直接传新的属性选择器即可
• 通用性高：通过泛型支持不同类型的属性（int、double、string等只要实现了IComparable/Comparable接口都能用）

如果因为特殊场景必须用字符串参数（比如从配置文件读取要比较的属性名），可以考虑用反射，但反射要注意性能开销，且没有编译时检查，所以优先推荐函数式的实现方式。

内容的提问来源于stack exchange，提问作者Laura Duffy