BlogJava-极限编程员-文章分类-Javahttp://www.blogjava.net/feng0801/category/54459.html学习交流平台zh-cnTue, 29 Jul 2014 09:12:32 GMTTue, 29 Jul 2014 09:12:32 GMT60Java调用dll文件http://www.blogjava.net/feng0801/articles/400111.html冯威威冯威威Mon, 03 Jun 2013 08:15:00 GMThttp://www.blogjava.net/feng0801/articles/400111.htmlhttp://www.blogjava.net/feng0801/comments/400111.htmlhttp://www.blogjava.net/feng0801/articles/400111.html#Feedback0http://www.blogjava.net/feng0801/comments/commentRss/400111.htmlhttp://www.blogjava.net/feng0801/services/trackbacks/400111.html先说一下我的运行环境：JDK6.0  VC++6简体中文版
我运行环境是这个，对于其他环境我也不知道行不行，可以试一下！

1，编写Java文件MyDll.java
 1 public class MyDll {
 2     static {
 3         System.loadLibrary("MyDll");
 4     }
 5     public native int sum(int i,int j); 
 6     public static void main(String args[]) {
 7         int i = 10;
 8         int j = 10;
 9         int temp = new MyDll().sum(i, j);
10         System.out.println("10+10的和为："+temp);
11     }
12 }
13 
2，编译Java文件 命令：javac MyDll.java 如果没有报错 ，再运行命令： javah MyDll 。前面命令生成MyDll.class文件，后面命令生成MyDll.h文件
 
3，在VC++6建立项目，选择Win32 Dynamic-Link Library ,工程名 MyDll。然后选择A simple DLL project，点击Finish。



4，将MyDll.h文件复制到你项目里面，就是项目名的文件夹里面。


在StdAfx文件里面#include <windows.h>后面添加
#include <jni.h>
#include "MyDll.h"
配置环境，选择“工具”，“选项”，“目录”，将你安装Java的目录中的include和win32目录添加上。

5，将下面代码复制到MyDll.cpp文件的后面，build项目，将项目文件夹下的Debug文件夹生成的MyDll.dll文件复制到与MyDll.java同一个目录。
1 JNIEXPORT jint JNICALL Java_MyDll_sum
2 (JNIEnv *env, jobject obj, jint _arg_i, jint _arg_j) 
3 {
4     int m_i = _arg_i;
5     int m_j = _arg_j;
6     int temp = m_i+m_j;
7     return temp;
8 }

6，运行Java文件,输出一下结果


7， 本例中也是参考网上的一些例子，弄了也是好久才做出来，所以贴出来加深印象。在做的过程中需要注意细节。
 


冯威威 2013-06-03 16:15 发表评论
]]> Java 接口和抽象类区别http://www.blogjava.net/feng0801/articles/396180.html冯威威冯威威Fri, 08 Mar 2013 01:03:00 GMThttp://www.blogjava.net/feng0801/articles/396180.htmlhttp://www.blogjava.net/feng0801/comments/396180.htmlhttp://www.blogjava.net/feng0801/articles/396180.html#Feedback0http://www.blogjava.net/feng0801/comments/commentRss/396180.htmlhttp://www.blogjava.net/feng0801/services/trackbacks/396180.html原文：http://blog.csdn.net/sunboard/article/details/3831823

1.概述

一个软件设计的好坏，我想很大程度上取决于它的整体架构，而这个整体架构其实就是你对整个宏观商业业务的抽象框架，当代表业务逻辑的高层抽象层结构 合理时，你底层的具体实现需要考虑的就仅仅是一些算法和一些具体的业务实现了。当你需要再开发另一个相近的项目时，你以前的抽象层说不定还可以再次利用 。面对对象的设计，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用。

说到了抽象，我就不能不提到曾让我头痛的Java接口和Java抽象类了，这也是本文我想说的重点。

既然面向对象设计的重点在于抽象，那Java接口和Java抽象类就有它存在的必然性了。

Java接口(interface)和Java抽象类(abstract class)代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序 的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些有用的抽象类型作为你结构层次上的顶层。

Java接口和Java抽象类有太多相似的地方，又有太多特别的地方，究竟在什么地方，才是它们的最佳位置呢？把它们比较一下，你就可以发现了。

  1. Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以（就是interface中只能定义方法，而不能有方法的实现，而在abstract class中则可以既有方法的具体实现，又有没有具体实现的抽象方法），这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。这个在我的另外一篇博客mapreduce 新旧API 区别中有提到类似的问题，在新的mapreduce api中更倾向于使用抽象类，而不是接口，因为这更容易扩展。原因就是上面划线部分所说的。
  2. 一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。（使用抽象类，那么继承这个抽象类的子类类型就比较单一，因为子类只能单继承抽象类；而子类能够同时实现多个接口，因为类型就比较多。接口和抽象类都可以定义对象，但是只能用他们的具体实现类来进行实例化。）
  3. 从第2点不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。
  4. 结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java 接口在最上面，然后紧跟着抽象类，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。（A extends AbstractB implements interfaceC，那么A即可以选择实现(@Override)接口interfaceC中的方法，也可以选择不实现；A即可以选择实现(@Override)抽象类AbstractB中的方法，也可以选择不实现）

Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的，如果你准备写一个具体类去继承另一个具体类的话，那你的设计就有很大问题了。Java抽象类就是为了继承而存在的，它的抽象方法就是为了强制子类必须去实现的。

使用Java接口和抽象Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。而不要用具体Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。

2.实例

下面给出一个具体的接口Action，代码如下所示：

  1. package org.springframework.webflow.execution;  
  2. public interface Action {  
  3.     public Event execute(RequestContext context) throws Exception;  
  4. }  
在这个接口中，定义了一个没有具体实现的方法，方法名叫做execute()，返回类型是Event。如前面第一条所述，接口中的方法都是没有实现的。这些方法的具体实现是在实现(implements)这个接口的类中给出的。

再来看一个实现Action接口的抽象类AbstractAction，代码如下。

  1. package org.springframework.webflow.action;  
  2.   
  3. import org.apache.commons.logging.Log;  
  4. import org.apache.commons.logging.LogFactory;  
  5. import org.springframework.beans.factory.BeanInitializationException;  
  6. import org.springframework.beans.factory.InitializingBean;  
  7. import org.springframework.util.ClassUtils;  
  8. import org.springframework.webflow.core.collection.AttributeMap;  
  9. import org.springframework.webflow.execution.Action;  
  10. import org.springframework.webflow.execution.Event;  
  11. import org.springframework.webflow.execution.RequestContext;  
  12.   
  13. public abstract class AbstractAction implements Action, InitializingBean {  
  14.   
  15.     protected final Log logger = LogFactory.getLog(getClass());  
  16.   
  17.     public EventFactorySupport getEventFactorySupport() {  
  18.         return new EventFactorySupport();  
  19.     }  
  20.   
  21.     public void afterPropertiesSet() throws Exception {  
  22.         try {  
  23.             initAction();  
  24.         } catch (Exception ex) {  
  25.             throw new BeanInitializationException("Initialization of this Action failed: " + ex.getMessage(), ex);  
  26.         }  
  27.     }  
  28.   
  29.     protected void initAction() throws Exception {  
  30.     }  
  31.   
  32.     protected Event success() {  
  33.         return getEventFactorySupport().success(this);  
  34.     }  
  35.   
  36.     protected Event success(Object result) {  
  37.         return getEventFactorySupport().success(this, result);  
  38.     }  
  39.   
  40.     protected Event error() {  
  41.         return getEventFactorySupport().error(this);  
  42.     }  
  43.   
  44.     protected Event error(Exception e) {  
  45.         return getEventFactorySupport().error(this, e);  
  46.     }  
  47.   
  48.     protected Event yes() {  
  49.         return getEventFactorySupport().yes(this);  
  50.     }  
  51.   
  52.     protected Event no() {  
  53.         return getEventFactorySupport().no(this);  
  54.     }  
  55.   
  56.     protected Event result(boolean booleanResult) {  
  57.         return getEventFactorySupport().event(this, booleanResult);  
  58.     }  
  59.   
  60.     protected Event result(String eventId) {  
  61.         return getEventFactorySupport().event(this, eventId);  
  62.     }  
  63.   
  64.     protected Event result(String eventId, AttributeMap resultAttributes) {  
  65.         return getEventFactorySupport().event(this, eventId, resultAttributes);  
  66.     }  
  67.   
  68.     protected Event result(String eventId, String resultAttributeName, Object resultAttributeValue) {  
  69.         return getEventFactorySupport().event(this, eventId, resultAttributeName, resultAttributeValue);  
  70.     }  
  71.   
  72.     public final Event execute(RequestContext context) throws Exception {  
  73.         Event result = doPreExecute(context);  
  74.         if (result == null) {  
  75.             result = doExecute(context);  
  76.             doPostExecute(context);  
  77.         } else {  
  78.             if (logger.isInfoEnabled()) {  
  79.                 logger.info("Action execution disallowed; pre-execution result is '" + result.getId() + "'");  
  80.             }  
  81.         }  
  82.         return result;  
  83.     }  
  84.   
  85.     protected String getActionNameForLogging() {  
  86.         return ClassUtils.getShortName(getClass());  
  87.     }  
  88.   
  89.     protected Event doPreExecute(RequestContext context) throws Exception {  
  90.         return null;  
  91.     }  
  92.   
  93.     //抽象方法  
  94.     protected abstract Event doExecute(RequestContext context) throws Exception;  
  95.   
  96.     protected void doPostExecute(RequestContext context) throws Exception {  
  97.     }  
  98. }  
在抽象类AbstractAction中，既有具体实现的方法，又有没有具体实现的抽象方法

  1. //抽象方法  
  2. protected abstract Event doExecute(RequestContext context) throws Exception;  
需要注意的是在抽象类中，如果方法没有具体实现（就是方法后面没有{}），那么必须加上abstract来声明这个方法，而接口中不需要使用abstract来声明（抽象类之所以被称为抽象类，就是因为它包含有抽象方法。含有抽象方法的类叫做抽象类）。

冯威威 2013-03-08 09:03 发表评论
]]>Collections.sort 使用方法http://www.blogjava.net/feng0801/articles/394350.html冯威威冯威威Thu, 17 Jan 2013 03:36:00 GMThttp://www.blogjava.net/feng0801/articles/394350.htmlhttp://www.blogjava.net/feng0801/comments/394350.htmlhttp://www.blogjava.net/feng0801/articles/394350.html#Feedback0http://www.blogjava.net/feng0801/comments/commentRss/394350.htmlhttp://www.blogjava.net/feng0801/services/trackbacks/394350.html 一种是：重新写一个类进行Comparator接口compare方法重写
建立Java文件 User.java 代码如下：注意（int没有compareTo方法，需要将int改成Integer）
 1 public class User {
 2     private String name;
 3     private Integer age;
 4     public User(String nameTemp,Integer ageTemp)
 5     {
 6         this.name = nameTemp;
 7         this.age = ageTemp;
 8     }
 9     public String getName() {
10         return name;
11     }
12     public void setName(String name) {
13         this.name = name;
14     }
15     public Integer getAge() {
16         return age;
17     }
18     public void setAge(Integer age) {
19         this.age = age;
20     }
21 }

建立SortTest.java文件

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.Comparator;
 4 import java.util.List;
 5 
 6 public class TestSort {
 7     @SuppressWarnings("unchecked")
 8     public static void main(String args[]) {
 9         List userlist = new ArrayList();
10         userlist.add(new User("dd", 4));
11         userlist.add(new User("aa", 1));
12         userlist.add(new User("ee", 5));
13         userlist.add(new User("bb", 2));
14         userlist.add(new User("ff", 5));
15         userlist.add(new User("cc", 3));
16         
17         Collections.sort(userlist, new Comparator(){
18             public int compare(Object arg1, Object arg2) {
19                 User u1 = (User)arg1;
20                 User u2 = (User)arg2;
21                 int flag = u1.getAge().compareTo(u2.getAge());
22                 return flag;
23             }
24         });
25 
26         for (int i = 0; i < userlist.size(); i++) {
27             User user_temp = (User) userlist.get(i);
28             System.out.println(user_temp.getAge() + "," + user_temp.getName());
29         }
30     }
31 }

另一种是：在实体对象中实现Comparable接口
建立user.java类
 1 public class User implements Comparable<User> {
 2     private String name;
 3     private Integer age;
 4     public User(String nameTemp,Integer ageTemp)
 5     {
 6         this.name = nameTemp;
 7         this.age = ageTemp;
 8     }
 9     public String getName() {
10         return name;
11     }
12 
13     public void setName(String name) {
14         this.name = name;
15     }
16 
17     public Integer getAge() {
18         return age;
19     }
20 
21     public void setAge(Integer age) {
22         this.age = age;
23     }
24     public String toString() {
25         return "name is "+name+" age is "+age;
26     }
27     public int compareTo(User o) {
28         return this.age.compareTo(o.getAge());
29     }
30 }
建立TestSort.java文件
 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class TestSort {
 6     @SuppressWarnings("unchecked")
 7     public static void main(String args[]) {
 8         List userlist = new ArrayList();
 9         userlist.add(new User("dd", 4));
10         userlist.add(new User("aa", 1));
11         userlist.add(new User("ee", 5));
12         userlist.add(new User("bb", 2));
13         userlist.add(new User("ff", 6));
14         userlist.add(new User("cc", 3));
15         
16         Collections.sort(userlist);
17         for (int i = 0; i < userlist.size(); i++) {
18             User user_temp = (User) userlist.get(i);
19             System.out.println(user_temp.getAge() + "," + user_temp.getName());
20         }
21     }
22 }


冯威威 2013-01-17 11:36 发表评论
]]>加法和打印时间、查找用户的程序http://www.blogjava.net/feng0801/articles/308806.html冯威威冯威威Sat, 09 Jan 2010 02:45:00 GMThttp://www.blogjava.net/feng0801/articles/308806.htmlhttp://www.blogjava.net/feng0801/comments/308806.htmlhttp://www.blogjava.net/feng0801/articles/308806.html#Feedback0http://www.blogjava.net/feng0801/comments/commentRss/308806.htmlhttp://www.blogjava.net/feng0801/services/trackbacks/308806.html

import java.util.*;
class Student //定义一个类
{
    String xing;
    String xingming;
    void setStu(String xing1,String xingming1)
    {
     xing = xing1;
     xingming = xingming1;
    }
    void printStudent()
    {
     System.out.println(xingming);
    }
    public String toString()
    {
     return xing+" "+xingming;
 }
 }
class YongHu {
    public static void main(String args[])
   {
        Scanner sc = new Scanner(System.in);
        ArrayList a = new ArrayList();
     Student stu = new Student();
  /*将有的对象添加到数组里面*/
  Student stu1 = new Student();
        stu1.setStu("张","张三");
        a.add(stu1);
          
        Student stu2 = new Student();
        stu2.setStu("李","李四");
             a.add(stu2);
            
        Student stu3 = new Student();
        stu3.setStu("王","王五");
        a.add(stu3);
            
        Student stu4 = new Student();
        stu4.setStu("李","李旺");
        a.add(stu4);
            
        Student stu5 = new Student();
        stu5.setStu("张","张磊");
        a.add(stu5);
            
        Student stu6 = new Student();
        stu6.setStu("张","张武");
        a.add(stu6);
            
        Student stu7 = new Student();
        stu7.setStu("张","张杰");
        a.add(stu7);
            
        Student stu8 = new Student();
        stu8.setStu("王","王石");
        a.add(stu8);

        while(true) {
         System.out.println("a:加法   b:输出当前日期   c:查找姓名  q是退出");
            System.out.print("请输入字母: ");
         String s = sc.next();
         if(s.equals("a"))
         {
    System.out.print("请输入第一个数:");//读取下面一样
    int m=sc.nextInt();
    System.out.print("请输入第二个数:");
    int n=sc.nextInt();
    int he=m+n;
    System.out.println("它们的和为:"+he);
         }
         if(s.equals("b"))
         {
          int Y,M,D,H,m,S;
        Y = Calendar.getInstance().get(Calendar.YEAR);//调用年份方法
             M = Calendar.getInstance().get(Calendar.MONTH);//调用月份方法
             D = Calendar.getInstance().get(Calendar.DAY_OF_MONTH);//调用天份方法
            H = Calendar.getInstance().get(Calendar.HOUR_OF_DAY);//调用方法
            m = Calendar.getInstance().get(Calendar.MINUTE);//调用方法
             S = Calendar.getInstance().get(Calendar.SECOND);
             System.out.println("当前系统时间为：" + Y + "年" + (M+1) + "月" + D +"日" + H+"点"+m + "分"+S+ "秒");
             System.out.println();
         }
         if(s.equals("c"))
         {  
          System.out.print("请输入姓名: ");
          String name = sc.next();
    //System.out.println(name.length());这是看看它的长度
          if(name.length()==2) //字节来限制
          {
              Iterator it = a.iterator(); // 迭代导引
        while(it.hasNext())
              {
                  Student h = (Student)it.next();//转化为Student对象
       if(h.xingming.equals(name))
      {
          h.printStudent();
      }
         }
          }
          if(name.length()==1) //字节来限制
          {
              Iterator it = a.iterator();  
              while(it.hasNext())
              {
       Student h = (Student)it.next();//转化为Student对象
      if(h.xing.equals(name))
            {
                h.printStudent();
  
            }
   
         } 
          }
          }
          if(s.equals("q"))
          {
           break;
          }
        }
    }
}
这是程序的全部,有点简陋请大家不见笑，请多多指教。



冯威威 2010-01-09 10:45 发表评论
]]>