Java - and is the code to examine the source code of custom user defined methods (see the code from within the program)

Looking for the way to accomplish showing the code for custom methods created by the user within a java program. I want to view the code for specifically named custom java methods. I am not looking for the way to view the code for those standard methods built into java.

In R, it's easy to see the code for either the user created functions, or view the code for many of the built-in functions. Just enter the name of the function without trailing parenthesis. For example, a portion of the code that is displayed from the function data.frame is shown below. It seems reasonable there should be a similar feature in java.

data.frame

function (..., row.names = NULL, check.rows = FALSE, check.names = TRUE, 
    fix.empty.names = TRUE, stringsAsFactors = default.stringsAsFactors()) 
{
    data.row.names <- if (check.rows && is.null(row.names)) 
        function(current, new, i) {
            if (is.character(current)) 
                new <- as.character(new)
            if (is.character(new)) 
                current <- as.character(current)
            if (anyDuplicated(new)) 
                return(current)
            if (is.null(current)) 
                return(new)
            if (all(current == new) || all(current == "")) 
                return(new)
            stop(gettextf("mismatch of row names in arguments of 'data.frame', item %d", 
                i), domain = NA)
        }
    else function(current, new, i) {
        if (is.null(current)) {
            if (anyDuplicated(new)) {
                warning(gettextf("some row.names duplicated: %s --> row.names NOT used", 
                  paste(which(duplicated(new)), collapse = ",")), 
                  domain = NA)
                current
            }
            else new
        }
        else current
    }
    object <- as.list(substitute(list(...)))[-1L]
    mirn <- missing(row.names)
    mrn <- is.null(row.names)
    x <- list(...)
    n <- length(x)
    if (n < 1L) {
        if (!mrn) {
            if (is.object(row.names) || !is.integer(row.names)) 
                row.names <- as.character(row.names)
            if (anyNA(row.names)) 
                stop("row names contain missing values")
            if (anyDuplicated(row.names)) 
                stop(gettextf("duplicate row.names: %s", paste(unique(row.names[duplicated(row.names)]), 
                  collapse = ", ")), domain = NA)
        }
        else row.names <- integer()
        return(structure(list(), names = character(), row.names = row.names, 
            class = "data.frame"))
    }
    vnames <- names(x) 

	 etc ...................

You can see functions made by other in Java too, but you have to do it through the source code. If you have an IDE, you should have a "show declaration" features. For example, in IntelliJ, simply ctrl-leftclick on a method call will show you what code is executed.

The feature you see here in R or for example Python is more often seen in langage that can be interpreted. With Jshell, which is the REPL of Java, you can have glimpse of java doc from the REPL directly, see https://cr.openjdk.java.net/~rfield/tutorial/JShellTutorial.html#tab-completion----snippets