[Typescript]第4章-ts面向对象

interface IPerson { 
    firstName:string, 
    lastName:string, 
    sayHi: ()=>string 
} 
var customer:IPerson = { 
    firstName:"Tom",
    lastName:"Hanks", 
    sayHi: ():string =>{return "Hi there"} 
} 

interface RunOptions { 
    program:string; 
    commandline:string[]|string|(()=>string); 
} 
// commandline 是字符串
var options:RunOptions = {program:"test1",commandline:"Hello"}; 
// commandline 是字符串数组
options = {program:"test1",commandline:["Hello","World"]}; 
// commandline 是一个函数表达式
options = {program:"test1",commandline:()=>{return "**Hello World**";}}; 

interface namelist { 
   [index:number]:string 
} 
// 类型一致，正确
var list2:namelist = ["Google","Runoob","Taobao"]
// 错误元素 1 不是 string 类型
// var list2:namelist = ["Runoob",1,"Taobao"]

• 单接口继承语法格式：Child_interface_name extends super_interface_name。
• 单继承实例：

  interface Person { 
     age:number 
  } 
  interface Musician extends Person { 
     instrument:string 
  } 
  var drummer = <Musician>{}; 
  drummer.age = 27 
  drummer.instrument = "Drums" 
  console.log("年龄:  "+drummer.age)
  console.log("喜欢的乐器:  "+drummer.instrument)
  

• 多接口继承语法格式：Child_interface_name extends super_interface1_name, super_interface2_name,…,super_interfaceN_name。
• 多继承实例：

  interface IParent1 { 
      v1:number 
  } 
  interface IParent2 { 
      v2:number 
  } 
  interface Child extends IParent1, IParent2 { } 
  var Iobj:Child = { v1:12, v2:23} 
  console.log("value 1: "+Iobj.v1+" value 2: "+Iobj.v2)
  

class Car { 
    // 字段 
    engine:string; 
    // 构造函数 
    constructor(engine:string) { 
        this.engine = engine 
    }  
    // 方法 
    disp():void { 
        console.log("发动机为 :   "+this.engine) 
    } 

class Car { 
   // 字段
   engine:string; 
   
   // 构造函数
   constructor(engine:string) { 
      this.engine = engine 
   }  
   
   // 方法
   disp():void { 
      console.log("函数中显示发动机型号  :   "+this.engine) 
   } 
} 
// 创建一个对象
var obj = new Car("XXSY1")
// 访问字段
console.log("读取发动机型号 :  "+obj.engine)  
// 访问方法
obj.disp()

• 类的继承示例：

  class Shape { 
     Area:number 
     
     constructor(a:number) { 
        this.Area = a 
     } 
  } 
  class Circle extends Shape { 
     disp():void { 
        console.log("圆的面积:  "+this.Area) 
     } 
  var obj = new Circle(223); 
  obj.disp()
  

• 多重继承示例：

  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)
  

class PrinterClass { 
   doPrint():void {
      console.log("父类的 doPrint() 方法。") 
   } 
} 
class StringPrinter extends PrinterClass { 
   doPrint():void { 
      super.doPrint() // 调用父类的函数
      console.log("子类的 doPrint()方法。")
   } 

class StaticMem {  
   static num:number; 
   
   static disp():void { 
      console.log("num 值为 "+ StaticMem.num) 
   } 
} 
StaticMem.num = 12     // 初始化静态变量
StaticMem.disp()       // 调用静态方法

class Person{ } 
var obj = new Person() 
var isPerson = obj instanceof Person; 
console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);

class Encapsulate { 
   str1:string = "hello" 
   private str2:string = "world" 
var obj = new Encapsulate() 
console.log(obj.str1)     // 可访问 
console.log(obj.str2)   // 编译错误， str2 是私有的

interface ILoan { 
   interest:number 
} 
class AgriLoan implements ILoan { 
   interest:number 
   rebate:number 
   
   constructor(interest:number,rebate:number) { 
      this.interest = interest 
      this.rebate = rebate 
   } 
} 
var obj = new AgriLoan(10,1) 
console.log("利润为 : "+obj.interest+"，抽成为 : "+obj.rebate )

var sites = { 
   site1:"Apple", 
   site2:"Google" 
}; 
// 访问对象的值
console.log(sites.site1) 
console.log(sites.site2)

var sites = {
    site1: "Apple",
    site2: "Google",
    sayHello: function () { } // 类型模板
};
sites.sayHello = function () {
    console.log("hello " + sites.site1);
};
sites.sayHello();

var sites = { 
    site1:"Apple", 
    site2:"Google",
}; 
var invokesites = function(obj: { site1:string, site2 :string }) { 
    console.log("site1 :"+obj.site1) 
    console.log("site2 :"+obj.site2) 
} 
invokesites(sites)

function identity<T>(arg: T): T {
     return arg;
}
// 使用泛型函数
let result = identity<string>("Hello");
console.log(result); // 输出: Hello
let numberResult = identity<number>(42);
console.log(numberResult); // 输出: 42

// 基本语法
interface Pair<T, U> {
     first: T;
     second: U;
// 使用泛型接口
let pair: Pair<string, number> = { first: "hello", second: 42 };
console.log(pair); // 输出: { first: 'hello', second: 42 }

// 基本语法
class Box<T> {
     private value: T;
     constructor(value: T) {
         this.value = value;
     }
     getValue(): T {
         return this.value;
     }
// 使用泛型类
let stringBox = new Box<string>("TypeScript");
console.log(stringBox.getValue()); // 输出: TypeScript

// 基本语法
interface Lengthwise {
     length: number;
function logLength<T extends Lengthwise>(arg: T): void {
     console.log(arg.length);
// 正确的使用
logLength("hello"); // 输出: 5
// 错误的使用，因为数字没有 length 属性
logLength(42); // 错误

// 基本语法
function defaultValue<T = string>(arg: T): T {
     return arg;
// 使用带默认值的泛型函数
let result1 = defaultValue("hello"); // 推断为 string 类型
let result2 = defaultValue(42);        // 推断为 number 类型