typescript 第二部分

　　ts 中不允许变量同名

　　函数定义的两种方式

　　第一种：命名函数 = 声明式定义

　　　　function fn(){}

　　第二种：匿名函数

　　　　var fn = function(){}

　　function fn(x:string,y:string):string{　　// x:string 这里指 变量x 的数据类型　　y:string 这里是 变量y 的数据类型　　():string 这里指 函数return 的数据类型

　　　　return  " hello world "

　　}

　　var fn=function(x:string,y:string):string{　　// 与上面的解释一致

　　　　return "hello world"

　　}

　　约束函数

　　var sf:(x:string,y:string)=>string=function(a:string,b:string):string{

　　　　return "hello"

　　}

　　可选参数 ：使用 ？来实现可选参数的功能，可选参数一定要放后面

　　function fn(x:string,y?:string):string{

　　　　return "hello"

　　}

　　fn("hello","world")　　 fn("hello") 　　// 这两种写法都不会报错　

　　默认参数：使用 = 给参数赋值

　　function fn(x:string,y:string="hello"):string{

　　　　return y;

　　}

　　fn("world")　　// = 给参数一个默认值

　　... 运算符：如果不确定传参的个数，我们可以用 ... 运算符来表示，且还会将元素转化成数组

　　　　function fn(...res):number{

　　　　　　console.log(res)

　　　　}

　　　　fn(12,24,36,48,60,72,84,96);　　

　　函数重载

　　　　在 js 里面不存在函数重载，但是有函数重写

　　函数重载的定义：函数名相同，跟据参数类型决定，使用哪个函数

　　函数重写：在 js 中，因为一旦函数名相同，后者会将前者覆盖

　　function fn(x){}　　// 像这里，我们没有指定数据类型，他会默认数据类型为 any （任何类型），但是 一般情况下 还是要加的

　　ts重载  案例：

　　　　定义两个函数的数据类型，没有实现他的功能

　　　　function fn(x:number):number;

　　　　function fn(x:string):string;

　　　　function fn(x):any{

　　　　　　return x

　　　　}　

　　　　fn(12)　/　fn("hello")　　// 这个案例是一个简单的写法　　主要是看实参传递什么样的格式，以便正常的返回什么样的数据类型

　　　　ts 函数重载：定义一个函数的数据类型，函数会进行重载

　　原生 js 伪实现一个重载的案例：

　　　　function fn(x){

　　　　　　if(typeof x == "string"){

　　　　　　　　console.log("string")

　　　　　　}

　　　　　　else if (typeof x == "number"){

　　　　　　　　console.log("number")

　　　　　　}

　　　　}

　　　　fn(12)

　　类

　　　　案例：

　　　　class Person{

　　　　　　name:string;　　　　// 定义属性

　　　　　　age:number;　　　　

　　　　　　constructor(name:string,age:number){　　　　// 实例

　　　　　　　　this.name=name;

　　　　　　　　this.age=age;

　　　　　　}

　　　　　　run(){

　　　　　　　　console.log("hello world")　　// 这个是定义方法

　　　　　　}

　　　　}

　　　　var person = new Person("zhang",20);

　　　　定义类的注意事项

　　　　1. ts 定义类，首先如果有属性，一定要定义属性，指定数据类型，不加修饰符，默认是 public

　　　　2. ts 中，类没有原型概念

　　　　3. new 实例的时候，就是调用构造函数

　　　　4. 方法中的 this 指向实例对象

　　类的继承：关键字 extends　　super

　　案例：

　　　　class Animal{

　　　　　　name:string;

　　　　　　age:number;

　　　　　　constructor(name:string,age:number){

　　　　　　　　this.name=name;

　　　　　　　　this.age=age;

　　　　　　}

　　　　　　move(){

　　　　　　　　console.log(this.name);

　　　　　　}

　　　　}　　

　　　　class Dog extends Animal{

　　　　　　constructor(name:string,age:number){

　　　　　　　　super(name,age)

　　　　　　}

　　　　}

　　　　var shinubi = new Dog("史努比",7);

　　　　shinubi.move()

　　多态：对父类的方法重写，并且子类之间，这个方法 表现/功能 不一样，这就叫多态，都是为了 继承 用的

　　多态的另一种解释：父类定义一个方法，没有去实现，由子类去实现，并且表现不一样，就也叫多态

　　多态的目的：都是继承用的

　　案例：

　　　　class Person{

　　　　　　move(){}

　　　　}

　　　　class dog extends Person{

　　　　　　move(){}

　　　　}

　　　　class cat extends Person{

　　　　　　move(){}

　　　　}

　　　　这个是一个简单的多态的案例，就只是函数名一样，但功能及用法，完全不同

　　类中的修饰符：一种访问权限

　　　　public　公共的　当没有在属性和方法前面加修饰符，默认 public ，在任何地方都可以访问（类内，子类，类外）

　　　　protected　受保护的　子类，类内 可以访问，类外面不能访问　

　　　　private　　只有 类内 可以访问，子类及类外 不可以访问

　　　　static 静态属性，类上面的属性；

　　　　访问静态的属性　　类 . 属性名

　　　　案例：

　　　　class Father{
　　　　　　name:string;
　　　　　　protected money:number;
　　　　　　private company:string="上市公司";
　　　　　　constructor(name:string,money:number){
　　　　　　　　this.name=name;
　　　　　　　　this.money=money;
　　　　　　　　console.log(this.company);
　　　　　　}
　　　　　　static query(){
　　　　　　　　console.log("我特别安静");
　　　　　　}
　　　　}
　　　　class Son extends Father{
　　　　　　constructor(name:string,money:number){
　　　　　　　　super(name,money);
　　　　　　}
　　　　}
　　　　var son = new Son("zhang",10);
　　　　console.dir(son);
　　　　console.dir(Father);

　　抽象类　　abstract

　　　　1. 作为其他子类的基类使用

　　　　2. 抽象类不能被实例化

　　　　3. 使用 abstract 关键字，来定义抽象类和抽象方法

　　　　4. 抽象类中的抽象方法，不包含实现，在他的派生类（子类）实现

　　　　5. 派生类中的必须实现抽象类的抽象方法，普通方法可以不用重写，子类继承抽象类和类的继承用法一致，唯一区别就是抽象方法必须写

　　　　6. 实现抽象类的子类使用关键字 extends

　　对于抽象类的理解

　　　　抽象类：就是给子类指定一些约束条件，实现抽象类，子类的时候，必须包含抽象类的所有属性

　　案例：　　

　　abstract class Ed{
　　　　abstract name:string;
　　　　abstract move():any;
　　}
　　class Fd extends Ed{
　　　　name:string;　　
　　　　move(){
　　　　　　console.log("我们被迫的");
　　　　}
　　}
　　var sd = new Fd;
　　sd.move();

　　接口：interface

　　　　接口和抽象类都是对事物的一种约束，抽象类只能约束类，接口可以约束条件，很多接口就是指定的一种规范，就是要按照这个规则来

　　使用关键字 interface 来指定规范

　　1. 指定属性的接口

　　　　interface obj{　　　//　obj 这个类上 规定了 name 属性 必须是字符串　　age 属性 必须是 数字 ，且必须有 name 和 age 属性

　　　　　　name:string;

　　　　　　age:number

　　　　}

　　　　var fs:obj={name:"zhang",age:10};　　

　　　　console.log(fs)　　// 我们的 fs 就使用了obj 的规范

　　　　function fn(x:obj):void{　　　// 我们的函数使用这种规范

　　　　　　console.log(x)

　　　　}

　　　　fn({name:"lisi",age:20});

　　2. 实现函数类型的接口

　　　　interface fn{　　　　// 规定函数规范

　　　　　　(x:string,y:string):string

　　　　}

　　　　var f:fn=function(a:string,b:string){　　　　// f 使用这 fn 规范

　　　　　　return a+b

　　　　}

　　3. 可索引类型（数组 ，对象）

　　　　1. 数组

　　　　　　interface arrs{

　　　　　　　　[index:number]:string

　　　　　　}

　　　　　　var arr:arrs = ["zhang","lisi"];

　　　　　　console.log(arr);

　　　　2. 对象

　　　　　　interface objs{

　　　　　　　　[index:string]:string

　　　　　　}

　　　　　　var obj:objs = {name:"zhang",age:"12"};

　　4. 定义类的类型接口

　　　　1. 里面的方法不能实现

　　　　2. 使用关键字 implements 实现这个接口类

　　　　3. 在类中实现接口的办法

　　　　interface Animal{

　　　　　　name:string;

　　　　　　eat():void;

　　　　}

　　　　class Dog implements Animal{

　　　　　　name:string;

　　　　　　eat(){

　　　　　　　　console.log("我是被迫的")

　　　　　　}

　　　　}

　　　　var dog = new Dog;

　　　　dog.eat()

　　5. 接口继承

　　　　接口继承的方式 extends 的关键字

　　interface A{

　　　　color:string

　　}　　

　　interface B extends A{

　　　　name:string

　　}

　　var afg:b={　　　　// 在这里知道，我们必须有 color 属性，还要由 name 属性才可以，

　　　　color:"red",

　　　　name:"zhang"

　　}

　　console.log(afg);