Objeto passado como parametro

Menkauren:

A questao é:
As modificações que eu fizer dentro da minha classe Alunos não ira surtir efeito no objeto escola que foi criado lá na minha classe Principal, correto??

Não sei se ta certo, mas eu penso assim:
O meu objeto escola criado na minha classe principal é passado para o meu construtor, este recebe meu objeto e faz uma cópia para o meu objeto escola declarado dentro da minha classe aluno. Na classe aluno eu irei fazer modificações em cima do meu objeto criado na classe aluno, ou seja o meu objeto criado na classe escola ainda mantém o estado original do momento em que ele foi passado para a classe Aluno.

Você fez isso?

Alunos aluno = new  Alunos( this.escola );

Nesse caso, você está passando a referência do objeto Escola para a variável do tipo Escola que consta na classe Alunos. Dessa forma, alterações feitas em Escola no objeto Alunos impactam aquele da classe Principal.

Sim eu fiz. Mas pela lógica veja se vc concorda comigo:

Observe meu construtor da classe Alunos. Ele recebe um objeto do tipo escola, para isso eu crio um objeto dentro do meu metodo construtor (não instancio) através da declaração em negrito:

public Alunos(Escola escola) {
}

Pois bem, o objeto recebido só é visivel dentro do metodo construtor, respeitando o conceito de escopo.
Para resolver isso eu declaro dentro do meu construtor que o meu objeto escola é igual ao meu objeto escola declarado dentro da minha classe.

public Alunos(Escola escola) {

this.escola = escola;

initComponents();

}

Objeto criado dentro da classe Alunos que recebe o valor do objeto passado ao construtor:

public class Alunos extends javax.swing.JInternalFrame {

Escola escola;

}

Em qualquer outro metodo dentro da minha classe Alunos eu irei usar o objeto criado acima (que foi criado fora do escopo do construtor), que não é o objeto original passado ao contrutor, mas apenas uma copia dele, por que o objeto que eu passei ao construtor só é visivel dentro do construtor.

Ou seja o meu objeto criado lá na minha classe principal irá manter o estado dele igual ao momento em que foi passado ao construtor e todas as modificações feitas na classe Alunos serão feitas em cima do objeto escola que foi criado na classe Alunos e que é uma cópia de meu objeto criado na classe Principal.

Olá Menkauren!

Execute o seguinte código (classes Teste1 e Teste2):

package br.epm.testes;

/**
 * Teste1
 */
public class Teste1 {
    private int number;

    public Teste1(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
}

package br.epm.testes;

/**
 * Teste2
 */
public class Teste2 {
    private final Teste1 teste1;

    public Teste2( final Teste1 teste1 ){
        this.teste1 = teste1;
    }

    public void setValue( final int value ){
        this.teste1.setNumber( value );
    }

    public int getValue( ){
        return this.teste1.getNumber();
    }

    public static void main( String[] args ){
        Teste1 t1 = new Teste1( 2 );    //Criada uma instancia de Teste1
        System.out.println( "Teste1 - value:" + t1.getNumber() );   //Valor retornado: 2

        Teste2 t2 = new Teste2( t1 );   //Criada uma instancia de Teste2, e passado como parametro uma referencia da variavel t1
        System.out.println( "Teste1 - value:" + t1.getNumber() );   //Valor retornado: 2
        System.out.println( "Teste2 - value:" + t2.getValue() );    //Valor retornado: 2
        t2.setValue( 4 );   //Invocado metodo para alterar o valor. Esse metodo acessa a variavel teste1, o qual eh uma referencia a instancia t1

        System.out.println( "Teste1 - value:" + t1.getNumber() );   //Valor retornado: 4
        System.out.println( "Teste2 - value:" + t2.getValue() );    //Valor retornado: 4
    }
}

Analisando o raciocínio do seu último post:

a) Para criar um novo objeto, é necessário utilizar a palavra-reservada new. Portanto você possui apenas um objeto do tipo Escola.

b) Em Java, todo objeto (excetua-se tipos primitivos) é passado por referência. Apenas tipos primitivos são passados por valor.

c) Portanto, quando você informou no construtor da classe Alunos uma instância de Escola, o que está sendo passado é a referência.

d) Dentro do construtor de Alunos, você passa uma referência de um objeto do tipo Escola para um atributo (this.escola = escola).

e) A partir deste momento, seu atributo escola (da classe Alunos) está “apontando” para o objeto que foi recebido pelo construtor, que por sua vez foi criado lá na sua classe principal.

f) Portanto, toda vez que você invoca um método do atributo escola (da classe Alunos), você está na verdade acessando o objeto criado lá na classe principal.

Pela sua argumentação, acho que você está confundindo alguns conceitos. Vamos a eles:

a) Escopo - O escopo define em qual local (bloco) uma determinada variável pode ser acessada. Uma variável criada dentro de um laço for, por exemplo, somente pode ser acessada no escopo do laço. Qualquer acesso fora não é permitido;

b) Objeto - Uma instância de um determinado tipo não-primitivo, criado através através do operador new. Todo objeto é único.

c) Variável não Primitiva - Em Java, variáveis não primitivas armazenam referência, e não o valor em si. Dessa forma, um mesmo objeto pode ser compartilhado (olha aqui o problema de acessos concorrentes - threads) por várias variáveis, inclusive em escopos distintos. É por isso que um objeto pode se “propagar” dentro de uma aplicação, mesmo que variáveis que apontem para ele não existam mais (tenha saído de seus escopos), mas desde que exista pelo menos uma (veja Garbage Colector).

d) Garbage Colector (GC) - O lixeiro do Java preocupa-se em destruir objetos e não variáveis. Dessa forma, um objeto é destruído quando nenhuma variável possui uma referência apontando para ele.

Resumindo:

Você está achando que um objeto só pode ser acessado dentro do escopo da variável, mas na verdade o escopo aplica-se à variável, e não ao objeto em si. É por isso que na sua classe Alunos é possível acessar um objeto criado dentro de um escopo totalmente diferente (no caso, na classe principal).