TypeScript:class类

一、类的定义：属性&方法

// 类中主要包含两个部分：属性&方法

class Person {
	// 定义实例属性
  name:string="张三";
  // 使用static关键字定义的属性（静态属性|类属性），即不用通过new实例可以直接访问的属性
 static age:number=18;
 // readonly:表示一个只读的属性
 readonly country:string="China";
 static readonly province:string="Shannxi";// 只读静态属性

 // 定义实例方法
 sayHi(){
	alert('Hi');
 }
 static sayNiHao(){
 	alert('你好');
 }
}

const per = new Person();
console.log(per.name)//实例属性
per.sayHi();//实例方法

console.log(Person.age)//类属性
Person.sayNiHao();//类方法

二、构造函数 constructor

class Dog {
	name:string；
	age:number;
	//构造函数 construct会在对象创建时执行
	constructor(name:string,age:number){
		// 在实例方法中，this表示当前的对象
		// 可以通过this像新建的对象中添加属性
		console.log(this)
		this.name=name;
		this.age=age;
	}
	sayHi(){
		// 在实例方法中，this表示当前的对象
		console.log(`${this.age}岁的${this.name}在汪汪汪叫~`)
	}
}
const dog1 = new Dog(name:"大黄"，age:2)
const dog2 = new Dog(name:"豆豆"，age:3);
const dog3 = new Dog(name:"福宝"，age:4);

dog1.sayHi();

三、 类的继承 extends

3-1继承 extends

class Animal {
	name:string;
	age:number;
	constructor(name:string,age:number){
		this.name=name;
		this.age=age;
	}
	sayHi(){
		console.log(`${this.age}岁的${this.name}在叫~`)
	}
}
class Dog extends Animal {
	run(){
		console.log(`${this.name}在跑`)
	}
	sayHi(){
		console.log(`${this.age}岁的${this.name}在汪汪汪~`)
	}
}
class Cat extends Animal {
	sayHi(){
		console.log(`${this.age}岁的${this.name}在喵喵喵`)
	}
}
// Animal是父类，Dog和Cat被称为子类；
// 子类会继承父类所有的方法和属性；
// 如果子类中有和父类相同的方法（如sayHi），则子类会覆盖掉父类的方法。这种形式，称为方法重写
const dog1 = new Dog (name:"大黄"，age:2);
dog1.sayHi();
dog1.run();
const cat1 = new Cat (name:"咪咪"，age:3);
cat1.sayHi()

3-2方法重写（或者称为方法重载）

什么是方法重写或者方法重载？

如果子类或子类具有与父类中声明的方法相同的方法，则称为方法重写。基本上，它在派生类或子类中重新定义了基类方法。
方法覆盖规则：
●该方法必须与父类中的名称相同。
●它必须具有与父类相同的参数。
●必须存在 IS - A 关系或继承。（IS-A就是继承关系）

3-3super关键字

class Animal {
	name:string;
	constructor(name:string){
		this.name=name;
	}
	sayHi(){
		console.log(`动物在叫~`)
	}
}
class Dog extends Animal {	
	age:number;
	constructor(name:string,age:number){
		// 如果子类需要构造函数传递数据，必须调用super();
		super(name);
		this.age=age;
	}
	sayHi(){
 		// super表是当前类的父类
		super.sayHello();
	}
}
const dog1 = new Dog (name:"大黄",age:3);
dog1.sayHi();

3-4抽象类abstract

// 抽象类abstract: 
// 只能作为被继承的父类，不能用来创建对象;
// 抽象类当中可以用来添加抽象方法
abstract class Animal {
	name:string;
	constructor(name:string){
		this.name=name;
	}
	// 抽象方法使用abstract开头，没有方法体；
	// 抽象方法只能定义在抽象类当中，子类必须对抽象方法进行重写
	abstract sayHi():void;
}
class Dog extends Animal {	
	sayHi(){
 		console.log(`汪汪汪~`)
	}
}
onst dog1 = new Dog (name:"大黄");
dog1.sayHi();

四、类的属性的封装（public，private，protected）

class Person {
	name:string;
	age:number;
	constructor(name:string,age:number){
		this.name = name;
		this.age = age;
	}
}
const per = new Person (name:"张三",age:18)；
// 属性在对象中设置，属性可以任意修改；
// 属性可以任意修改将会导致对象中的数据变得非常不安全；
per.name="李四"；
per.age=-10;

1.需求：对象中的数据不可以进行任意的修改；
解决方法：可以在属性前添加属性修饰符

• public 公共的，共有的，可以在任意位置访问，修改；（默认值）
• private 私有属性，只能在类的内部进行修改；通过在类中添加get|set方法使得私有属性可以被访问；(TS中设置getter方法的方式)
• protected 受保护的属性，只能在当前类和子类中使用（只能在类中使用）

class Person {
   private name:string;
   private age:number;
   constructor(name:string,age:number){
   	this.name = name;
   	this.age = age;
   }
   // get定义方法，用来获取name属性
   getName(){
   	return this.name;
   }
   // set定义方法，用来设置name属性
   setName(value:string){
   	this.name=value;// 可以在此判断value是否是合法数据
   }
   
   //  TS中设置getter|setter方法的方式
   get name(){
   	return this.name;
   }
   set name(value:string){
   	this.name=value;
   }
}
const per = new Person (name:"张三",age:18)；
console.log(per.getName());
console.log(per.name)// TS写法获取name

console.log(per.setName('李四'));
per.name="李四"// TS写法修改name

// protected :受保护的属性，只能在当前类和子类中使用；
class A{
	protected name:string="张三";
	num:number;
	constructor(num:number){
		this.num=num;
	}
}
class B extends A{
	test(){
		console.log(this.name)
	}
}
// 语法糖
class C{
	// 可以直接将属性定义在构造函数中
	constructor(name:string,age:number){}
}
const c= new C (name:"王五",age:19)