Como entender orientada a objeto
características abstratas orientadas a objetos são encapsulamento, herança, polimorfismo baseado na premissa. análise racional abstrato do negócio da compreensão legítima e razoável do tópico. O resumo deve ser razoavelmente auto-consistente, fácil de entender a relação entre a combinação e agregação: a principal diferença é a diferença entre o ciclo de vida. relações combinação global e o indivíduo como um todo, deixou o todo, o indivíduo não faz sentido, ao produzir, ao mesmo tempo destruída. Relação polimerizado, é a presença de uma parte separada indivíduo que possui o significado de existência, mesmo a partir do acabamento, um indivíduo pode também estar presente separadamente. Não abuse Herança: Mais herdar o papel do tempo é a maioria dos conceitos básicos de propriedades multi-estado orientadas a objetos para dois serviços: Classes e Objetos
Qual é a distinção entre "programação orientada a objetos," eo que é "linguagem de programação orientada a objetos."
É um estilo de programação orientada a objetos especificação ou programação. É um objeto da classe ea organização código da unidade base, e por abstração, encapsulamento, herança, polimorfismo quatro mais código característico desenho e implementação pedra angular
programação de apoio sintaxe da linguagem aulas mecanismo e objetos, e um açúcar sintático ready-made (mecanismo de gramática), pode facilitar a realização das quatro características de programação linguagem de programação orientada a objetos para distinguir entre o que é "programação orientada a processo" e que está "orientada orientada a objeto programação do objeto "
面向过程编程: 以动词为主，分析出解决问题所需要的步奏，然后用函数把这些步奏一步一步实现，使用的时候一个一个依次调用就可以了。 面向对象编程: 以名词为主，把构成问题事务分解各个对象，建立对象的目的不是为了完成一个步奏，而是为了描述某个事物在整个解决问题的步奏中的行为。-Orientado a objeto: os cães (ossos) orientadas para o processo: (ossos cão) comer.
Programação orientada a objetos apresenta Princípios Básicos
Pacote: Os atributos e métodos abstratos embalados em conjunto e, em seguida, para esconder informações, proteção de dados
/*
* @title 创建对象实现封装有四种方法
* @method1 对象字面量方式{name: 'Mark_Zhang',key:'value'} 只能创建一次、复用率差、字面量多了代码冗余
* @method2 内置构造函数创建 var parson = new Object(); parson.name="内置构造函数创建对象"
* @method3 简单的工厂函数 function createObj (name){let obj = new Object(); obj.name = name; return obj}
* @method4 自定义构造函数
*/
function Person (name, agei) {
// 构造函数中多包含的属性和方法就可以理解抽象的一部分
// public 公共属性
this.name = name; // 实例可以直接通过对象点的方式直接访问
// private 私有属性
let age = agei;
this.getAge = function(){
return age;
}
this.setAge = function(a){
age = a;
}
}
Person.prototype.show = function(){
return this.name ' 今年' this.getAge() '岁';
}
// 必须通过 new 关键字创建对象，否则 this 指向的就是 window 对象
let p1 = new Person('Mark_Zhang',18)
console.info(p1.name, p1.age) // Mark_Zhang undefined
// 调用对象方法 (调用对象暴露的接口)
p1.setAge(30);
console.info(p1.getAge());
// 调用原型方法
console.info(p1.show())
let p2 = new Person();
// 利用对象动态性来添加属性
p1.n = 'sunLine'
console.info(p2.n) //sunLine
/**
* @title 通过【构造函数】和【原型法】添加成员的区别
* @区别一: 通过【原型法】分配的函数(引用类型即可) 所有对象共享
* @区别二: 通过【原型法】分配的属性( 基本类型)独立
* @区别2.2: 我们还可以在类的外部通过. 语法进行添加，因为在实例化对象的时候，并不会执行到在类外部通过. 语法添加的属性，所以实例化之后的对象是不能访问到. 语法所添加的对象和属性的，只能通过该类访问。
* @区别三: 若希望所有对象使用同一个函数，建议使用原型法添加函数，节省内存
* @区别四: 通过prototype给所有对象添加方法，不能访问所在类的私有属性和方法
*/Resumo: Como a implementação Ocultar método, para que o chamador fornece apenas as funções necessárias abordagem relacional, esses recursos não precisam saber especificamente como conseguir. Herança: Herança é um dos maiores benefícios da reutilização de código
Herança: subclasses pode usar todas as funções da classe pai, e estender esses recursos. Processo de sucessão, isto é, a partir do geral ao processo particular.
A classe herdada, herdada, a chamada classe é o método protótipo utilizado, o método para adicionar na classe protótipo pai, então o protótipo subclasse pai instância objeto de classe
// 声明父类
let SuperClass function (){
let id = 1;
this.name = ["继承"];
this.superValue = function () {
console.info("superValue is true")
console.info('id---->',id)
}
}
// 通过原型给父类添加方法
SuperClass.prototype.getSuperValue = function() {
return this.superValue();
}
// 声明子类
let SubClass = function () {
this.subValue = function () {
console.info("this is subValue")
}
}
// 子类继承父类
SubClass.prototype = new SuperClass();
// 为子类添加公有方法
SubClass.prototype.getSubValue = function() {
return this.subValue();
}
let sub = new SubClass(),
sub2 = new SubClass();
sub.getSuperValue(); // superValue is true
sub.getSubValue(); // this is subValue
console.info(sub.id) // undefined
console.info(sub.name) // 继承
sub.name.push('类式继承')
console.info(sub2.name) // ['继承','类式继承']O núcleo do que é um SubClass.prototype código = new SuperClass (); o papel do método protótipo objeto de protótipo de classe de objeto é adicionar um total de protótipo para a classe, depois da aula, mas não pode acessar diretamente esses métodos, somente a classe é instanciado, o novo as cópias criadas com as propriedades do objecto e os métodos do construtor classe pai e protótipo proto -mãe pontas objecto protótipo classe. De modo que as subclasses pode acessar as propriedades e métodos do público classe pai e protegido, ao mesmo tempo, propriedades privadas e métodos da classe pai não é herdada por subclasses. Bata negro como o último parágrafo do código acima, a utilização do método de herança classe, se houver um construtor de tipo de referência na classe principal, irá ser comum a todos os exemplos de subclasses, portanto, um exemplo de uma subclasse se o tipo de referência é alterada ele irá afetar as instâncias de outras subclasses. construtores Inheritance
Oficialmente devido às insuficiências acima mencionados, somente a herança construtor, construtores herdado ideia central é SuperClass.call (isto, ID), que aponta directamente alterar esta, de modo que as propriedades e métodos criados por essa cópia em uma subclasse um, porque é um só exemplar, de modo que cada instância de uma subclasse de outro. Mas ele irá resultar em uma perda de problemas de memória
// SubClass.prototype = new SuperClass();
function SubClass(id) {
SuperClass.call(this,id)
}Classes herdam construtor subclasse herda a ideia central é o protótipo pai objecto de classe exemplo SuperClass.call (isto, ID) objectos zodiac e vantagens do método do Exemplo subclasses do ponto protótipo classe pai
Cada exemplo de uma subclasse de resíduos são possíveis interacções entre a memória individual de forma independente uns dos outros desvantagens subclasse (atributos comuns subcoluna e métodos na superclasse adicionando protótipo) combinado herança
Pelo exposto duas herança, combinadas as vantagens de ambos sorteio herdado, isto é, para evitar a perda de memória, e de tal modo que cada um exemplo de uma subclasse de cada outro.
// 组合式继承
// 声明父类
let SuperClass = function(name) {
this.name = name ;
this.books = ['js','html','css']
}
// 声明父类原型上的f方法
SuperClass.prototype.showBooks = function(){
console.info(this.books)
}
// 声明子类
let SubClass = function (name) {
SuperClass.call(this,name);
}
// 子类继承父类(链式继承)
SubClass.prototype = new SuperClass();
let subclass1 = new SubClass('java');
let subclass2 = new SubClass('php');
subclass2.showBooks();
subclass1.books.push('ios'); //["js", "html", "css"]
console.log(subclass1.books); //["js", "html", "css", "ios"]
console.log(subclass2.books); //["js", "html", "css"]Parasita combinação de herança
Portanto, a pergunta novamente - método herdado combinado é bom, mas pode causar um problema, o construtor da classe pai será criado duas vezes (call () outra vez, tempo novo e de novo), de modo a fim de resolver este problema , houve uma combinação de herança parasitária. A questão-chave é apenas o construtor da classe pai é criado na forma de uma combinação de herança e construtores classe duas vezes em sucessão, mas na hierarquia de classes, não precisamos para criar o construtor da classe pai, nós só queremos herda subclasse do pai protótipo para a classe. Por isso, criamos um protótipo dar ao pai uma cópia e, em seguida, modificar a propriedade construtor de subclasse, e, finalmente, criar o protótipo pode ser um herda subclasse // //-style protótipo de estilo protótipo tipo de classe é realmente herdou a implementação do pacote herdado função retorna um exemplo, um exemplo modificado da herança protótipo objectos recebidos, S
function inheritObject(o) {
//声明一个过渡函数对象
function F() {}
//过渡对象的原型继承父对象
F.prototype = o;
//返回一个过渡对象的实例，该实例的原型继承了父对象
return new F();
}// // Parasitárias Parasitic herança é para herdar o pacote segundo protótipo herdou, de modo que o protótipo é igual às subclasses protótipo da classe pai. E durante o segundo pacote na herança objeto da extensão
function inheritPrototype(subClass, superClass){
//复制一份父类的原型保存在变量中，使得p的原型等于父类的原型
var p = inheritObject(superClass.prototype);
//修正因为重写子类原型导致子类constructor属性被修改
p.constructor = subClass;
//设置子类的原型
subClass.prototype = p;
}
//定义父类
var SuperClass = function (name) {
this.name = name;
this.books = ['javascript','html','css']
};
//定义父类原型方法
SuperClass.prototype.getBooks = function () {
console.log(this.books)
};
//定义子类
var SubClass = function (name) {
SuperClass.call(this,name)
}
inheritPrototype(SubClass,SuperClass);
var subclass1 = new SubClass('php')Polimorfismo: A maior vantagem é melhorar o resumo escalabilidade e reutilização de código:
pacote
O quê: informações escondidos, acesso a dados de proteção. Como: interfaces de exposição e propriedades, a necessidade de programação sintaxe da linguagem para fornecer controle de acesso limitado. Por: melhorar a manutenção, reduzir a complexidade da interface, melhorando a facilidade de classes.
abstrato
O que: hide implementação, os usuários só precisam se preocupar com a função, sem a preocupação de implementação. Como: pela classe ou classe abstrata implementa uma interface, um mecanismo especial gramática não-essencial. Por: melhorar a escalabilidade da manutenção de código; complexidade reduzida, reduziu a carga dos detalhes.
Herdar
O que: representa a relação é-um, dividido em herança simples e múltipla. Como: a necessidade de fornecer mecanismo especial de programação sintaxe da linguagem. Por exemplo, o Java "estende", C de ":". Por: para resolver o problema de reutilização de código.
polimorfismo
O que: subclasse substituição classe pai, a implementação chamada subclasse em tempo de execução. Como: a necessidade de fornecer mecanismo especial de programação sintaxe da linguagem. Tais como herança, interfaces, classes, pato-digitação. Por: melhorar a reutilização de código e extensibilidade.
modelo 3W é a chave Por que, não por que, os outros dois haveria sentido da existência. Como pode ser visto a partir dos quatro propriedades, o objecto final orientada para um único propósito: manutenção. Fácil de expandir e fácil reutilizar e afins pertencem a reduzir a complexidade da manutenção de implementação.
