// 启用DataBinding的build.gradle配置
android {...dataBinding {enabled = true}
}

<!-- 简单的数据绑定表达式示例 -->
<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getName()}" /> <!-- 方法调用 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{String.valueOf(user.getAge())}" /> <!-- 静态方法调用 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getFullName(`Mr.`)}" /> <!-- 带参数的方法调用 -->

<!-- 实例方法调用示例 -->
<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getName()}" /> <!-- 调用无参数方法 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getFormattedAge()}" /> <!-- 调用返回格式化字符串的方法 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getGreeting(context)}" /> <!-- 调用带参数的方法 -->

<!-- 静态方法调用示例 -->
<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{StringUtils.capitalize(user.name)}" /> <!-- 调用静态工具方法 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{NumberFormat.getCurrencyInstance().format(product.price)}" /> <!-- 调用静态工厂方法 -->

<!-- 带参数的方法调用示例 -->
<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getFullName(`Mr.`)}" /> <!-- 传递字符串字面量 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getScoreDescription(scores)}" /> <!-- 传递变量 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getDiscountPrice(product.originalPrice, product.discountRate)}" /> <!-- 传递表达式 -->

<!-- 方法引用示例 -->
<Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Submit"android:onClick="@{() -> viewModel.submitForm()}" /> <!-- 无参数方法引用 --><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Delete"android:onClick="@{(view) -> viewModel.deleteItem(item)}" /> <!-- 带参数方法引用 -->

// 表达式解析器的简化实现
public class ExpressionParser {// 解析方法调用表达式public MethodCallExpression parseMethodCall(String expression) {// 移除首尾空格expression = expression.trim();// 检查是否是方法调用if (!expression.contains("(") || !expression.endsWith(")")) {throw new IllegalArgumentException("Not a method call expression: " + expression);}// 分割方法名和参数int openParenIndex = expression.indexOf("(");String methodName = expression.substring(0, openParenIndex);String argumentsString = expression.substring(openParenIndex + 1, expression.length() - 1);// 创建方法调用表达式对象MethodCallExpression methodCall = new MethodCallExpression();methodCall.setMethodName(methodName);// 解析参数List<Expression> arguments = parseArguments(argumentsString);methodCall.setArguments(arguments);return methodCall;}// 解析方法参数private List<Expression> parseArguments(String argumentsString) {List<Expression> arguments = new ArrayList<>();// 处理空参数if (argumentsString.trim().isEmpty()) {return arguments;}// 分割参数String[] args = splitArguments(argumentsString);// 解析每个参数for (String arg : args) {Expression argument = parseArgument(arg);arguments.add(argument);}return arguments;}// 分割参数（考虑逗号可能出现在字符串字面量或表达式中的情况）private String[] splitArguments(String argumentsString) {List<String> args = new ArrayList<>();StringBuilder currentArg = new StringBuilder();int parenCount = 0;int quoteCount = 0;for (char c : argumentsString.toCharArray()) {if (c == '(') {parenCount++;} else if (c == ')') {parenCount--;} else if (c == '"') {quoteCount = (quoteCount + 1) % 2;} else if (c == ',' && parenCount == 0 && quoteCount == 0) {args.add(currentArg.toString().trim());currentArg.setLength(0);continue;}currentArg.append(c);}if (currentArg.length() > 0) {args.add(currentArg.toString().trim());}return args.toArray(new String[0]);}// 解析单个参数private Expression parseArgument(String arg) {// 简化实现：在实际代码中，这里会进行更复杂的表达式解析if (arg.startsWith("`") && arg.endsWith("`")) {// 字符串字面量StringLiteralExpression literal = new StringLiteralExpression();literal.setValue(arg.substring(1, arg.length() - 1));return literal;} else if (arg.matches("\\d+(\\.\\d+)?")) {// 数值字面量NumericLiteralExpression literal = new NumericLiteralExpression();if (arg.contains(".")) {literal.setValue(Double.parseDouble(arg));literal.setType(DataType.DOUBLE);} else {literal.setValue(Integer.parseInt(arg));literal.setType(DataType.INT);}return literal;} else if (arg.equals("true") || arg.equals("false")) {// 布尔字面量BooleanLiteralExpression literal = new BooleanLiteralExpression();literal.setValue(Boolean.parseBoolean(arg));return literal;} else if (arg.contains(".")) {// 可能是变量引用或方法调用if (arg.contains("(") && arg.endsWith(")")) {// 嵌套方法调用return parseMethodCall(arg);} else {// 变量引用VariableReferenceExpression varRef = new VariableReferenceExpression();varRef.setVariableName(arg);return varRef;}} else {// 简单变量引用VariableReferenceExpression varRef = new VariableReferenceExpression();varRef.setVariableName(arg);return varRef;}}
}

// 方法签名解析器的简化实现
public class MethodSignatureParser {// 解析方法签名public MethodSignature parseSignature(Class<?> targetClass, String methodName, List<Expression> arguments) {// 获取目标类的所有方法Method[] methods = targetClass.getMethods();// 查找匹配的方法for (Method method : methods) {if (method.getName().equals(methodName)) {// 检查参数数量是否匹配if (method.getParameterCount() == arguments.size()) {// 检查参数类型是否兼容if (areArgumentsCompatible(method.getParameterTypes(), arguments)) {MethodSignature signature = new MethodSignature();signature.setMethod(method);signature.setParameterTypes(method.getParameterTypes());return signature;}}}}// 如果没有找到匹配的方法，抛出异常throw new NoSuchMethodException("Method " + methodName + " not found in class " + targetClass.getName());}// 检查参数是否兼容private boolean areArgumentsCompatible(Class<?>[] parameterTypes, List<Expression> arguments) {if (parameterTypes.length != arguments.size()) {return false;}for (int i = 0; i < parameterTypes.length; i++) {Class<?> paramType = parameterTypes[i];Expression argument = arguments.get(i);// 简化实现：在实际代码中，这里会进行更复杂的类型兼容性检查if (!isExpressionCompatibleWithType(argument, paramType)) {return false;}}return true;}// 检查表达式是否与类型兼容private boolean isExpressionCompatibleWithType(Expression expression, Class<?> targetType) {if (expression instanceof StringLiteralExpression) {return targetType == String.class;} else if (expression instanceof NumericLiteralExpression) {NumericLiteralExpression numericExpr = (NumericLiteralExpression) expression;if (targetType == int.class || targetType == Integer.class) {return numericExpr.getType() == DataType.INT;} else if (targetType == double.class || targetType == Double.class) {return numericExpr.getType() == DataType.DOUBLE;}} else if (expression instanceof BooleanLiteralExpression) {return targetType == boolean.class || targetType == Boolean.class;} else if (expression instanceof VariableReferenceExpression) {// 简化实现：在实际代码中，这里会查找变量的实际类型return true;} else if (expression instanceof MethodCallExpression) {// 简化实现：在实际代码中，这里会检查方法返回类型return true;}return false;}
}

// 生成的ActivityMainBinding类示例
public class ActivityMainBinding extends ViewDataBinding {@NonNullprivate final LinearLayout rootView;@NonNullpublic final TextView textViewName;@NonNullpublic final TextView textViewAge;@Nullableprivate User mUser;  // 数据源对象// 构造方法public ActivityMainBinding(@NonNull View root) {super(root);this.rootView = (LinearLayout) root;this.textViewName = findViewById(root, R.id.textViewName);this.textViewAge = findViewById(root, R.id.textViewAge);}// 设置User对象public void setUser(@Nullable User user) {mUser = user;invalidateAll();  // 标记所有绑定需要重新计算}// 获取User对象@Nullablepublic User getUser() {return mUser;}// 执行绑定操作@Overrideprotected void executeBindings() {User userValue = mUser;String nameValue = null;String formattedAge = null;if (userValue != null) {// 调用实例方法nameValue = userValue.getName();// 调用带参数的实例方法formattedAge = userValue.getFormattedAge("Years old: ");}// 更新视图textViewName.setText(nameValue);textViewAge.setText(formattedAge);}
}

// 方法调用器的简化实现
public class MethodInvoker {// 调用方法public Object invokeMethod(Object target, Method method, List<Object> arguments) {try {// 设置方法可访问（如果是私有方法）if (!method.isAccessible()) {method.setAccessible(true);}// 调用方法return method.invoke(target, arguments.toArray());} catch (IllegalAccessException e) {throw new RuntimeException("Failed to access method: " + method.getName(), e);} catch (InvocationTargetException e) {throw new RuntimeException("Method invocation failed: " + method.getName(), e.getCause());}}// 计算方法参数值public List<Object> evaluateArguments(List<Expression> argumentExpressions, BindingContext context) {List<Object> argumentValues = new ArrayList<>();for (Expression expression : argumentExpressions) {// 计算表达式值Object value = evaluateExpression(expression, context);argumentValues.add(value);}return argumentValues;}// 计算表达式值private Object evaluateExpression(Expression expression, BindingContext context) {if (expression instanceof StringLiteralExpression) {return ((StringLiteralExpression) expression).getValue();} else if (expression instanceof NumericLiteralExpression) {return ((NumericLiteralExpression) expression).getValue();} else if (expression instanceof BooleanLiteralExpression) {return ((BooleanLiteralExpression) expression).getValue();} else if (expression instanceof VariableReferenceExpression) {String variableName = ((VariableReferenceExpression) expression).getVariableName();return context.getVariable(variableName);} else if (expression instanceof MethodCallExpression) {// 递归调用方法return evaluateMethodCall((MethodCallExpression) expression, context);}return null;}// 计算方法调用表达式private Object evaluateMethodCall(MethodCallExpression methodCall, BindingContext context) {String methodName = methodCall.getMethodName();List<Expression> arguments = methodCall.getArguments();// 获取目标对象Object target = context.getVariable(methodCall.getTargetVariableName());if (target == null) {return null;}// 解析方法签名MethodSignatureParser signatureParser = new MethodSignatureParser();MethodSignature signature = signatureParser.parseSignature(target.getClass(), methodName, arguments);// 计算参数值List<Object> argumentValues = evaluateArguments(arguments, context);// 调用方法MethodInvoker invoker = new MethodInvoker();return invoker.invokeMethod(target, signature.getMethod(), argumentValues);}
}

// 空值安全处理的简化实现
public class NullSafeMethodInvoker {// 安全地调用方法，处理空值情况public Object safelyInvokeMethod(Object target, Method method, List<Object> arguments) {// 检查目标对象是否为空if (target == null) {return null;}// 检查参数是否有空值（如果方法参数不允许空值）Class<?>[] parameterTypes = method.getParameterTypes();for (int i = 0; i < arguments.size(); i++) {Object argument = arguments.get(i);if (argument == null && !isPrimitive(parameterTypes[i])) {// 参数为空，但方法参数类型是非基本类型，允许空值continue;}if (argument == null && isPrimitive(parameterTypes[i])) {// 参数为空，但方法参数类型是基本类型，抛出异常或返回默认值return getDefaultReturnValue(method.getReturnType());}}// 调用方法MethodInvoker invoker = new MethodInvoker();return invoker.invokeMethod(target, method, arguments);}// 判断是否是基本类型private boolean isPrimitive(Class<?> type) {return type.isPrimitive();}// 获取方法返回类型的默认值private Object getDefaultReturnValue(Class<?> returnType) {if (returnType == void.class) {return null;} else if (returnType == boolean.class) {return false;} else if (returnType == int.class) {return 0;} else if (returnType == long.class) {return 0L;} else if (returnType == float.class) {return 0.0f;} else if (returnType == double.class) {return 0.0;} else if (returnType == char.class) {return '\0';} else if (returnType == short.class) {return (short) 0;} else if (returnType == byte.class) {return (byte) 0;} else {return null;}}
}

<!-- 静态方法调用示例 -->
<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{StringUtils.capitalize(user.name)}" /> <!-- 调用静态工具方法 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{DateUtils.formatDate(user.birthday)}" /> <!-- 调用静态日期格式化方法 -->

// 静态方法调用处理的简化实现
public class StaticMethodCallProcessor {// 处理静态方法调用public StaticMethodCallExpression processStaticMethodCall(String expression) {// 检查是否是静态方法调用if (!expression.contains(".") || !expression.contains("(") || !expression.endsWith(")")) {throw new IllegalArgumentException("Not a static method call expression: " + expression);}// 分割类名和方法名int lastDotIndex = expression.lastIndexOf(".");String className = expression.substring(0, lastDotIndex);String methodPart = expression.substring(lastDotIndex + 1);// 分割方法名和参数int openParenIndex = methodPart.indexOf("(");String methodName = methodPart.substring(0, openParenIndex);String argumentsString = methodPart.substring(openParenIndex + 1, methodPart.length() - 1);// 创建静态方法调用表达式对象StaticMethodCallExpression staticCall = new StaticMethodCallExpression();staticCall.setClassName(className);staticCall.setMethodName(methodName);// 解析参数ExpressionParser parser = new ExpressionParser();List<Expression> arguments = parser.parseArguments(argumentsString);staticCall.setArguments(arguments);return staticCall;}// 验证静态方法是否存在public void validateStaticMethod(String className, String methodName, List<Expression> arguments) {try {// 加载类Class<?> clazz = Class.forName(className);// 查找静态方法Method[] methods = clazz.getMethods();for (Method method : methods) {if (Modifier.isStatic(method.getModifiers()) && method.getName().equals(methodName) && method.getParameterCount() == arguments.size()) {// 找到匹配的静态方法return;}}throw new NoSuchMethodException("Static method " + methodName + " not found in class " + className);} catch (ClassNotFoundException e) {throw new RuntimeException("Class not found: " + className, e);} catch (NoSuchMethodException e) {throw new RuntimeException(e);}}
}

// 静态方法调用器的简化实现
public class StaticMethodInvoker {// 调用静态方法public Object invokeStaticMethod(String className, String methodName, List<Object> arguments) {try {// 加载类Class<?> clazz = Class.forName(className);// 查找静态方法Method method = findStaticMethod(clazz, methodName, arguments);// 设置方法可访问if (!method.isAccessible()) {method.setAccessible(true);}// 调用静态方法（第一个参数为null，表示没有实例）return method.invoke(null, arguments.toArray());} catch (ClassNotFoundException e) {throw new RuntimeException("Class not found: " + className, e);} catch (NoSuchMethodException e) {throw new RuntimeException("Static method not found: " + methodName, e);} catch (IllegalAccessException e) {throw new RuntimeException("Failed to access static method: " + methodName, e);} catch (InvocationTargetException e) {throw new RuntimeException("Static method invocation failed: " + methodName, e.getCause());}}// 查找静态方法private Method findStaticMethod(Class<?> clazz, String methodName, List<Object> arguments) throws NoSuchMethodException {// 获取所有公共方法Method[] methods = clazz.getMethods();// 查找匹配的静态方法for (Method method : methods) {if (Modifier.isStatic(method.getModifiers()) && method.getName().equals(methodName) && method.getParameterCount() == arguments.size()) {// 检查参数类型兼容性if (areArgumentsCompatible(method.getParameterTypes(), arguments)) {return method;}}}throw new NoSuchMethodException("Static method " + methodName + " with matching parameters not found in class " + clazz.getName());}// 检查参数是否兼容private boolean areArgumentsCompatible(Class<?>[] parameterTypes, List<Object> arguments) {if (parameterTypes.length != arguments.size()) {return false;}for (int i = 0; i < parameterTypes.length; i++) {Class<?> paramType = parameterTypes[i];Object argument = arguments.get(i);// 检查参数是否为nullif (argument == null) {// 基本类型不能为nullif (paramType.isPrimitive()) {return false;}continue;}// 检查参数类型是否兼容if (!paramType.isAssignableFrom(argument.getClass())) {// 尝试基本类型装箱/拆箱if (paramType == int.class && argument instanceof Integer) {continue;} else if (paramType == long.class && argument instanceof Long) {continue;} else if (paramType == double.class && argument instanceof Double) {continue;} else if (paramType == float.class && argument instanceof Float) {continue;} else if (paramType == boolean.class && argument instanceof Boolean) {continue;} else if (paramType == char.class && argument instanceof Character) {continue;} else if (paramType == short.class && argument instanceof Short) {continue;} else if (paramType == byte.class && argument instanceof Byte) {continue;}return false;}}return true;}
}

<!-- 带参数的方法调用示例 -->
<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getFullName(`Mr.`)}" /> <!-- 传递字符串字面量 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getScorePercentage(totalScores)}" /> <!-- 传递变量 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getDiscountPrice(product.price, product.discount)}" /> <!-- 传递表达式 -->

// 参数类型转换器的简化实现
public class ParameterTypeConverter {// 转换参数类型public Object convertParameter(Object value, Class<?> targetType) {if (value == null) {return null;}// 如果类型已经匹配，直接返回if (targetType.isAssignableFrom(value.getClass())) {return value;}// 基本类型和包装类型的转换if (targetType == int.class || targetType == Integer.class) {if (value instanceof String) {return Integer.parseInt((String) value);} else if (value instanceof Double) {return ((Double) value).intValue();}} else if (targetType == double.class || targetType == Double.class) {if (value instanceof String) {return Double.parseDouble((String) value);} else if (value instanceof Integer) {return ((Integer) value).doubleValue();}} else if (targetType == String.class) {return String.valueOf(value);}// 其他类型转换...throw new IllegalArgumentException("Cannot convert " + value.getClass().getName() + " to " + targetType.getName());}// 转换所有参数public List<Object> convertParameters(List<Object> values, Class<?>[] targetTypes) {List<Object> convertedValues = new ArrayList<>(values.size());for (int i = 0; i < values.size(); i++) {Object value = values.get(i);Class<?> targetType = targetTypes[i];// 转换参数类型Object convertedValue = convertParameter(value, targetType);convertedValues.add(convertedValue);}return convertedValues;}
}

// 参数验证器的简化实现
public class ParameterValidator {// 验证方法参数public void validateParameters(Method method, List<Expression> arguments) {// 获取方法参数类型Class<?>[] parameterTypes = method.getParameterTypes();// 验证参数数量if (arguments.size() != parameterTypes.length) {throw new IllegalArgumentException("Method " + method.getName() + " requires " + parameterTypes.length + " parameters, but " + arguments.size() + " were provided.");}// 验证每个参数for (int i = 0; i < arguments.size(); i++) {Expression argument = arguments.get(i);Class<?> parameterType = parameterTypes[i];// 简化实现：在实际代码中，这里会进行更复杂的类型验证if (!isArgumentCompatible(argument, parameterType)) {throw new IllegalArgumentException("Argument " + i + " of type " + getExpressionType(argument) + " is not compatible with parameter type " + parameterType.getName() + " in method " + method.getName());}}}// 检查参数是否兼容private boolean isArgumentCompatible(Expression argument, Class<?> parameterType) {if (argument instanceof StringLiteralExpression) {return parameterType == String.class;} else if (argument instanceof NumericLiteralExpression) {NumericLiteralExpression numericExpr = (NumericLiteralExpression) argument;if (parameterType == int.class || parameterType == Integer.class) {return numericExpr.getType() == DataType.INT;} else if (parameterType == double.class || parameterType == Double.class) {return numericExpr.getType() == DataType.DOUBLE;}} else if (argument instanceof BooleanLiteralExpression) {return parameterType == boolean.class || parameterType == Boolean.class;} else if (argument instanceof VariableReferenceExpression) {// 简化实现：在实际代码中，这里会查找变量的实际类型return true;} else if (argument instanceof MethodCallExpression) {// 简化实现：在实际代码中，这里会检查方法返回类型return true;}return false;}// 获取表达式类型private String getExpressionType(Expression expression) {if (expression instanceof StringLiteralExpression) {return "String";} else if (expression instanceof NumericLiteralExpression) {NumericLiteralExpression numericExpr = (NumericLiteralExpression) expression;return numericExpr.getType() == DataType.INT ? "int" : "double";} else if (expression instanceof BooleanLiteralExpression) {return "boolean";} else if (expression instanceof VariableReferenceExpression) {return "variable";} else if (expression instanceof MethodCallExpression) {return "method call";}return "unknown";}
}

<!-- 方法引用示例 -->
<Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Submit"android:onClick="@{() -> viewModel.submitForm()}" /> <!-- 无参数方法引用 --><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Delete"android:onClick="@{(view) -> viewModel.deleteItem(item)}" /> <!-- 带参数方法引用 --><EditTextandroid:layout_width="match_parent"android:layout_height="wrap_content"android:onTextChanged="@{(text, start, before, count) -> viewModel.onTextChanged(text)}" /> <!-- 多参数方法引用 -->

// 方法引用处理器的简化实现
public class MethodReferenceProcessor {// 处理方法引用表达式public MethodReferenceExpression processMethodReference(String expression) {// 检查是否是方法引用if (!expression.contains("->")) {throw new IllegalArgumentException("Not a method reference expression: " + expression);}// 分割参数列表和方法体String[] parts = expression.split("->", 2);String parametersPart = parts[0].trim();String methodCallPart = parts[1].trim();// 创建方法引用表达式对象MethodReferenceExpression methodRef = new MethodReferenceExpression();// 解析参数List<Parameter> parameters = parseParameters(parametersPart);methodRef.setParameters(parameters);// 解析方法调用ExpressionParser parser = new ExpressionParser();Expression methodCall = parser.parseExpression(methodCallPart);methodRef.setMethodCall(methodCall);return methodRef;}// 解析参数列表private List<Parameter> parseParameters(String parametersPart) {List<Parameter> parameters = new ArrayList<>();// 移除括号if (parametersPart.startsWith("(") && parametersPart.endsWith(")")) {parametersPart = parametersPart.substring(1, parametersPart.length() - 1);}// 处理空参数if (parametersPart.trim().isEmpty()) {return parameters;}// 分割参数String[] paramStrings = parametersPart.split(",");// 创建参数对象for (String paramString : paramStrings) {paramString = paramString.trim();// 简化实现：在实际代码中，这里会解析参数类型和名称Parameter parameter = new Parameter();parameter.setName(paramString);// 默认使用Object类型parameter.setType(Object.class);parameters.add(parameter);}return parameters;}
}

// 方法引用调用器的简化实现
public class MethodReferenceInvoker {// 调用方法引用public Object invokeMethodReference(MethodReferenceExpression methodRef, BindingContext context, Object... args) {// 获取方法调用表达式Expression methodCall = methodRef.getMethodCall();// 设置参数到上下文中List<Parameter> parameters = methodRef.getParameters();if (parameters.size() != args.length) {throw new IllegalArgumentException("Method reference expects " + parameters.size() + " parameters, but " + args.length + " were provided.");}for (int i = 0; i < parameters.size(); i++) {Parameter parameter = parameters.get(i);context.setVariable(parameter.getName(), args[i]);}// 计算方法调用表达式ExpressionEvaluator evaluator = new ExpressionEvaluator();return evaluator.evaluateExpression(methodCall, context);}
}

// 可观察的数据类
public class User extends BaseObservable {private String name;private int age;@Bindablepublic String getName() {return name;}public void setName(String name) {this.name = name;notifyPropertyChanged(BR.name);  // 通知属性变化}@Bindablepublic int getAge() {return age;}public void setAge(int age) {this.age = age;notifyPropertyChanged(BR.age);  // 通知属性变化}// 可在绑定表达式中调用的方法public String getFormattedAge(String prefix) {return prefix + age;}
}

<!-- 布局文件 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"><data><variablename="user"type="com.example.User" /></data><LinearLayoutandroid:layout_width="match_parent"android:layout_height="match_parent"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.getFormattedAge(`Age: `)}" /></LinearLayout>
</layout>

// ViewModel类
public class UserViewModel extends ViewModel {private MutableLiveData<User> userLiveData = new MutableLiveData<>();public UserViewModel() {// 初始化用户数据User user = new User("John Doe", 30);userLiveData.setValue(user);}// 获取用户LiveDatapublic LiveData<User> getUser() {return userLiveData;}// 更新用户年龄的方法public void incrementAge() {User user = userLiveData.getValue();if (user != null) {user.setAge(user.getAge() + 1);userLiveData.setValue(user);}}
}

<!-- 布局文件 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"><data><variablename="viewModel"type="com.example.UserViewModel" /></data><LinearLayoutandroid:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{viewModel.user.getFormattedAge(`Age: `)}" /><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Increment Age"android:onClick="@{() -> viewModel.incrementAge()}" /></LinearLayout>
</layout>

// 自定义BindingAdapter
public class CustomBindingAdapters {// 设置文本并添加前缀@BindingAdapter("app:setTextWithPrefix")public static void setTextWithPrefix(TextView view, String text) {view.setText("Prefix: " + text);}// 基于分数设置文本颜色@BindingAdapter("app:setScoreColor")public static void setScoreColor(TextView view, int score) {if (score >= 90) {view.setTextColor(Color.GREEN);} else if (score >= 60) {view.setTextColor(Color.YELLOW);} else {view.setTextColor(Color.RED);}}
}

<!-- 布局文件 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"><data><variablename="user"type="com.example.User" /></data><LinearLayoutandroid:layout_width="match_parent"android:layout_height="match_parent"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"app:setTextWithPrefix="@{user.getName()}" /><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{String.valueOf(user.getScore())}"app:setScoreColor="@{user.getScore()}" /></LinearLayout>
</layout>

// 方法引用缓存器的简化实现
public class MethodReferenceCache {private Map<String, Method> methodCache = new HashMap<>();// 获取缓存的方法public Method getCachedMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {String key = clazz.getName() + "." + methodName + "(" + getParameterTypesString(parameterTypes) + ")";// 检查缓存if (methodCache.containsKey(key)) {return methodCache.get(key);}// 查找方法try {Method method = clazz.getMethod(methodName, parameterTypes);// 缓存方法methodCache.put(key, method);return method;} catch (NoSuchMethodException e) {throw new RuntimeException("Method not found: " + methodName, e);}}// 获取参数类型字符串private String getParameterTypesString(Class<?>[] parameterTypes) {StringBuilder sb = new StringBuilder();for (int i = 0; i < parameterTypes.length; i++) {if (i > 0) {sb.append(",");}sb.append(parameterTypes[i].getName());}return sb.toString();}
}

<!-- 避免复杂表达式 -->
<TextViewandroid:text="@{calculateDiscountPrice(product.originalPrice, product.discountRate, product.taxRate)}" /><!-- 更好的做法：在ViewModel中处理逻辑 -->
<TextViewandroid:text="@{viewModel.getFinalPrice()}" />

// 避免基本类型装箱
public void setScore(int score) {  // 优先使用基本类型this.score = score;
}// 而不是
public void setScore(Integer score) {  // 避免包装类型this.score = score;
}

// 方法查找失败的处理
try {Method method = targetClass.getMethod(methodName, parameterTypes);
} catch (NoSuchMethodException e) {// 处理方法不存在的情况Log.e(TAG, "Method not found: " + methodName, e);// 可以提供默认值或执行其他操作
}

<!-- 使用安全调用操作符 -->
<TextViewandroid:text="@{user?.getName() ?: `Unknown`}" />

// 方法重载解析器的简化实现
public class MethodOverloadResolver {// 解析最合适的重载方法public Method resolveOverload(Class<?> targetClass, String methodName, List<Object> arguments) {// 获取所有同名方法Method[] methods = targetClass.getMethods();List<Method> matchingMethods = new ArrayList<>();// 找出参数数量匹配的方法for (Method method : methods) {if (method.getName().equals(methodName) && method.getParameterCount() == arguments.size()) {matchingMethods.add(method);}}// 如果没有找到匹配的方法，抛出异常if (matchingMethods.isEmpty()) {throw new NoSuchMethodException("No method found with name " + methodName + " and " + arguments.size() + " parameters");}// 如果只有一个匹配的方法，直接返回if (matchingMethods.size() == 1) {return matchingMethods.get(0);}// 多个匹配方法，选择最适合的return findBestMatchingMethod(matchingMethods, arguments);}// 找到最匹配的方法private Method findBestMatchingMethod(List<Method> methods, List<Object> arguments) {// 简化实现：在实际代码中，这里会进行更复杂的类型匹配// 例如，选择参数类型最具体的方法// 简单返回第一个方法return methods.get(0);}
}