O que são classes, referências e objetos?
estou programando java Há 2 anos, e aparentemente eu encontrei um problema onde eu não poderia entender e diferenciar classe, referência, e um objeto novamente (eu não entendo por que me esqueço desses conceitos).
[[1]} vamos chegar ao problema, que é que eu não tenho certeza se uma classe ou referência são a mesma, embora eu já tenho uma idéia do que é objeto. Alguém pode diferenciar de uma maneira agradável, compreensível e completa o que são as aulas, referências e objecto? Tudo o que sei é que a classe é mais como um modelo para um objeto (planta de uma casa onde a classe é o modelo e a casa é um objeto).9 answers
Se gostas de metáforas de habitação:
- A classe é como a planta de uma casa. Usando esta planta, você pode construir quantas casas quiser.
- cada casa que constróis (ou instantiate, em OO lingo) é um objecto , Também conhecido como uma instância. Cada casa também tem uma morada, claro. Se quiser dizer a alguém onde está a casa, dê-lhe um cartão com a morada escrita. Essa carta é do objecto. referência Se quiser visitar a casa, veja a morada escrita no cartão. Isto chama-se dereferenciação.
Foo myFoo = new Foo(); // 1
callBar(myFoo); // 2
myFoo.doSomething() // 4
void callBar(Foo foo) {
foo = new Foo(); // 3
}
Então vamos ver o que é acontecimento.
-
Estão a acontecer várias coisas na linha 1.
- na linha 2, dá este endereço a outro método,
callBar
. Vamos saltar para esse método a seguir.
Aqui, nós ter uma referência - de volta ao primeiro método, dereference {[[3]} para chamar um método nele (
doSomething()
). Isto é como olhar para o cartão, ir para a casa cuja morada está no cartão, e depois fazer alguma coisa naquela casa. Note que o nosso cartão com o endereço demyFoo
é inalterado pelo métodocallBar
-- Lembre-se, demoscallBar
a cópia da nossa referência.
new Foo()
diz ao JVM para construir uma nova casa usando a planta Foo
. A JVM faz isso, e retorna uma referência à casa. Você então copia esta referência a myFoo
. Isto é basicamente como pedir a um empreiteiro para te construir uma casa. Ele tem, e depois diz-lhe a morada da casa; você escreve esta morada.
Foo foo
. Java é pass-by-value, então o foo
em callBar
é uma cópia da referência myFoo
. Pense nisso como dar o seu próprio cartão com a morada da casa. O que faz este cartão? Pede a construção de uma casa nova, e depois usa o cartão que lhe deu para escrever a morada da casa nova. Note que callBar
Agora não pode chegar à primeira casa (a que construímos na linha 1), mas essa casa é inalterada pelo fato de que um cartão que costumava ter o seu endereço é para já,tem a morada de outra casa.
Toda a sequência seria algo como:
- pede à JVM para construir uma casa. Sim, e dá-nos a morada. Copiamos este endereço para um cartão chamado
myFoo
.
Nós invocamos. Antes de o fazermos, copiamos o endereço escrito em -
callBar
pede ao JVM outra casa. Cria-o e devolve a morada da nova casa. Copia esta morada para o cartão que lhe demos.
De volta ao primeiro método, olhamos para o nosso cartão original, inalterado; vamos para a casa onde a morada está no nosso cartão e faz alguma coisa lá.
myfoo
para um novo cartão, que damos a callBar
. Chama a esse cartão.
Quando se codifica, constrói-se um
Instância (ocorrência, cópia)
De um
Objecto
Of a said
Classe
E manter um
A ele, assim você pode chamar seus métodos.Referência
Também, algumas classes OOP básicas: , objecto, instância , e referência.
String s;
Mas aqui você criou apenas a referência, não um objeto. Se você decidiu enviar uma mensagem para s neste momento, você vai ter um erro porque s
não é realmente apegado a qualquer coisa (não há televisão). Uma prática mais segura, então, é sempre inicializar uma referência quando você a cria:
String s = "asdf";
No entanto, isto usa uma funcionalidade Java especial: Cadeias de caracteres podem ser inicializadas com texto citado. Normalmente, você deve usar um tipo mais geral de inicialização para objetos.
Quando você cria uma referência, você quer conectá-la com um novo objeto. Você faz isso, em geral, com o novo operador. A palavra-chave nova diz: "Faz-me um destes objectos."Então no exemplo anterior, você pode dizer:
String s = new String("asdf");
Não só isso significa "Faça-me uma nova String", como também dá informações sobre como fazer a String fornecendo uma string de caracteres inicial. Claro, Java vem com uma pletora de tipos prontos-feitos, além de String. O mais importante é que você pode criar seus próprios tipos. Na verdade, criar novos tipos é a atividade fundamental na programação Java."
Engine app1 = new Engine(); //LINE 1
Engine app2 = app1; //LINE 2
Na linha 1, o motor é uma classe , é basicamente uma Impressão azul.
O novo motor() é a instância {[6] } que é feita no heap.
Está a referir-se a essa instância usando o app1 e o app2 no seu código.
Por isso o app1 e o app2 são as referências .
Você usa a referência para dizer que " eu quero tocar Este objecto agora!", ou " I want to read a value from this object!".
A classe é um modelo, tens razão. É algum conhecimento sobre a estrutura de dados. Objeto é aquela instância de estrutura na memória. Referência é um endereço de memória dessa instância.
Se por Object
quis dizer o identificador java, então Object
é a classe básica para todas as classes Java complexas.
Object
é a representação do tempo de execução da definição Class
. E o nome com o qual você usa o objeto é chamado de reference
(porque ele faz referência à localização real do objeto na memória)
Exemplo
MyClass ref = new MyClass();
Aqui, a minha classe é (contém) a definição da classe.
A nova classe MyClass () cria um objecto para esta classe (feita apenas durante a execução, daí a representação em tempo de execução)
Ref é o nome que usa para trabalhar. no objeto da classe, está a referência .
========= classe e objecto ===========
Classe = > ex: pessoa (mais como imaginação)
Objecto = > ex: John, Mike (pessoa Real)
=========== Referência ============
Ex:
Television tv1; - (Television is a class, tv1 is a remote controller without Television) {[[2]}
Televisão tv2 = Nova Televisão(); - (Agora O controlador remoto da tv2 tem uma televisão)
Tv1 = tv2; - (actualmente a tv1 e a tv2 podem controlar mesmo televisor)
Televisão tv3 = Nova Televisão(); - (tv3 é um novo controlador remoto com nova Televisão)
Classe: usada para definir uma entidade da vida real em um ambiente de programação.
Qualquer entidade da vida real que tenha pelo menos um property
e um behaviour
correspondente pode ser considerada como uma classe. Vejamos um exemplo de um carro , que tem uma propriedade accelerator
que ajuda o carro a mover-se e a controlar a sua velocidade. O comportamento correspondente é acceleration
, que é directamente proporcional ao impulso aplicado ao acelerador.
class Car {
private String tier;
private String tierFriction;
private double weight;
private double gasFedToEngine;
}
A classe acima mostra algumas propriedades de um carro, das quais a sua aceleração depende. O comportamento (method in the class
depende sempre da(S) propriedade (s) (global attribute(s) of the class
). Agora, se quiser mais detalhes que possa definir Tier
como outra entidade, então a definição parecerá com
class Tier {
private String tierMaterial;
private String tierFriction;
private double weight;
private double tierDiameter;
}
class Car {
private Tier tier; // getting all properties of Tier here itself
private double weight;
private double gasFedToEngine;
}
Agora definimos uma entidade para nosso programa, digamos que estamos tendo um showroom de carros usados, ter carros de diferentes empresas. Então cada carro torna-se um da nossa entidade. Objetos podem ser Audi, Nissan, Ferrari etc. Então, depois de abrir o showroom, adicionamos carros assim.objeto: usado para definir vários sabores de uma entidade e para realizar manipulações de dados sobre eles separadamente.
static List<Car> showroomCars = new ArrayList<Car>();
public boolean addCarToShowroom() {
Car carNissan = new Car(); // always creates a new objects and allocates some memory in heap
carNissan.setName("Nissan");
carNissan.setColor(RED);
carNissan.setWeight(300);
showroomCars.add(carNissan);
Car carAudi = new Car();
carAudi.setName("Audi");
carAudi.setColor(BLACK);
carAudi.setWeight(270);
showroomCars.add(carAudi);
}
Então agora dois carros novos são adicionados ao Showroom, um de Nissan e outro de Audi, cada um com seus próprios atributos específicos.
Class
só dá definição, a manipulação é feita em Object
, para fazer manipulação em qualquer Classe, o objeto deve ser criado. Cada vez que um objeto é criado para uma classe todas as suas variáveis não-satic(instância) carregarão na memória com seus respectivos valores padrão.
referência: usado para endereçar um objeto
Quando dizemos Car carAudi = new Car();
definimos um novo objecto para o carro e uma localização de memória é atribuída para esse objecto. A variável de referência carAudi
contém o endereço de memória desse objecto. O objecto nunca é acedido directamente pelo utilizador, nem a localização da memória. É aí que a variável de referência tem significado, armazena o formato hexadecimal
da localização da memória. Se queremos fazer modificações em um objeto fazer com a ajuda de referência não diretamente.
Um objeto pode ter qualquer número de referência, mas uma referência pode apontar apenas para um objeto de cada vez.
class Car {
void test() {
Car car1 = new Car(); // (1)
Car car2 = new Car(); // (2)
car2 = car1;
/**
Says that car2 should point to where car1 points, so now both points to first object of Car
But for this car2 has to loose its current object-(2), making it an Abandoned object (An object with no active reference from the stack).
**/
}
}