BlogJava-Coundy-随笔分类-Java

关于navicat连接oracle 报 ORA-12737 set CHS16GBK错误的解决

Coundy — Sat, 18 Jun 2011 06:04:00 GMT

参考资料： http://apps.hi.baidu.com/share/detail/32733067
1、原因：
ORA-12737: Instant Client Light: unsupported server character set CHS16GBK
Google，解释如下：
ORA-12737:
Instant Client Light: unsupported server character set string
Cause: The character set specified is not allowed for this operation or is invalid. Instant Client Light has only minimal character sets.
Action: Do not use Instant Client Light for this character set

2、首先，我们打开“tools”-->"options"菜单，见到如下界面，依据OCI library(oci.dll) 路径，导航到 navicat oci 目录下，备份里面的文件（通过在该目录新建bak文件夹，将“%dir%/Navicat Lite\instantclient_10_2”路径下的所有dll文件剪切到bak文件夹）。

3、在oracle 客户端安装目录bin/目录下，找到如下几个.dll文件
4、将上面所列文件放置到“%dir%/Navicat Lite\instantclient_10_2” 目录下，重新启动navcat即可。

Coundy 2011-06-18 14:04 发表评论

Effective Java对象创建（一）静态工厂方法代替构造函数

Coundy — Wed, 11 Apr 2007 20:14:00 GMT

一、对象的创建
       第1条：考虑用静态工厂方法代替构造函数
             概念：所谓静态工厂方法（static factory method），实际上只是一个简单的静态方法，它返回的是类
                         的一个实例。
              例子：pbulic static Boolean getBoolean()
                          {
                               return (Boolean.TRUE);
                          }
                优点：1、与构造函数相比，静态工厂方法可以具有一个具有意义的名字
                             2、与构造函数相比，每一次调用并不一定非要创建一个新的对象
                                   例子：
                                           class SingletonFactory
                                            {   // 可以看作全局唯一的变量
                                                  private static singletonfactory=new SingletonFactory()；

                                                  private SingletonFactory()
                                                  {}

                                                  public static SingletonFactory getSingletonFactoryInstance()
                                                  {
                                                      //这里并不是每次都返回一个新的对象，而是反复返回同一个对象
                                                        return singletonfactory;
                                                    }
                                             }
                               3、与构造函数不同，可以返回一个原返回类型的子类型的对象
                                       例子：
                                               Interface BaseInterface
                                                {
                                                        void printlns();
                                                }
                                                class BaseImp implements BaseInterface
                                                {
                                                         public BaseImp ()
                                                         {}
                                                         public void printlns()
                                                          {
                                                                  System.out.println("BaseImp's printlns method ");
                                                           }
                                                }

                                                abstract class SingletionFactory
                                                {
                                                      private static SingletionFactory singletionfactory;
                                                     private static String classname="";
                                                      private static Object object=new Object();

                                                      public static BaseInterface getBaseInterface()
                                                      {
                                                               if (singletionfactory==null)
                                                                {
                                                                    synchorinzed(obj){
                                                                          try
                                                                          {
                                                                                   singletionfactory=(SingletionFactory)Class.forNmae(
                                                                                  classname).newInstaance();
                                                                          }
                                                                          catch(ClassNotFoundException e)
                                                                          {

                                                                           }
                                                                     }
                                                                 }
                                                                return singletionfactory.createObject();
                                                       }
                                                        abstract BaseInterface createObject();
                                                }

                      缺点：
                          1、如果类没有public or protected 构造函数，不能子类化
                          2、与其他静态方法没有任何区别，静态工厂方法代表了一种对规范的背离

Coundy 2007-04-12 04:14 发表评论

linear-list think

Coundy — Sun, 08 Apr 2007 19:23:00 GMT

code:

package com.algorithms;

/**
* @author oracle
*
*/

//下面注释掉的类是线性链表组合模式的实现
//
// class LineNode {
//
// private int id;
//
// private String name;
//
// private LineNode nextnode;
//
// public LineNode() {
// }
//
// public int getId() {
// return id;
// }
//
// public void setId(int id) {
// this.id = id;
// }
//
// public LineNode getNextnode() {
// return nextnode;
// }
//
// // composite pattern implements linear-list
// public void setNextnode(LineNode linenode) {
// if (this.nextnode == null)
// this.nextnode = linenode;
// else
// this.nextnode.setNextnode(linenode);
// }
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
// }

class LineNode {

    private int id;

    private String name;

    private LineNode nextnode;

    public LineNode() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public LineNode getNextnode() {
        return nextnode;
    }
    public void setNextnode(LineNode linenode) {

        this.nextnode = linenode;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class LineList {
   //添加一个节点到线性链表中
    public static void addNode(LineNode linenode, LineNode root) {
        LineNode newnode = root;
        while (newnode != null) {
            // newnode = newnode.getNextnode();
            if (newnode.getNextnode() == null) {
                newnode.setNextnode(linenode);
                // root = newnode;
                newnode = null;
            } else {
                newnode = newnode.getNextnode();
            }

        }

    }
   //删除线性链表中的一个指定节点
    public static void deleteNode(LineNode linenode, LineNode root) {
        LineNode newnode = root;
        LineNode tempnode = null;
        while (newnode != null) {
            if (newnode.getNextnode() == linenode) {
                tempnode = newnode.getNextnode();
                if (tempnode.getNextnode() != null)
                    newnode.setNextnode(tempnode.getNextnode());
                tempnode = null;
                newnode = null;
            } else
                newnode = newnode.getNextnode();
        }
    }

    /**
    * @param args
    */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LineNode root = new LineNode();
        root.setId(0);
        root.setName("root");

        LineNode sonone = new LineNode();
        sonone.setId(1);
        sonone.setName("sonone");
        // root.setNextnode(sonone);
        LineList.addNode(sonone, root);

        LineNode sontwo = new LineNode();
        sontwo.setId(2);
        sontwo.setName("sontwo");
        // root.setNextnode(sontwo);
        LineList.addNode(sontwo, root);

        LineList.deleteNode(sonone, root);
    }
}

Coundy 2007-04-09 03:23 发表评论

Binary Tree

Coundy — Sun, 08 Apr 2007 19:10:00 GMT

code:
/**
*
*/
package com.algorithms;

/**
* @author oracle
*
*/
class BinaryNode {

    private int id;

    private BinaryNode left;

    private BinaryNode right;

    public BinaryNode() {
    }

    // composite模式实现binay tree
    //
    // public void addNode(BinaryNode node) {
    // if (node.getId() > id) {
    // if (left == null)
    // this.left = node;
    // else
    // this.left.addNode(node);
    // } else {
    // if (right == null)
    // this.right = node;
    // else
    // this.right.addNode(node);
    // }
    //
    // }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public BinaryNode getLeft() {
        return left;
    }

    public void setLeft(BinaryNode left) {
        this.left = left;
    }

    public BinaryNode getRight() {
        return right;
    }

    public void setRight(BinaryNode right) {
        this.right = right;
    }

}

public class BinaryTree {

    // 添加一个节点到二叉树
    // 下面的代码显示一个对象的名字相当于指向一个对象的handle
    public static void addNode(BinaryNode root, BinaryNode node) {
        BinaryNode newnode = root;
        while (newnode != null) {
            if (newnode.getId() < node.getId()) {
                if (newnode.getLeft() == null) {
                    newnode.setLeft(node);
                    newnode = null;
                } else {
                    newnode = newnode.getLeft();
                }
            } else {
                if (newnode.getRight() == null) {
                    newnode.setRight(node);
                    newnode = null;
                } else
                    newnode = newnode.getRight();
            }
        }
    }

    /**
    * @param args
    */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BinaryNode root = new BinaryNode();

        root.setId(50);

        BinaryNode one = new BinaryNode();

        one.setId(80);

        BinaryTree.addNode(root, one);

        BinaryNode two = new BinaryNode();

        two.setId(40);

        BinaryTree.addNode(root, two);

        BinaryNode three = new BinaryNode();

        three.setId(90);

        BinaryTree.addNode(root, three);
    }

}

Coundy 2007-04-09 03:10 发表评论