神经网络游戏场04：类+继承+抽象类+接口+泛型

类

类的构造省略，可以直接参见下边的例子（nn.ts中的 class Link）
注意，类中的静态对象
      还有readonly 关键字用于描述只读的对象的属性

# Link是一个类，
# 其具有   id， source: Node;dest: Node; weight ，isDead ， errorDer ，   accErrorDer = 0，   numAccumulatedDers = 0，  regularization: RegularizationFunction 这些属性
# 具有 一个 constructor 构造函数（创建实例时调用）：
#           在用随机权重初始化的神经网络中构造一个链接。
#           以设定source源节点， dest目标节点，regulation正则化函数(可以为null)



# 每个链接都有一个权重以及一个源节点和目标节点。它还有一个内部状态（相对于特定输入的误差导数），在运行反向传播后更新。
#  

export class Link {
  id: string;
  source: Node;
  dest: Node;
  weight = Math.random() - 0.5;
  isDead = false;
  /** Error derivative with respect to this weight. */
  errorDer = 0;
  /** Accumulated error derivative since the last update. */
  accErrorDer = 0;
  /** Number of accumulated derivatives since the last update. */
  numAccumulatedDers = 0;
  regularization: RegularizationFunction;


  constructor(source: Node, dest: Node,
      regularization: RegularizationFunction, initZero?: boolean) {
    this.id = source.id + "-" + dest.id;
    this.source = source;
    this.dest = dest;
    this.regularization = regularization;
    if (initZero) {
      this.weight = 0;
    }
  }
}

继承

class Dog extends Animal{

}

super

class Dog extends Animal{
   move(){
   		super.move() # 使用super关键字调用父类
   }
}

class Dog extends Animal{
  constructor(*,age:number ) {
   super(*);# 重写构造函数时必须调用父类的构造函数
   this.age=age;
    }

}

抽象类

希望继承时的效果如下

class Dog extends Animal{
  constructor(age:number ) {
   super();
   this.age=age;
    }
}

abstract class  Animal{
  name :string;
  constructor(name) {
   		this.name =name;
  }
  abstract func():void;# 抽象方法，子类必须实现
 }

接口

# 使用接口定义类的结构
export interface ErrorFunction {
  error: (output: number, target: number) => number;
  der: (output: number, target: number) => number;
}

class aErrorFunction implements ErrorFunction {
  error: (output: number, target: number) { return 0;};
  der: (output: number, target: number) { return 0;};
}

/** Built-in error functions */
export class Errors {
  public static SQUARE: ErrorFunction = {
    error: (output: number, target: number) =>
               0.5 * Math.pow(output - target, 2),
    der: (output: number, target: number) => output - target
  };
}

泛型

# 类
class ani<T>(){
	name:T;
   constructor(name:T) {
   this.name=name;
    }
}
# 函数
function func<T>(a:T):number{
    return 0;
}

# 调用
func(a:"a is a string") # 自动推断
func<string>(a:"a is a string") # 手动指定（自动推断无法运行时）

# 两个泛型
function func<T1，T2>(a:T1,b:T2):number{
    return 0;
}

这里的泛型有点像any,下边另一种的模式：

function func<T>(a:T extends Animal):number{
    return 0;
}

参考和更多

# typescript和java一样有响应的封装方式 有private等关键字，get set 方法。如文 https://blog.csdn.net/chelen_jak/article/details/82800532所写：
class Person {
    constructor() {
    }
    private _name: string;
 
    public get name() {
        return this._name;
    }
 
    public set name(name: string) {
        this._name = name;
    }
}
let person = new Person();
person.name = "apple";