获取属性名称。 如果属性对应字段，则返回字段名称，否则返回[get 方法名称]|[set 方法名称]
775449
public String getName() {
		if (m_strFieldName != null)
			return m_strFieldName;

		String str;

		if (m_strGetName != null)
			str = m_strGetName + "()|";
		else
			str = "|";

		if (m_strSetName != null)
			return str + m_strSetName;

		return str;
	}
1231190
public String getFullyQualifiedNameForMethodName(String methodName) {
    if (!methodNameToFullyQualifiedName.containsKey(methodName)) {
      return methodName;
    }

    return methodNameToFullyQualifiedName.get(methodName);
  }
1180922
function(name) {
        var list = this.getMethods();
        for (var i in list) {
            if (list[i].getName() === name) {
                return true;
            }
        }
        return false;
    }
1355207
public static String getPropertyName(Method method) {
        String methodName = method.getName();
        final String get = "get";
        final String is = "is";
        if (methodName.startsWith(get)) {
            return decapitalize(methodName.substring(get.length()));
        } else if (methodName.startsWith(is)) {
            return decapitalize(methodName.substring(is.length()));
        } else {
            return null;
        }

    }
1019019
public static Name calledMethodName(JCTree tree) {
        if (tree.hasTag(EXEC)) {
            JCExpressionStatement exec = (JCExpressionStatement)tree;
            if (exec.expr.hasTag(APPLY)) {
                Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);
                return mname;
            }
        }
        return null;
    }
841652
@Override
	public boolean permit(String resourceId, Class c, Object target, String method) {
		if (c.isArray()) {
			// 允许调用，但实际上会在在其后调用中报错。不归此处管理
			return true;
		}
		String name = c.getName();
		String className = null;
		String pkgName = null;
		int i = name.lastIndexOf('.');
		if (i != -1) {
			pkgName = name.substring(0, i);
			className = name.substring(i + 1);

		} else {
			// 无包名，允许调用
			return true;
		}

		if (pkgName.startsWith("java.lang")) {
			if (className.equals("Runtime") || className.equals("Process") || className.equals("ProcessBuilder")
					|| className.equals("System")) {
				return false;
			}
		}

		return true;
	}
1329735
private String getMethodName(Method method) {
        StatName statName = method.getAnnotation(StatName.class);
        return statName == null ? method.getName() : statName.value();
    }
919896
def action_set(method_name):
    

    def action_set(value, context, **_params):
        method = getattr(context["action"], method_name)
        return _set(method, context["key"], value, (), {})

    return action_set
532045
public static boolean isSetterMethod(final Method method) {
        
        final String methodName = method.getName();
        if(!methodName.startsWith("set")) {
            return false;
            
        } else if(methodName.length() <= 3) {
            return false;
        }
        
        if(method.getParameterCount() != 1) {
            return false;
        }
        
        return true;
        
    }
823174
Method getSetter(Method getter) {
        synchronized (setterCache) {
            if ( !setterCache.containsKey(getter) ) {
                String attributeName = null;
                if ( getter.getName().startsWith("get") ) {
                    attributeName = getter.getName().substring("get".length());
                } else if ( getter.getName().startsWith("is") ) {
                    attributeName = getter.getName().substring("is".length());
                } else {
                    // should be impossible to reach this exception
                    throw new RuntimeException("Getter method must start with 'is' or 'get'");
                }
                String setterName = "set" + attributeName;
                Method setter = null;
                try {
                    setter = getter.getDeclaringClass().getMethod(setterName, getter.getReturnType());
                } catch ( NoSuchMethodException e ) {
                    throw new DynamoDBMappingException("Expected a public, one-argument method called " + setterName
                            + " on class " + getter.getDeclaringClass(), e);
                } catch ( SecurityException e ) {
                    throw new DynamoDBMappingException("No access to public, one-argument method called " + setterName
                            + " on class " + getter.getDeclaringClass(), e);
                }
                setterCache.put(getter, setter);
            }
        }
        
        return setterCache.get(getter);
    }
1095283
def method_missing(key_name, *args)
      key_name_str = key_name.to_s()
      if key_name_str =~ /=$/ then
        self[key_name_str.chop()] = args[0]
      else
        return self[key_name_str]
      end
    end
1182856
static boolean isJavaPropertyMethod(final String methodName) {
        return (methodName.length() > PROPERTY_METHOD_PREFIX_LEN
                && (methodName.startsWith("get") || methodName.startsWith(("set"))));
    }
1211595
public static String getTitle(final String namePattern, final String methodName,
                                  final Object instance, final Object... parameters) {
        final String finalPattern = namePattern
                .replaceAll("\\{method}", methodName)
                .replaceAll("\\{this}", String.valueOf(instance));
        final int paramsCount = parameters == null ? 0 : parameters.length;
        final Object[] results = new Object[paramsCount];
        for (int i = 0; i < paramsCount; i++) {
            results[i] = arrayToString(parameters[i]);
        }

        return MessageFormat.format(finalPattern, results);
    }
233078
public static String getPropertyName(MethodNode mNode) {
        String name = mNode.getName();
        if (name.startsWith("set") || name.startsWith("get") || name.startsWith("is")) {
            String pname = decapitalize(name.substring(name.startsWith("is") ? 2 : 3));
            if (!pname.isEmpty()) {
                if (name.startsWith("set")) {
                    if (mNode.getParameters().length == 1) {
                        return pname;
                    }
                } else if (mNode.getParameters().length == 0 && !ClassHelper.VOID_TYPE.equals(mNode.getReturnType())) {
                    if (name.startsWith("get") || ClassHelper.boolean_TYPE.equals(mNode.getReturnType())) {
                        return pname;
                    }
                }
            }
        }
        return null;
    }
89346
private IMethodInfo getSingleMethodWithName( String methodName, IType typeToResolveAgainst, ITypeInfo typeInfo )
  {
    MethodList methods;
    if( typeInfo instanceof IRelativeTypeInfo )
    {
      methods = ((IRelativeTypeInfo)typeInfo).getMethods( typeToResolveAgainst );
    }
    else
    {
      methods = typeInfo.getMethods();
    }

    IMethodInfo match = null;
    for( IMethodInfo possibleMatch : methods )
    {
      if( possibleMatch.getDisplayName().equals( methodName ) )
      {
        if( match != null )
        {
          return null; // more than one, bail
        }
        else
        {
          match = possibleMatch;
        }
      }
    }
    return match;
  }
482389
public static Function<Object,Set<String>> setOfString(final String methodName, final Object... optionalParameters) {
        return methodForSetOfString(methodName, optionalParameters);
    }
1299203
def MethodName(self, name, separator='_'):
        """"""
        if name is None:
            return None
        name = Names.__ToCamel(name, separator=separator)
        return Names.CleanName(name)