类
类描述了所创建的对象共同的属性和方法。
使用关键字 class 声明，后面紧跟类名，类可以包含以下几个模块（类的数据成员)
字段 − 字段是类里面声明的变量。字段表示对象的有关数据。
构造函数 − 类实例化时调用，可以为类的对象分配内存。
方法 − 方法为对象要执行的操作。
- public修饰的属性或者方法是共有的, 可以在任何地方被访问到, 默认所有的属性或者都是public的
- private修饰的属性或者方法是私有的, 不能在声明它的类外面访问, 只能在类的内部进行访问
- protected修饰的属性或者方法是受保护的, 它和private类似, 外部是不可以访问的, 在类的内部和子类的内部是可以访问的
class Person {
private name='张三'
age=19
protected sex: string='男'
say(a: number): string{
return('名字:'+this.name+'年龄:'+this.age+a)
}
}
// 创建Person的实例
var p = new Person()
console.log(p.say(2))
====>> 名字:张三年龄:192
- 构造函数constructor
- 多个对象具有共同属性, 面对不同对象实例化的时候在去赋值 使用构造函数
- constructor一般在实例化的时候执行, new一次就会执行一次
class Person {
// 字段
name: string
age: number
/**
* 构造函数constructor
* 多个对象具有共同属性, 面对不同对象实例化的时候在去赋值 使用构造函数constructor
* constructor一般在实例化的时候执行, new一次就会执行一次
*/
constructor(name: string, age: number){
console.log('执行构造函数')
this.name = name
this.age = age
}
}
const p1 = new Person('姓名', 18)
const p2 = new Person('姓名2', 19)
console.log(p1, p1)
====>> 执行构造函数
====>> 执行构造函数
====>> Person { name: '姓名', age: 18 } Person { name: '姓名', age: 18 }
- 类的继承 extends
- 子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。
- 一次只能继承一个类，不支持继承多个类，但支持多重继承（A 继承 B，B 继承 C）。
- 在实现继承时，子类构造函数中必须调用 super 方法，super 关键字是对父类的直接引用，该关键字可以引用父类的属性和方法。
- abstract: 抽像类 使用abstract修饰的类只能做为其他类继承的父类, 不能直接被实例化
- 使用 abstract 关键字定义抽象类和抽象方法，抽象类中的抽象方法不能直接实现并且必须在子类中实现。抽象方法必须放在抽象类中使用
- static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用
abstract class Animal {
name: string
static age: number // 类的静态方法里面, 是不允许用this, 只能使用类名访问
constructor(name: string, age: number) {
this.name = name
Animal.age = age
}
// abstract move(distance: number): void // 抽象方法, 只能为子类重新定义的方法, 抽像方法只能在抽象类中使用
move(distance: number, sex: string) {
console.log(`${this.name} 跑了 ${distance}M, ${sex},, ${Animal.age}`);
}
// 抽象方法
abstract eat(): void
static work(): void{
console.log('静态方法')
}
}
Animal.work()
====>> 静态方法
class Dog extends Animal {
move(distance: number) {
console.log('正在跑…', distance, '-000-----', this.name)
super.move(distance, '123')
}
eat(): void{
console.log(`${this.name}正在吃`);
}
}
class Snake extends Animal {
// 子类的构造函数必须包含super调用
// 子类中定义相当于是对父类的取代, 父类当中的constructor就不会执行, 需要使用super重定义调用, 即可以在子类当中在执行一次constructor
constructor(name: string) {
super(name, 30)
console.log('211111', this.name)
}
eat(): void{
console.log(`${this.name}正在吃`);
}
}
const dog = new Dog('老', 20)
const snake = new Snake('小')
dog.move(50)
dog.eat()
snake.move(19, 'll')
snake.eat()
====>>
211111 小
正在跑… 50 -000----- 老
老 跑了 50M, 123,, 30
老正在吃
小 跑了 19M, ll,, 30
小正在吃
接口
使用关键字interface 声明
- 接口是一系列抽象方法的声明，是一些方法特征的集合，这些方法都应该是抽象的，需要由具体的类去实现，然后通过这组抽象方法调用，让具体的类执行具体的方法。
- 在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范。在程序设计里，它起到了一种限制和规范的作用
- 两个接口同名可以进行声明合并
interface User {
name: string
age: number
}
/**
* 接口可以继承接口
*/
interface InUser extends User {
sex: string
}
const obj: InUser ={
name: '姓名',
age: 20,
sex: '男'
}
console.log(obj);
====>> { name: '姓名', age: 20, sex: '男' }
- 动态添加属性
interface Istate {
name: string
age?: number
[propName: string]: any // 动态添加属性
}
var obj3: Istate = {name: '张', age: 10, sex: '男', isMa: true }
- 只读属性
interface Istate4 {
name: string
readonly age: number // 用readonly修饰就变为只读属性, 赋初始值之后就不能在进行更改
}
var obj4: Istate4 = {name: '张', age: 10}
obj4.name = '李'
// obj4.age = 20 // 不支持更改
- 函数类型接口
- 函数类型接口是对函数的传入参数以及返回值进行约束
interface Iencrypt {
(key: string, value: string): string
}
const encry: Iencrypt = function(key: string, value: string): string{
return key + '=' + value
}
console.log('函数类型接口', encry('name', 'star'))
====>> 函数类型接口 name=star
- 可索引接口
- 可索引接口一般用于对数组和对象的约束。
interface IFoo {
[index: number]: string // 表示了当用 number去索引fooArr时会得到string类型的返回值。
}
const fooArr: IFoo = ['ww', 'ee', 'ss']
console.log(fooArr[0])
====>> ww
- 类类型接口
- 类类型接口是对类的约束，它是对属性接口和函数型接口的结合
interface Myinter {
name: string
move(): number
}
// 创建类使用implements限定接口类型
class MyClass implements Myinter {
name: string // 必须包含Myinter中的属性和方法
age: number
// 必须进行constructor初始化
constructor(name: string, age: number) {
this.name = name
this.age = age
}
move(): number{
return 11
}
}
const cla = new MyClass('name', 1)
console.log('类类型接口', cla.move());
====>> 类类型接口 11
interface Ieat {
eat(food: string):void
}
interface Irun{
run(distance: number):void
}
class Per implements Ieat, Irun {
eat(food: string): void{
console.log(`eat: ${food}`)
}
run(distance: number) {
console.log(`run: ${distance}`)
}
}
class Animal1 implements Ieat, Irun {
eat(food: string): void{
console.log(`eat: ${food}`)
}
run(distance: number) {
console.log(`run ${distance}`)
}
}
const a1 = new Per()
a1.eat('i lk gyt ')
