抽象的概念

  狭义的架空,也尽管是代码里之泛,就是拿有互动关联的事情逻辑分离成属性和艺术(行为),这些性和方式就是可构成一个对象。

  这种肤浅是为着将不便知晓的代码归纳成跟实际世界关系的定义,比如小狗这样一个对象:属性可以概括出“毛色”、“品种”、“年龄”等等;方法(行为)可以归纳出“叫”、“跑”、“啃骨头”等。

  注意:这里的泛不是恃抽象类,抽象类我觉着放封装平节约讲比较确切。

10:简单密码

  • 查看
  • 提交
  • 统计
  • 提问

究竟时限定: 
1000ms

内存限制: 
65536kB

描述
Julius
Caesar曾经使用了千篇一律栽特别粗略的密码。对于公开中的每个字符,将她用她配母表中后5员对应的字符来顶替,这样虽赢得了密文。比如字符A用F来取代。如下是密文和当面中字符的呼应关系。

密文
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

明文
V W X Y Z A B C D E F G H I J K L M N O P Q R S T U 

您的天职是对加的密文进行解密得到明文。

若用专注的是,密文中出现的字母都是坏写字母。密文中呢囊括非字母的字符,对这些字符不用进行解码。

输入
一行,给出密文,密文不为空,而且里面的字符数不跳200。

输出
输出一行,即密文对应之公开。

样例输入
NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX

样例输出
IN WAR, EVENTS OF IMPORTANCE ARE THE RESULT OF TRIVIAL CAUSES

来源
翻译自 South Central USA 2002 的试题

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 using namespace std;
 5 char a[100001];
 6 char ans[100001];
 7 int now=0;
 8 int main()
 9 {
10     gets(a);
11     int l=strlen(a);
12     for(int i=0;i<l;i++)
13     {
14         if(a[i]>=70&&a[i]<=90)a[i]=a[i]-5;
15         else if(a[i]>=65&&a[i]<70)a[i]=a[i]+21;
16     }
17     puts(a);
18     return 0;
19 }

 

看似的悬空

  上面的事例是我们明显知道要创建一个目标(实例)dog,但骨子里付出中是无丁告我们需要创造哪些对象的,领导被咱们的只有需求,所以我们如果分析需求的事务逻辑,把需要分解变成一个个靶。

  比如说现在官员让咱们一个急需:做一个杂货店收银系统,分为两种角色:收银员和组织者,收银员可以查询物品信息、统计价格、录入账单信息、打印小票,管理员可以查阅账单信息、统计账单信息。

  注意需中之名词:收银员、管理员、物品信息、账单、小票,这些就是是自发之目标,这是不过开头的泛。

  让我们再度小心动词:查询、统计、录入、打印,我们是匪是啊得抽象成靶子?查询器?统计器?

  然后我们开始coding吧,不要纠结自己之泛是否全面,作者非常赞同Facebook的相同句子口号:Done is better
than perfect(比到更主要的凡形成).

  当某个对象的代码不断膨胀,慢慢超出控制的时候(作者自己的之规范是一个靶尽量不越300行代码),这时候你就得考虑重新怪层次的空洞了,查找这目标里代码比较多之属性、方法、然后抽象成外一个靶,把新目标作为本对象的成员(属性)。

 

function Dog(){
    this._tail = new Tail();//把尾巴tail抽象成另一个对象,作为dog的一个属性;
}

 

 

  当然,你成了直驾驶员后得以同样始就是把一个目标又抽象出不少分子对象,随你喜欢。

后话

  如果您欢喜作者的文章,记得收藏,你的点赞是本着笔者最深的砥砺;

  作者会尽量每周更新一回,下一样章是说话封装;

  大家来啊问题可留言或私信作者,作者尽量第一时间回复大家;

  如果一味驾驶员等觉得那里可以发未确切的,或可以发挥的双重好之,欢迎指出来,作者会赶紧修正、完善。

好像的概念和贯彻

  Javascript里创建一个靶有特别多种主意,也非常简单,就因为小狗之目标也条例:

 1 var dog = {
 2     hairColor: '白色',
 3     breed: '贵宾',
 4     age: 2,
 5     shout: function() {
 6         console.log('汪!汪!汪!'); //这里是你的业务逻辑代码,这里我就简单用这个来代替
 7     },
 8     run: function() {
 9         console.log('吃我灰吧,哈哈!');
10     },
11     gnawBone: function() {
12         console.log('这是本狗最幸福的时候');
13     }
14 };

  非常便捷,但此时有只问题:我一旦创很多独自dog怎么收拾?每创建同只有dog我都var一普呢?

  于是这我们就算引入了接近(class)的定义,类就为接近,具有相同特征的目标的原型,它的来意是创建对象(实例),类本身并无存在内存中,当运行类的代码时,一个靶(实例/instance)就让创造以内存中了,可以大概的明白类为创建对象的厂。

  Javascript(ES5)里无类似(class)这东西,它是透过构造函数来落实类似的:

 

 1 /*类的创建*/
 2 function Dog() {
 3     //构造函数:人们一致协定把构造函数的名字(即类名),首字母大写,以便区分
 4     this.hairColor = '白色';
 5     /*this指向被创造的对象(实例),如果不明白可以简单的理解为给对象(this)赋予hairColor这个属性
 6      */
 7     this.breed = '贵宾';
 8     this.age = 2;
 9     this.runSpeed = null; //string
10     /*属性的声明一定要放在构造函数的最顶部;
11     有的属性可能一开始没有初始值,会在方法里才赋值,但你一定要在构造函数里声明一下
12     有必要的话再声明一下属性的类型
13     */
14 }
15 Dog.prototype.shout = function() {
16     /*我们把方法追加到构造函数的prototype属性,而不是直接在构造函数里用this.shout = function(){};
17     这样的好处是会让Dog创造的所有对象都共享一个方法,从而节约内存;
18     一般来说属性在构造函数里赋予,方法在prototype里赋予;
19     更多prototype的知识就看书去吧,这里不会深讲,作者要保持本章知识的封装性;
20     */
21     console.log('汪!汪!汪!我是一只' + this.age + '岁的' + this.hairColor + this.breed);
22     //方法里通过this可以访问属性
23 }
24 Dog.prototype.run = function() {
25     this.runSpeed = '10m/s';
26     console.log('吃我灰吧,哈哈!本狗的速度可是有' + this.runSpeed);
27 }
28 Dog.prototype.gnawBone = function() {
29     console.log('这是本狗最幸福的时候');
30 }
31 /*对象(实例)的创建与使用*/
32 var dog1 = new Dog(); //
33 console.log(dog1.breed); //log: '贵宾'
34 dog1.shout(); //log: '汪!汪!汪!我是一只2岁的白色贵宾'
35 var dog2 = new Dog(); //创建多只dog(对象/实例)
36 var dog3 = new Dog();
37 /*dog1、dog2、dog3这些对象的属性是各自的,但方法是共享的*/
38 dog1.hairColor = '黑色'; //修改dog1的属性
39 console.log(dog1.hairColor); //log: '黑色';dog1属性已被修改;
40 console.log(dog2.hairColor); //'白色';其它对象不受影响;
41 console.log(dog3.hairColor); //log: '白色'
42 console.log(dog1.shout === dog2.shout); //log: true;dog1的shout方法和dog2的是同一个方法;

 

  但新的问题而来了:我怀念创立一个棕色的泰迪怎么处置也?创建的当儿传递参数给类的构造函数就可以解决当时问题。
  上单案例被说了,类创建的次第对象(实例)的法门的共享的,属性是独家的,但我不怕想创立一个共享的性怎么收拾吧?比如说我怀念创立一个instanceNumber属性来记录程序中dog对象(实例)的个数。

  这时候就好为此Dog类创建一个静态属性,静态属性是属于类的,所以她是休会见以对象(实例)的变型而变更,可以就此来装该类的全局变量,全局参数配置当。

  下面是初代码:

 1 function Dog(hairColor, breed, age) {
 2     this.hairColor = hairColor; //string,这种依赖参数的属性最好声明下类型或接口;
 3     this.breed = breed; //string
 4     this.age = age; //number
 5     this.runSpeed = null; //string
 6     Dog.instanceNumber++;
 7 }
 8 Dog.instanceNumber = 0; //创建静态属性
 9 Dog.prototype.shout = function() {
10     console.log('汪!汪!汪!我是一只' + this.age + '岁的' + this.hairColor + this.breed);
11 }
12 Dog.prototype.run = function() {
13     this.runSpeed = '10m/s';
14     console.log('吃我灰吧,哈哈!本狗的速度可是有' + this.runSpeed);
15 }
16 Dog.prototype.gnawBone = function() {
17     console.log('这是本狗最幸福的时候');
18 }
19 Dog.prototype.getInstanceNumber = function() { //为访问静态属性封装方法
20     return Dog.instanceNumber;
21 }
22 var dog1 = new Dog('白色', '贵宾', 2);
23 console.log(Dog.instanceNumber); //log: 1;虽然可以这样访问静态属性,并且还可以修改它,但坚决不推荐这样做
24 console.log(dog1.getInstanceNumber()); //log: 1;正确的做法!为什么要这样做,在封装一节会详细讲
25 var dog2 = new Dog('棕色', '泰迪', 1);
26 console.log(dog1.getInstanceNumber()); //log: 2;
27 var dog3 = new Dog('黑色', '土狗', 3);
28 console.log(dog1.getInstanceNumber()); //log: 3;
29 dog1.shout(); //log: '汪!汪!汪!我是一只2岁的白色贵宾'
30 dog2.shout(); //log: '汪!汪!汪!我是一只1岁的棕色泰迪'
31 dog3.shout(); //log: '汪!汪!汪!我是一只3岁的黑色土狗'

  接下是ES6的接近的始建方法,这段代码可以一直当Chrome浏览器运行,新手而不要管这一部分,包括再下的TypeScript代码。

  

 1 class Dog {
 2     constructor(hairColor, breed, age) { //代表这个类的构造函数
 3         this.hairColor = hairColor; //string
 4         this.breed = breed; //string
 5         this.age = age; //number
 6         this.runSpeed = null; //string
 7         Dog.instanceNumber++;
 8     }
 9     shout() {
10         console.log('汪!汪!汪!我是一只' + this.age + '岁的' + this.hairColor + this.breed);
11     }
12     run() {
13         this.runSpeed = '10m/s';
14         console.log('吃我灰吧,哈哈!本狗的速度可是有' + this.runSpeed);
15     }
16     gnawBone() {
17         console.log('这是本狗最幸福的时候');
18     }
19     getInstanceNumber() {
20         return Dog.instanceNumber;
21     }
22 }//ES6类的创建就比较舒服了,class把整个类用{}包裹在一起,写法也比较方便。
23 Dog.instanceNumber = 0;//遗憾的是ES6里也没有规范静态属性,还是跟ES5一样的用法,据说ES7已有一个静态属性的提案
24 let dog1 = new Dog('白色', '贵宾', 2);
25 let dog2 = new Dog('棕色', '泰迪', 1);
26 let dog3 = new Dog('黑色', '土狗', 3);
27 dog1.shout(); //log: '汪!汪!汪!我是一只2岁的白色贵宾'
28 dog2.shout(); //log: '汪!汪!汪!我是一只1岁的棕色泰迪'
29 dog3.shout(); //log: '汪!汪!汪!我是一只3岁的黑色土狗'
30 console.log(dog1.getInstanceNumber()); //log: 3;

  TypeScript创建对象,TypeScript还生无数得力的风味,但本章不便于介绍更多。

class Dog {
    hairColor: string;//class的所有属性必须在顶部全部声明,否则无法通过编译,这让类的创建更加规范;
    breed: string;//并且可以声明属性类型,如果给属性赋值的时候类型不正确也无法通过编译,当然,你也可以不声明类型或声明为any任何类型;
    age: number;
    runSpeed: string;
    static instanceNumber: number = 0;//TS静态变量的声明就比较舒服了,在class的{}里面,保证了代码的干净
    constructor(hairColor, breed, age) {
        this.hairColor = hairColor;
        this.breed = breed;
        this.age = age;
        Dog.instanceNumber++;
    }
    shout() {
        console.log('汪!汪!汪!我是一只' + this.age + '岁的' + this.hairColor + this.breed);
    }
    run() {
        this.runSpeed = '10m/s';
        console.log('吃我灰吧,哈哈!本狗的速度可是有' + this.runSpeed);
    }
    gnawBone() {
        console.log('这是本狗最幸福的时候');
    }
    getInstanceNumber() {
        return Dog.instanceNumber;
    }
}
let dog1 = new Dog('白色', '贵宾', 2);
let dog2 = new Dog('棕色', '泰迪', 1);
let dog3 = new Dog('黑色', '土狗', 3);
dog1.shout();//log: '汪!汪!汪!我是一只2岁的白色贵宾'
dog2.shout();//log: '汪!汪!汪!我是一只1岁的棕色泰迪'
dog3.shout();//log: '汪!汪!汪!我是一只3岁的黑色土狗'
console.log(dog1.getInstanceNumber());//log: 3;