NOKIA(诺基亚)

适合诺基亚3020的Java手机浏览器:UC浏览器VS欧鹏VS诺基亚

诺基亚3020配备了一颗不错的1G处理器,和150MB左右的内置可以存储空间,显然我们不能让这些资源空闲着。但鉴于诺基亚3020是采用的S40这款基于Java的系统故而只能安装Java版本的应用。

于是笔者开始在网上寻找一些较为实用的Java程序,今天就说说诺基亚3020上合适的3款Java浏览器:UC浏览器、欧鹏、诺基亚浏览器(默认安装),另外在这个过程中笔者还遇到了一些有趣的现象。

诺基亚手机浏览器

显然一款合适的浏览器几乎是每一款手机的必备应用——无论是智能手机还是类似于诺基亚3020这样的功能型手机。让我很不屑的是还有很多人在使用各种手机自带的那种原始浏览器,那显然是很不可取的。而诺基亚3020默认的浏览器是诺基亚浏览器,虽然在他的介绍中似乎一直在阐明其各种优点,但缺点也是显而易见的:

  • 诺基亚浏览器默认的那个鼠标治标使用起来非常不方便,特别是在分页或者是移动页面的时候尤其如此,如果是大屏幕还好点,但诺基亚3020的屏幕只有320×240。
  • 流量资费我想对于大多数人来说还是在意的,诺基亚手机浏览器在这里点上做的还不错,但说是在的浏览体验不怎么样。
  • 无法全屏总是让我非常的不习惯,总觉得它有些笨拙

基于以上几点我果断不建议大家使用。那么我们用什么呢?Opera手机浏览器!或者UC

Opera手机浏览器

为什么我首先推荐的是Opera手机浏览器(现在改名欧鹏)?这个和我个人使用习惯有关,我应用浏览器最主要是浏览一些新闻网站,但那入口都不是国内某某门户,而且我一向喜欢简洁快速,这一点上诺基亚3020自带的诺基亚浏览器和UC手机浏览器都是浮云,进去一大堆的推介网址放在那然我好生不爽快。而且Opera手机浏览器的载入速度是最快的,至少在诺基亚3020上的Java签名版我用起来就是秒开,而不用等待那个启动界面。另外Opera手机浏览器还有一下特点:

  • 支持网页压缩,这意味着节省流量和提高载入速度。
  • 支持全屏显示,这意味着更高效的利用诺基亚3020的320×240屏幕
  • 整体操作简捷流畅而不失功能

反观UC浏览器,我个人觉得不太适合我,它所打的广告声称多么节省流量,但这在Opera手机浏览器和诺基亚手机浏览器面前简直就是小菜。而在观首页界面上,UC和诺基亚都放置了大量“无用”网址,看着头疼。不过UC浏览器还是比诺基亚浏览器整体感觉要好很多,起码翻页移动位置要方便,所以可能对于大多数其他用户而言使用体验也还是可以的。

当然了,我这里所说的仅仅是针对诺基亚3020以及其他Java环境下的浏览器而言(诺基亚3020怎么样?从6要素分析我为什么买诺基亚3020手机),而对于Android或者iOS系统而言可能并不适用,因为就我的适用情况来看,欧鹏浏览器在智能手机上的适用体验优势并不突出。但如果考虑到节省流量的话,欧鹏浏览器还是第一选择。

对于安装这些Java应用,我建议还是通过诺基亚商店以及诺基亚PC套件在电脑上安装,这样更快更方便而且安装的程序图标上没有那个“钥匙”图标,看起来要舒服很多。另外关于诺基亚3020的型号很多提供应用下载的网站将其归类到C310或者C300里面了,下载的时候大家注意一下便可。

Java

jqs.exe是什么进程?及如何关闭jqs.exe和识别相关病毒?

看到Windows务管理器中的jqs.exe进程了吗?它的运行起到什么功能?会是病毒吗?下面就了解下jqs.exe是什么进程吧!

jqs.exe进程基本信息:
程序厂商:Sun Microsystems
进程描述:Java快速启动
进程属性:不是Windows系统进程
使用网络:没有
启动情况:随系统自动启动

来历及作用

Java标志jqs.exe进程程序文件是由Sun Microsystems(美国太阳微系统公司,已被甲骨文公司收购)定义的独立于操作系统的应用程序环境Java套件的一部分,被描述为:Java Quick Starter Service(Java快速启动)简称JQS。Java SE 6 Update 10版的Java中增加了这项功能,其主要作用是改善大部分的Java Applet和应用程式的初次启动时间。(延伸:Jusched.exe是什么进程?

jqs.exe会定期将一些最常使用的Java运行环境文件读取到计算机内存中(占用不超过20MB的RAM),当Java的启动后,将会大幅降低程序所需的磁碟I/O,因而让启动更为顺利且明显加快启动速度。本进程通常只存在于Windows 2000何XP系统中,而在Windows Vista和Windows 7系统中由于有自己的预先载入机制则不需要jqs.exe。

jqs.exe所在位置: C:\Program Files\Java\jre6\bin\jqs.exe

温馨提示:jqs.exe进程的快速启动服务在运行时会先执行检查,如果是使用电池供电的笔记本电脑或者平板电脑、上网本等jqs.exe的快速启动服务会停止工作,当接入外接电源时会继续运行。另外,Java运行环境常常是Java开发人员用到的功能,作为普通用户通常很少用到它,所以如果发现jqs.exe存有异常,可用下文的方法禁止其运行。

禁止jqs.exe运行

如果你需要jqs.exe,但它当前存在异常,你可以直接在Windows任务管理器中将其进程结束。如果你并非Java环境用户,可以用一下方法彻底禁止其运行:

对于Windows XP用户而言,首先打开控制面板(控制面板在哪?),然后找到“Java控制面板”(就是左上图的那个茶杯图标),点击“高级”选项卡展开“杂项”后去掉“Java Quick Starter”的选取状态,然后点击确定重启系统即可。

jqs.exe病毒

由于本进程是比较常见的,而这样的程序通常也是那些流氓软件或者木马病毒们感染的目标,它们常使用与jqs.exe相同或类似的名称来迷惑用户。虽然目前还鲜有jqs.exe感染病毒的情况发生,但出于防范于未然的目的,我们可以用些方法进行鉴别:

  • jqs.exe进程不在上文所述的Java安装目录下;
  • 任务管理器中有多个jqs.exe在运行;
  • 无法通过上面介绍的方法将其禁止;
  • 系统出现jqs.exe错误的提示;(文件被病毒修改或替换所致)

若出现以上情况请及时更新杀毒软件病毒库对电脑进行全盘查杀,必要时可考虑重装系统。

Java

Jusched.exe是什么进程?了解Jusched.exe文件及相关病毒

当你打开Windows系统任务管理器时是否在里面看到有jusched.exe进程在运行?那么这个jusched.exe是什么进程呢?

jusched.exe进程基本信息
程序厂商:Sun Microsystems
进程描述:Java程序更新调度
进程属性:不是Windows系统进程
使用网络:没有
所在位置:C:\Program Files\Java\…

来历及作用

任务管理器中的jusched.exe进程Javajusched.exe进程程序文件是由Sun®(美国太阳微系统公司,已被甲骨文收购)定义的独立于操作系统的应用程序环境Java套件的一部分,这个进程会定期启动另一个进程处理Java检测的技术更新以确保Java能更安全、稳定的运行。

默认情况下此服务被设置为自动启动并后台运行(不需用户干预的情况下运行于操作系统后台的计算机进程)。不过显然Java没有那么多的更新需要,而这个过程中无所事事的jusched.exe却一直在占用了电脑的内存资源(平均内存占用3MB左右)。

通常情况下此进程的运行是安全的,当然,如果你觉得它没必要运行,那么可以通过在控制面板中查找到Java控制面板选到“更新(Update)”选项卡去掉下面“自动检查更新”前面的勾选状态即可,如下图所示:(延伸:rundll32.exe是什么进程?

禁止Java自动更新jusched.exe

Jusched.exe病毒

作为一个运行在Windows系统中的常见的进程,jusched.exe也吸引到了木马病毒及流氓软件的关注,他们的时始作俑者曾试图使用相同的名称来迷惑用户以便获得信任,相关病毒已被杀毒软件厂商查获,比如W32/Agobot-OW网络蠕虫病毒、Troj / DwnLdr FUX自动下载其他的恶意软件的木马程序等。如果的系统出现以下情况应使用杀毒软件对电脑进程全盘查杀:

  • 在任务管理器中看到多个jusched.exe在同时运行;
  • 程序文件不在你按照Java的目录中;
  • 程序占用网络资源或过高的CPU占用率;

另外如果出现jusched.exe程序错误也可能是感染病毒所致,不过也不排除程序问题,对于这种程序导致的错误可以通过控制面板将Java自动更新关闭,如果依然出现问题应考虑重新安装Java。如果你发现更多信息期望您的留言,任何内容都将是重要的参考。

Lisp真是一门好语言

lisp真是一门终极的编程语言。我接触lisp也不过一个月时间?现在发自肺腑的这么觉得。为什么?因为lisp又高级又基础,lisp没有python或者ruby里那些便利的数组或者hash操作函数,很多时候,lisp的数据只由2个部分组成:

(AAA . BBB)

第一个元素AAA称为car部分,剩下的另外一半。不管有多少,称为cdr部分。也就是对称的第二个元素。这叫con cell元素。很多复杂的数据结构,比如数组,hash表,红黑树,二叉树都是由它实现的。你说它不基础?但是lisp又很高级,c语言的一个特性是,机器效率虽高,但是人工效率很低。而lisp不同,《黑客与画家》中指出,lisp只需要c语言十分之一的代码就能实现同等的功能。而lisp甚至能直接操作cpu的寄存器,这是哪种高级虚拟机语言能实现的?

lisp很简洁,用一句话就能概括lisp的语法:

例如(A B C)

用圆括号括起来称为一个列表,列表中第一个原子被视为函数,其他原子被视为变量。而由单括号‘前导的元素什么也不视为(不求值),只按原样返回。

完了,就这么简单。剩下的都是细节。要知道真理都是很简洁的,比如e=mc2,真理总结出来都这么简单。所以lisp很强。

用多数人可以理解的话说,lisp没有”保留字“。我们知道每种语言包括c但是有保留字的。这意味着2点:

1.他们的处理语句和数据是分开的,不一样的。
2.他们都是被限制了的

但是lisp没有保留字,为什么呢?你看多数语言像c++,Java根本就没有所谓符号(symbol),ruby有符号,但是应用很少。lisp不同,lisp大多数原子都是符号。比如(print atom-1 atom-2),每一个符号可以连接着一个函数定义,或者一个变量定义,这个例子就是对atom-1,atom-2 两个符号进行求值,找出他们的变量定义然后交给print这个函数去运算。你可以把它调过来。(atom-1 print atom-2) ,这个例子就是对print,atom-2 两个符号进行求值,找出他们的变量定义然后交给atom-1连接的函数去运算,区别可能是print可能是一个系统预先定义好的函数,而atom-1可能是用户自定义函数。所以说lisp是没有保留字,也不需要保留字的。

所以我们就可以看到了,lisp一个有名的特点,数据和语句是一样的,是怎么实现的了。非常简单,同样的东西,你把它放在列表第一个,就是函数,否则就是变量,如果加上单引号不求值,那就是数据。如此,lisp也可以实现非常强大的宏系统,这也是独一无二的,其他语言都不能,因为他们都不可以把数据和语句区别开来。简单的说,宏就是接受一个参数,然后返回对应的代码,插入到调用宏的位置

( defmacros (args)
`(defun aaaaa(,args)
;; process ))
这样的东西

把对应的代码恢复到对应位置,只要求值,就和普通的代码无异。所以lisp可以。而其他语言不可以。你返回一段语句,这段货的数据类型是啥?它就是数据,不是语句。要运行它,eval它,然后只能得到一个结果(以我对ruby粗浅的了解,它已经比java灵活太多了)。不像lisp可以替代源代码中的一个部分,比如替代函数中的一部分,这段代码可以操作参数,其他语言可以么?

但是lisp这么强大,为什么1958年就被发明,半个世纪以来,lisp没有广泛的应用?

lisp并非没有得到过应用。在教学领域,lisp是一门非常广泛使用的语言,那些不急功近利的学校比如麻省理工,入门课都采用schme(一门lisp的方言),而在商业领域,有名的《黑客与画家》的作者P··G在创立世界第一家互联网企业viaweb时,使用的是lisp。lisp之所以没有被广泛应用,是因为它太强大了,这么说似乎有点欠揍,但强大就意味着灵活,而灵活就意味着几乎没有语法。那些商业公司想要的只是稳定,把工作完成,他们并不在乎你用什么语言开发。他们才恨不得每一行都是钉死的,所有人都用一个名字写函数,因为这样可以花更少的钱维护。ruby之父松本行宏曾这么说:

而lisp的问题在于,只要你掌握了s表达式,想写出什么样的程序都行,这意味lisp是没有语法的。这在应用上带来了一定的麻烦。我不希望自己的语言是没有语法的。所以ruby加入了一定的语法限制。

而在程序员的角度来说,以我看来,大多数人似乎不那么聪明,多数人喜欢用一种死语言(java/c++)也无可厚非,因为他们的思维可能就是死的。lisp可能更适用于强大的黑客,自己或者少数人每个人都很强的类型,它是一种黑客语言,而不是一种商业语言。

综上所述,lisp是灵活的,天马行空的,没有限制的。在我看来,一旦使用lisp,就不会想在去使用其他语言。lisp有一种和谐的美。我认为,Fortran,c++,java这样的东西是应需而生的,他们是为了满足当下的需要和硬件条件而设计使用的。而lisp从开始就是为了迎合真理和美而生。所以50年过去了,lisp还没有过时。lisp就是计算机界的真理,记得漫画《风云》中有这么一句,因为不管到哪里,真理(或者是类似的词)就是真理,所以绝世好剑的形状在哪都是一样的。lisp也是一样。以后可能会出现别的名字的语言,也可能不叫lisp,但是真理总是真理,所以绝世好剑的形状总是一样的。

但是从现实的角度来看,我们要编程,如何运用lisp呢?

  1. emacs使用emacs lisp作为架构语言(不仅仅是扩展语言),这是绝佳的学习lisp的途径
  2. common lisp和scheme作为lisp最有名的两门方言,广为人知。但是在教育领域应用比较多。实际用途似乎比较少
  3. GNU组织使用guile作为gnu通用扩展语言,但是我没听说哪有它的应用。
  4. 时下最火的clojure,你可能听说过,这是一种运行在java虚拟机上的lisp,编译为java字节码,具有和java一样的速度,使用它可以无缝使用jdk里的所有库和java的无数第三方库,现在你知道它为啥火了。clojure的一个子集可以编译为javaascript运行在浏览器中,这带来了无尽的可能,尽情的享受那些愚民们的成果吧,node.js貌似也行。
Java

Java设计模式之State状态模式

网上也看些文章,有的模式和我写的差不多,有的就差别就很大,思路根本不一样。这不一定说谁对谁错,某些模式实现方式就有很多。还有网上一大堆的文章很多都一样,不一定是大家的观点,有些就是抄来抄去而且不带出处的,太坑爹了。

我说过我的JAVA文章仅代表一家观点,本人又是个彩笔,有什么错误在所难免。不过我还是要认真研究研究,也不能一味盲目相信。

今天还是继续写文章,Java设计模式系列之State状态模式。状态我们很熟悉了,像进程调度啊,线程运行啊,Hibernate中的实体类都有状态,这一步的状态是什么,要做什么,下一个状态又是什么,都需要确定。但是我们要判断事务的状态,有很多比如IF/ELSE ,SWITCH(),不过这样会导致大量的判断代码,网上就有一些大湿就提出IF/ELSE已死的说法,大牛就是意识超前啊,很多人现在就提出NOSQL设计,不见得就能被广泛的采用,有数据库巨头像Oracle肯定不同意撒,思想就是百家争鸣嘛,感兴趣的话了解了解。当然IF/ELSE太多的话很定不好撒,而且你要增加状态怎么办,像Android中的Activity的生命周期有七个状态,有人就说加IF/ELSE呗,用的地方太多难道要一个一个的改么。

我们的State状态模式就解决这个问题,这里就用四个状态,多了也一样,就是多加几个类,这就使得State模式的缺点暴露出来了,状态太多了有几十个就不宜用这个模式了。我们有一个State接口,其它的状态类实现这个接口,有四个状态类Create,Start,End,和Destroy。

State接口代码
package org.javaer.code.pattern.state;

import java.util.ArrayList;
import java.util.List;

public interface State {
        List<State> commands  = new ArrayList<State>();
 public void handle();
}

Create状态类代码
package org.javaer.code.pattern.state;

public class Create implements State {

        public Create() {
      commands.add(this);
        }
 @Override
 public void handle() {     
      execute(this);      
 }

 public void execute(State command){
     System.out.println(“create”);
     commands.get(commands.indexOf(this)+1).handle();
 }
}

Start状态类代码
package org.javaer.code.pattern.state;

public class Start implements State{

    public Start() {
 commands.add(this);
    }
 @Override
 public void handle() {
     execute(this);     
 }

 public void execute(State command){
     System.out.println(“start”);
     commands.get(commands.indexOf(this)+1).handle();
 }
}

End状态类代码
package org.javaer.code.pattern.state;

public class End implements State {

    public End() {
 commands.add(this);
    }
 @Override
 public void handle() {
     execute(this);
 }

 public void execute(State command){
     System.out.println(“end”);
     commands.get(commands.indexOf(this)+1).handle();
 }
}

Destroy状态类代码
package org.javaer.code.pattern.state;

public class Destroy implements State {

    public  Destroy() {
 commands.add(this);
    }
 @Override
 public void handle() {
     execute(this);
 }

 public void execute(State command){
     System.out.println(“destory”);
     //我这里加了这一句,就是想让它循环的转换状态,就会导致内存溢出
     commands.get(commands.indexOf(this)>=commands.size()-1?0:commands.indexOf(this)+1).handle();
 }
}

测试类Main代码
package org.javaer.code.pattern.state;

public class Main {
 @SuppressWarnings(“unused”)
 public static void main(String[] args) {
  State state1 = new Create();
  State state2 = new Start();
  State state3 = new End();
  State state4 = new Destroy(); 
  state1.handle();
 }
}

输出:
create
start
end
destory
create
start
end
destory
create
start
end
destory
.
.
.
.
.
Exception in thread “main” java.lang.StackOverflowError
 at sun.nio.cs.UTF_8.updatePositions(Unknown Source)
 at sun.nio.cs.UTF_8$Encoder.encodeArrayLoop(Unknown Source)
.
.
.
当然了状态处理handle方法没做啥子,就打印了个单词。
如果不想出现内存溢出(没有写方法停止),就把最后一个状态的handle方法的循环调用的一句代码去掉。
好了,状态模式就写完了,下面还是常用的Java设计模式,敬请持续关注。。。。
MSN:donglinmei@hotmail.com 
Skype:donglinmeimei 转载请注明出处http://mtoou.info/java-state-moshi/

Java设计模式之Factory工厂设计模式

首先向大家道个歉,这篇文章出的慢。其实呢,我也费了很大的劲来写的,从礼拜天就开始写了,后来因为小区停电了,没有保存,后面不得不重新写了。嗯,昨天晚上又是写到12点了,今天是公司培训,中午回家吃了泡面又接着写下去。下午非常累吧,中途睡着了,财务培训的检测做的很差,估计要挂了,希望不要找我回来再培训啊。条件比较幸苦吧,不管怎么样,我还是必须坚持下去,嗯,加油!!!

这期的文章是Java设计模式系列之Factory工厂模式,内容相对呢多一些,但是我会尽量把她写详细清楚。

工厂模式呢有三种,简单工厂模式工厂方法模式抽象工厂模式。基本掌握前两种就可以了,第三种要慢慢理解,我也是慢慢体会才弄明白的,呵呵,大家应该比我聪明,更容易理解。

简单工厂模式
简单工厂模式就是根据条件产生对象,比如条件为1产生什么对象,条件为2产生什么对象。。。嗯,我这里没有这么做,为了方便起见就打印了句话。
package org.javaer.pattern.factory;

public class SimpleFactory {
    //这里就用到了singleton单例模式
    private static SimpleFactory factory = new SimpleFactory();
    private SimpleFactory(){}
   
    public static SimpleFactory getInstance(){
        return factory;
    }
   
    public void factory(int type){
        if(type==1){//条件为1,打印KFC鸡翅
            System.out.println(“KFC’s chicken wing”);
        }else if(type==2){//条件为2,打印麦当劳鸡翅
            System.out.println(“Mcdonald’s chicken wing”);
        }else{//其他情况,没有鸡翅
            System.out.println(“no chicken wing”);
        }
    }
   
    public void factory(String type){
        if(“KFC”.equals(type)){
            System.out.println(“KFC’s chicken wing”);
        }else if(“Mcdonald’s”.equals(type)){
            System.out.println(“Mcdonald’s chicken wing”);
        }else{
            System.out.println(“no chicken wing”);
        }
    }
    public static void main(String[] args) {
        SimpleFactory simpleFactory = SimpleFactory.getInstance();
        simpleFactory.factory(1);
        simpleFactory.factory(“Mcdonald’s”);
    }
}

——————————————————————————————-简单工厂模式完

我们就可以在配置文件里配置我们要产生的对象的全名就可以了,比如erp.cfg.properties 文件中这样配置org.javaer.erp.dao.DAO=org.javaer.erp.dao.impl.DAOSupport
调用的时候就传入通过读取配置文件得到的Properties类,根据key得到value。有这个字符串,那就容易啦,就像你有了数据库的驱动类的类路径
就用Class.forName(“classname”).newInstance();得到对象,同理是吧。这样就可以通过配置来得到提高系统的可维护性,后面你要是替换实现了,就只要
该配置文件好啦,比如org.javaer.erp.dao.DAO=org.javaer.erp.dao.impl.DAOImpl,那么系统用到这个的时候就会自动全部换掉,而不用一个一个的更改,
是不是方便多了呢。

工厂方法模式
工厂方法我就不多说了,就是多态嘛,父类或接口引用不同的子类对象。我这里用的例子是快餐店生产快餐,有点尴尬了,我不提倡吃快餐的,又贵又没有营养。不过吃的时候貌似不得以而为之,呵呵,下次坚决不吃。
package org.javaer.pattern.factory;

public class FactoryMethod {

    public static void main(String[] args) {
        Store store = new KFCStore();
        store.makeFood();//KFC卖鸡翅
        Store store1 = new McdonaldStore();
        store1.makeFood();//麦当劳卖汉堡
    }

}

//快餐店卖食物
interface Store{
    public Food makeFood();
}
//KFC卖快餐(kfc鸡翅)
class KFCStore implements Store{
    public Food makeFood(){
        return new Food(“KFC wing”);
    }
}
//Mcdonald卖快餐(Mcdonald汉堡)
class McdonaldStore implements Store{
    public Food makeFood(){
        return new Food(“Mcdonald’s hamburger”);
    }
}
//食物类(鸡翅、汉堡)
class Food{
    String name = null;
    public Food(){}
   
    public Food(String name){
        this.name = name;
    }
}

如果你要开个必胜客快餐店,写个类实现Store接口就好了,业务就扩展了。

//必胜客卖食物(披萨)
class Pizzahut implements Store{
    public Food makeFood(){
        return new Food(“Pizza hut pizza”);
    }
}
用的时候就用Store store = new Pizzahut();store.makeFood();
——————————————————————————————————-工厂方法模式完
抽象工厂模式

抽象工厂呢就是在工厂方法模式上面在包一层,因为你的业务可能还需要根据不同的情况产生不同的工厂。
比如我们要有FoodFactory食物工厂,又要有SoftFactory软件工厂。。。那我们就在上面加一层用来产生工厂。而工厂又去生产产品(工厂方法)
package org.javaer.pattern.factory;
//抽象工厂
public abstract class AbstractFactory {

    public abstract FoodFactory createFoodFactory();
    public abstract SoftFactory createSoftFactory();
//测试main方法,懒得再写一测试类
    public static void main(String[] args) {
       
AbstractFactory abstractFactory = new AbstractFactorySupport();
  //产生一级工厂FoodFactory
  FoodFactory foodFactory = abstractFactory.createFoodFactory();
  foodFactory.makeFood();
  System.out.println(“==============================”);
  //产生二级工厂KFCFactory
  KFCFactory kfcFactory =  foodFactory.createKFCFactory();
  kfcFactory.makeFood();
  //产生二级工厂McdonaldFactory
  McdonaldFactory mcdonaldFactory =  foodFactory.createMcdonaldFactory();
  mcdonaldFactory.makeFood();
 
  System.out.println();
 
  //产生一级工厂SoftFactory
  SoftFactory softFactory = abstractFactory.createSoftFactory();
  softFactory.createSoft();
  System.out.println(“=================================”);
  //产生二级工厂IBMFactory
  IBMFactory ibmFactory =  softFactory.createIBMFactory();
  ibmFactory.createSoft();
  //产生二级工厂SUNFactory
  SUNFactory sunFactory = softFactory.createSUNFactory();
  sunFactory.createSoft();
       
    }
}

//抽象工厂实现类,实现产生工厂的抽象方法
class AbstractFactorySupport extends AbstractFactory{
//长生食物工厂
    @Override
    public FoodFactory createFoodFactory() {
        return new FoodFactory();
    }
//产生软件公司
    @Override
    public SoftFactory createSoftFactory() {
        return new SoftFactory();
    }
   
}
//食物工厂
class FoodFactory {
 public void makeFood(){System.out.println(“food factory make food”);}
 public McdonaldFactory createMcdonaldFactory() {return new McdonaldFactory();}
 public KFCFactory createKFCFactory(){return new KFCFactory();}
}

//KFC工厂继承食物工厂,生产KFC食物

class KFCFactory extends FoodFactory {
 public void makeFood(){
  System.out.println(“we make KFC wing”);
 }
}

//Mcdonald工厂继承食物工厂,生产Mcdonald食物

class McdonaldFactory extends FoodFactory {
 public void makeFood(){
  System.out.println(“we make Mcdonald’s wing”);
 }
}

//软件公司开发软件

class SoftFactory {
 public void createSoft(){System.out.println(“soft factory create software”);}
 public SUNFactory createSUNFactory() {return new SUNFactory();}
 public IBMFactory createIBMFactory(){return new IBMFactory();}
}

//IBM公司继承软件工厂,开发软件(IBM软件)

class IBMFactory extends SoftFactory{
 public void createSoft(){
  System.out.println(“we create IBM software”);
 }
}

//SUN公司继承软件工厂,开发软件(开源软件)

class SUNFactory extends SoftFactory{
 public void createSoft(){
  System.out.println(“we create SUN software”);
 }
}

运行AbstractFactory 的main方法输出:

food factory make food
==============================
we make KFC wing
we make Mcdonald’s wing

soft factory create software
=================================
we create IBM software
we create SUN software
我们要加一个手机工厂就可以这样做
//手机生产商设计手机
class MobileFactory{
    public AppleFactory createAppleFactory(){return new AppleFactory();}
    public MeizuFactory createMeizuFactory(){return new MeizuFactory();}
    public Product designMobile(){System.out.println(“mobile factory design mobile”);}
}
//Apple公司设计手机(iPhone4)
class AppleFactory extends MobileFactory{
    public Product designMobile(){
        return new Product(“Apple iphone4”);
    }
}
//魅族公司设计手机(M9)
class MeizuFactory extends MobileFactory(){
    public Product designMobile(){
        return new Product(“Meizu M9”);
    }
}

而在抽象工厂类就添加
public abstract MobileFactory createMobileFactory();
—————————————————————————-抽象工厂模式完
嗯这个抽象工厂我做的不是很好,也是因为我的业务比较松散有关吧,我这里的工厂都是没有关联的FoodFactory,SoftFactory,MobileFactory
网上有例子,我觉得那个更好些。网址是http://zhidao.baidu.com/question/63058512.html,大家可以去看看。

最后呢给出一个综合的例子,加上之前的singleton单例模式,我们做一个JMS发送消息的demo吧。这里有点难懂了,嗯涉及到了EJB3.0中的知识了,不过不必深究了,知道整个程序的大致思路就可以啦。

class ContextHelper{

//这个类是一个单例模式,主要功能有两个1.loadJBOSSProperties(String filename)读取JBOSS的上下文环境配置2.得到上下文,那么我们就可以通过这个上下文从EJB容器中通过JNDI读取对象了Lookup(String ejb)。
        private static ContextHelper chelper = new ContextHelper();
        private ContextHelper(){};
        public static ContextHelper getInstance(){
            return chelper;
        }
        public Properties loadJBOSSProperties(String filename){
            Properties props = new Properties();
            props.load(new FileInputStream(filename));
            return props;
        }
        public Object lookup(String ejb){
            Context conx = new InitailContext(this.loadJBOSSProperties());
            return conx.lookup(ejb);
        }
    }
      
    //发送消息的接口
    interface MessageSender{
        public void sendMessage(Message message);
    }
    //发送一对一消息的实现
    class QueueMessageSender implements MessageSender{
        public void sendMessage(){
            QueueConnectionFctory qcf = (QueueConnectionFctory)ContextHelper.getInstance().lookup(“ConnectionFactory”);
            QueueConnection qconnection = qcf.getConnection();
            QueueSession qs = qconnection.getSession(false,TopicConnection.AUTO_ACKOWNLEDGE);
            Queue queue = (Queue)ContextHelper.getInstance().lookup(“Queue/myQueue”);

    Message message =(TextMessage) queue .createMessage(“我是一个消息”);
            QueueSender qsender = qs.createSender(queue);
            qsender.send(message);
            qs.close();
            qconnection.close();
        }
    }
    //发送一对多消息的实现
    class TopicMessageSender implements MessageSender{
        public void sendMessage(){
            TopicConnectionFctory tcf = (TopicConnectionFctory)ContextHelper.getInstance().lookup(“ConnectionFactory”);
            TopicConnection tconnection = tcf.getConnection();
            TopicSession ts = tconnection.getSession(false,TopicConnection.AUTO_ACKOWNLEDGE);
            Topic topic = (Topic)ContextHelper.getInstance().lookup(“Topic/myTopic”);
          Message message =(TextMessage) topic.createMessage(“我是一个主题”);

     TopicPublisher tp= ts.createPublisher(topic);
            tp.send(message);
            ts.close();
            tconnection.close();
        }
    }
    //消息发送的工厂类
    class MessageSenderFactory{
        public MessageSender createQueueMessageSender(){
            return new QueueMessageSender();
        }
       
        public MessageSender createTopicMessageSender(){
            return new TopicMessageSender();
        }
       
        public static void main(String[] args) {
            MessageSenderFactory msf = new MessageSenderFactory();
            msf.createQueueMessageSender().sendMessage();//我们就发送消息
            msf.createTopicMessageSender().sendMessage();//我们就发送主题
        }
    }

有朋友说文章不是很容易看懂,特别是抽象工厂模式。嗯,我觉得也是,今天有空就再看看,增加了更多的注释,文章机构画一下。有什么意见可以提,不同意见可以排版,还有不明白的可以交流。Skeype:linmei.dong、MSN:donglinmei@hotmail.com(文/linmei.dong)转载请注明出处http://mtoou.info/java-factory-gcmoshi/

嗯,java设计模式系列之factory工厂模式就写到这里啦,下期是java设计模式系列之Builder构建模式,敬请持续关注~

Java

Java设计模式之singleton单例设计模式

现在网上到处是单例设计模式,都开玩笑说现在满城尽是singleton,呵呵,我也拿出来了,因为我平时用到最多的就是单例设计模式吧,而且比较简单,可以作为Java设计模式的入门篇吧。

SINGLETON—俺有6个漂亮的老婆,她们的老公都是我,我就是我们家里的老公Sigleton,她们只要说道“老公”,都是指的同一个 人,那就是我(刚才做了个梦啦,哪有这么好的事)

单例模式:单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的 “单一实例”的需求时才可使用。’‘————————–先引用下“从追MM谈Java的23种设计模式”文章中的说法。

单例设计模式形式有4种,一般人只知道有两种,懒汉式和饿汉式。
懒汉式(只有需要的时候才new出来,这里要用synchronized方法或代码块同步,因为在多线程情况下,不同的人同时进来拿到的引用可能都是null,结果都去new了)
public class LazzSingleton{
private LazzSingleton lazzSingleton = null;
 private LazzSingleton() {}//私有构造期 这个很重要啦,如果共有那么外面就可以随便new了,那么我们写这个单例意义就不大了,我发现公司老员工都写public的了,大家要注意下!

public synchronized LazzSingleton getInstance(){
 if(lazzSingleton==null){
   lazzSingleton = new LazzSingleton ();
return lazzSingleton ;
}
return null;
}

}

用的时候就:LazzSingleton lazzSingleton = LazzSingleton.getInstance();

饿汉式(一来就new,拿的时候直接拿对象)
public class HungerSingleton{
private HungerSingleton hungerSingleton = new HungerSingleton ();
private HungerSingleton() {}//私有构造期
public HungerSingleton getInstance(){
return hungerSingleton ;
}
}

用的时候就:HungerSingleton singleton = HungerSingleton.getInstance();

还有一种和饿汉式差不多(Effective Java这本书中有),因为式静态常量,当然内存中只有一个对象啦。
public class StaticFinalSingleton(){
public static final StaticFinalSingleton singleton= new StaticFinalSingleton();

private StaticFinalSingleton (){};//私有构造期
}

用的时候就:StaticFinalSingleton staticFinalSingleton = StaticFinalSingleton.staticFinalSingleton ;

最后一种我记不起来了,用的不多。(我有个坏习惯,嗯,比喜欢记笔记,而且记性不好,希望大家不要学我)

所以实现单例要点:1.私有化构造器(外部不能new),2.用对象名去引用属性(第三种)或静态方法(第一第二种);

应用场景(单例设计模式一般和工厂设计模式联合起来用,等做factory工厂模式时再一起使用,很简单)
如果你的系统中有要读配置文件,那么读配置文件的类就可以用单例设计模式了。例子:
public class LoadProperties {
 private static LoadProperties loadProperties = new LoadProperties();
 private LoadProperties(){};
 
 public static LoadPropertiesgetInstance(){
  return loadProperties
 }
 /**
  * 根据文件名、模块名,从配置文件中取得菜单名
  * @param model
  * @param fileName
  * @return
  */
 public String[] getMenus(String model,String fileName){
  //….
  return null;
 }
 /**
  * 根据文件名,读取显示风格
  * @param fileName
  * @return
  */
 public String[] getStyle(String fileName){
  //……
  return null;
 }

 }
 /**
  * 根据文件名,用户名,读取用户权限,<p>先判断用户级别,然后读取其权限</p>
  * @param fileName
  * @param user
  */

public String[] getPrivileges(String filename,String username){

    return null;

}

//……
}

接下来我们来做个实验,检验到底是不是singleton单例,单线程下我们一眼就看的出来是,所以我们就在多线程下测试。
package org.javaer.code.pattern;

public class Singleton {
 static LazzSingleton lazzSingleton1, lazzSingleton2;
 static HungerSingleton hungerSingleton1, hungerSingleton2;
 static StaticFinalSingleton staticFinalSingleton1, staticFinalSingleton2;

 public static void main(String[] args) {

  while (1 > 0) {
   new Runnable() {
    public void run() {
     lazzSingleton1 = LazzSingleton.getInstance();
     hungerSingleton1 = HungerSingleton.getInstance();
     staticFinalSingleton1 = StaticFinalSingleton.staticFinalSingleton;
    }
   }.run();

   new Runnable() {
    public void run() {
     lazzSingleton2 = LazzSingleton.getInstance();
     hungerSingleton2 = HungerSingleton.getInstance();
     staticFinalSingleton2 = StaticFinalSingleton.staticFinalSingleton;
    }
   }.run();
   System.out.println(lazzSingleton1 == lazzSingleton2 ? “是单例”
     : “不是单例”);
   System.out.println(hungerSingleton1 == hungerSingleton2 ? “是单例”
     : “不是单例”);
   System.out
     .println(staticFinalSingleton1 == staticFinalSingleton2 ? “是单例”
       : “不是单例”);
  }
 }
}

class LazzSingleton {
 private static LazzSingleton lazzSingleton = null;
 private LazzSingleton() {}
 public synchronized static LazzSingleton getInstance() {
  if (lazzSingleton == null) {
   lazzSingleton = new LazzSingleton();//需要的时候new出来
   return lazzSingleton;
  }
  return null;
 }

}

用的时候就:LazzSingleton lazzSingleton = LazzSingleton.getInstance();

class HungerSingleton {
 private static HungerSingleton hungerSingleton = new HungerSingleton();//先new出来
 private HungerSingleton() {}
 public static HungerSingleton getInstance() {
  return hungerSingleton;
 }
}

用的时候就:HungerSingleton singleton = HungerSingleton.getInstance();

class StaticFinalSingleton {
 public static final StaticFinalSingleton staticFinalSingleton = new StaticFinalSingleton();

private StaticFinalSingleton (){};
}

我们比较的是他们的内存地址,显示的结果一直是”是单例”,说明我们写的代码都是正确的单例设计模式。我这里人品比较好啊,用的Thread 和 Runnable实现多线程测试结果都一样,
我之前做过测试发现只有是Rnnable实现的多线程始终是”是单例”,而用Thread实现的多线程有的情况是,有的情况不是。我不是很清楚,貌似这是Rnnable 和Thread实现多线程有区别吧。
我弄了很久也不是很清楚,得看类的源码了,我们就不用关心啦,感兴趣的盆友就去研究下。

总结下:如果你的系统中需要的对象只有一个(为了节约内存,内存对于程序来说是非常重要的,尤其是嵌入式开发。不要以为你的内存大,用户访问多了,服务器的几十的G的内存也受不了,性能下降),如读取配置信息的类(多了去),不同的模块访问的公共类等等;那么就可以用单例设计模式了。Servlet的设计就是单例的,所有的用户拿到的都是服务器上的一个实例对象。(文/linmei.dong)转载请注明出处http://mtoou.info/java-singleton/

Java

四个Java编程小技巧

看到了不少观众的支持,我的信心更足了,决定继续写下去。由于第一期的Java面向对象观众反应代码过多,表达不够清楚,思路有点乱,而且有错别字(好吧,我承认我的外语水平不好^_^)呵呵,谢谢大家的意见,所以本来是要写Java设计模式系列,我临时做了下调整,这期就写Java编程小技巧吧。

(1)你的判断两个数的奇偶性你用的方法合适吗
     if(num%2!=0) 奇数 else 偶数
     大家都知道这个方法,其实还有更快的小方法,可能有些人就不知道了
     if(num & 1 ==1) 奇数else 偶数,用的屎位运算,肯定要快些啦。
(2)两个数的互换,大家都可能会用
     type temp;
     temp = x;
     x = y;
     y = temp;
     也有不用临时变量的方法
        x = x+y;    
        y = x-y;   
        x = x-y;
          或
        x = x^y;
        y = y^x;
        x = x^y;同样可以实现两个两个数交换,说有什么技术含量还真没什么,就是面试可能会考到。
(3)LINUX里面的权限判断,也可以借鉴,这里也是用位运算
     int read = 1<<0;
     int write = 1<<1;
     int execute = 1<<2;
    定义用户操作一个文件的权限为read | execute(权限值为5);linux里面文件的权限是三位数如777(系统任何人都有可读,可写,可执行的权限),可以用ls -l命名查看,因为linux里面的权限有组的概念,和windows的组策略差不多。
    那么用户操作该文件的权限就可以算出来了 (read | execute) & read>=1?可读:不可读; 以此类推…
(4)字符串处理最好用正则表达式,和编译原理的神马自动机理论有关,处理速度也是非常快,在linux下大量使用如Grep命令,例子查找文件Hello.java文件里面是否有main关键字,
就可以用 find -name home\Hello.java | grep *\s+main\s+* |more
    我们要处理根据xml旳节点的命名标准来判断字符串,XML节点命名标准如下:
 1.第一个字符必须位字符
 2.中间必须位数字和字符或.-_
 3.最后必须位数字或字符或空格或.-_
    我们就用JAVA的regex来处理,非常方便,正则表达是为:
    String regex = “^[[a-zA-Z]|[\u2E80-\u9FFF]]+[[a-zA-Z]|[0-9]|[\u2E80-\u9FFF]|[.|\\-|_]]+\\s*”; (不要看这么长,实际上是非常简单的,看看Java API就知道怎么写了)
     public class RegexTest{
 @org.junit.Test
 public void regexTest(){
  String regex = “^[[a-zA-Z]|[\u2E80-\u9FFF]]+[[a-zA-Z]|[0-9]|[\u2E80-\u9FFF]|[.|\\-|_]]+\\s*”;
  String input = “w你w好.-.553.你-.__.-.   “;
  java.util.regex.Pattern pattern = Pattern.compile(regex);
  Matcher matcher = pattern.matcher(input);
  while(!matcher.matches()){
   System.out.println(“匹配失败”);
   break;
  }
  System.out.println(“匹配成功”);
  //也可以用这种方式判断
  /*
        boolean isMacher = Pattern.matches(regex,input );
  System.out.println(isMacher?”匹配”:”不匹配”);
  */
 }
    }
xml文件节点<w你w好.-.553.你-.__.-.   />用上面的正则表达式来判断是没有问题的。
小技巧也就是平时编程的经验积累吧,所以呢我还是提倡多写代码,多思考。
一时半伙儿也想不到很多的小技巧,就写这么多了。如果你还不知道,就赶快学一下吧。如果你还有神马小技巧,赶快和大家分享!!
我的Email:donglinmei@hotmail.com 964318731@qq.com、Mobile Phone :(+86)182 5196 5264、qq :964318731 转载请注明出处http://mtoou.info/java-bcjqiao/

Java

实例谈谈Java面向对象

虽然我学JAVA两年多了,基础还可以,一些常用的框架也会弄,设计模式也会个几种。但是我还不敢我说我JAVA或者软件多么多么在行,对面向对象思想有多少多少领悟。那为什么我还要在这里对人现眼呢,嗯,我还是想用一个JAVA初级水平的角色和大家一起来探讨JAVA软件编程的经验,分享自己的见地,欢迎喜爱JAVA的朋友前来拍板提出异议。

java面向对象

大家都知道JAVA的核心就是面向对象思想,也就是OO,但是说起来很容易,真正想弄个透彻,并不是那么容易的。说来说去面向对象的特征也就那几个:抽象,封装,继承,多态,其实一个抽象就可能难倒70%-80%的程序员,包括什么软件工程师(我更喜欢JAVA程序员的职称)。不是说简单就容易,二分法算法很简单吧,可是1947就出现的二分算法,直到1961年才有世界上第一个没有BUG的二分算法(盗用下经典的例子啦)。还是别扯远了,来个例子:

业务需求如下:
1.一个客户可以有多套房子的房贷
2.签署贷款合同以后要监控是否按照还贷计划表来执行
3.自动还款,当多套房贷时,一次还款可能包括多个房贷的额度,需要自动匹配
4.可以提前还款
5.可以延长或缩短贷款的时间
6.利率可以调整
7.滞纳金的问题

是不是看的有点头昏呢,其实我对贷款买房业务也不了解,为了大致把问题用面向对象进行描述,那么我们就开始进行问题抽象(这里不包括领域驱动设计DDD)。

对象分析

首先我们知道肯定有一个事务用来表示贷款买房的人,用Coustomer来表示,他有什么属性呢,人我们就用姓名区分好了,因为他贷款要买房,肯定有一些钱(否则还是不要有买房的念头吧)
房子就用House来表示,房子有什么属性呢,肯定有价格啦,利率啦,年限啦.每个月你要还多少,或者一年还多少(只有爱存不存ICBC,没有爱还不还)。贷款就用Credit来表示,贷款就有客户啦,还钱时间啦,房子啦。

你贷款银行就会跟你签合同,你跑不了了。合同就用agreement来表示,贷款合同有什么属性呢,合同肯定有贷款,是否坏账标记,滞纳金。

业务分析

客户买房子,假设所购的房子已经付了首付(不然银行不可能给你贷,除非你爸是李刚)。要跟银行贷款,那么就要和银行签订贷款合同。
贷款买的房子可能不止一套,我们就不管银监会的神马限购令了。
客户还款,你每隔多少时间还银行钱,那么就会自动根据利率给你匹配计算了(因为银行工作的MM有点懒哦),如果还的钱不够,那么就会给你记坏账了,你拖得太久
银行就会通知你要付款,要是你没有能力还了,银行就会销毁合同,收走你的房,花你的钱,抢你的女朋友,打你的娃(开玩笑啦)。
这里我们的业务方法加了年限和利率的改变实现,主要是为了简单易懂。最好使用JAVA DEGISN PATTER 中的Observer(观察者设计模式)来实现,只要贷款监听倒利率或年限改变,就会自动进行操作。
后面我们再用观察者设计模式来解决这个问题。
package org.javaer.code.test;
import java.util.List;
import java.util.Map;
class Customer {
 /**
  * 客户
  */
 private String username = “donglinmeimei”;
private double money = 0.0;
public String getUsername() {
  return username;
 }
public void setUsername(String username) {
  this.username = username;
 }
public double getMoney() {
  return money;
 }
public void setMoney(double money) {
  this.money = money;
 }
}
class House {
 /**
  * 房子
  */
 private String num = “3#116”;
private double price = 0.0;
private double rax = 0.0;// 利率
private int years = 0;// 年限
public String getNum() {
  return num;
 }
public void setNum(String num) {
  this.num = num;
 }
public double getPrice() {
  return price;
 }
public void setPrice(double price) {
  this.price = price;
 }
public double getRax() {
  return rax;
 }
public void setRax(double rax) {
  this.rax = rax;
 }
public int getYears() {
  return years;
 }
public void setYears(int years) {
  this.years = years;
 }
}
class Credit {
 /**
  * 贷款
  */
 private Customer customer;
 
 private int backTime;
private List<House> housees;
// 每月还多少
 private Map<House, Double> toPay;
public Customer getCustomer() {
  return customer;
 }
public void setCustomer(Customer customer) {
  this.customer = customer;
 }
public int getBackTime() {
  return backTime;
 }
public void setBackTime(int backTime) {
  this.backTime = backTime;
 }
public List<House> getHousees() {
  return housees;
 }
public void setHousees(List<House> housees) {
  this.housees = housees;
 }
public Map<House, Double> getToPay() {
  return toPay;
 }
public void setToPay(Map<House, Double> toPay) {
  this.toPay = toPay;
 }
}
class Agreement {
 /**
  * 合同
  */
 private Credit credit;
 private boolean isContinue;
// 滞纳金
 private double amercement = 0.0;
 public Credit getCredit() {
  return credit;
 }
 public void setCredit(Credit credit) {
  this.credit = credit;
 }
 public boolean isContinue() {
  return isContinue;
 }
 public void setContinue(boolean isContinue) {
  this.isContinue = isContinue;
 }
 public double getAmercement() {
  return amercement;
 }
 public void setAmercement(double amercement) {
  this.amercement = amercement;
 }
 
}
interface BankService {
 // 买房,同时产生贷款和合同
 public void buyHousees(Customer customer, List<House> houseed);
// 还款,计算是否有滞纳金
 public double payMoney(int backTime, Agreement agreement, double money,
   Customer customer);
// 改变利率
 public Map<House, Double> changeRax(House house, double rax);
// 改变年限
 public Map<House, Double> changeYears(House house, int backTime);
}
class BankServiceImpl implements BankService {
public void buyHousees(Customer customer, List<House> houseed) {
 }
public double payMoney(int backTime, Agreement agreement, double money,
   Customer customer) {
  return money;
 }
public Map<House, Double> changeRax(House house, double rax) {
  return null;
 }
public Map<House, Double> changeYears(House house, int backTime) {
  return null;
 }
}
public class Bank{
 public static void main(String[] args) {
  Customer customer = new Customer();
  customer.setUsername(“董林美美”);
  customer.setMoney(10);
 
  List<House> housees = new ArrayList<House>();
  House house = new House();
  house.setNum(“3#116”);
  house.setPrice(1500000);
  house.setRax(0.96);
  house.setYears(20);
  housees.add(house);
 
  House house1 = new House();
  house1.setNum(“4#112”);
  house1.setPrice(1100000);
  house.setRax(0.155);
  house.setYears(30);
  housees.add(house1);
 
  House house2 = new House();
  house2.setNum(“1#001″);
  house2.setPrice(2000000);
  house.setRax(0.12);
  house.setYears(100);
  housees.add(house2);
  
  BankService bs = new BankServiceImpl();
  Credit credit = bs.buyHousees(customer, housees);//买房
  Agreement agreement = bs.orderAgreement(customer, credit);//签订合同
  if(!agreement.isContinue())return;//合同作废
  else{
   agreement.setAmercement(bs.payMoney(1, agreement, 111111, customer));//还款    
   for(Entry<House,Double> entry : agreement.getCredit().getToPay().entrySet()){
    if(agreement.getAmercement().get(entry.getKey())>=entry.getValue()/3){
     agreement.setContinue(false);
     System.out.println(agreement.getCredit().getCustomer().getUsername()+”,你的账户产生坏账,合同终止”);
     break;
    }else{
 
            System.out.println(agreement.getAmercement().get(entry.getKey())>=0?
      agreement.getCredit().getCustomer().getUsername()+”,房子”+entry.getKey().getNum()+”的滞纳金为:”+agreement.getAmercement():””);
    
    }
    Map<House,Double> topay = bs.changeRax(house2, 1.58);//改变利率
    Map<House,Double> topay = bs.changeYears(house2, 50);//改变年限
    System.out.println(agreement.getCredit().getCustomer().getUsername()+”,房 子”+entry.getKey().getNum()+”每月还款金额为:”+entry.getValue());
   
   }
  }
 
 
 }
}
文本内容长度有限制,所以例子就只写这一个了,请大家原谅。
如果面对一个领域的问题,能够进行事务抽象分析,那么问题就好解决了。这需要很长时间的项目锻炼,积累不少经验才能做到。但是今天的一小步,明天的一大步(又涉嫌抄袭了),不要忽视平时的小小的成功。

都说JAVA程序员的三件法宝是Question ,DesignPattern ,framework,那么接下来我就根据这几个法宝来一一表达我的观点。我说了希望大家来交流和拍板,大家共同学习,共同进步。
我的Email:donglinmei@hotmail.com、Mobile Phone :182 5196 5264(翻一下才知道)

今天是第一期,由于时间有限和个人能力有限,做的不好,但我会努力的。下期是JAVA设计模式系列,敬请持续关注。转载请注明出处http://mtoou.info/java-mxdx-zt/

Java

由iteye上女程序员:会SSH框架是低薪的代名词的文章而谈

上次在iteye(以前叫javaeye,上面的大牛很多,竟然被烂的csdn收购了,想不通)上看了一篇女Java软件工程师写的文章,说的是会SSH框架是低薪的代名词,呵呵,我不太赞成这个观点的。

文章分析现在随便在街上逮个JAVA软件开发者,都说精通SSH三大框架,不管是应届生还是老鸟的个人简历上都写着精通SSH框架,MVC思想。貌似会个框架整合就牛逼哄哄的,且不论这些框架使用和理解怎么样,Java基础怎么样呢,面向对象思想到不到家呢。听说仅仅精通Javascript的在IBM的年薪是25w,这是我们JavaEE开发的都看不上眼的技术吧,可见只要对一项技术精通就了不得了,什么框架,什么平台,真正会多少才是最重要的。

说实话吧,SSH框架也没这么简单,要在项目中整合使用,不见得什么都得用上,还得根据项目来定。三个框架整合加上数据库效率是很低的,只有大项目或需要易扩展升级的项目才考虑用,而且超大的项目都用分布式EJB了,基于组件开发。

SSH框架其实不仅仅是要学会怎么使用,这个不难,只要花时间,都学的会,而是要真正理解人家的思路和解决方案,最好看看框架的源代码,这对你的编程是有很大帮助的。就拿Struts的MVC来说吧,为什么要用MVC呢,人家Google(姑且说是)的android中用的就是MVC嘛,比Swing编程的代码乱、长、难维护好多了。Spring中的AOP不就是用动态代理(Dynamic Proxy)嘛,这些框架还是用Java的反射技术什么的。JavaEE的模式也不仅仅是MVC一个,框架技术多了去,一辈子也学不完啊。基础不错的话,自己开发框架也不是没有可能。

我的框架技术是不咋的,而且没用过Struts框架,学的和用的都是Struts2,我把它叫为Webwork好些吧。其实我觉得Struts是MVC的体现,看了点别人使用,而且我对Struts2不是很支持的,所以打算在项目中使用的是Struts + Spring2.5 +JPA1.0(Hibernate实现),结果就出问题了,没有出现任何错误,就是运行没有任何的结果,一直找不出问题的原因,现在才知道要用Spring框架读Struts的注解,还需要在struts-config.xml中加配置的。所以说不要盲目的使用一些技术,别人用什么也跟着用什么,这是我用SSH框架的一个笑话吧。

JavaEE开发除了要会SSH框架,其他的也是很重要的,比如Jsp、Servlet、Javascript及web层框架,我就比较坑爹了。还有其他的一些技术像JNDI、EJB、WebService、JavaMail、RMI、JMS…JavaWeb只是一小部分罢了。做项目还要考虑很多东西的,想性能啊,这个就很重要了,一个网站操作响应超过5秒,谁受得了,就算你给我钱我肯定还是跑了。为了性能我们可能在项目中用缓存,ORM框架中和第三方都有缓存,而且数据库用本来也有缓存。除此之外我们还可以用模版技术像Fremarker、Volicity,还有shtml静态网页技术SSI等等。大型的项目可能就要考虑负载均衡和集群了,我弄了几个小时,按照网上的资料配置Apache和Tomcat的负载均衡,实现倒是实现了,不过集群中Session共享我始终没弄好。所以做JavaWeb不只是写JSP和数据库CURD,还有解决问题和思想的体现。

如果你想做项目的设计架构,像UML设计,数据库设计、工作流等能力也是必不可少的。做系统的性能测试,方法啊工具啊也得知道个一二三吧。

我感觉Java最难的不是这些框架(SSH只是部分),更难的是Java设计模式,JavaEE设计模式,Java面向对象。大家都认为Java面向对象简单,我不这么认为,Java的优点和精髓就是面向对象了。看看Jdon网站上的东西,就发现这么多人都在讨论这个,他们的思想比我们先进多了,我们已经落后一大截了。什么DDD(Domain Driver Design),什么贫血模型啊、失血模型啊、充血模型啊、涨血模型,不像我们只考虑实现,就会操作数据库,不考虑架构,不考虑业务,更不会考虑领域(Domian)了。如果说这些人都是大牛,我们惹不起,但是我们是需要不断成长,需要吸收更多的技术和思想,我们要成为大牛。

好久没有写文章了,每周最好写点技术文章,保持自己的状态,不至于遗忘了落后了。最近比较忙,项目快结束了,加班特多。做饭的时间的没有,房间好久都没收拾了,厨房又脏,一切都乱死了。上周末连续加班通宵,其实我也就打酱油,听听音乐玩玩facebook睡睡觉,昨晚还是2:00以后睡的,敲几行代码。放了假,天气又热,还是呆在家了,做点吃的,休息休息,听听音乐,写点文章,敲点代码。

不知不觉都快12:30了,就写这么多了,烧饭去咯,人品不错哦,上周买的菜,还没坏,好久没做饭了,不要太难吃了哈。(文/linmei.dong)转载务必注明出处http://mtoou.info/ssh-dixin/

Java

纠结了N久总结的:Java之高效编程

JAVA高效编程的一些总结,我纠结了很久,总结再总结出以下四点。

  1. 命令行才是最方便的,图形界面只是面向初级用户的。代码才是我们的好朋友!图形界面用多了会脑残……(只针对专业人员……)
  2. 如果好多函数里都用了同一段代码,可以吧这段代码写成一个类(是否为静态类看具体情况,静态类会更加节省系统资源!),然后继承之~

 3. web工程里,如果每个页面都对应一个servlet的话,不仅会使编写麻烦,而且不利后期的管理维护。利用多重映射的方法,将一个servlet映射到多个url,每个页面的处理对应一个url,这样会解决上述问题。如:一个servlet映射到了两个url:/user/register.do和/user/login.do,在web.xml中的配置对应为:

  <servlet-mapping>

    <servlet-name>UserServlet</servlet-name>

    <url-pattern>/user/register.do</url-pattern>

    <url-pattern>/user/login.do</url-pattern>

  </servlet-mapping>

在假设在register.jsp页面里:<form method=”post” action=”/user/register.do>…</form>声明了表单动作(action)的url

同理,在另一个login.jsp页面中可能会有<form method=”post” action=”/user/login.do”>…</form>

那么,在servlet端就可以写成:

if (request.getRequestURI().endsWith(“/user/register.do”)) {

    doRegister(request, resopnse);    //doRegister(request, response)是自定义的函数

} else if (request.getRequestURI().endsWith(“/user/login.do”)) {

       doLogin(request, response);        //同上

}

那么提交register.jsp的表单时就会执行doRegister(requset.response)方法,提交login.jsp的表单时,你知道了的……

这样,实现了多个页面的操作整合到一个servlet的功能。

4. 类名用首字母大写,函数名一般用小写,目录名、文件名用小写,取名尽量简洁。这些细节涉及后续的管理维护,十分重要~(文/Zeqi)转载请注明出处http://mtoou.info/jiava-gaoxiao/