概述

面向对象思想：这也不是一朝一夕建立起来的

基础部分，学习类的时候，仅仅讨论新增的语法部分。
进阶的时候再讨论 抽象类 等等。

新增的类语法

  1. TS不允许动态的给对象添加属性，要求使用 属性列表(name: string) 来描述类中的属性！
    1. 属性列表也不存在于编译结果中！
  2. 防止在属性列表中声明属性却没在constructor中初始化的情况
    1. 配置：”strictPropertyInitialization”: true,//更加严格的方式检查属性是否进行了初始化
  3. 属性的初始化位置
    1. 构造函数中
    2. 属性默认值（可以在属性列表里设置默认值，也可以在构造函数的参数中使用默认值写法）
  4. 属性可以是可选的 ?: 也可以是只读的 readonly
  5. 我不希望类外面能访问到我的属性, JS怎么做? Symbol; TS呢?—>添加访问修饰符，有三种
    1. public：默认的访问修饰符，公开的，所有的代码均可访问
    2. private：私有的，只有在 类里面 可以访问
    3. protected：暂时不讲，todolist
  6. 语法糖：属性简写
    1. 如果某个属性，通过构造函数的参数传递，并且加上了修饰符(只读或者访问修饰符均可)且不做任何处理的赋值给该属性，则可以进行简写 ```typescript constructor(public name: string, readonly age: number){

}

  1. ```typescript
  2. class User {
  3.     readonly id: number;//不能改变
  4.     name: string;
  5.     age: number;
  6.     gender: '男' | '女'  = '男';
  7.     pid ?: string;
  9.     //我不希望外面能访问到这两个属性, js怎么做? Symbol;   TS呢?-->添加访问修饰符
  11.     private publishNumber: number = 5;//每天最多发布的文章数量
  12.     private curNumber: number = 0;//当前发布的文章数量,
  14.     constructor(name: string, age: number, gender:'男'|'女', readonly what: string = 'whatever', pid?: string,){
  15.         this.name = name;//报错，为啥。因为TS不允许动态的在对象中添加属性
  16.         this.age = age;
  17.         // this.gender = gender;
  18.         // this.pid = pid;
  19.         this.id = Math.random();
  20.         console.log(this.curNumber);
  21.     }
  23.     publish(title: string){
  24.         if(this.curNumber < this.publishNumber){
  25.             console.log('发布一篇文章', title);
  26.             this.curNumber++;
  27.         }else{
  28.             console.log('今日发布文章数量已上限.');
  29.         }
  30.     }
  31. }
  33. const u = new User('aa', 2, '女', );
  34. u.name = '2341';
  35. u.age = 324;
  36. // u.gender = '男';
  37. console.log(u);
  38. u.publish('title1');

访问器

比如：要对年龄的值要进行控制不能为负吧，不能大的离谱吧。
我们希望用函数来控制，这是最合适的。

Java中就是用 setName; getName ，JS也可以这样，这样需要调用函数
但是js有这个对应的语法糖，set name; get name;故ts也可以使用，也会在编译结果中出现，都是函数
注意：setter getter中用变量的时候不能出现 this.name 否则陷入无限递归，应该用this._name
这个就相当于是setter和getter，u.name会自动调用get name 而u.name = ‘wjw’;就会自动调用set name

练习：增加洗牌和发牌功能

用类改造扑克牌程序（在接口改造的基础上）

  1. //发牌: 发完牌后，有四个card的数组，按斗地主来 17 17 17 3
  2. dealCards():[Card[], Card[], Card[], Card[]]{
  3.   const res: [Card[], Card[], Card[], Card[]] = [[],[],[],[]];
  5.   return res;
  6. }

上述看着挺烦的，那怎么改造呢？Card[]就是一叠牌Deck

  1. import { Mark, Color } from "./enums";
  2. import { Card, Joker } from "./types"
  4. interface DealCardsResult {
  5.     player1: Deck
  6.     player2: Deck
  7.     player3: Deck
  8.     left: Deck
  9. }
  11. export class Deck {
  12.     private cards: Card[] = [];
  14.     constructor(cards?: Card[]) {
  15.         if (cards) {
  16.             this.cards = cards;
  17.         } else {
  18.             this.init();//你不传我就自己初始化
  19.         }
  20.     }
  22.     //因为我不需要让外面知道我的初始化
  23.     private init() {
  24.         const marks = Object.values(Mark);
  25.         const colors = Object.values(Color);
  27.         for (const m of marks) {
  28.             for (const c of colors) {
  29.                 this.cards.push({
  30.                     color: c,
  31.                     mark: m,
  32.                     getString() {
  33.                         return this.color + ' ' + this.mark;
  34.                     }
  35.                 } as Card);//类型断言
  36.             }
  37.         }
  38.         let joker: Joker = {
  39.             type: 'small',
  40.             getString() {
  41.                 return 'joker'
  42.             }
  43.         }
  44.         this.cards.push(joker);
  45.         joker = {
  46.             type: 'big',
  47.             getString() {
  48.                 return 'JOKER';
  49.             }
  50.         }
  51.         this.cards.push(joker);
  52.     }
  54.     //洗牌
  55.     shuffle() {
  56.         const len = this.cards.length;
  57.         for (let i = 0; i < len; i++) {
  58.             const targetIndex = this.getRandomNum(0, this.cards.length);
  59.             [this.cards[i], this.cards[targetIndex]] = [this.cards[targetIndex], this.cards[i]];
  60.         }
  61.     }
  63.     //发牌: 发完牌后，有四个card的数组，按斗地主来 17 17 17 3
  64.     // dealCards(): [Card[], Card[], Card[], Card[]] {
  65.     //     const res: [Card[], Card[], Card[], Card[]] = [[], [], [], []];
  66.     //     return res;
  67.     // }
  69.     dealCards(): DealCardsResult {//这里可以直接使用这个问下下定义的类Deck
  70.         const player1: Deck = this.takeCards(17);
  71.         const player2: Deck = this.takeCards(17);
  72.         const player3: Deck = this.takeCards(17);
  73.         const left: Deck = this.takeCards(3);
  75.         return { player1, player2, player3, left };
  76.     }
  79.     private takeCards(n: number): Deck {
  80.         const cards: Card[] = [];
  81.         for (let i = 0; i < n; i++) {
  82.             cards.push(this.cards.shift() as Card);//如果不断言,有可能是undefined,就会报错!
  83.         }
  84.         return new Deck(cards);//我给你的牌, 拿好
  85.     }
  88.     //无法取到最大值,最多是max-1
  89.     private getRandomNum(min: number, max: number) {
  90.         const sub = max - min;
  91.         return Math.floor(Math.random() * sub + min);
  92.     }
  94.     print() {
  95.         this.cards.forEach((card, i) => {
  96.             let str = card.getString();
  97.             console.log(str);
  98.             if ((i + 1) % 4 === 0) {
  99.                 console.log('\n');
  100.             }
  101.         });
  102.     }
  103. }