6、面向对象特性：
（1）类(Class)的声明
类是TypeScript的核心，使用TypeScript开发时，大部分代码都是写在类里面

类的访问控制符：public、 private、protected

class Person{ // 类
    public name; // 属性  public 是访问控制符，控制类可以在类的内部和外部使用，不写就是默认
    private eating() { // 方法 private私有的，只有在内部可以访问
        console.log('I am eating');
    }
    protected age; // 受保护的，可以在类的内部，和它的子类里被访问，在外部不能
    protected shopping() {
        console.log(`I am ${age}`)
    }
}
var p1 = new Person(); // 类的实例化通过关键字new
p1.name = 'xiao ming'; // 类的外部
p1.eating(); // 这里就会报错，告诉不能在外部访问

var p2 = new Person(); // 类的实例化通过关键字new
p2.name = 'xiao hong';
p2.eating();// 这里就会报错，告诉不能在外部访问

（2）类(Class)的构造函数
在类被实例化时被调用，且只被调用一次

class Person{ 
    constructor() { // 类的构造函数 不能在外部被访问到
        console.log('haha'); 
    }
    name;
    eating() { 
        console.log('I am eating');
    }
}
var p1 = new Person(); // 在new实例化时会被调用，且只调用一次
p1.name = 'xiao ming';
class Person{ 
    // name;
    // constructor(name: string) { 
    //     console.log(name)
    //     this.name = name;
    // }
    // 上面的写法等同于下面的写法
    constructor(public name: string) { // 在构造函数中需要明确的声明访问控制符
    }
    eating() {
        console.log(this.name) // 构造函数中不声明， 写成name: string 这边会报错
    }
}
var p1 = new Person('xiaoming');
p1.eating();

（3）类(Class)的继承 extends声明继承关系

类的继承extends:
class Person{ 
    constructor(public name: string) { 
        console.log(name)
        this.name = name;
    }
    eating() {
        console.log(this.name)
    }
}
class Employee extends Person{ //extends继承了Person类的属性和方法
    code: string;
    work() {
        console.log('work')
    }
}
var p2 = new Employee('xiaohong');
p2.eating();
p2.work();

var p1 = new Person('xiaoming'); // 在new实例化时会被调用，且只调用一次
p1.eating()
class Person{ 
    constructor(public name: string) { 
        console.log('haha')
    }
    eating() {
        console.log('I am eating')
    }
}
class Employee extends Person{ //extends继承了Person类的属性和方法
    constructor(name: string, code: string) {
        super(name); // 子类的构造函数必须调用父类的构函数
        console.log('xixi')
        this.code = code;
    }
    code: string;
    work() {
        super.eating();
        this.doworking();
    }
    private doworking() {
        console.log('I am working')
    }
}
var p2 = new Employee('xiaohong','123');
p2.work();

typeScript Object插入数据 typescript concat_构造函数

（4）泛型(generic)
参数化的类型，一般用来限制集合的内容，用来指定参数类型

class Person{ 
    constructor(public name: string) { 
        console.log('haha')
    }
    eating() {
        console.log('I am eating')
    }
}
class Employee extends Person{ //extends继承了Person类的属性和方法
    constructor(name: string, code: string) {
        super(name); // 子类的构造函数必须调用父类的构函数
        console.log('xixi')
        this.code = code;
    }
    code: string;
    work() {
        super.eating();
        this.doworking();
    }
    private doworking() {
        console.log('I am working')
    }
}
var p2 = new Employee('xiaohong','123');
p2.work();

// 指定泛型
var workers: Array<Person> = [];
workers[0] = new Person('zhang san');
workers[1] = new Employee('lisi', '20');
workers[2] = 2; // 这里就会报错，因为指定了类型

（5）接口(Interface)
用来建议某种代码约定，使得其他开发者在调用某种方法或创建新的类时必须遵循接口所定义的代码约定
方法一：当接口用作方法的参数类型声明

interface IPerson{
    name: string;
    age: number;
}

class Person{
    constructor(public config: IPerson) {//接口当成构造函数中参数的声明类型
        
    }
}

var p1 = new Person({ // 检查传入的参数是否满足接口声明的所有属性
    name: 'xiao ming',
    age: 20
})

方法二：接口来声明方法implements

interface Animal{
    eat();
}

class Sheep implements Animal{
    eat() { //实现声明的类Animal必须执行Animal里的方法
        console.log('I am eating')
    }
}

（6）模块(Module) export import
模块可以帮助开发者将代码分割为可重用的单元。开发者可以自己决定将模块中的哪些资源（类、方法、变量）暴露出去供外部使用，哪些资源只能在模块内使用。

// a.ts
export var a1;
var a2;

export function func1() {
    
}
function func2() {
    
}

export class Class1 {
    
}

class Class2 {
    
}
// b.ts
// 一个文件既能导入，又能导出
import {a1, Class1, func1} from "./a";

console.log(a1)

func1()

new Class1()

export class classzz { 
    
}

（7）类型定义文件（*.d.ts）
用来帮助开发者在TypeScript中使用已有的JavaScript包，如JQuery