typescript- class

类

const name = 'Joe';
enum Color { 'Yellow' = 1, 'Red' }
const bgColor = Color.Red;
function Demo(k: {}) {
return 'ok';
}

const someValue: {} = 'This is a string .';
const strLength = (someValue as string).length;
// const length: number = ( someValue).length;

const obj = {
a: 'ok',
b: 23,
c: []
};

// 解构后变量的类型
const { a: first, b: second }: { a: string, b: number } = obj;

const baz = {
test() {
console.log(this.name);
},
name: 'Joe'
};

baz.test();

const bar = { ...baz };

console.log('---------');
bar.test();

// class Foo {
// constructor() {
// this.p = 12;
// }

// m() {
// return this.p;
// }
// }

// const f = new Foo();
// console.log(f.m())
// const b = { ...f };
// console.log(b.p);

class Foo {
x: number;
constructor() {
this.x = 12;
}
}
console.log(new Foo());

class Greeting {
greeting: string;

constructor(greeting: string) {
this.greeting = greeting;
}

greet() {
return Hello ${this.greeting};
}
}

const greeting = new Greeting('Joe');
console.log(greeting.greet());

// 类继承
class Animal {
// 当成员被标记成private时，它就不能在声明它的类的外部访问
// private name: string;
public name: string;
public constructor(theName: string) {
this.name = theName;
}

public move(distanceInMeters: number = 0) {
console.log(${this.name} moved ${distanceInMeters});
}
}

class Snake extends Animal {
constructor(theName: string) {
super(theName);
}

move(distanceInMeters: number = 5) {
console.log('Slithering...');
super.move(distanceInMeters);
}
}

class Horse extends Animal {
constructor(theName: string) {
super(theName);
}

move(distanceInMeters: number = 10) {
super.move(distanceInMeters);
}
}

const snake = new Snake('Smith');

const tom: Animal = new Horse('Tom');

snake.move();
tom.move();
console.log(snake.name);

// 比较带有private或protected成员的类型的时候，情况就不同了。
// 如果其中一个类型里包含一个 private成员，那么只有当另外一个类型中也存在这样一个private成员，
// 并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。 对于 protected成员也使用这个规则

class Animal0 {
private name: string;
constructor(theName: string) {
this.name = theName;
}
}

class Rhino extends Animal0 {
constructor(theName: string) {
super(theName);
}
}

class Employee {
private name: string;
constructor(theName: string) {
this.name = theName;
}
}

let animal = new Animal0('Goat');
let rhino = new Rhino('Test');
let employee = new Employee('Bob');

animal = rhino;
rhino = animal;

// 私有属性在类外不能访问
// animal.name;

// 报错 Error: Animal and Employee are not compatible
// animal = employee;
console.log(employee);

// protected 与 private类似,不同在于protected修饰的成员在派生类中可以被访问

class Person {
protected name: string;
public constructor(theName: string) {
this.name = theName;
}
}

class Employee0 extends Person {
private department: string;
public constructor(theName: string, department: string) {
super(theName);
this.department = department;
}

public getElevatorPitch() {
// 在派生类中仍然可以访问基类得protected成员
console.log(Hello I am ${this.name}, I am work in ${this.department});
}
}

const employee0 = new Employee0('Haward', 'New York');
employee0.getElevatorPitch();

// 类外边不能访问protected修饰的类成员
// employee0.name;

// 构造函数也可以被标记成protected。 这意味着这个类不能在包含它的类外被实例化，但是能被继承

class Folks {
protected name: string;
protected constructor(theName: string) {
this.name = theName;
}
}

class Coder extends Folks {
private department: string;

public constructor(theName: string, department: string) {
super(theName);
this.department = department;
}

public getElevatorPitch() {
console.log(I am ${this.name}, I am working in ${this.department});
}
}

const coder = new Coder('Joe', 'Chengdu');
coder.getElevatorPitch();

// protected修饰的构造函数不能在类之外直接被实例化
// const folks = new Folks('Dennis');

// readonly 修饰符修饰的字段只能在声明或者构造函数中初始化

// class Octopus {
// readonly name: string;
// readonly numberOfLegs: number = 10;
// constructor(theName: string) {
// this.name = theName;
// }
// }

// 参数属性
// 给构造函数参数添加一个访问限定符来声明
// 参数属性会声明并初始化一个属性成员
class Octopus {
// private readonly name: string;
readonly numberOfLegs: number = 10;
constructor(public readonly name: string = 'I am default') {
// this.name = theName;
}
}

const octopus = new Octopus('Man with the 8 strong legs');
console.log(octopus.name);
// error! name is readonly.
// octopus.name = 'kkk';

const passcode = 'Joe`s psw';
class FontEndCoder {
private _fullName: string;

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

set fullName(newName: string) {
if (passcode && passcode === 'Joe`s psw') {
this._fullName = newName;
} else {
console.log('Error: Unauthorized update of coder!');
}
}
}

const fontendCoder = new FontEndCoder();
fontendCoder.fullName = 'Dennis...';
if (fontendCoder.fullName) {
console.log(fontendCoder.fullName);
}

class Grid {
// 静态属性
static origin = { x: 0, y: 0 };
public calculateDistanceFromOrigin(point: { x: number, y: number }) {
const xDist = point.x - Grid.origin.x;
const yDist = point.y - Grid.origin.y;
const dis = Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
return dis;
}

constructor(public scale: number = 1) { }
}

const grid1 = new Grid(4);
const grid2 = new Grid();

console.log(grid1.calculateDistanceFromOrigin({ x: 10, y: 20 }));
console.log(grid2.calculateDistanceFromOrigin({ x: 3, y: 4 }));

// 抽象类
// 抽象类不能被实例化
// 抽象类用abstract关键之修饰,抽象类与接口的不同在于,抽象类可以包含方法的实现,抽象方法只能包含签名,且必须在派生类中实现。

// abstract class AnimalAbstact {
// abstract makeSound(): void;
// move(): void{
// console.log('roaming the earch...');
// }
// }

abstract class Human {
static legs: number = 2;
constructor(protected name: string = '') { }
abstract learn(): void;
}

class Chinese extends Human {
constructor(theName: string) {
super(theName);
}

learn(): void {
console.log('I can learn Chinese...');
}

run() {
console.log(I can run with ${Human.legs} legs.);
}
}

const Joe = new Chinese('Joe');
Joe.learn();
Joe.run();