面向对象
面向对象，面向对象的软件开发方法，一种编程范式。
面向对象的概念和应用已经超越了编程和软件开发typescript 定义函数，扩展到数据库系统、交互界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。 面向对象是一种理解和可视化现实世界的方式，是计算机编程技术发展到一定阶段的产物。
面向对象三大特点：封装、继承、多态。
TypeScript面向对象，类（class）
1. static关键字表示通过类访问的静态属性。
2、readonly关键字表示只读属性，该属性不能改变，构造函数可以初始化。
构造函数和 this 关键字
1、构造函数，称为构造函数，在创建对象时调用。
2. 在实例模式下，表示当前实例。
继承 (extends) 和 super 关键字
1.子类编写构造函数构造函数必须使用super来继承父构造函数构造函数的属性
2.通过继承，可以将多个类共享的代码写在一个父类中。 继承后，泛型类型将拥有父类的所有技能和属性。
3.方法重绘，子类中添加与父类相同的方法，子类方法会覆盖父类的方法
抽象的
1、abstract开头的类是抽象类typescript 定义函数，抽象类不能实例化，是专门用来继承的类。
2.具体方法可以添加到抽象类中，但不能添加到非抽象类中。
3、抽象方法以abstract开头，没有方法体，只能定义在抽象类中，子类必须重绘具体方法。
界面
1、接口的功能类似于抽象类。 不同的是，套接字中的所有函数和属性都没有实际值，而接口中的所有方法都是具体方法。
2、接口主要负责定义一个类的结构以及限制一个对象的socket。 仅当该对象包含套接字中定义的所有属性和技能时，该对象才会与套接字匹配。
3. 一个类实现socket。 实现套接字时，类必须包含套接字中的所有属性。
封装和属性封装
1.私有修饰符、私有属性、私有属性只能在类内部访问和改变。
2、protected修饰符，受保护的属性，只能在当前类以及当前类的基类中访问。
3. 公共修饰符、共享属性和修饰属性可以在任何地方访问以更改默认值。
4. getter方法用于读取属性。
5.setter方法欢迎设置属性。
6. getter和setter统称为属性的存储。 定义时在方法前添加get、set，调用时直接通过点句调用。
代码示例
情况1：
class MyUser {
static desc: string = "用户类"; // 使用static开头的属性是静态属性（类属性），可以直接通过类去访问
readonly id: number = 1000004; // readonly开头的属性表示一个只读的属性无法修改
name: string = "张三";
age: number = 28;
toString() {
return "id=" + this.id + ",name=" + this.name + ",age=" + this.age;
}
}
let myUser = new MyUser();
console.log("myUser=", myUser); // myUser= MyUser { id: 1000004, name: '张三', age: 28 }
console.log("myUser.desc=", MyUser.desc); // myUser.desc= 用户类
案例2：
class MyUser2 {
readonly id: number;
name: string;
age: number;
/**
* 构造函数和this
* @param id
* @param name
* @param age
*/
constructor(id: number, name: string, age: number) {
this.id = id;
this.name = name;
this.age = age;
}
toString() {
return "id=" + this.id + ",name=" + this.name + ",age=" + this.age;
}
}
let myUser2 = new MyUser2(1000001, "孔子", 2000);
console.log("myUser2=", myUser2);
// myUser2= MyUser2 { id: 1000001, name: '孔子', age: 2000 }案例3：
(
function () {
/**
* 以abstract开头的类是抽象类，抽象类和其他类区别不大，不能用来创建对象
* 抽象类就是专门用来被继承的类
* 抽象类中可以添加抽象方法
*/
abstract class MyUser3 {
readonly id: number;
name: string;
age: number;
/**
* 构造函数和this
* @param id
* @param name
* @param age
*/
constructor(id: number, name: string, age: number) {
this.id = id;
this.name = name;
this.age = age;
}
toString() {
return "id=" + this.id + ",name=" + this.name + ",age=" + this.age;
}
/**
* 抽象方法使用 abstract开头，没有方法体
* 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
*/
abstract work():void ;
}
class MyEmployee extends MyUser3 {
/**
* 构造函数
* @param id
* @param name
* @param age
*/
constructor(id: number, name: string, age: number) {
super(id, name, age);
}
work() {
console.log("雇员，id=" + this.id + ",name=" + this.name + "在工作");
}
}
class MyManager extends MyUser3 {
work() {
console.log("经理，id=" + this.id + ",name=" + this.name + "在工作");
}
}
let myEmployee = new MyEmployee(1, "沙僧", 501);
// myEmployee= MyEmployee { id: 1, name: '沙僧', age: 501 }
console.log("myEmployee=", myEmployee);
myEmployee.work();
// 雇员，id=1,name=沙僧在工作
let myManager = new MyManager(1, "唐僧", 500);
// myManager= MyManager { id: 1, name: '唐僧', age: 500 }
console.log("myManager=", myManager);
myManager.work();
// 经理，id=1,name=唐僧在工作
}
)();案例4：
interface MyWorker{
work():void;
}
class MyUser4 implements MyWorker {
readonly id: number = 1000004; // readonly开头的属性表示一个只读的属性无法修改
name: string = "张三";
age: number = 28;
toString() {
return "id=" + this.id + ",name=" + this.name + ",age=" + this.age;
}
work() {
console.log("用户，id=" + this.id + ",name=" + this.name + "在工作");
}
}
let myUser4 = new MyUser4();
// myUser4= MyUser4 { id: 1000004, name: '张三', age: 28 }
console.log("myUser4=", myUser4);
myUser4.work();
//用户，id=1000004,name=张三在工作案例5：
(function () {
// 定义一个表示人的类
class Person {
// TS可以在属性前添加属性的修饰符
/*
* public，修饰的属性可以在任意位置访问（修改） 默认值
* private，私有属性，私有属性只能在类内部进行访问（修改）
* - 通过在类中添加方法使得私有属性可以被外部访问
* protected 受包含的属性，只能在当前类和当前类的子类中访问（修改）
*
* */
private _name: string;
private _age: number;
/**
* 构造函数
*
* @param name
* @param age
*/
constructor(name: string, age: number) {
this._name = name;
this._age = age;
}
/*
* getter方法用来读取属性
* setter方法用来设置属性
* - 它们被称为属性的存取器
* */
// TS中设置getter方法的方式
get name() {
// console.log('get name()执行了！！');
return this._name;
}
set name(value) {
this._name = value;
}
get age() {
return this._age;
}
set age(value) {
if (value >= 0) {
this._age = value
}
}
}
const person = new Person('孙悟空', 18);
/*
* 现在属性是在对象中设置的，属性可以任意的被修改,
* 属性可以任意被修改将会导致对象中的数据变得非常不安全
* */
// person.setName('猪八戒');
// person.setAge(33);
person.name = '猪八戒';
person.age = 33;
console.log(person);
class A {
//protected是保护的属性，只能在当前类和子类中设置
//protected只能在当前类和当前类的子类中设置
protected num: number;
constructor(num: number) {
this.num = num;
}
}
class B extends A {
test() {
console.log(this.num);
}
}
const b = new B(123456789);
// b.num = 33; // 属性“num”受保护，只能在类“A”及其子类中访问。
class C1 {
name: string;
age: number
// 可以直接将属性定义在构造函数中
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
const c1 = new C1('沙僧', 111222333);
console.log(c1);
// C1 { name: '沙僧', age: 111222333 }
class C2 {
// 直接将属性定义在构造函数中
constructor(public name: string, public age: number) {
}
}
const c2 = new C2('沙僧', 111222333);
console.log(c2);
// C2 { name: '沙僧', age: 111222333 }
})();
