typeScript学习笔记-03

// 1类的定义
class Person{
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name=name;
        this.age=age;
    }

    print(){
        return this.name+":"+this.age
    }
}

var p=new Person('zhangsan',20)

console.log(p.print())


// 类的继承

// class Student extends Person{
//    cardnumber:string;
//    school:string;
//    dohmoework(){
//        return  this.name+"今年"+this.age+"岁，就读于"+this.school+"学号"+this.cardnumber
//    }
// }

// let stu=new Student('王笑',20)
// stu.cardnumber="10"
// stu.school="大学"
// console.log(stu.dohmoework())

class Student extends Person{
    cardnumber:string;
    school:string;
    constructor(cardnumber:string,school:string){
        super('马大哈',10);
        this.cardnumber=cardnumber;
        this.school=school;
    }
    print(){
        return  this.name+"今年"+this.age+"岁，就读于"+this.school+"学号"+this.cardnumber
    }
 }
 
 let stu=new Student('10','大学');

console.log(stu.print())  //子类自己身上有的方法不会取父类身上找  马大哈今年10岁，就读于大学学号10

// 接口的继承
interface Printer1{
   getmsg1();
}

interface ColorPrinter extends Printer1{
    printing1()
}

class Hpprinter implements ColorPrinter{
    printing1(){
        console.log('打印成功')
    }
    getmsg1(){
        console.log('HP1020490')
    }
}

var hp=new Hpprinter()
hp.getmsg1()
hp.printing1()


// 访问修饰符

// public(公共的) private(私有的) protected(受保护的)

class Person1{
    public name:string;
    private age:number;
    protected email:string
    constructor(name:string,age:number,email:string){
        this.name=name;
        this.age=age;
        this.email=email;
    }
    print(){
        return this.name+":"+this.age
    }
}


var P1=new Person1('zhangsan',15,'142355@qq.com');
console.log(P1.name);
// console.log(P1.age) 因为age设置了 private私有属性所以访问会报错
// console.log(P1.email)  因为email设置了受保护的属性，所以访问也会报错  只有它的子类可以访问

class mStudent extends Person1{
    show(){
        console.log(this.email) //是Person1的子类所以可以访问email
    }
} 

// javascript的静态属性和静态方法

function People(){
    // 实例属性
    this.name="zhangsan"
    // 实例方法
    this.print=function(){

    }
}
People.age=19 //静态属性
// 静态方法
People.print=function(){}
People.print()//调用静态方法
console.log(People.age)
var p2=new People()
p2.print()//调用实例方法


class Person2{
    // 实例属性
    public name:string;
    static age:number;
    protected email:string
    constructor(name:string,age:number,email:string){
        this.name=name;
        this.email=email;
    }
    print(){
        return this.name+":"
    }
    // 静态方法
    static show(){

    }
}
// 调用静态方法
Person2.show();
var p3=new Person2('wangxiao',11,'@qq')
console.log(p3.print())

// 多态   同一个父类下边不同的子类可以有不同的实现
class Animal{
    eat(){
        console.log('animal is eat')
    }
}

class Cat extends Animal{
    eat(){
        console.log('猫吃鱼')
    }
}
class Dog extends Animal{
    eat(){
        console.log('狗吃肉')
    }
}

var cat1=new Cat()
cat1.eat();

// 抽象类、抽象方法
// 抽象类是提供其他类继承的基类（父类），不能直接被实例
// 抽象方法只能包含在抽象类中,抽象类中可以包含抽象方法和非抽象方法
// 子类继承抽象类,实现抽象方法

// abstract 抽象类关键字
abstract class Animal1{
    abstract eat();
    run(){
        console.log("run in run")
    }
}


class Cat1 extends Animal1{
   eat(){
       console.log('猫吃鱼1')
   }
}

class Dog1 extends Animal1{
    eat(){
        console.log('狗吃肉1')
    }
}

let c1=new Cat1();
c1.eat();
let d1=new Dog()
d1.eat()