2007年4月8日随笔档案 - 小哈儿的学习日记

关于Eclipse首选项的几点问题

今天调试一个bug，迷惑了很久。最后发现是关于首选项取值存值问题。
这里ps为IPreferenceStore对象.

ps.getString(XXX_KEY)是首选查找首选项，如果取出的值为空，如果有default值的话则执行ps.getDefault(XXX_KEY)。

ps.setValue(XXX_KEY, "XXX")时首先和default中的XXX_KEY比较，如果不同的话才put进去，否则就删除。这也是我今天这个bug的原因。修改办法是用putValue函数来代替setValue.

有什么说的不对的地方欢迎批评指正.

posted @ 2007-08-28 22:17 dayue 阅读(1107) | 评论 (0) | 编辑收藏

[转]eclipse插件中取得路径的方法

从插件中获得绝对路径：

TestPlugin.getDefault().getStateLocation().makeAbsolute().toFile().getAbsolutePath());

通过文件得到Project：

IProject project = ((IFile)o).getProject();

通过文件得到全路径：

String path = ((IFile)o).getLocation().makeAbsolute().toFile().getAbsolutePath();

得到整个Workspace的根：

IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

从根来查找资源：

IResource resource = root.findMember(new Path(containerName));

从Bundle来查找资源：

Bundle bundle = Platform.getBundle(pluginId);

URL fullPathString = BundleUtility.find(bundle, filePath);

得到Appliaction workspace：

Platform.asLocalURL(PRODUCT_BUNDLE.getEntry("")).getPath()).getAbsolutePath();

得到runtimeworkspace：

Platform.getInstanceLocation().getURL().getPath();

从编辑器来获得编辑文件

IEditorPart editor = ((DefaultEditDomain)(parent.getViewer().getEditDomain())).getEditorPart();

IEditorInput input = editor.getEditorInput();
   if(input instanceof IFileEditorInput){
     IFile file = ((IFileEditorInput)input).getFile();
   }

posted @ 2007-05-24 18:07 dayue 阅读(345) | 评论 (0) | 编辑收藏

      CSS 意思就是叠层样式表Cascading Style Sheets ，样式定义了HTML元素怎样去显示，样式一般存储在样式表中，外部样式表存储在CSS文件中。使用CSS，你的HTML文档可以用不同的样式输出来显示。
       HTML标签起初被设计成为定义文档的内容。通过使用像<h1>,<p>,<table>这样的标签他们应该表达的是"这是一个标题","这是一个段落","这是一张表格",而布局该由浏览器来处理并非使用格式化标签. 作为两大浏览器 - 网景和 IE - 不断地将新的HTML标签和属性(像<font>标签和颜色属性)添加到原来的HTML规格中,这让建立清晰的HTML文档内容并从形式中分离出来变的越来越困难.为了解决这个难题,W3C 这个非赢利的,建立标准的组织,为HTML4.0增加了样式。所有主流浏览器都支持样式表。
        样式表定义元素怎样去显示,就像在HTML3.2中字体标签和颜色属性一般保存在一个外部的.css文件一样.外部样式表能够让你改变所有出现在你WEB中的外观和布局,而仅仅通过编辑一个单独的CSS文档.(原理就是一动多变)。
         当多于一种的样式指定一HTML元素时使用怎样的样式呢?

浏览器默认
外部样式表
内嵌样式表(在<head>标签内)
行内样式(在一HTML元素内) （最高优先级）

posted @ 2007-05-08 17:48 dayue 阅读(305) | 评论 (0) | 编辑收藏

面向对象设计（OOD）原则

单一职责原则（SRP）：一个类应当只有一个改变的原因，类只需要知道一件事情，它们应当有一个单独的职责，要点就是当一个类需要改变时，应当只有一个原因。
开放-封闭原则（OCP）：软件实体(类、模块、函数等)应当为扩展而开放，又为修改而封闭。这个原则有一个相当详细的定义，但是一个简单的意思是：你应当能够改变一个模块的周边环境而无须改变模块本身。
Liskov替换原则(LSP)：子类型(subtypes)必须是为它们的基类型(base types)可替代的。
依存关系倒置原则(DIP) ：A．高层模块应当不依赖低层模块，它们应当依赖于抽象。
B．抽象应当不依赖于细节，细节应当依赖于抽象。
更好的描述是：不要依赖那些容易变化的具体类。如果你要继承一个类，从一个抽象类继承吧。如果你要持有一个类的引用，从一个抽象的类引用吧。如果你要调用一个函数，从一个抽象的函数调用吧。
接口隔离原则（ISP）：客户不应当依赖那些它们根本不用的方法。

总结：
五个简单的原则是：
1、SRP－－一个类应当只有一个发生变化的原因。
2、OCP――应当能够改变一个类的环境，而无须改变类本身。
3、LSP――避免造成派生类的方法非法或退化，一个基类的用户应当不需要知道这个派生类。
4、DIP ――用依赖于接口和抽象类来替代依赖容易变化的具体类。
5、ISP――给一个对象的每一个用户一个接口，这个接口仅有用户需要的方法。

posted @ 2007-04-30 15:27 dayue 阅读(389) | 评论 (0) | 编辑收藏

设计模式之命令（Command）模式笔记

命令模式是一个行为型模式，允许你创造一个对象的命令然后在需要时候可以执行。当你想创造一个undo/redo，log操作或者在稍晚时候执行命令时这个模式是有用的。
在这个模式里一个命令接口是必需的。对一个命令对象来说，它必须事先实现这个命令的方法。下面是一个简单的命令接口，有一个方法需要实现执行的。

public interface Command{

public void execute();

}

所有被命令的类必须实现这个命令接口。下面是一个简单的命令：当执行时控制台打印"hello world"。

public class HelloCommand implements Command{

public void execute(){

System.out.println("Hello World");

}

你可以创建一个HelloCommand的实例然后执行这个方法。

posted @ 2007-04-30 14:13 dayue 阅读(285) | 评论 (0) | 编辑收藏

在rcp中获得父Shell的几种方法

在实现了IWorkbenchWindowActionDelegate接口的类中：

private IWorkbenchWindow window;

public void init(IWorkbenchWindow window) {

this.window = window;

}

public void run(IAction action) {

Shell parentShell = window.getShell();

MyDialog dialog = new MyDialog(parentShell,

);

etc

}

在实现了IObjectActionDelegate 接口的类中：

private IWorkbenchPart targetPart;

public void setActivePart(IAction action, IWorkbenchPart targetPart)

{

this.targetPart = targetPart;

}

public void run(IAction action) {

IWorkbenchPartSite site = targetPart.getSite();

MyDialog dialog = new MyDialog(site,

);

etc

}

IViewPart 或者IEditorPart ：

IShellProvider shellProvider = viewOrEditor.getSite();

PlatformUI：

Shell parentShell =

PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();

Display ：

Shell parentShell = Display.getDefault().getActiveShell();

以上各种方法对于获取其它的一些rcp中的重要对象也都有借鉴意义。

posted @ 2007-04-23 14:00 dayue 阅读(1210) | 评论 (0) | 编辑收藏

设计模式之工厂方法（factory method）笔记

       工厂方法设计模式是一种使用工厂原则的创造型模式。工厂原则就是通过调用一个方法，这个方法创造一个对象的实例然后将它返回。通过向这个方法传递参数来决定返回哪个类型的对象。
       工厂方法设计模式使用继承来决定返回哪个对象。基础的创造类是抽象的。而具体的创造类继承这个基类。工厂方法在基类中声明。如果工厂方法是抽象的，那么所有继承这个类的类都必须有这个方法。如果不是，则可以根据需要选择覆盖它与否。
       当一个类想实例化其中一个具体类的实例时，这个类就可以通过调用具体类的工厂方法来生成正确的对象。
       举例来说，假设我们有两个类，Product1和Product2。为了能接收到这两个类任何一个的实例，我们必须让他们继承或实现相同的类或接口。我们创造一个叫做Creator的抽象类。如下：

public abstract class Creator{

public abstract getProduct();

}

现在我们创造两个类继承Creator,叫做Product1Creator和Product2Creator。每一个都有一个getProduct方法。
例如Product1Creator：

public class Product1Creator extends Creator{

public Product getProduct(){

return new Product1();

}

posted @ 2007-04-18 13:48 dayue 阅读(224) | 评论 (0) | 编辑收藏

设计模式之单例（Singleton）笔记

单例模式是最简单的一种设计模式，它是创造型的。一个单例类仅允许他的一个实例被初始化。它检查一个实例是否已经被创建，如果是则返回这个实例。下面是一个单例类的基本结构：

1

package dp.singleton;
2

3

public class Singleton {
4

private static Singleton singleton;
5

private Singleton(){
6

7

}
8

9

public static Singleton getInstance(){
10

if(singleton==null){
11

singleton=new Singleton();
12

}
13

return singleton;
14

}
15

16

}
17

在这个类中，有一个private static 的域，构造函数被设为私有的，这样调用它的类就不能使用构造器来创建它的一个实例。从一个单例类中取得一个实例的唯一办法是通过public static getInstance()方法。通过以下方法：

Singleton instance=Singleton.getInstance();

这个 getInstance()通过测试实例与是否为空来检查这个类的唯一实例是否被创建，如果是空的，则创建一个实例，如果非空，则返回这个已经存在的实例，一旦一个实例被创建了，那么 getInstance()这个方法就返回这个实例。

另一种稍微有些不同的实现单例类的方法是将域声明改为

private static final Singleton singleton=new Singleton();

这种方法总是创建一个实例。

posted @ 2007-04-18 10:17 dayue 阅读(246) | 评论 (0) | 编辑收藏

发现了一个好玩的插件PatternBox

Design Pattern Editor Plugin for Eclipse
可以通过选择模版来生成对应模式的java代码，倒不失为一个学习设计模式的好方法。

越来越觉得eclipse以及各方开发的插件的强大了，好像潜意识里需要什么东西，在某一天自己就会蹦出来这样一个插件。

posted @ 2007-04-12 04:06 dayue 阅读(444) | 评论 (0) | 编辑收藏

网上收集的设计模式资料全部转贴

设计模式(Design Patterns)笔记之一：Abstract Factory

定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。提供创建对象的接。

工厂模式是我们最常用的模式，是用来创建对象的，它就相当于创建对象的new。
例如我们有一个类Example,我们要创建Example的对象:

Example example=new Example();

或

Example example=new Example(参数);

如果创建Example时做的事情不是如赋值这样简单的事,可能是很长一段代码,如果也写入构造函数中,那明显的就违背了面向对象的原则.
我们需要将创建实例的责任与使用实例的责任分开, 使得

Example example=new Example(参数);

就是简单的责任:使用Example这个实例;而创建Example的任务就交给了Factory工厂模式.

按照传统方法，我们如果需要继承Example类，生成MyExample，就需要定义Example为Interface，然后，不断继承这个Interface，生成许多子类，造成以后代码维护是如此的困难。

如果，我们开始就采用了工厂模式，也许就没有这么多的烦恼了。

我们生成一个Factory，它专门负责生成Example的实例。

public class Factory {

public static Example getIntance() {

if(flag == 1)

return new MyExample();

if(flag == 2)

return new YourExample();

}

然后，那么在你的程序中,如果要实例化MyExample时.就使用

Example example=Factory.getIntance();//还有其它标志，不具体写了。

具体使用：
工厂模式有以下三种：
1. 简单工厂(Simple Factory)
2. 工厂方法(Factory Method)；
3. 抽象工厂(Abstract Factory)。

我们先看一段代码

public abstract class Factory{

　　public abstract MyExample creator();

　　public abstract YourExample creator();

}

public class FirstFactory extends Factory{

　　public MyExample creator(){

　　}

　　public YourExample creator(){

　　}

public class SecondFactory extends Factory{

　　public MyExample creator(){

　　}

　　public YourExample creator(){

　　}

这里，我们需要创建多个对象，复杂性提高，于是需要采用Abstract Factory来封装共同属性和方法，而将不同的属性和方法通过子类来实现。

简而言之，工厂模式的目的就是用来实现实例分发。

工厂模式中几种类型的一些差别：
简单工厂模式是根据参数来决定产生实例；
简单工厂模式, 核心是一个实类；
工厂方法模式的核心是一个抽象工厂类；
工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合；
工厂方法一般只创建一个实例，而Abstract Factory创建多个实例。

posted @ 2007-04-12 03:53 dayue 阅读(223) | 评论 (0) | 编辑收藏

准备SCWCD，目标7月之前通过

初步计划用资料为
Exam.Study.Kit.Java.Web.Component.Developer.Certification.(2005),.2Ed.BBL.LotB和 HEAD FIRST servlets and jsp

昨天去参加了托业考试模拟，原来托业考试是这么回事。原来就是为了我的弱项而准备的，听力和语法。
恩。。。又一个提高自己的好机会。

复习准备用书：
大学英语语法教程（好不容易翻出来的，看来书是不能丢的，说不定什么时候有用）。
toeic success

高程复习用书：

官方教材第一版

posted @ 2007-04-10 00:09 dayue 阅读(197) | 评论 (0) | 编辑收藏