Metodos da apostila, nao estou conseguindo entender

package br.com.caelum.ed;

public class Vetor {
	// declarando e inicializando um array de aluno com capacidade 100
	/**
	 * Se amanhã ou depois precisarmos de uma Lista de carro ou uma Lista de
	 * computador teríamos que implementar novamente o Vetor. Em vez de
	 * colocarmos um array de Aluno na classe Vetor vamos colocar um array de
	 * Object. Assim, estamos generalizando a nossa estrutura de dados. Desta
	 * forma, poderemos armazenar qualquer tipo de objeto.
	 */

	private Object[] objetos = new Object[100];

	private int TotalDeObjetos = 0;// atributo para guardar a quantidade de

	// alunos existentes na lista

	/**
	 * 
	 * @param aluno
	 */
	public void adiciona(Object objeto) {
		this.garantaEspaço();// verifica antes se tem espaço para adicionar
		// aluno
		this.objetos[TotalDeObjetos] = objeto;
		this.TotalDeObjetos++;
		
		// implementação que leva mais tempo
		/*
		 * for (int i = 0; i < this.alunos.length; i++) { if (this.alunos[i] ==
		 * null) {// achando o primeiro valor null // guarda o alunonessa
		 * referencia. this.alunos[i] = aluno;// achando o valor null entao
		 * guarda o // aluno. break;// para o laço for quando for encontrado } }
		 */

	}

	/**
	 * esse metodo tem como caracteristica verificar se o array esta cheio. caso
	 * estiver cheio ele criará um novo array com o dobro do tamanho e moverá os
	 * alunos do array antigo para o novo. O metodo garantaEspaco() so e util
	 * dentro da classe vetor, e nao sera disponivel para o usuario por isso
	 * esta como private
	 */
	private void garantaEspaço() {
		if (this.TotalDeObjetos == this.objetos.length) {
			Object[] novaArray = new Object[this.objetos.length * 2];
			for (int i = 0; i < objetos.length; i++) {
				novaArray[i] = this.objetos[i];

			}
			this.objetos = novaArray;
		}
	}

	// metodo para deslocar aluno de posicao
	public void adiciona(int posicao, Aluno aluno) {
		this.garantaEspaço(); // verificar se tem espaço
		if (!this.posicaoValida(posicao)) {
			throw new IllegalArgumentException("posicao invalida");

		}
		for (int i = TotalDeObjetos - 1; i >= posicao; i--) {
			this.objetos[i + 1] = objetos[i];
		}
		this.objetos[posicao] = aluno;
		this.TotalDeObjetos++;
	}

	public Object pega(int posicao) {
		if (!this.posicaoOcupada(posicao)) {
			throw new IllegalArgumentException("posicao invalida");
		}
		return this.objetos[posicao];
	}


	/**
	 * este metodo faz com que compara o aluno dado com os demais alunos
	 * existentes
	 * 
	 * @param aluno
	 */
	public boolean contem(Aluno aluno) {
		for (int i = 0; i < this.TotalDeObjetos; i++) {// nao e necessario
			// percorrer o array
			// todo para achar o
			// aluno,nos podemos
			// obter a ultima posiçao ocupada atraves do atributo TotalDeAlunos
			// // totaldeobjetos
			if (aluno.equals(this.objetos[i])) {
				// equals e para comparar object
				return true;
			}
		}
		return false;
	}

	/**
	 * esse metodo devolve verdadeiro se posicao estiver ocupada ou false caso
	 * contrario
	 * 
	 * @param posicao
	 * @return verdadeiro se a posicao estiver ocupada e falso se nao estiver
	 */
	public boolean posicaoOcupada(int posicao) {
		return posicao >= 0 && posicao < this.TotalDeObjetos;

	}

	/**
	 * este metodo verifica se podemos adicionar um aluno numda dada posicao
	 * devemos testar se o aluno esta no intervalo [0, this.TotalDeAlunos]
	 * 
	 * @param posicao
	 * @return um aluno numa dada posicao
	 */
	private boolean posicaoValida(int posicao) {
		return posicao >= 0 && posicao <= TotalDeObjetos;
	}

	/**
	 * esta implementaçao ficou simples porque na classe vetor ja tem o atributo
	 * para armazenar a quantidade de alunos armazenados.Entao basta devolver o
	 * valor do total de alunos.
	 */
	public int tamanho() {
		return this.TotalDeObjetos;
	}

	/**
	 * utilizamos a classe StringBuilder para Construir a String que mostrara os
	 * elementos da lista.
	 */
	public String toString() {
		if (this.TotalDeObjetos == 0) {
			return "[]";
		}
		StringBuilder builder = new StringBuilder();
		builder.append("[");

		for (int i = 0; i < this.TotalDeObjetos - 1; i++) {
			builder.append(this.objetos[i]);
			builder.append(", ");

		}
		builder.append(this.objetos[TotalDeObjetos - 1]);
		builder.append("]");
		return builder.toString();
		// return Arrays.toString(alunos);
	}

}

public String toString() {  
        if (this.TotalDeObjetos == 0) {  // se não tiver objetos retona apenas "[]" isso. e claro, é vazio porque não tem objetos.
            return "[]";  
        }  
        StringBuilder builder = new StringBuilder();  // Instancia a StringBuilder.
        builder.append("[");  //aciciona na builder o valor em String > "[" . oque temoa até agorá?, bem se o vetor não estiver vazio temos isso > "[", guarde as infomações pra entender
  
        for (int i = 0; i < this.TotalDeObjetos - 1; i++) {  //cria uma condição para que i = 0 e i menor que o Total de Objetos -1; enquando isso for verdadeiro o "i" vai acrescentar.
            builder.append(this.objetos[i]);  // enquanto o for tiver sendo rodado ele vai adicionar os objetos existentes no teu Array aqui. digamos que seus objetos até agora vc só tem os objetos "oi" e "oioi"
//oque esse for vaifazer é justamente incluir esses teus objetos aqui na builder. e depois por uma virgula , 
            builder.append(", ");  //< tae a virgula. pra separar.
          //oque temos até agora? , bom juntando tudo e aceitando os objetos que dei como exemplo temos isso "[ oi, oioi, " < essa virgula no final será corigida logo abaixo.
  
        }  
        builder.append(this.objetos[TotalDeObjetos - 1]);  //adiciona o ultimo objeto depois daquela virgula o valor dele é =(Objeto na posição TotaldeObjetos -1) diagamos que esse objeto tem valor "oioioi".
        builder.append("]");// fecha a chaves, no final temos isso >> "[oi, oioi, oioioi]"  <<< ;)
        return builder.toString();  
        // return Arrays.toString(alunos);  
    }