TypeScript -- 面向对象特性

                                面向对象特性

一、类（class）--TypeScript的核心，使用TypeScript开发时，在部分代码都是写在类里面的。
        、class关键字和类名就可以定义一个类
            、 类的访问控制符--有三个，public,private,protected
                class Person {
                    public name;//public(公有的)访问控制符,其为默认的
private eat() {//private为私有的访问打控制符
console.log('im eating');
                    }
                    protected age;//protected为受保护的
}
                var p1 = new Person() //类的实例化
p1.name = "banane";
                p1.eat();
            、类的构造函数
                class Person {
                    constructor(name:string){//这个方法不能在外部调用;只有在实例化时被调用，且只调用一次
this.name = name
                    }//简写constructor(public name:string){ }（必须写访问控制符）
name;
                    eat() {
                        console.log(this.name);
                    }
                }
             、类的继承--extends,super
                    class Employee extends  Person {//继承父类所有的属性和方法
constructor(name:string,code:string){//子类的构造函数必须调用父类的构造函数
super(name);//super第一个用法--用来调用父类的构造函数
this.code = code;
                        }
                        code :string;
                        work() {
                            super.eat();//super第二种方法--用来调用父类其它方法，用super.来调的”
this.doWork();
                        }
                        doWork(){
                            console.log('lai')
                        }
                    }
                    var e1 = new Employee('name');//继承Person的属性
var e1.eat()//继承Person的方法

二、泛型（generic）--参数化的类型，一般用来限制集合的内容
        、var workers:Array<Person> = [];
             workers[] = new Person("zhangsan");//Person是Person里面的
workers[] = new Employee("zhangsi",'2');//Employee也是Person里面的
workers[] = ;//2不是Person里面的
三、接口（Interface）--用来建立某种代码约定，使得其它开发者在调用某个方法或创建新的类时必须遵循接口所定义的代码约定
        、声明参数
            interface Person {
                name: string;
                age: number;
            }
            class Person {
                constructor(public  config:Person){

                }//接口（第一个使用方式）用作一个方法的参数的类型声明时，当在调用这个方法时，会查传入的参数是否满足接口所声明的所有属性
}

            var p1 = new Person ({
                name: "zhangsan";
                age:18
})
          、用接口声明方法
            interface  Animal {
                eat()
             }
             class Sheep implements Animal {//关键字implements表示声明一个类实现Animal这个接口,必须要实现接口的方法
eat() {
                        console.log('i eat grass')
                    }
             }
四、模块（Module）-- 模块可以帮助开发者将代码分割为可重用的单元。开发者可以自己决定将模块中的哪些资源（类、方法、变量）
                            暴露出去供外部使用，哪些资源只在模块内使用。
            、理解模块--一个文件就是一个模块，就是这么个意思 ，不用想的多么高大尚
                文件1名为：a.ts，内容如下
                     export var prop1;
                          var prop2;
                      export function func1(){

                      }
                      function func2(){

                      }
                      export class Cla1 {

                      }
                      class Cla2 {

                      }
                 文件2名为：b.ts，内容如下
                      console.log(prop1)
                      func1();
                      new Cla1();//上面这些都可以拿到，因为在文件a.ts中用export暴露出来了可以拿到，而其它这个文件拿不到
                                            //当然你也可以暴露b.ts文件里的东西，在a.ts文件中就可以做得到了，都可以暴露

五、注解（annotation）-- 注解为程序的元素（类、方法、变量）加上更直观更明了的说明，这些说明信息与程序 的业务逻辑无关
                                而是供指定的工具或框架使用的。

               、类的举例
                    import {Component} from '@angular/core';
                    @Component({
                        selecto:'app-root',
                        templateUrl:'./app.componemt.html',
                        styleUrls:['./app.component.css']
                    })//@Component这里面就是注解
export class AppComponent {
                        title = 'app works!';
                    }//告诉框架（angulars）怎么如何来处理标准的tpyeScript写出来的一个类如何放在这个框架中使用

六、类型定义文件（*.d.ts）-- 类型定义文件用来开发者在TpyeScript中使用已有的javaScript的工具包 如：jQuery
                、有一个工具叫Typings,这个是专门用来将一个框架变成定义文件用

面向对象特性
一、类（class）--TypeScript的核心，使用TypeScript开发时，在部分代码都是写在类里面的。        1、class关键字和类名就可以定义一个类            、 类的访问控制符--有三个，public,private,protected                class Person {                    public name;//public(公有的)访问控制符,其为默认的                    private eat() {//private为私有的访问打控制符                        console.log('im eating');                    }                    protected age;//protected为受保护的                }                var p1 = new Person() //类的实例化                p1.name = "banane";                p1.eat();            、类的构造函数                class Person {                    constructor(name:string){//这个方法不能在外部调用;只有在实例化时被调用，且只调用一次                        this.name = name                    }//简写constructor(public name:string){ }（必须写访问控制符）                    name;                    eat() {                        console.log(this.name);                    }                }             、类的继承--extends,super                    class Employee extends  Person {//继承父类所有的属性和方法                        constructor(name:string,code:string){//子类的构造函数必须调用父类的构造函数                            super(name);//super第一个用法--用来调用父类的构造函数                            this.code = code;                        }                        code :string;                        work() {                            super.eat();//super第二种方法--用来调用父类其它方法，用super.来调的”                            this.doWork();                        }                        doWork(){                            console.log('lai')                        }                    }                    var e1 = new Employee('name');//继承Person的属性                    var e1.eat()//继承Person的方法
二、泛型（generic）--参数化的类型，一般用来限制集合的内容        1、var workers:Array<Person> = [];             workers[0] = new Person("zhangsan");//Person是Person里面的             workers[1] = new Employee("zhangsi",'2');//Employee也是Person里面的             workers[2] = 2;//2不是Person里面的三、接口（Interface）--用来建立某种代码约定，使得其它开发者在调用某个方法或创建新的类时必须遵循接口所定义的代码约定        1、声明参数            interface Person {                name: string;                age: number;            }            class Person {                constructor(public  config:Person){
                }//接口（第一个使用方式）用作一个方法的参数的类型声明时，当在调用这个方法时，会查传入的参数是否满足接口所声明的所有属性            }
            var p1 = new Person ({                name: "zhangsan";                age:18            })          2、用接口声明方法            interface  Animal {                eat()             }             class Sheep implements Animal {//关键字implements表示声明一个类实现Animal这个接口,必须要实现接口的方法                    eat() {                        console.log('i eat grass')                    }             }四、模块（Module）-- 模块可以帮助开发者将代码分割为可重用的单元。开发者可以自己决定将模块中的哪些资源（类、方法、变量）                            暴露出去供外部使用，哪些资源只在模块内使用。            1、理解模块--一个文件就是一个模块，就是这么个意思 ，不用想的多么高大尚                文件1名为：a.ts，内容如下                     export var prop1;                          var prop2;                      export function func1(){
                      }                      function func2(){
                      }                      export class Cla1 {
                      }                      class Cla2 {
                      }                 文件2名为：b.ts，内容如下                      console.log(prop1)                      func1();                      new Cla1();//上面这些都可以拿到，因为在文件a.ts中用export暴露出来了可以拿到，而其它这个文件拿不到                                            //当然你也可以暴露b.ts文件里的东西，在a.ts文件中就可以做得到了，都可以暴露

五、注解（annotation）-- 注解为程序的元素（类、方法、变量）加上更直观更明了的说明，这些说明信息与程序 的业务逻辑无关                                而是供指定的工具或框架使用的。
               1、类的举例                    import {Component} from '@angular/core';                    @Component({                        selecto:'app-root',                        templateUrl:'./app.componemt.html',                        styleUrls:['./app.component.css']                    })//@Component这里面就是注解                     export class AppComponent {                        title = 'app works!';                    }//告诉框架（angulars）怎么如何来处理标准的tpyeScript写出来的一个类如何放在这个框架中使用
六、类型定义文件（*.d.ts）-- 类型定义文件用来开发者在TpyeScript中使用已有的javaScript的工具包 如：jQuery                1、有一个工具叫Typings,这个是专门用来将一个框架变成定义文件用