<h3>接口</h3>
<p>TypeScript的核心原则之一是对值所具有的结构进行类型检查。</p>
<pre><code class="lang-ts language-ts ts">interface LabelledValue {
  label: string;
}

function printLabel(labelledObj: LabelledValue) {
  console.log(labelledObj.label);
}

let myObj = {size: 10, label: &quot;Size 10 Object&quot;};
printLabel(myObj);</code></pre>
<h4>可选属性</h4>
<pre><code class="lang-ts language-ts ts">interface SquareConfig {
    width: number
    height: number
    color?: string // 可选属性
}</code></pre>
<h4>只读属性</h4>
<p>只能在刚创建时修改其值</p>
<pre><code class="lang-ts language-ts ts">interface Point {
    readonly x: number;
    readonly y: number;
}</code></pre>
<h4>额外的属性检查</h4>
<p>如果 SquareConfig带有上面定义的类型的color和width属性，并且还会带有任意数量的其它属性，可以这样定义：</p>
<pre><code class="lang-ts language-ts ts">interface SquareConfig {
    width: number
    color?: string
    [propName: string]: any
}</code></pre>
<h4>函数类型</h4>
<pre><code class="lang-ts language-ts ts">interface SearchFunc {
  (source: string, subString: string): boolean
}

// 对于函数类型的类型检查来说，函数的参数名不需要与接口里定义的名字相匹配。 
let mySearch: SearchFunc;
mySearch = function(src: string, sub: string): boolean {
  let result = src.search(sub);
  return result &gt; -1;
}</code></pre>
<h4>可索引的类型</h4>
<pre><code class="lang-ts language-ts ts">interface StringArray {
  [index: number]: string;
}

let myArray: StringArray;
myArray = [&quot;Bob&quot;, &quot;Fred&quot;];

let myStr: string = myArray[0];</code></pre>
<h4>类类型</h4>
<pre><code class="lang-ts language-ts ts">interface ClockInterface {
    currentTime: Date;
    setTime(d: Date);
}

// 通过 implements 描述
class Clock implements ClockInterface {
    currentTime: Date;
    setTime(d: Date) {
        this.currentTime = d;
    }
    constructor(h: number, m: number) { }
}</code></pre>
<h4>继承接口</h4>
<pre><code class="lang-ts language-ts ts">interface Shape {
    color: string;
}

interface PenStroke {
    penWidth: number;
}

interface Square extends Shape, PenStroke {
    sideLength: number;
}

let square = 
&lt;Square&gt;{};
square.color = &quot;blue&quot;
square.sideLength = 10
square.penWidth = 5</code></pre>
<h4>混合类型</h4>
<p>一个对象可以同时做为函数和对象使用，并带有额外的属性</p>
<pre><code class="lang-ts language-ts ts">interface Counter {
    (start: number): string;
    interval: number;
    reset(): void;
}

function getCounter(): Counter {
    let counter = 
&lt;Counter&gt;function (start: number) { };
    counter.interval = 123;
    counter.reset = function () { };
    return counter;
}

let c = getCounter();
c(10);
c.reset();
c.interval = 5.0;</code></pre>
<h3>类</h3>
<pre><code class="lang-ts language-ts ts">class Animal {
    move(distanceInMeters: number = 0) {
        console.log(`Animal moved ${distanceInMeters}m.`);
    }
}

class Dog extends Animal {
    bark() {
        console.log(&#039;Woof! Woof!&#039;);
    }
}

const dog = new Dog();
dog.bark();
dog.move(10);
dog.bark();</code></pre>
<h4>继承</h4>
<p>通过 extends 关键字</p>
<pre><code class="lang-ts language-ts ts">class Animal {
    name: string;
    constructor(theName: string) { this.name = theName; }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

class Snake extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 5) {
        console.log(&quot;Slithering...&quot;);
        super.move(distanceInMeters);
    }
}</code></pre>
<h4>公共，私有与受保护的修饰符</h4>
<h5>public（默认）</h5>
<p>在TypeScript里，成员都默认为 public。</p>
<pre><code class="lang-ts language-ts ts">class Animal {
    public name: string;
}</code></pre>
<h5>private</h5>
<p>当成员被标记成private时，它就不能在声明它的类的外部访问。</p>
<pre><code class="lang-ts language-ts ts">class Animal {
    private name: string
    constructor(theName: string) { this.name = theName; }
}

new Animal(&#039;Cat&#039;).name // 错误: &#039;name&#039; 是私有的.</code></pre>
<h5>protected</h5>
<p>protected与private修饰符的行为很相似，但有一点不同， protected成员在派生类中仍然可以访问。</p>
<pre><code class="lang-ts language-ts ts">class Person {
    protected name: string
    constructor(name: string) { this.name = name }
}

class Employee extends Person {
    private department: string
    public getElevatorPitch() {
        return `my name is ${this.name} and I work in ${this.department}.`
    }
}

let dick = new Employee(&quot;Howard&quot;, &quot;Sales&quot;)
console.log(dick.getElevatorPitch());
console.log(dick.name); // 错误</code></pre>
<h4>readonly修饰符</h4>
<p>readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。</p>
<pre><code class="lang-ts language-ts ts">class Octopus {
    readonly name: string;
    constructor (theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus(&quot;Man with the 8 strong legs&quot;);
dad.name = &quot;Man with the 3-piece suit&quot;; // 错误! name 是只读的.</code></pre>
<h4>存取器</h4>
<p>TypeScript支持通过getters/setters来截取对对象成员的访问。</p>
<pre><code class="lang-ts language-ts ts">let passcode = &quot;secret passcode&quot;;

class Employee {
    private _fullName: string;

    get fullName(): string {
        return this._fullName;
    }

    set fullName(newName: string) {
        if (passcode &amp;&amp; passcode == &quot;secret passcode&quot;) {
            this._fullName = newName;
        }
        else {
            console.log(&quot;Error: Unauthorized update of employee!&quot;);
        }
    }
}

let employee = new Employee();
employee.fullName = &quot;Bob Smith&quot;;
if (employee.fullName) {
    alert(employee.fullName);
}</code></pre>
<h4>抽象类</h4>
<p>抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。</p>
<pre><code class="lang-ts language-ts ts">abstract class Department { ... }
class AccountingDepartment extends Department { ... }

let department: Department // 允许创建一个对抽象类型的引用
department = new Department() // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment() // 允许对一个抽象子类进行实例化和赋值</code></pre>

【Typescript】接口、类