[java]__如何用你的编程语言表达至尊宝"爱你一万年"的浪漫情怀.

• 前言

我在很多地方,或多或少都了解到人们对程序员的看法,大多是智商高情商低,不懂的浪漫之类的,并且看到了一个十分有趣的视频,用程序来表达你对女朋友的爱,于是,便来了兴趣,我想最浪漫的承诺,应该就是大话西游中周星驰的那段爱你一万年的台词:

曾经有一份真诚的爱情放在我面前，我没有珍惜，等我失去的时候我才后悔莫及，人世间最痛苦的事莫过于此。如果上天能够给我一个再来一次的机会，我会对那个女孩子说三个字：我爱你。如果非要在这份爱上加上一个期限，我希望是……一万年.

于是便有了这篇文章的起源,我思考着,用我学过的编程语言,应该怎么样去表达这件事情,接下来我将根据思路的由浅入深进行表述:

---

1. 我们首先会联想到的方案

程序员的世界里,也有一个无人不知的浪漫故事,我想大家都应该知道,说的是一个外国程序员,喜欢一个姑凉,但苦于自己的身份与性格,总不敢说出口,于是有一天他编写了一个十分简单的程序发个了那个喜欢的菇凉,其中就只有一句话,那就是"hello world !".

所以我们会很理所当然的用到下面这样的代码来表述"爱你一万年"这个承诺:

public class thinkforlove {
    public static void main(String[] args) {
        System.out.println("爱你一万年");
    }
}

直接打印输出这句话应该是每个程序员最初也是最容易想到的方式.

1. 稍微深入一些的方案

但是在我们稍微思考过后我们或许就会否决上面的方案了,因为在程序的思想里,上面的1方案只是输出了一个没有意义的字符串.之所以我们能够确认并理解其含义,是因为这行字符串是中文,相当于是中国人通用的编程语言,我们在大脑里编译,并得到其含义,然后使得我们能够理解.

所以我们在使用编程语言来表达他们的时候,最基本的应该对其名词性的"爱","年(爱的期限)"进行定义,声明变量来表示他们.并通过这两个变量来表述这件事情,所以就可以演化为下面的这种方案:

 int loveyear = 0;  // 声明变量
    boolean love = true;
    while (loveyear<10000){
        loveyear++;
    }
        System.out.println("我对你的爱是:"+love+",期限是:"+loveyear+"年");
    }

我们看到,在这里我们定义了"爱","爱的期限",并初始化了它们,并同过循环来控制其具体值为10000年.看起来这应该是就是比较完美的表述了.但是一直到这里,可能会有疑问,这里并没有更编程语言的特点联系起来吧,这两种表述应该在很多编程语言都是共同的,这又怎么能算是使用"你的编程语言"来表述这件事情呢.文不符题;

3 .结合java面向对象编程思想的方案

我们在题目中就说过了,用我们的编程语言来表述这件事情,而我们知道,java语言的根本是面向对象,即一切都可以看做是对象,任何问题都可以通过对象来解决,并且通过面向对象的思想,实际上,上面的两种方案都或多或少的有些缺陷的.于是我们可以使用面向对象的思想来改进上面的方案:

• 首先,我们应该把"我"和"你"封装为一个humanity类,这是"爱你一万年"这个承诺是两个人之间的事.

并且声明humanity类的属性:应该有名字,性别,爱,与所爱的人,当然,我们要想获取和设置他们,还需要成员方法与构造方法,另外,每个人类还有确定自己爱人的方法,于是,hummanity类的构建就完成了:

class Humanity{
// 声明人类的属性,成员变量.
    private String name;
    private char sex;
    private boolean love;
    private String Lovename; // 爱人的名字

// 成员方法,用来获取和设置类的属性.
    public boolean isLove() {
        return love;
    }
    public void setLove(boolean love) {
        this.love = love;
    }
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex){
        this.sex = sex;
    }

// humanity类的构造方法,用来构造对象,构造我们的爱人.
    Humanity(String name,char sex){
        this.name=name;
        this.sex=sex;
    }
    Humanity(String name,char sex,String Lovername){
        this.name=name;
        this.sex=sex;
        this.Lovename = Lovername;
    }

    // 定义确认爱的方法
    boolean forlove(Humanity woman){
        if (this.Lovename.equals(woman.name)){
            this.love=true;
        }else
        {
            this.love=false;
        }
        return love;
    }
}

那么我们就可以通过面向对象的思想,通过实例化我们自己并new一个我们的爱人(我会告诉你们我的爱人还需要new吗?)然后通过循环控制爱的期限,输出,就可以得到下面的方案了:

 public static void main(String[] args) {
        int loveyear = 0;  // 声明变量

        Humanity xiaoshe = new Humanity("小舍", '男', "小舍的女朋友");  // 实例化自己
        Humanity lover = new Humanity("小舍的女朋友", '女'); // new一个女朋友
      // 通过循环完成承诺的年限
        if (xiaoshe.forlove(lover)==true){
            while (loveyear<10000){
                loveyear++;
            }
        }
        System.out.println(xiaoshe.getName()+"对"+lover.getName()+"的爱是:"+xiaoshe.isLove()+"期限是:"+loveyear);
    }

如此,应该算是符合JAVA语言特点的一种表达方案了;但是,在我们学习了解了java语言的类的高级特性,与类部类,抽象类,java的继承与多态.其实上面的方案中还是有一些地方可以修改完善一下的.

1. 结合Java类的特性,面向对象的继承与多态的方案

在前面的学习中,我们了解到了类的继承关系,并且其实上面方案中从humanity中实例化出来的男人和女人是有些缺陷的,因为男人和女人之间是有明显的属性差异的,所以我们应该将它们封装成为两个不同的类,并将humanity类封装为抽象类,由子类继承并设置属性,重写其中方法来实现多态性:

并且,前面,我们将"确认自己的爱人"这一行为封装到类方法里面了,其实也可以将每个人对爱人的爱的年限也可以封装成类中的方法;这样其实更加合理一些,应为爱一个人年限,取决于这个人,也可以说是个人的行为,而行为在面向对象的思想中就是一方法体来表现的.

我们整理好思路之后,便可以重新修改上面改进上面的的方案了,使得它更加能够体现java编程语言的特点:

• 首先将humanity类重新定义为抽象类并确认属性和抽象方法

abstract class Humanity{
     private String name;
     private char sex;
     provate boolean love;
     private String Lovename; // 爱人的名字
    // 成员方法
    abstract boolean getlove();
    abstract void setlove();
    abstract char getSex();
    abstract void setSex();
    abstract String getName();
    abstract void setName(String name);

    // 定义确认爱人的方法和爱的年限的方法
    abstract boolean forlove(Humanity woman);
    abstract int loveyear();
}

• 然后定义man和woman类继承humanity类,并初始化其部分属性,并重写实现抽象方法,

class woman extends Humanity{
    private int  breastsize;  // 你可以添加子类的属性,使其能够new一个更加具体的女朋友.

// 成员方法
    @Override
    boolean getlove() {
        return this.love;
    }

    ......

    @Override
    void setSex(char sex) {
    this.sex='女'; //通过重写父类方法来初始化子类应该有的特性.
    }
// 构造方法
woman(String name,String lovername){
    this.name=name;
    this.Lovename=lovername;
}
woman(String name){
    this.name = name;
}
// 行为方法
    @Override
    boolean forlove(Humanity woman) {
        if (super.Lovename.equals(woman.name)){
            this.love=true;
        }else
        {
            this.love=false;
        }
        return this.love;
    }
    @Override
    int loveyear() {
        int loveyear = 0; // 初始化一个人爱的年限.
        if (this.love==true){
            while(loveyear<10000){
                loveyear++;
            }
        }
        return loveyear;
    }
}

man类以相同原理定义,在相关类和方法定义完成后,我们就可以编写如下方案了:

  public static void main(String[] args) {
        man aman = new man("小舍先生", "小舍先生的女朋友");
        woman awoman = new woman("小舍先生的女朋友");
        aman.forlove(awoman);
        System.out.println(aman.getName()+"对"+awoman.getName()+"的爱是:"+aman.love);
        System.out.println("爱的期限是:"+aman.loveyear()+"年");
    }

• 使用匿名内部类的方案

当然,你还可以通过匿名内部类来过滤掉无意义的继承类man与woman.直接通过匿名内部类间接实现humanity类的实例化对象,通过匿名内部类继承的方法直接实例化自己.并new一个女朋友.因为在这里我们并不需要man类与woman类,我们只需要两个具体的人(对象).于是我们可以直接通过匿名内部类继承humanity类,并在其中通过重写方法的操作来实现:

package java02.day_4_17;

/**
 * @outhor xiaoshe
 * @date 2019/4/17  - @time 13:38
 *关于
 */
public class thinkforlove {

    public static void main(String[] args) {
        Humanity aman = new Humanity() {
            @Override
            char Sex() {
                return '男';
            }

            @Override
            String Lovename() {
                return "小舍的女朋友";
            }

            @Override
            boolean love() {
                return false;
            }

            @Override
            String Name() {
                return "小舍";
            }

            @Override
            boolean forlove(Humanity woman) {
                if (this.Lovename().equals(woman.Name())){
                    return this.love=true;
                }else
                {
                   return this.love=false;
                }
            }

            @Override
            int loveyear() {
                int lovear = 0;
                if (this.love==true){
                    while(lovear<10000){
                        lovear++;
                    }
                }
                return lovear;
            }
        };  // 直接通过匿名内部类直接继承humanity类实例化自己.
        Humanity awoman = new Humanity() {
            @Override
            char Sex() {
                return '女';
            }

            @Override
            String Lovename() {
                return null;
            }

            @Override
            boolean love() {
                return false;
            }

            @Override
            String Name() {
                return "小舍的女朋友";
            }

            @Override
            boolean forlove(Humanity woman) {
                if (this.Name().equals(woman.Name())){
                    return this.love=true;
                }else
                {
                    return this.love=false;
                }
            }
            @Override
            int loveyear() {
                int lovear = 0;
                if (this.love==true){
                    while(lovear<10000){
                        lovear++;
                    }
                }
                return lovear;
            }
        }; // 直接通过匿名内部类直接继承humanity类new一个女朋友.
        aman.forlove(awoman);  // 调用forlove方法来确认自己对女朋友的爱是否为true.
        System.out.println(aman.Name()+"对"+awoman.Name()+"的爱是:"+aman.love);
        System.out.println("爱的期限是:"+aman.loveyear());
    }
}
// 抽象类
abstract class Humanity{
     private String name;
     private char sex;
     protected boolean love;
     private String Lovename; // 爱人的名字
    abstract char Sex();
    abstract String Lovename();
    abstract boolean love();
    abstract String Name();
    // 定义确认爱人的方法和爱的年限的方法
    abstract boolean forlove(Humanity woman);
    abstract int loveyear();
}

以便于观察IDEA可以收起方法体或类体:

输出结果是这样的:

以目前的能力,貌似就只能到这里了.这就是我从java语言方面对"爱你一万年"这样的浪漫情怀,亦或者说珍贵承诺的表达.

---

所以,还有谁说程序员不懂浪漫的呢,我们可是也会使用程序,代码来表达"爱你一万年"这样具有浪漫情怀的情话的哈,我们可不是钢铁直男.!!!

---

那么,你们可以如何使用你们的编程语言来表达这一具有浪漫情怀的事件呢.???

欢迎留言,一起讨论学习.

---

更新时间:

2019-4-17

21:56