MemoryDiagrams-Java.tex

\DocumentMetadata{
  lang=en,
  pdfversion=2.0,
  testphase={phase-III}
}
\documentclass{article}
\usepackage{fullpage}
\usepackage{float}
\usepackage{graphicx}
\setkeys{Gin}{width=\textwidth,keepaspectratio}%,draft}

\usepackage[hidelinks]{hyperref}
\usepackage{bookmark}
\hypersetup{
  pdftitle={Reference Guide for Stack Tracing in Java},
  pdfauthor={},
  pdflang={en},
  pdfdisplaydoctitle=true,
  bookmarksopen=true,
  bookmarksnumbered=true,
}

\begin{document}

\title{Reference Guide for Stack Tracing in Java}
\author{}
\date{2026-03-28}

\maketitle

\section{Basic Java}

\begin{verbatim}
    public static void main(String[] args) {
        int anInt = 10;
        double aDouble = 5.8;
        boolean aBoolean = true;
        String aString = "6.3";
        anInt = 20;
    }
\end{verbatim}

\begin{itemize}
	\item variable changes result in previous values being crossed out and
	new ones written in so that progression can be seen
\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for main: stack frame with local variables anInt, aDouble, aBoolean, 
	and aString. anInt shows reassignment from 10 to 
	20 with the previous value crossed out.}]{1-variables.png}
\end{figure}

\pagebreak


\section{Method calls}

\subsection{Return value}

\begin{verbatim}
	public static double multiplyByTwo(double input) {
	    double x = input * 2;
	    return x;
	}

	public static void main (String[] args) {
	    double x = 7.0;
	    double result = multiplyByTwo(x);
	    result = multiplyByTwo(result);
	    System.out.println(result);
	    int y = 3;
	}
\end{verbatim}

\begin{itemize}
	\item each function call is put in its own stack frame
	\item variables created after the function call appear further down the stack
	\item IO stands for input/output and is where any command line user input or
	outputs in terms of print statements appear
\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for multiplyByTwo and main: separate stack frames for 
	each call. parameters and local variables including x and result. return values flowing back to 
	the caller. references from stack variables to heap as needed. IO area showing println 
	output.}]{functionReturn.png}
\end{figure}

\pagebreak

\subsection{No return value}

\begin{verbatim}
    public static void printValue(int n) {
        int temp = n+2;
        System.out.println("temp == " + temp);
    }

    public static void main (String[] args) {
        printValue(4);
    }
\end{verbatim}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for printValue and main. separate stack frames for each call. 
	local temp computed from the argument. println output in the IO area. no 
	return value passed back to main.}]{2_2-functionNoReturn.png}
\end{figure}

\pagebreak

\section{For loops}

\subsection{Basic}

\begin{verbatim}
	public static void main (String[] args) {
	    int x = 4;
	    for (int i = 1; i < 5; i++) {
	        System.out.println("i == " + i);
	    }
	}
\end{verbatim}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for a basic for loop. main frame with x and loop index i. progression 
	of i across iterations. println output for each i in the IO area.}]{forBasic.png}
\end{figure}

\subsection{Scoped Variable}

\begin{verbatim}
	public static void main (String[] args) {
	    int x = 4;
	    for (int i = 1; i < 5; i++) {
	        int temp = i + 2;
	    }
	}
\end{verbatim}

\begin{itemize}
	\item the dashed lines indicates the variables that are scoped within the loop are crossed out after the loop completes
\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for a for loop with scoped variable temp: temp exists only 
	inside the loop body. dashed or crossed-out notation after the loop ends to show temp is out of scope.}]{forScoped.png}
\end{figure}

\pagebreak


\section{ArrayLists}

\begin{verbatim}
	public static void main (String[] args) {
	    ArrayList<Integer> arr1 = new ArrayList<>();
	    for (int x = 0; x < 4; x++) {
	        arr1.add(x);
	    }
	    System.out.println(arr1);
	    ArrayList<Integer> arr2 = arr1;
	    System.out.println(arr2);
	}
\end{verbatim}

\begin{itemize}
	\item note that the assignment statement for arr2 assigns the memory address
	and does not do a deep copy
	\item memory addresses all start with 0x to indicate that they are
	hexadecimal numbers.
	\begin{itemize}
		\item heap addresses are given 3 digit numbers in the tracing tool
		\item numbers effectively random. The values are not important as long it is consistent across the stack and heap
	\end{itemize}
\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for two ArrayList variables: arr1 on the stack pointing to 
	an ArrayList object on the heap with elements added in the loop, and arr2 assigned from arr1 so 
	both references share the same heap object. addresses labeled consistently on stack and heap.}]{arrayLists.png}
\end{figure}

\pagebreak

\subsection{Passed to functions}

\begin{verbatim}
	public static int sum(ArrayList<Integer> arrIn) {
	    int out = 0;
	    for (int x = 0; x < arrIn.size(); x++) {
	        out += arrIn.get(x);
	    }
	    return out;
	}

	public static void main (String[] args) {
	    ArrayList<Integer> arr1 = new ArrayList<>();
	    for (int x = 0; x < 4; x++) {
	        arr1.add(x);
	    }
	    System.out.println(arr1);
	    ArrayList<Integer> arr2 = arr1;
	    System.out.println(arr2);
	    int total = sum(arr1);
	    System.out.println("total: " + total);
	}
\end{verbatim}

\begin{itemize}
	\item when passing variables to functions as arguments the value on the
	stack associated with the variable name is the argument to the function
	that sets the parameter, even when that value is a reference to an object on the heap

\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for sum and main: main holds arr1 and arr2 
	referencing the same heap ArrayList. sum frame with parameter arrIn referencing that 
	same ArrayList. loop index and accumulator out while summing via get. return value 
	total on the stack.}]{arrayListsFunc.png}
\end{figure}

\pagebreak


\section{HashMaps}

\begin{verbatim}
    public static void main(String[] args) {
        HashMap<String, Integer> bills = new HashMap<>();
        bills.put("Allen", 17);
        bills.put("Knox", 88);
        for (String key : bills.keySet()) {
            System.out.println(key);
        }
    }
\end{verbatim}

\begin{itemize}
	\item HashMaps are like dictionaries in python
	\item we loop through them in a manner more similar to loops in python
	\item note that the loop still has scoped variables like the previous for loop
\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for a HashMap bills: map object on the heap with 
	string keys and integer values. main frame. for-each over keySet with a scoped loop variable. 
	println keys in the IO area.}]{5-hashMaps.png}
\end{figure}

\pagebreak


\section{Recursion}

\subsection{Standard Recursion}

\begin{verbatim}
	public static int computeGeometricSum(int n) {
	    if (n > 0) {
	        int result = computeGeometricSum(n - 1);
	        result += n;
	        return result;
	    } else {
	        return 0;
	    }
	}

	public static void main (String[] args) {
	    int result = computeGeometricSum(3);
	}
\end{verbatim}

\begin{itemize}
	\item each new call of computeGeometricSum is performed in a new color
	\begin{itemize}
		\item returned values are kept in the color of the method that returns it
	\end{itemize}
\end{itemize}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for standard recursion computeGeometricSum: 
	stack frames for each recursive call. local result 
	and return arrows showing values passed back. base case at n equals 0.}]{recursionStandard.png}
\end{figure}

\pagebreak

\subsection{Tail Recursion}

\begin{verbatim}
	public static int computeGeometricSumTail(int n, int total) {
	    if (n > 0) {
	        return computeGeometricSumTail(n - 1, total + n);
	    } else {
	        return total;
	    }
	}

	public static int cGSTHelper(int n) {
	    return computeGeometricSumTail(n, 0);
	}

	public static void main (String[] args) {
	    int result = cGSTHelper(3);
	}
\end{verbatim}

\begin{itemize}
	\item Note that all the return arrows point to the original return variable when using tail recursion. It is also acceptable to omit 
	the return arrows entirely since the recursive calls do not return direectly to a variable
\end{itemize}

\textit{(Solution on next page)}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for tail recursion computeGeometricSumTail and helper: 
	 frames with n and total. return arrows pointing through the chain to the original 
	caller result variable rather than to intermediate locals.}]{recursionTail.png}
\end{figure}

\pagebreak


\section{Classes}

\begin{verbatim}
public class Player {
    private double xLoc;
    private double yLoc;
    private int maxHP;
    private int HP;
    private int damageDealt;

    public Player(double xLoc, double yLoc, int maxHP) {
        this.xLoc = xLoc;
        this.yLoc = yLoc;
        this.maxHP = maxHP;
        this.HP = maxHP;
        this.damageDealt = 4;
    }
    public int getHP() {
        return this.HP;
    }
    public void takeDamage(int damage) {
        this.HP -= damage;
    }
    public void attack(Player otherPlayer) {
        otherPlayer.takeDamage(this.damageDealt);
    }
    public void move(double dx, double dy) {
        this.xLoc += dx;
        this.yLoc += dy;
    }

    public static void main(String[] args) {
        Player player1 = new Player(0.0, 0.0, 10);
        Player player2 = new Player(7.0, -4.0, 10);
        player2.move(-6.5, 3.4);
        player2.attack(player1);
    }
}
\end{verbatim}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for Player objects: two Player instances on the heap with 
	fields xLoc, yLoc, maxHP, HP, and damageDealt. main with player1 and player2 references. effects 
	of move and attack on instance variables.}]{7-classes.png}
\end{figure}

\pagebreak


\section{Inheritance}

\begin{verbatim}
public class GameItem {
    private double xLoc;
    private double yLoc;

    public GameItem(double xLoc, double yLoc) {
        this.xLoc = xLoc;
        this.yLoc = yLoc;
    }
    public void move(double dx, double dy) {
        this.xLoc += dx;
        this.yLoc += dy;
    }
}

public class Teleporter extends GameItem {
    private double dx;
    private double dy;

    public Teleporter(double xLoc, double yLoc, double dx, double dy) {
        super(xLoc, yLoc);
        this.dx = dx;
        this.dy = dy;
    }

    public static void main(String[] args) {
        Teleporter t = new Teleporter(2, 2, 3, 3);
        t.move(2, 3);
    }
}
\end{verbatim}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for GameItem and Teleporter: Teleporter object on the heap 
	with subclass fields dx and dy plus inherited xLoc and yLoc. constructor calling super constructor. stack 
	frame for main and reference t. move updating locations.}]{8-inheritance.png}
\end{figure}

\pagebreak


\section{Polymorphism}

\begin{verbatim}
public class A {
    protected int a;

    public A(int a) {
        this.a = a;
    }
}

public class B extends A{
    private int b;

    public B(int b) {
        super(b);
        this.b = b*2;
    }
}

public class C extends A{
    private int c;

    public C(int a, int c) {
        super(a);
        this.c = c;
    }
}

public class RunABC {
    public static void main(String[] args) {
        A a = new A(1);
        A b = new B(2);
        A c = new C(3, 4);
    }
}
\end{verbatim}

\begin{figure}[H]
	\centering
	\includegraphics[alt={Memory diagram for polymorphism with classes A, B, and C: variables 
	of type A in main holding references to an A instance, a B instance, and a C instance on 
	the heap. each object shows its actual instance variables including a, b, or c.}]{9-polymorphism.png}
\end{figure}

\end{document}