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);