typescript 学习（16）—— 类

class class_name { 
    // 类作用域
}

类的接口描述的是类的公共部分，而不是公有和私有两部分。它不会帮你检查类是否具有某些私有成员。

定义类的关键字为 class，后面紧跟类名，类可以包含以下几个模块（类的数据成员）：

• 字段 − 字段是类里面声明的变量。字段表示对象的有关数据。

• 构造函数 − 类实例化时调用，可以为类的对象分配内存。

• 方法 − 方法为对象要执行的操作。

class Car {
    engine: string;
    constructor(engine:string) {
        this.engine = engine;
    }

    disp() : void {
        console.log('this.engine', this.engine);
    }
}

let car = new Car('test');
console.log('car --->', car);

类的继承：

class child_class_name extends parent_class_name

需要注意的是子类只能继承一个父类，TypeScript 不支持继承多个类，但支持多重继承!

例：

class Shape {
    area: number;
    wid: number;
    height: number;
    desc: string;

    constructor(wid:number, height: number, desc: string) {
        this.area = wid * height;
        this.desc = desc;
    }

    disp():void {
        console.log(`area is ${this.area}, description is ${this.desc}`);
    }
}

class Circle extends Shape{
    radius: number;
    constructor(radius: number){
        super(radius, radius, '圆形');
    }
}

let circle1 = new Circle(10);
console.log('circle : ', circle1);

多重继承 例：

class Root { 
   str:string; 
} 
 
class Child extends Root {} 
class Leaf extends Child {} // 多重继承，继承了 Child 和 Root 类
 
var obj = new Leaf(); 
obj.str ="hello" 
console.log(obj.str)

继承类的方法重写：

类继承后，子类可以对父类的方法重新定义，这个过程称之为方法的重写。

其中 super 关键字是对父类的直接引用，该关键字可以引用父类的属性和方法。

class PrinterClass {
    doPrint() : void {
        console.log('父类的 doPrint 方法');
    }
}

class StringPrinterClass extends PrinterClass {
    doPrint(): void {
        super.doPrint();
        console.log('子类的 doPrint 方法');
    }
}

var obj = new StringPrinterClass();
console.log(obj.doPrint());

static 关键字：

static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。(实例化的对象娶不到静态成员（静态的属性和方法）)

例：

class StaticMember{
    static num: number;
    static disp():void {
        console.log('num is', StaticMember.num);
    }
}

StaticMember.num = 12;
StaticMember.disp();

// let obj = new StaticMember();
// obj.sum    // 会报错，实例化对象上没有类的静态属性
// obj.disp() // 会报错，实例化对象上没有类的静态方法

instanceof 运算符：

instanceof 运算符用于判断对象是否是指定的类型，如果是返回 true，否则返回 false

class Person {}
let obj = new Person();
let isPerson = obj instanceof Person;
console.log('isPerson', isPerson);

访问控制修饰符：

TypeScript 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。TypeScript 支持 3 种不同的访问权限。

• public（默认） : 公有，可以在任何地方被访问。

• protected : 受保护，可以被其自身以及其子类和父类访问。(通过自己被定义的类的实例化不能使用)

• private : 私有，只能被其定义所在的类访问。(子类以及通过自己被定义的类的实例化都不能使用)

class Encapsulate {
    public str: string = 'aa';
    protected str2: string = 'bb';
    private str3:string = 'cc';
    static str4:string = 'dd';
    
    sayStr3():void{
        console.log(this.str3);
    }
    parentSayStr2() {
        console.log(this.str2);
        
    }
}

class Test extends Encapsulate{
    sayStr2():void {
        console.log(this.str2); //编译报错，不可以访问：用 proctected 声明的变量， 可以在父类，也可以在子类中使用，但不能通过实例化使用
    }
    // sayStr3():void{
    //     console.log(this.str3);
    // } // 编译报错，不可以访问：用 private 声明的变量 只能在自己被定义的类中使用，
         // 通过自己被定义的类的实例化都不能使用
}

let obj = new Test();
console.log(obj.str);
// console.log(obj.str2); // 编译错误，不可以访问
// console.log(obj.str3); // 编译错误，不可以访问
// console.log(obj.str4); // 编译错误，不可以访问

类和接口：

类可以实现接口，使用关键字 implements。

实现（implements）是面向对象中的一个重要概念。一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把特性提取成接口（interfaces），用 implements 关键字来实现。这个特性大大提高了面向对象的灵活性。

interface Alarm {
    alert();
}

class Door{

}

class SecurityDoor extends Door implements Alarm {
    alert() {
        console.log('door alarm');
    }
}

class Car implements Alarm {
    alert() {
        console.log('car alarm');
    }
}

let c1 = new Car();
let d1 = new SecurityDoor();

或者：

interface Alarm {
    alert();
}

interface Light {
    lightOn();
    lightOff();
}

class Car implements Alarm, Light {
    alert() {
        console.log('car alarming...');
    }

    lightOn() {
        console.log('lighton the car');
    }

    lightOff() {
        console.log('lightoff the car');
    }
}

接口也可以继承类:

class Point{
    x: number;
    y: number;
}

interface Point3d extends Point {
    z: number;
}

let point: Point3d = {x: 10, y: 20, z: 10};

当接口继承了一个类类型时，它会继承类的成员但不包括其实现。 就好像接口声明了所有类中存在的成员，但并没有提供具体实现一样。 接口同样会继承到类的private和protected成员。 这意味着当你创建了一个接口继承了一个拥有私有或受保护的成员的类时，这个接口类型只能被这个类或其子类所实现（implement）

 不明白的地方：

1. 什么是继承类的成员但不包括其实现？？？？？？

2. 什么是接口类型只能背这个类或其子类所实现？？？？？？？

混合类型

接口能够描述JavaScript里丰富的类型。 因为JavaScript其动态灵活的特点，有时你会希望一个对象可以同时具有上面提到的多种类型。

例如：一个对象可以同时作为一个函数和对象使用，并带有额外的属性

interface Counter {
    (start: number): string;
    interval: number;
    reset(): void;
}

function getCounter(): Counter {
    let counter = <Counter>function (start: number) { };
    counter.interval = 123;
    counter.reset = function () { };
    return counter;
}

let c = getCounter();
c(10);
c.reset();
c.interval = 5.0;

 

 

类静态部分与实例部分的区别? 没有看懂，需要以后再看