- 前言
我在很多地方,或多或少都了解到人們對程序員的看法,大多是智商高情商低,不懂的浪漫之類的,並且看到了一個十分有趣的視頻,用程序來表達你對女朋友的愛,於是,便來了興趣,我想最浪漫的承諾,應該就是大話西游中周星馳的那段愛你一萬年的台詞:
曾經有一份真誠的愛情放在我面前，我沒有珍惜，等我失去的時候我才后悔莫及，人世間最痛苦的事莫過於此。如果上天能夠給我一個再來一次的機會，我會對那個女孩子說三個字：我愛你。如果非要在這份愛上加上一個期限，我希望是……一萬年.
於是便有了這篇文章的起源,我思考着,用我學過的編程語言,應該怎么樣去表達這件事情,接下來我將根據思路的由淺入深進行表述:
- 我們首先會聯想到的方案
程序員的世界里,也有一個無人不知的浪漫故事,我想大家都應該知道,說的是一個外國程序員,喜歡一個姑涼,但苦於自己的身份與性格,總不敢說出口,於是有一天他編寫了一個十分簡單的程序發個了那個喜歡的菇涼,其中就只有一句話,那就是"hello world !".
所以我們會很理所當然的用到下面這樣的代碼來表述"愛你一萬年"這個承諾:
public class thinkforlove {
public static void main(String[] args) {
System.out.println("愛你一萬年");
}
}
直接打印輸出這句話應該是每個程序員最初也是最容易想到的方式.
- 稍微深入一些的方案
但是在我們稍微思考過后我們或許就會否決上面的方案了,因為在程序的思想里,上面的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的繼承與多態.其實上面的方案中還是有一些地方可以修改完善一下的.
- 結合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