typescript静态属性,静态方法,抽象类,多态

Posted 2020-12-25 spinoza

  1 /*
  2 1、vscode配置自动编译
  3 
  4     1.第一步   tsc --inti 生成tsconfig.json   改 "outDir": "./js",  
  5 
  6 
  7     2、第二步 任务 - 运行任务  监视tsconfig.json
  8 
  9 
 10 2、typeScript中的数据类型
 11 
 12     typescript中为了使编写的代码更规范，更有利于维护，增加了类型校验，在typescript中主要给我们提供了以下数据类型
 13 
 14 
 15         布尔类型（boolean）
 16         数字类型（number）
 17         字符串类型(string)
 18         数组类型（array）
 19         元组类型（tuple）
 20         枚举类型（enum）
 21         
 22         任意类型（any）
 23         null 和 undefined
 24         void类型
 25         never类型
 26 
 27 3、typeScript中的函数
 28 
 29     3.1、函数的定义
 30     3.2、可选参数
 31     3.3、默认参数
 32     3.4、剩余参数
 33     3.5、函数重载
 34     3.6、箭头函数  es6
 35 4、typeScript中的类
 36 
 37     4.1 类的定义
 38     4.2 继承
 39     4.3 类里面的修饰符
 40 
 41     4.4 静态属性 静态方法
 42     4.5 抽象类 多态
 43 
 44     
 45 */
 46 
 47 
 48 // 静态属性 静态方法  
 49 
 50 /*
 51 
 52     function Person(){
 53         this.run1=function(){
 54 
 55         }
 56     }
 57     Person.name=‘哈哈哈‘;
 58 
 59     Person.run2=function(){  静态方法
 60 
 61 
 62     }
 63     var p=new Person();
 64 
 65     Person.run2(); 静态方法的调用
 66 */
 67 
 68 
 69 
 70 /*
 71 
 72 
 73         function $(element){
 74 
 75             return new Base(element)
 76         }
 77 
 78         $.get=function(){
 79             
 80         }
 81 
 82         function Base(element){
 83 
 84             this.element=获取dom节点;
 85 
 86 
 87             this.css=function(arr,value){
 88 
 89                 this.element.style.arr=value;
 90             }
 91         }
 92 
 93 
 94 
 95         $(‘#box‘).css(‘color‘,‘red‘)
 96 
 97 
 98         $.get(‘url‘,function(){
 99 
100         })
101 */
102 
103 
104 
105 
106 
107 
108 
109 
110 
111 
112 
113 
114 
115 
116     // class Per{
117     //     public name:string;
118     //     public age:number=20;
119     //     //静态属性
120 
121     //     static sex="男";
122     //     constructor(name:string) {
123     //             this.name=name;
124     //     }
125     //     run(){  /*实例方法*/
126 
127     //         alert(`${this.name}在运动`)
128     //     }
129     //     work(){
130 
131     //         alert(`${this.name}在工作`)
132     //     }
133     //     static print(){  /*静态方法  里面没法直接调用类里面的属性*/
134 
135     //         alert(‘print方法‘+Per.sex);
136     //     }
137     // }
138 
139     // // var p=new Per(‘张三‘);
140 
141     // // p.run();
142 
143     // Per.print();
144 
145     // alert(Per.sex);
146 
147 
148 
149 
150 
151 
152 //多态:父类定义一个方法不去实现，让继承它的子类去实现  每一个子类有不同的表现 
153 
154 //多态属于继承
155         /*
156 
157 
158                 class Animal {
159 
160                     name:string;
161                     constructor(name:string) {
162                         this.name=name;
163                     }
164                     eat(){   //具体吃什么  不知道   ，  具体吃什么?继承它的子类去实现 ，每一个子类的表现不一样
165                         console.log(‘吃的方法‘)
166                     }
167                 }
168 
169                 class Dog extends Animal{
170                     constructor(name:string){
171                         super(name)
172                     }
173                     eat(){
174                 
175                         return this.name+‘吃粮食‘
176                     }
177                 }
178 
179 
180                 class Cat extends Animal{
181 
182                     constructor(name:string){
183                         super(name)
184                     }
185 
186                     eat(){
187 
188                         return this.name+‘吃老鼠‘
189                     }
190                 }
191 
192         */
193 
194 
195 
196 //typescript中的抽象类：它是提供其他类继承的基类，不能直接被实例化。
197 
198 
199 //用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
200 
201 
202 // abstract抽象方法只能放在抽象类里面
203 
204 
205 // 抽象类和抽象方法用来定义标准 。   标准：Animal 这个类要求它的子类必须包含eat方法
206 
207 
208 //标准:
209 
210 abstract class Animal{
211     
212     public name:string;
213     constructor(name:string){
214 
215         this.name=name;
216 
217     }
218     abstract eat():any;  //抽象方法不包含具体实现并且必须在派生类中实现。
219     
220     run(){
221 
222         console.log(‘其他方法可以不实现‘)
223     }
224 }
225 
226 
227 // var a=new Animal() /*错误的写法*/
228  
229 
230 
231 class Dog extends Animal{
232 
233     //抽象类的子类必须实现抽象类里面的抽象方法
234     constructor(name:any){
235         super(name)
236     }
237     eat(){
238 
239         console.log(this.name+‘吃粮食‘)
240     }
241 }
242 
243 var d=new Dog(‘小花花‘);
244 d.eat();
245 
246 
247 
248 
249 class Cat extends Animal{
250 
251     //抽象类的子类必须实现抽象类里面的抽象方法
252     constructor(name:any){
253         super(name)
254     }
255     run(){
256 
257 
258     }
259     eat(){
260 
261         console.log(this.name+‘吃老鼠‘)
262     }
263     
264 }
265 
266 var c=new Cat(‘小花猫‘);
267 c.eat();