1、多态
其实感觉就像是js的构造函数
// 创建一个类
class Person {
// 声明变量
name: string;
age: number
// 创建构造函数
constructor(name: string, age: number) {
this.name = name
this.age = age
}
// 声明方法
say() {
return '我的名字叫' + this.name + ',今年' + this.age + '岁!'
}
}
let p1 = new Person('李狗蛋', 23)
console.log(p1) => // Person { name: '李狗蛋', age: 23 }
let psay = p1.say()
console.log(psay) => // 我的名字叫李狗蛋,今年23岁!2、继承
类似JQextends，起到拓展功能作用，新的类可以继承引用和调用extends后面的类里面的方法和属性
// Student是新类，Person就是已经建成需要调用其内部属性和方法的类
class Student extends Person {
school: string;
constructor(school: string) {
// Person构造函数的参数必须在此通过super()方法传入参数，super是代指父类(基类)，super()执行一遍父类的构造函数
super('王翠花', 18)
this.school = school
}
// 相当于重写方法，如果不重写，相当于调用Person的say(),比如我们把Student的say改成sayHi
sayHi() {
return `我的名字叫${this.name},今年${this.age}岁,先就读于${this.school}`
}
}
let p2 = new Student('北大青鸟')
let nsay = p2.say()
// 这是重写了say方法后打印结果,调用的是Student的say()，优先级大于Person
console.log(nsay) => // 我的名字叫王翠花,今年18岁,先就读于北大青鸟
// 这是没有重新say方法的打印结果，调用的是Person的say()
console.log(nsay) => // 我的名字叫王翠花,今年18岁!3、类（构造函数）变量作用域
// 我们可以通过一些修饰符来限制lei里面变量的作用范围(作用域)
// public => 一个类里面声明的属性和方法在这个类的里面和外面都可以访问到，默认不写，即这个模式
class Person {
public name: string;
constructor(name: string) {
this.name = name
}
}
let p3 = new Testname('孙二丫')
console.log(p3.name) => // 孙二丫
// private => 一个类里面声明的属性和方法只能在这个类的内部访问
class Person {
private name: string;
constructor(name: string) {
this.name = name
}
}
let p3 = new Testname('孙二丫')
console.log(p3.name) => // 报错
// vsCode里面我们可以看见还未打印就已经报错：属性“name”为私有属性，只能在类“Testname”中访问
// 解析文件文件直接报错：Property 'name' is private and only accessible within class 'Testname'
// 由此可知，private的属性只能在类里面被调用，否则无法调用
// protected => 一个类里面声明的方法和属性只能在类的内部和其子类能访问
class Person {
pretected name: string;
constructor(name: string) {
this.name = name
}
}
let p3 = new Testname('孙二丫')
console.log(p3.name) => // 报错
// vsCode里面我们可以看见还未打印就已经报错： 属性“name”受保护，只能在类“Testname”及其子类中访问
// 解析文件直接报错：Property 'name' is protected and only accessible within class 'Testname' and its subclasses
// 由此可知，pretected的属性只能在类里面的使用子类和基类(父类)
class Son extends Father {}
// 从这里看
Son其实就是基类Father的子类4、readonly只读属性
只读属性必须在声明时或构造函数里被初始化，且值不能不能被修改，和const类似。
class Person {
pretected name: string;
constructor(name: string) {
this.name = name => // 必须初始化
}
}5、存取器
在一个类中我们将其中一个属性用private修饰，那么，在类的外部就无法访问到该属性，这个时候我们可以通过getters/setters来封装一下，以便在类的外部去访问该属性。需要注意的是，只带有 get不带有set的存取器自动被推断为readonly。也就是说，如果只写get但没有set的话，我们是不能更改值的。
class Person {
private _age: number; => // 报错，属性“_age”没有初始化表达式，且未在构造函数中明确赋值。
constructor() {
this._age = 0 => // 必须赋值，才不会报上面的错
}
// 返回设置的值
/*相当于java中的getAge()*/
get age () {
return this._age
}
/*相当于java中的setAge()*/
set age (newAge: number) {
if (newAge < 0 || newAge > 150) {
console.log('对不起，你输入的年龄不合法!')
} else {
this._age = newAge
}
}
say () {
return `我今年${this._age}岁了!`
}
}
let p4 = new Person()
p4._age = 30 => 属性“_age”为私有属性，只能在类“Person”中访问
p4.age = 30
console.log(p4.say()) => //我今年30岁了!6、静态属性
跟java类似，也是使用static关键字修饰。用static修饰的属性会在这个类被加载的时候就进行初始化。 静态属性直接通过类名访问，无需实例化。
class Person {
// 注意不要在constructor里面赋值，因为static不能修改值
static school:String = "山东蓝翔";
/*参数属性 直接给参数添加一个访问修饰符来定义一个属性*/
constructor(private name: String, protected age: number) {
this.name = name;
this.age = age;
}
private say() {
console.log(`${this.name},${this.age}`);
}
protected tell() {
console.log(`${this.name},${this.age}`);
}
}
Person.school;//直接通过类名访问，无需实例化
console.log(Testschool.school) => // 只声明属性，未手动初始化时会自动初始化为undefined,而且正常情况下应该new一个实例，在调用
console.log(Testschool.school) => // 山东蓝翔，初始化后显示初始化的值7、抽象类 (abstract)
abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法，子类必须实现父类的抽象方法 ，它们不会被实例化，仅提供继承
abstract class Father {
name: string;
age: number;
constructor() {
this.name = '李狗蛋'
this.age = 23
}
abstract say():string => 必须声明类型，否则报错
tell() {
console.log('这是抽象类的方法!')
}
}
class Son extends Father {
school: string;
constructor() {
super()
this.school = '学校'
}
say() {
return '这是非抽象类!'
}
}
let p5 = new Son()
p5.tell() => // 这是抽象类的方法!
console.log(p5.say()) => // 这是非抽象类!
let p6 = new Father() => // 报错：无法创建抽象类的实例8、重写
class NewFather {
say() {
console.log('我是父亲')
}
}
class NewSon extends NewFather {
say() {
super.say()
console.log('我是儿子')
}
}
let g: NewSon = new NewSon()
g.say() => 继承重写
result:
我是父亲
我是儿子