Quando falamos sobre o objeto orientado, podemos pensar em classe, objetos, embalagens, herança, polimorfismo. No livro "JavaScript Advanced Program Design" (Post's Post e Telecommunications Press, Cao Li, Zhang Xin. O nome em inglês é: Javascript Professional para desenvolvedores da Web) é descrito no livro. Vamos dar uma olhada nos vários métodos definidos no JavaScript.
1. Método da fábrica
Crie nossa própria classe e objetos em JavaScript, devemos ter que dominar.
Copie o código do código da seguinte forma:
<script type = "text/javascript">
//definição
var ocar = new Object ();
ocar.color = "vermelho";
ocar.Doors = 4;
ocar.showcolor = function () {
Alerta (this.color);
}
// Chamar
ocar.showcolor ();
</script>
Somos fáceis de usar objetos Ocar, mas criamos várias instâncias de carro. Podemos usar uma função para encapsular o código acima para implementar:
Copie o código do código da seguinte forma:
<script type = "text/javascript">
//definição
função createCar () {
var ocar = new Object ();
ocar.color = "vermelho";
ocar.Doors = 4;
ocar.showcolor = function () {
Alerta (this.color);
}
Retornar ocar;
}
// Chamar
var ocar1 = createCar ();
var ocar2 = createCar ();
ocar1.color = "preto";
ocar1.showcolor ();
ocar2.showcolor ();
</script>
A propósito, os atributos de associação padrão do objeto JavaScript são públicos. Dessa forma, chamamos isso de método de fábrica e criamos fábricas que podem criar e retornar tipos específicos de objetos.
Isso é um pouco interessante, mas no objeto objeto, o método de criar o objeto é:
Carro carro = carro novo ();
O uso de novas palavras -chave está profundamente enraizado nos corações das pessoas, por isso usamos o método acima para defini -lo. . Vejamos a definição do formulário do construtor.
2. Construtor
Este método parece um pouco como uma função de fábrica. O desempenho específico é o seguinte:
Copie o código do código da seguinte forma:
<script type = "text/javascript">
//definição
Carro de função (cor, portas) {
this.color = cor;
this.Doors = portas;
this.showcolor = function () {
Alerta (this.color);
};
}
// Chamar
var car1 = novo carro ("vermelho", 4);
var car2 = novo carro ("azul", 4);
car1.showcolor ();
car2.showcolor ();
</script>
Parece óbvio, existem diferenças. Parece um pouco interessante. Crie um objeto dentro da função de construção usando essas palavras -chave e é muito gentil criar objetos usando o novo símbolo de computação. Mas também existem alguns problemas: toda vez que o novo objeto é criado, todos os atributos, incluindo a criação da função, ou seja, para dizer que vários objetos são completamente independentes. O objeto car1 e o objeto CAR2 são ambos. Esta é a vantagem da forma original.
3. Protótipo
Usando o atributo de protótipo do objeto, você pode ver o protótipo do qual o novo objeto depende. O método é o seguinte:
Copie o código do código da seguinte forma:
<script type = "text/javascript">
//definição
carro function () {
};
Car.prototype.color = "vermelho";
Car.prototype.doors = 4;
Car.prototype.drivers = new Array ("Tom", "Jerry");
Car.prototype.showcolor = function () {
Alerta (this.color);
}
// Chamar:
var car1 = novo carro ();
var car2 = novo carro ();
car1.showcolor ();
car2.showcolor ();
alerta (car1.drivers);
car1.drivers.push ("Stephen");
Alerta (Car1.Drivers);
Alerta (Car2.Drivers);
// Você pode usar o JSON para simplificar a definição de protótipo:
Car.prototype =
{{
Cor: "Red",
Portas: 4,
Drivers: ["Tom", "Jerry", 'Safdad'],
ShowColor: function () {
Alerta (this.color);
}
}
</script>
Primeiro de tudo, o construtor deste código, não há código e, em seguida, adicione o atributo do objeto para definir o atributo do objeto do carro através do atributo protótipo do objeto. Esse método é muito bom, mas o problema é que o objeto do carro aponta para o ponteiro da matriz. Car2 também ao mesmo tempo, isso não é permitido.
Ao mesmo tempo, o problema também se manifesta no protótipo que não pode trazer parâmetros de inicialização, o que faz com que o construtor não possa inicializar normalmente. Isso requer outra maneira de resolver: esse é o modo de construtor/protótipo misto.
4. Modo de construtor/protótipo misto
A combinação de construtor e protótipo é muito conveniente para definir a classe.
Copie o código do código da seguinte forma:
<script type = "text/javascript">
//definição
Carro de função (cor, portas)
{{
this.color = cor;
this.Doors = portas;
this.drivers = new Array ("Tom", "Jerry");
}
Car.prototype.showcolor = function () {
Alerta (this.color);
}
// Chamar:
var car1 = novo carro ('vermelho', 4);
var car2 = novo carro ('azul', 4);
car1.showcolor ();
car2.showcolor ();
alerta (car1.drivers);
car1.drivers.push ("Stephen");
Alerta (Car1.Drivers);
Alerta (Car2.Drivers);
Alerta (Car1 Instância do carro);
</script>
Este método é definir os atributos dentro e usar o protótipo para defini -lo fora. O problema de resolver o terceiro método.
Esse método deve ser muito amigável, mas comparado à gramática de Java, deve haver alguma desarmonia e parece mais confuso. Para o pessoal de P&D da J2EE, esse método é sempre estranho. Sempre sente que não é uma embalagem amigável , considera -se que é mais problemático. Esse é o protótipo dinâmico.
5. Protótipo dinâmico
Para os desenvolvedores acostumados a usar outros idiomas, o uso de construtor/protótipos misto não é tão harmonioso. Afinal, ao definir categorias, a maioria dos idiomas orientados a objetos são visualmente empacotados em atributos e métodos. Considere a seguinte classe C#:
Copie o código do código da seguinte forma:
Classe Car // Classe
{{
public string color = "vermelho";
Public int Doors = 4;
public int mpg = 23;
Public Car (cor da corda, int portas, int mpg) // construtor
{{
this.color = cor;
this.Doors = portas;
this.mpg = mpg;
}
public void showcolor () // medhod
{{
Console.writeLine (this.color);
}
}
C#está bem embalado todos os atributos e métodos da classe de carros; portanto, quando você vê esse código, sabe quais funções é alcançar e define as informações de um objeto. As pessoas que criticam o construtor/protótipo de construtores mistos acreditam que o método de encontrar atributos na memória do construtor e o método de encontrar métodos fora dele não é lógico. Portanto, eles projetaram um protótipo dinâmico para fornecer um estilo de codificação mais amigável.
A idéia básica do método de protótipo dinâmico é o mesmo que o construtor/protótipo da estrutura mista, ou seja, define atributos de não função no construtor e o atributo de função é definido usando o atributo protótipo. A única diferença é a posição do método do objeto. A seguir, a classe de carros reescrita por protótipo dinâmico:
Copie o código do código da seguinte forma:
<script type = "text/javascript">
//definição
carro function () {
this.color = "vermelho";
this.Doors = 4;
this.drivers = new Array ("Tom", "Jerry");
ifof car._initialized == "indefinido") {{
Car.prototype.showcolor = function () {
Alerta (this.color);
}
// ............
}
// última definição
Car._initialized = true;
}
</script>
Até verificar o tipo de carro._initializado equivalente igual a "indefinido", esse construtor não mudou. Essa linha de código é a parte mais importante do método de protótipo dinâmico. Se esse valor não estiver definido, o construtor continuará definindo o método do objeto por protótipo e, em seguida, definirá o carro._Initialized como true. Se esse valor for definido (quando seu valor for verdadeiro, o valor do tipo de é booleano), esse método não será criado. Em suma, esse método usa o logotipo (_initializado) para determinar se ele forneceu algum método ao protótipo. Este método é criado e atribuído apenas uma vez.
6 Método de fábrica híbrida
Esse método geralmente é uma maneira de mudar o caminho quando o método anterior não pode ser aplicado. Seu objetivo é criar um construtor falso e retornar apenas um novo exemplo de outro objeto. Este código parece ser muito semelhante à função de fábrica:
Copie o código do código da seguinte forma:
carro function () {
var ompcar = new Object ();
ionmpcar.color = "vermelho";
ionmpcar.doors = 4;
ionmpcar.mpg = 23;
ionmpcar.showcolor = function () {
Alerta (this.color);
}
Retornar otempcar;
}
Diferente do método clássico, esse método usa o novo operador para fazer parecer uma função de estrutura real:
var ocar = novo carro ();
Como o novo operador é chamado dentro do construtor do carro (), o segundo novo operador será ignorado (localizado fora do construtor). O objeto criado no construtor é transmitido de volta à variável var. Este método tem os mesmos problemas que os métodos clássicos do método de objeto. Altamente recomendado: a menos que você precise (consulte o capítulo 15), você ainda evita esse método.
Resumo: (qual método é usado)
Atualmente, o mais amplamente utilizado é um construtor/protótipo misto. Além disso, os protótipos dinâmicos também são muito populares e são equivalentes à função/protótipo funcional na função. Você pode usar qualquer um desses dois métodos. No entanto, não use o construtor ou protótipo clássico, porque isso apresentará o código ao problema.
Copie o código do código da seguinte forma:
// ps
// classe estática (1: função)
VarCollection = new Function () {
var _Carcollection = new Array ();
this.add = function (objcar) {
alerta ('add');
}
this.get = function (carid) {
alerta ('obtenha');
}
}
// Classe estática (2: JSON)
var carro = {
Cor: 'Vermelho',
Portas: 4,
ShowColor: function () {alert (this.color);}
}
Car.showcolor ();