面向对象(OOP)

Object Oriented Programming

面向对象不是一种语法，而是一种编程思想

将对应的过程替换成对应的对象，而不去追求对应的过程实现，而通过找对象的方式去实现

综合思想：找有这个功能的对象，做这个事情 万物皆对象

对象的创建

1.直接创建

var obj = {};

2.构造函数创建

var obj = new Object()

3.工厂模式创建

创建一个函数专门用来构造对象，每一次调用都能得到一个对象

function factory(name,age)
{
    var obj = {};
    obj.name = name;
    obj.age = age
    return obj;
}

var person = factory("rosy",18);
console.log(person);//{name:"rosy",age:18}

工厂模式构建对象的步骤

• 手动初始化一个对象
• 手动给对象添加属性
• 手动将对象返回

不能很好的去将细节补充；可以构建任何对象

4.用 构造函数 来创建 (一定要用new es3的)

function Person(name,age)
{
    this.name = name;
    this.age = age;
    this.run = function(){
        console.log("running....");
    }
}
var person = new Person("lucy",18);
console.log(person);//Person{name:"lucy",age:18}
person.run();//running

5.用类里面的构造器

class Person{
    constructor(name,age){ //构造器 其实就是一个构造函数
        this.age = age;
        this.name = name;
    }
}
var person = new Person("lili",18);
console.log(person);

构造函数构建的步骤

• 自动构建对象
• 手动添加属性
• 自动返回对象

抽取对象

不会动的 (名词) 抽为属性

会动的(动词)抽为方法

面向对象的三大特性

封装（抽取内容封装），继承（子类继承父类），多态（重写，重载）

继承：子类继承父类的内容，子类可以拥有父类的所有的非私有的属性及方法

原型继承

构造函数继承 === 继承属性

原型继承 === 继承方法与属性

组合继承 == 构造函数继承 + 原型继承

原型继承

// 原型继承
function Person()
{
	this.name = 'lucy'
}
function Son(){

}
Son.prototype = new Person();
console.log(new Son().name); //lucy

组合继承

//组合继承
function Person(){
	this.name = 'rosy'
}
function Son(){
	Person.apply(this);
}
Son.prototype = new Person();
console.log(new Son().name); //rosy

function Person(name,age){
	this.name = name;
	this.age = age;
}

Person.prototype.say = function(){
	console.log(this.name,"hello");
}

function Student(name,age,grade){
	//继承Person那个构造函数已有的属性
	//将当前的this指向传给Person，并传属性给Person

	//以下两种方法均只继承了属性，并不能继承方法
	// Person.call(this,name,age) 
	Person.apply(this,[name,age])

	this.grade = grade;
}

//原型里会获取Person的所有，包括属性与方法，但是属性不影响
// 因为在访问属性时会先访问对象自己身上的，没访问到才会去访问原型的
//原型继承
Student.prototype = new Person();

// 也可以在这基础上继续增加方法
Student.prototype.printGrade = function(){
	console.log(this.name,"成绩：" ,this.grade)
}

//也可以覆盖从父类继承原方法,但是会完全覆盖
// Student.prototype.say = function(){
//     console.log(this.name,"你好");
// }

// 增强原继承方法,不能取与原方法相同的函数名
Student.prototype.say2 = function(){
// 执行原方法
	this.say();
	console.log(this.name,"你好");
}

var obj = new Student('yule',18,100);
console.log(obj);
obj.printGrade();
obj.say2();

ES6继承

class Person{
	constructor(name,age){
		this.name = name;
		this.age = age;
	}
	say(){
		console.log(this.name,"hello");
	}
}

//继承Person类 用extends关键词
class Student extends Person{ 
	constructor(name,age,grade){
		//继承父类的属性，要写在最前面
		super(name,age); 
		this.grade = grade;
	}

	say()
	{
		//使用父类的同名方法
		super.say();
		console.log(this.name,"你好")
	}
}

var st1 = new Student('yule',18,98);
console.log(st1);
st1.say();

多态

概念：一个东西的多种形态体现，子类是父类多态的体现（基于继承的），重写和重载

重载：同一个类里面有多个同名的方法（覆盖 JS没有重载）