typescript类 继承 修饰符

1//1、ts中类的定义
2
3    /*
4    es5:
5
6        function Person(name){
7
8            this.name=name;
9
10            this.run=function(){
11
12                console.log(this.name)
13            }
14        }
15
16        var p=new Person('张三');
17
18        p.run()
19    */
20
21
22  /*
23        ts中定义类：
24
25
26            class Person{
27
28                name:string;   //属性  前面省略了public关键词
29
30                constructor(n:string){  //构造函数   实例化类的时候触发的方法
31                    this.name=n;
32                }
33
34                run():void{
35
36                    alert(this.name);
37                }
38
39            }
40            var p=new Person('张三');
41
42            p.run()
43  
44  */
45
46
47
48    /*
49    class Person{
50
51        name:string; 
52
53        constructor(name:string){  //构造函数   实例化类的时候触发的方法
54            this.name=name;
55        }
56
57        getName():string{
58
59            return this.name;
60        }
61        setName(name:string):void{
62
63            this.name=name;
64        }
65    }
66    var p=new Person('张三');
67
68    alert(p.getName());
69
70
71    p.setName('李四');
72
73
74    alert(p.getName());
75
76*/
77
78
79
80
81
82//2、ts中实现继承  extends、 super
83
84
85    // class Person{
86
87    //     name:string;
88
89    //     constructor(name:string){
90    //         this.name=name;
91    //     }
92
93    //     run():string{
94
95    //         return `${this.name}在运动`
96    //     }
97    // }
98    // // var p=new Person('王五');
99    // // alert(p.run())
100
101
102    // class Web extends Person{
103    //     constructor(name:string){
104
105    //         super(name);  /*初始化父类的构造函数*/
106    //     }
107    // }
108
109
110    // var w=new Web('李四');
111    // alert(w.run());
112
113
114
115
116
117
118    //ts中继承的探讨  父类的方法和子类的方法一致
119
120        // class Person{
121
122        //     name:string;
123
124        //     constructor(name:string){
125        //         this.name=name;
126        //     }
127
128        //     run():string{
129
130        //         return `${this.name}在运动`
131        //     }
132        // }
133        // // var p=new Person('王五');
134        // // alert(p.run())
135
136
137        // class Web extends Person{
138        //     constructor(name:string){
139
140        //         super(name);  /*初始化父类的构造函数*/
141        //     }
142        //     run():string{
143
144        //         return `${this.name}在运动-子类`
145        //     }
146        //     work(){
147
148        //         alert(`${this.name}在工作`)
149        //     }
150        // }
151
152
153        // var w=new Web('李四');
154        // // alert(w.run());
155
156        // // w.work();
157
158        // alert(w.run());
159
160
161
162
163
164
165
166
167
168// 3 类里面的修饰符  typescript里面定义属性的时候给我们提供了 三种修饰符
169
170/*
171    public :公有          在当前类里面、 子类  、类外面都可以访问
172    protected：保护类型    在当前类里面、子类里面可以访问 ，在类外部没法访问
173    private ：私有         在当前类里面可以访问，子类、类外部都没法访问
174
175    属性如果不加修饰符 默认就是 公有 （public）
176
177*/
178
179
180
181//public :公有          在类里面、 子类  、类外面都可以访问
182
183
184            //   class Person{
185
186            //         public name:string;  /*公有属性*/
187
188            //         constructor(name:string){
189            //             this.name=name;
190            //         }
191
192            //         run():string{
193
194            //             return `${this.name}在运动`
195            //         }
196            //     }
197            //     // var p=new Person('王五');
198            //     // alert(p.run())
199
200
201            //     class Web extends Person{
202            //         constructor(name:string){
203
204            //             super(name);  /*初始化父类的构造函数*/
205            //         }
206            //         run():string{
207
208            //             return `${this.name}在运动-子类`
209            //         }
210            //         work(){
211
212            //             alert(`${this.name}在工作`)
213            //         }
214            //     }
215
216            //     var w=new Web('李四');
217
218            //     w.work();
219
220
221        //类外部访问公有属性
222
223
224                //   class Person{
225
226                //     public name:string;  /*公有属性*/
227
228                //     constructor(name:string){
229                //         this.name=name;
230                //     }
231
232                //     run():string{
233
234                //         return `${this.name}在运动`
235                //     }
236                // }
237
238                // var  p=new Person('哈哈哈');
239
240                // alert(p.name);
241
242
243
244
245
246//protected：保护类型    在类里面、子类里面可以访问 ，在类外部没法访问
247
248
249            //   class Person{
250
251            //         protected name:string;  /*公有属性*/
252
253            //         constructor(name:string){
254            //             this.name=name;
255            //         }
256
257            //         run():string{
258
259            //             return `${this.name}在运动`
260            //         }
261            //     }
262                // var p=new Person('王五');
263                // alert(p.run())
264
265
266                // class Web extends Person{
267                //     constructor(name:string){
268
269                //         super(name);  /*初始化父类的构造函数*/
270                //     }                  
271                //     work(){
272
273                //         alert(`${this.name}在工作`)
274                //     }
275                // }
276
277                // var w=new Web('李四11');
278
279                // w.work();
280
281                // alert( w.run());
282
283
284                
285        //类外外部没法访问保护类型的属性
286
287
288                // class Person{
289
290                //     protected name:string;  /*保护类型*/
291
292                //     constructor(name:string){
293                //         this.name=name;
294                //     }
295
296                //     run():string{
297
298                //         return `${this.name}在运动`
299                //     }
300                // }
301
302                // var  p=new Person('哈哈哈');
303
304                // alert(p.name);
305
306
307
308
309
310// private ：私有        在类里面可以访问，子类、类外部都没法访问
311            
312
313                // class Person{
314
315                //     private name:string;  /*私有*/
316
317                //     constructor(name:string){
318                //         this.name=name;
319                //     }
320
321                //     run():string{
322
323                //         return `${this.name}在运动`
324                //     }
325                // }
326
327
328                // class Web extends Person{
329
330                //     constructor(name:string){
331                //         super(name)
332                //     }
333
334                //     work(){
335
336                //         console.log(`${this.name}在工作`)
337                //     }
338                // }
339
340
341
342    class Person{
343
344        private name:string;  /*私有*/
345
346        constructor(name:string){
347            this.name=name;
348        }
349
350        run():string{
351
352            return `${this.name}在运动`
353        }
354    }
355
356    var p=new Person('哈哈哈');
357
358    alert(p.run());