官网文档地址 http://www.typescriptlang.org/docs/index.html
类
es5中类使用
es5中类使用
function Person(){
//属性
this.name = 'name';
this.age = 22;
this.run = function(){
// 方法【为实例方法，通过new对象实例使用】
}
}
====================
//原型类Person通过prototype增加类的属性【会被多个实例共享，而内部构造的不会共享】及方法
Person.prototype.sex = '男';// 静态属性
Person.prototype.work = function(){
// 方法
}
====================
//静态方法设置
//Person.prototype.sex = '男';// 静态属性
// 原型类.方法
Person.getInfo = function(){
// 静态方法
alert('这是静态方法')
}
var pers = new Person();
console.log(pers.name);
console.log(pers.run());
console.log(pers.getInfo())
====================
// web继承Person实现，原型链+对象冒充的组合继承模式
function Web(){
Person.cal(this);/*对象冒充实现继承*/
}
var wb = new Web();
wb.run() // 对象冒充可以继承构造函数里面的属性和方法
wb.work()// 无法执行，对象冒充不能继承原型类的通过prototype添加的方法属性。
====================
//原型链 实现继承
Web.prototype = new Person();// 原型链实现继承
var w = new Web();
w.run();// 原型链实现继承可以继承构造函数里面的属性和方法也可以继承原型链上面的属性和方法
====================
原型链继承存在的问题：实例化子类时无法给父类传参。
function Web(name,age){}
Web.prototype = new Person();
var w = new Web("xiaoxi",22);// 这时子类的name,age 无法传递给父类 Person 进行初始化父类的name和age。
====================
以上两种方式相互结合 优劣互补=> 原型链+对象冒充的组合继承模式
function Web(name,age){
Person.call(this,name,age);//对象冒充
}
Web.prototype = new Person(); 或 Web.prototype =Person.prototype;
var w = new Web("xiaoxi",22);// 原型链
typescript中类使用
typescript中类使用
s2.7引入了一个新的flag：--strictPropertyInitialization。这个flag检查并确保一个类在初始化时，每一个属性都必须在构造器内初始化，或者在属性定义时赋予初始值。
class person{ name!: string;} // definite assignment assertion 明确的赋值断言,由用户自己保证，这个属性在使用前会初始化，类型检查不管这个属性
定义
class Person{
public name:string;// 属性 访问修饰符 public protected private
constructor(name:string){// 构造函数 实例化类时触发
this.name=name;
}
run():void{
// 方法
}
getName():string{
return this.name;
}
setName(name:string):void{
this.name=name;
}
}
var p = new Person("name")
====================
继承 extends、super，父类和子类有相同的方法时调用方法时会先在子类中查找，在再父类中查找
class Web extends Person{
constructor(name:string){
super(name);// 初始化父类构造函数
}
run():void{
}
}
====================
访问修饰符 public protected private
public 范围 在类内部 子类内部 类外面都可以访问
protected 范围 在类内部 子类内部 都可以访问
private 范围 在类内部 都可以访问
class Person{
public name:string;
constructor(name:string){
this.name = name;
}
protected run():void{
console.log('22')
//return `${this.name} 类内部`;// 类内部访问
}
}
// let p = new Person('xiaoxi');
// console.log(p.name) // 类外面访问
// p.run();// 类外面访问
// console.log(p.work());// 类外面访问
class Web extends Person{
constructor(name:string){
super(name);
}
work():void{
this.run();// 子类内部访问父类
console.log(`${this.name}dd`)//子类内部访问父类
}
}
let w = new Web('xiaoxi2');
// console.log(w.name) // 子类外面访问
// w.run();// 类外面访问
console.log(w.work());// 类外面访问
====================
静态属性 静态方法 ，关键字 static
静态属性及方法原因：为了不进行实例化而直接使用方法。Person.method
class Person{
public name:string;
static age:number=2;// 静态属性
constructor(name:string){
this.name = name;
}
public run():void{
console.log('22')
//return `${this.name}类内部`;// 类内部访问
}
static printWord(){// 静态方法
console.log('word${this.age}')// 注意静态方法中无法直接调用类里面的非静态属性
}
}
多态：父类定义一个方法不去实现，让继承它的子类去实现 每一个子类有不同的表现
1 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的
2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.
java里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。
class Animal{
name:string;
constructor(name:string){
this.name=name;
}
eat(){}
}
class Dog extends Animal{
constructor(name:string){
super(name)
}
eat():void{
console.log(`${this.name}啃骨头`)
}
}
class Cat extends Animal{
constructor(name:string){
super(name)
}
eat():void{
console.log(`${this.name}吃鱼`)
}
}
抽象类及抽象方法
用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。必须包含抽象方法。abstract抽象方法只能放在抽象类里面，抽象类不能创建实例
abstract class Animal{
abstract eat():any;
run(){
console.log('run')
}
}
class Dog extends Animal{
constructor(){
super()
}
eat(){
console.log('eat fish');
}
}
class Cat extends Animal{
constructor(){
super()
}
eat(){
console.log('eat fish2');
}
}