1.类的定义
class Person {
name: String;//属性不加修饰符时,默认是public的
age: number;
//构造方法 与java不同,不是使用类名,而是使用constructor
constructor(name: String, age: number) {
this.name = name;
this.age = age;
}
//方法,不用加function关键字
say() {
return `Hello,my name is ${this.name},I'm ${this.age} years old`;
}
}
var person = new Person("yzq", 23);
alert(person.say());
2.继承
class Student extends Person{
school:String;
constructor(){
super("yzq",23);//调用父类构造函数
this.school="清华"
}
/*这个地方类似 重写 */
say(){
return `姓名:${this.name},年龄${this.age},学校${this.school}`
}
}
3.访问修饰符
跟java类似,TypeScript的访问修饰符有三个,分别是public、private、protected 。
TypeScript的默认访问修饰符是public。
1)public声明的属性和方法在类的内部和外部均能访问到。
2)protected声明的方法和属性只能在类的内部和其子类能访问。
3)private声明的方法和属性只能在其类的内部访问。
4.readonly修饰符
使用readonly关键字会将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。且值不能不能被修改,和const类似。
class Person {
readonly name: string;
readonly age: number=23;//必须初始化
constructor(name:string) {
this.name = name;//必须初始化
}
}
let p = new Person("yzq");
p.name = "aaa"//错误,不能被修改
p.age=24//错误,不能被修改
6.存取器(Getter And Setter)
TypeScript中的存取器就类似与java中set和get方法,只不过调用的方式不一样。比如在一个类中我们将其中一个属性用private修饰,那么,在类的外部就无法访问到该属性,这个时候我们可以通过getters/setters来封装一下,以便在类的外部去访问该属性。
class Person {
private age: number;
get age() {
return this._age;
}
set age(inputAge: number) {
/*这里可以做一些逻辑处理 */
if (inputAge < 0 || inputAge > 150) {
alert("年龄异常");
} else {
this._age = inputAge;
}
}}
7.静态方法
静态属性直接通过类名访问,无需实例化。用static修饰的属性会在这个类被加载的时候就进行初始化。
(1)es5中静态方法定义(直接在构造函数上定义):
Person.talk=function(){
}
(2)TypeScript在方法名前加上static,静态方法不能访问类里面的非静态属性,只能访问类里面的静态属性
class Person {
static name: String;
static age: number;
constructor(name: String, age: number)
{ this.name = name; this.age = age; }
static say() {
return “Hello,my name is”+Person.name+“,I'm ”+Person.age+“years old”;
}
}
8.多态类
多态属于继承。父类有个方法不去实现,让继承的子类去实现,每个子类都有不同的表现。
class Animal {//父类
name:string;
constructor(name:string) {
this.name=name;
}
eat(){ //具体吃什么 不知道 , 具体吃什么?继承它的子类去实现 ,每一个子类的表现不一样
console.log('吃的方法')
}
}
class Dog extends Animal{//子类
constructor(name:string){
super(name)
}
eat(){
return this.name+'吃粮食'
}
}
class Cat extends Animal{//子类
constructor(name:string){
super(name)
}
eat(){
return this.name+'吃老鼠'
}
}
8.抽象
用abstract关键字定义抽象类和抽象方法,抽象方法只能存在于抽象类中,不包含具体实现{...}
abstract class Animal{
public name:string;
constructor(name:string){
this.name=name;
}
abstract eat():any; //抽象方法不包含具体实现并且必须在子类中实现。
run(){
console.log('其他方法可以不实现') //抽象类中可以有非抽象方法
}
}
// var a=new Animal() /*错误的写法,抽象类不能被实例化,只能用作其他类的基类*/
class Dog extends Animal{
constructor(name:any){
super(name)
}
//抽象类的子类必须实现抽象类里面的抽象方法
eat(){
console.log(this.name+'吃粮食')
}
}
var d=new Dog('小狗');
d.eat();