三·、类

//public 公共修饰符
//表示属性或方法都是共有的，在类的内部，子类的内部，类的实例都能被访问， 默认情况下，为public
class People {
  public name : string
  constructor (name: string) {
    this.name = name
  }
  public say() : void {
    console.log('你好')
  }
}

const a = new People('hong');
a.say();
console.log(a.name);

// private 私有修饰符
// 表示子类，外部类不可以访问
class People1 {
  private name : string
  constructor(name: string) {
    this.name = name
  }
  public say () : void {
    console.log('你好')
  }
}
const b = new People1('hong');
//由于报错所以就不展示了

class People2 {
  protected name: string
  // private sex: number
  constructor(name: string) {
    this.name = name
  }
  protected say(): void {
    console.log('prefect world');//完美世界
  }
}

class People3 extends People2 {
  constructor(name: string) {
    super(name);
    this.name = name
  }
}

const c = new People3('hong')

// readonly 只读修饰符
// 就是不能修改
class People4 {
  readonly name : string;
  constructor(name: string) {
    this.name = name
  }
}

// 2、声明类
class People5 {
  name: string //默认为public
  age: number
  constructor(name: string, age: number = 18) {
    this.name = name
    this.age = age
  }
  say() : void {
    console.log('你好')
  }
}
const HH = new People5('京鸿');
console.log(HH.name);
console.log(HH.age);
HH.say();

// 3、类的继承
class Student extends People5 {
  cm: number
  constructor (name: string, age: number, cm?: number) {
    super(name, age);
    this.cm = cm;
  }
  work() : void {
    console.log('学习');
  }
}
const stu1: Student = new Student('liu',18,173)
console.log(stu1.name)
console.log(stu1.age)
console.log(stu1.cm)
stu1.say()
stu1.work()

// 4、 静态属性和静态方法
class People6 {
  static name1: string = '静态属性';
  static say() :void {
    console.log('静态方法')
  }
}

console.log(People6.name1)
People6.say()
//  注意: 静态方法调用不了实例化方法和实例化属性，因为静态域加载是在解析阶段，而实例化是在初始化阶段，（java原理），所以静态方法里面不能调用本类方法和属性，可以调用静态属性和静态方法

// 5、多态 ---> 重写方法
// 父类定义一个方法不去实现，让继承它的子类去实现，每个子类的该方法有不同的表现
class Animal {
    name : string
    constructor(name: string) {
      this.name = name
    }
    eat () :void {
      // 让它的子类去实现不同的eat 方法
    }
}

class Laohu extends Animal {
  constructor (name: string) {
    super(name)
  }
  eat() : void {
    console.log(`${this.name}吃人`)
  }
}

class Laoshu extends Animal {
  constructor (name:string) {
    super(name)
  }
  eat() : void {
    console.log(`${this.name}吃粮食!`)
  }
}
const laohu : Laohu = new Laohu('老虎');
laohu.eat();
const laoshu : Laoshu = new Laoshu('老鼠');
laoshu.eat();

// 6、类和接口
// 类可以实现（implement）接口。通过接口，你可以强制地指名类遵守某个契约。你可以在接口中声明一个方法，然后要求类去具体实现它
// 接口不可以被实例化， 实现接口必须重写接口中的抽象方法
interface Play {
  plays (difang: string) :void;
}

class Playy implements Play {
  plays(difang: string): void {
    console.log(`我们要去${difang}玩!!!`)
  }
}

const pl : Playy = new Playy();
pl.plays('北京')

 

//public 公共修饰符

//表示属性或方法都是共有的，在类的内部，子类的内部，类的实例都能被访问， 默认情况下，为public

class People {

  public name : string

  constructor (name: string) {

    this.name = name

  }

  public say() : void {

    console.log('你好')

  }

}

const a = new People('hong');

a.say();

console.log(a.name);

// private 私有修饰符

// 表示子类，外部类不可以访问

class People1 {

  private name : string

  constructor(name: string) {

    this.name = name

  }

  public say () : void {

    console.log('你好')

  }

}

const b = new People1('hong');

//由于报错所以就不展示了

class People2 {

  protected name: string

  // private sex: number

  constructor(name: string) {

    this.name = name

  }

  protected say(): void {

    console.log('prefect world');//完美世界

  }

}

class People3 extends People2 {

  constructor(name: string) {

    super(name);

    this.name = name

  }

}

const c = new People3('hong')

// readonly 只读修饰符

// 就是不能修改

class People4 {

  readonly name : string;

  constructor(name: string) {

    this.name = name

  }

}

// 2、声明类

class People5 {

  name: string //默认为public

  age: number

  constructor(name: string, age: number = 18) {

    this.name = name

    this.age = age

  }

  say() : void {

    console.log('你好')

  }

}

const HH = new People5('京鸿');

console.log(HH.name);

console.log(HH.age);

HH.say();

// 3、类的继承

class Student extends People5 {

  cm: number

  constructor (name: string, age: number, cm?: number) {

    super(name, age);

    this.cm = cm;

  }

  work() : void {

    console.log('学习');

  }

}

const stu1: Student = new Student('liu',18,173)

console.log(stu1.name)

console.log(stu1.age)

console.log(stu1.cm)

stu1.say()

stu1.work()

// 4、 静态属性和静态方法

class People6 {

  static name1: string = '静态属性';

  static say() :void {

    console.log('静态方法')

  }

}

console.log(People6.name1)

People6.say()

//  注意: 静态方法调用不了实例化方法和实例化属性，因为静态域加载是在解析阶段，而实例化是在初始化阶段，（java原理），所以静态方法里面不能调用本类方法和属性，可以调用静态属性和静态方法

// 5、多态 ---> 重写方法

// 父类定义一个方法不去实现，让继承它的子类去实现，每个子类的该方法有不同的表现

class Animal {

    name : string

    constructor(name: string) {

      this.name = name

    }

    eat () :void {

      // 让它的子类去实现不同的eat 方法

    }

}

class Laohu extends Animal {

  constructor (name: string) {

    super(name)

  }

  eat() : void {

    console.log(`${this.name}吃人`)

  }

}

class Laoshu extends Animal {

  constructor (name:string) {

    super(name)

  }

  eat() : void {

    console.log(`${this.name}吃粮食!`)

  }

}

const laohu : Laohu = new Laohu('老虎');

laohu.eat();

const laoshu : Laoshu = new Laoshu('老鼠');

laoshu.eat();

// 6、类和接口

// 类可以实现（implement）接口。通过接口，你可以强制地指名类遵守某个契约。你可以在接口中声明一个方法，然后要求类去具体实现它

// 接口不可以被实例化， 实现接口必须重写接口中的抽象方法

interface Play {

  plays (difang: string) :void;

}

class Playy implements Play {

  plays(difang: string): void {

    console.log(`我们要去${difang}玩!!!`)

  }

}

const pl : Playy = new Playy();

pl.plays('北京')