博客园_yongwnet

jQuery调用WebService详解

2011-07-17T15:58:00Z

ws.aspx 代码

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
    <title></title>

    <script src="jquery.js" type="text/javascript"></script>

    <style type="text/css">
        .hover
        {
            cursor: pointer; /*小手*/
            background: #ffc; /*背景*/
        }
        .button
        {
            width: 150px;
            float: left;
            text-align: center;
            margin: 10px;
            padding: 10px;
            border: 1px solid #888;
        }
        #dictionary
        {
            text-align: center;
            font-size: 18px;
            clear: both;
            border-top: 3px solid #888;
        }
        #loading
        {
            border: 1px #000 solid;
            background-color: #eee;
            padding: 20px;
            margin: 100px 0 0 200px;
            position: absolute;
            display: none;
        }
        #switcher
        {
        }
    </style>

    <script type="text/javascript">


        //无参数调用
        $(document).ready(function() {
            $('#btn1').click(function() {
                $.ajax({
                    type: "POST",   //访问WebService使用Post方式请求
                    contentType: "application/json", //WebService 会返回Json类型
                    url: "WebService1.asmx/HelloWorld", //调用WebService的地址和方法名称组合 ---- WsURL/方法名
                    data: "{}",         //这里是要传递的参数，格式为 data: "{paraName:paraValue}",下面将会看到       
                    dataType: 'json',
                    success: function(result) {     //回调函数，result，返回值
                        $('#dictionary').append(result.d);
                    }
                });
            });
        });


        //有参数调用
        $(document).ready(function() {
            $("#btn2").click(function() {
                $.ajax({
                    type: "POST",
                    contentType: "application/json",
                    url: "WebService1.asmx/GetWish",
                    data: "{value1:'心想事成',value2:'万事如意',value3:'牛牛牛',value4:2009}",
                    dataType: 'json',
                    success: function(result) {
                        $('#dictionary').append(result.d);
                    }
                });
            });
        });
        
        
        //返回集合（引用自网络，很说明问题）
        $(document).ready(function() {
            $("#btn3").click(function() {
                $.ajax({
                    type: "POST",
                    contentType: "application/json",
                    url: "WebService1.asmx/GetArray",
                    data: "{i:10}",
                    dataType: 'json',
                    success: function(result) {
                        $(result.d).each(function() {
                            //alert(this);
                            $('#dictionary').append(this.toString() + " ");
                            //alert(result.d.join(" | "));
                        });
                    }
                });
            });
        });


        //返回复合类型
        $(document).ready(function() {
            $('#btn4').click(function() {
                $.ajax({
                    type: "POST",
                    contentType: "application/json",
                    url: "WebService1.asmx/GetClass",
                    data: "{}",
                    dataType: 'json',
                    success: function(result) {
                        $(result.d).each(function() {
                            //alert(this);
                            $('#dictionary').append(this['ID'] + " " + this['Value']);
                            //alert(result.d.join(" | "));
                        });

                    }
                });
            });
        });

        //返回DataSet(XML)
        $(document).ready(function() {
            $('#btn5').click(function() {
                $.ajax({
                    type: "POST",
                    url: "WebService1.asmx/GetDataSet",
                    data: "{}",
                    dataType: 'xml', //返回的类型为XML ，和前面的Json，不一样了
                    success: function(result) {
                    //演示一下捕获
                        try {   
                            $(result).find("Table1").each(function() {
                                $('#dictionary').append($(this).find("ID").text() + " " + $(this).find("Value").text());
                            });
                        }
                        catch (e) {
                            alert(e);
                            return;
                        }
                    },
                    error: function(result, status) { //如果没有上面的捕获出错会执行这里的回调函数
                        if (status == 'error') {
                            alert(status);
                        }
                    }
                });
            });
        });




        //Ajax 为用户提供反馈，利用ajaxStart和ajaxStop 方法，演示ajax跟踪相关事件的回调，他们两个方法可以添加给jQuery对象在Ajax前后回调
        //但对与Ajax的监控，本身是全局性的
        $(document).ready(function() {
            $('#loading').ajaxStart(function() {
                $(this).show();
            }).ajaxStop(function() {
                $(this).hide();
            });
        });

        // 鼠标移入移出效果，多个元素的时候，可以使用“，”隔开
        $(document).ready(function() {
            $('div.button').hover(function() {
                $(this).addClass('hover');
            }, function() {
                $(this).removeClass('hover');
            });
        });
        
        
    </script>

</head>
<body>
    <form id="form1" runat="server">
    <div id="switcher">
        <h2>
            jQuery 的WebServices 调用</h2>
        <div class="button" id="btn1">
            HelloWorld</div>
        <div class="button" id="btn2">
            传入参数</div>
        <div class="button" id="btn3">
            返回集合</div>
        <div class="button" id="btn4">
            返回复合类型</div>
        <div class="button" id="btn5">
            返回DataSet(XML)</div>
    </div>
    <div id="loading">
        服务器处理中，请稍后。
    </div>
    <div id="dictionary">
    </div>
    </form>
</body>
</html>

WebService1.asmx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using System.Data;

namespace jQuery.Learning
{
    /// <summary>
    /// WebService1 的摘要说明
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消对下行的注释。
    [System.Web.Script.Services.ScriptService]
    public class WebService1 : System.Web.Services.WebService
    {
        /// <summary>
        /// 无参数
        /// </summary>
        /// <returns></returns>
        [WebMethod]
        public string HelloWorld()
        {
            return "Hello World ";
        }

        /// <summary>
        /// 带参数
        /// </summary>
        /// <param name="value1"></param>
        /// <param name="value2"></param>
        /// <param name="value3"></param>
        /// <param name="value4"></param>
        /// <returns></returns>
        [WebMethod]
        public string GetWish(string value1, string value2, string value3, int value4)
        {
            return string.Format("祝您在{3}年里 {0}、{1}、{2}", value1, value2, value3, value4);
        }

        /// <summary>
        /// 返回集合
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        [WebMethod]
        public List<int> GetArray(int i)
        {
            List<int> list = new List<int>();

            while (i >= 0)
            {
                list.Add(i--);
            }

            return list;
        }

        /// <summary>
        /// 返回一个复合类型
        /// </summary>
        /// <returns></returns>
        [WebMethod]
        public Class1 GetClass()
        {
            return new Class1 { ID = "1", Value = "牛年大吉" };
        }


        /// <summary>
        /// 返回XML
        /// </summary>
        /// <returns></returns>
        [WebMethod]
        public DataSet GetDataSet()
        {
            DataSet ds = new DataSet();
            DataTable dt = new DataTable();
            dt.Columns.Add("ID", Type.GetType("System.String"));
            dt.Columns.Add("Value", Type.GetType("System.String"));
            DataRow dr = dt.NewRow();
            dr["ID"] = "1";
            dr["Value"] = "新年快乐";
            dt.Rows.Add(dr);
            dr = dt.NewRow();
            dr["ID"] = "2";
            dr["Value"] = "万事如意";
            dt.Rows.Add(dr);
            ds.Tables.Add(dt);
            return ds;
        }


    }
    //自定义的类，只有两个属性
    public class Class1
    {
        public string ID { get; set; }
        public string Value { get; set; }
    }
}

来自: http://hi.baidu.com/lanxigang/blog/item/a51a730995fc82a42fddd4af.html

本文链接

产品经理的素质

2011-03-29T12:35:00Z

一个产品经理需要一些素质？怎么样才能做一个成功的产品经理？产品经理的性格是怎么样的？产品经理是“通”才还是“专”才……很多问题困扰着产品经理，其实能真正称得上产品经理的有多少人？有多少人可以全力承担一条产品线，将产品打造成一个品牌，不是靠流量，而是靠用户对产品的认识，一提起产品名就让用户头脑中有产品的印象，深入人心的产品又有多少？一个真正的产品经理就决定了这个产品的什么样，所以对于产品经理的要求在很多企业已经越来越高了。
下面的内容仅代表自己作为一个产品经理想到的，如有不同意见欢迎大家拍砖。
产品经理的素质归为三类：1、个人能力；2、管理知识；3、核心能力。

1、个人能力
1）创新能力
一个产品经理如果墨守成规那他真的不适合在互联网中，互联网注定是一个日新月异的环境，将创新能力做为个人素养的第一条，要说明的就是产品经理一定要有自己的思想，没思想的产品经理是可怕的，创新能力不来于一朝一夕，更多的是时间的积累。
2）执行能力
当需求确定后，产品经理需要有严格的执行能力，对产品概念的理解，对产品需求的理解，而后去执行产品过程，当你BOSS为最大的产品经理时，你需要做的就是执行，同时在执行过程中得表达你的想法，你的认识，你才是真正的产品经理，做的同时更需要你的产品理念去执行这个产品。
3）协调能力
产品经理一定是个“中场大师”，输送炮弹的指挥官，面对UED，面对用户，面对开发，面对BOSS，如何做到资源沟通协调，如保做到最适度的协调保证产品正常的按周期进行，更多的体现你在人际中的个人魅力、人格魅力。千万别让其它同事跟着你做无用功，需求变更是经常的事，但尽可能少的改动需求，其它人不怨老板，但会怨产品经理。
4）自我管理能力
产品经理要学会自我管理，个人的知识、能力、性格等多方面的管理，暴君似的产品经理真的不适合拥有健康的企业文化的公司，而伪娘似的产品经理很多时候可以在众多的企业中生存下来。自我管理，资源及技术等的掌握，做一个适合企业和产品发展的产品经理。
5）承受压力能力
产品经理是忍者神龟。压力会来自多方面，而产品经理一定要有过硬的心理素质，上对BOSS，下对用户，产品永远是产品经理的孩子，不论是多丑，出生了就有义务将它带大，用户的指责，BOSS的KPI，个个压力都压在产品经理肩上，学会释放压力，自我调节，当然加班对产品经理来说永远是家常便饭。

2、管理知识
1）战略管理知识
战略管理很多在公司BOSS已经定好了，而产品经理只要理解产品的战略规划就行，但做为产品经理职业发展规划中的一部分，产品经理要将产品战略管理当成自己的职能之一，当到高级产品经理，或更上一层职位时一定会触到产品战略，站在更高层次看产品经理。
2）产品管理知识
当产品定下来后，一切的计划及工作都将围绕着产品展开。制定产品计划、评估产品风险、竞争对手分析、争取产品资源、管理产品团队、协调产品问题、控制产品周期进度等一系列产品管理计划需要产品经理去制定。产品管理的知识涉透到产品的整个过程，需要产品经理不断的完善，更新，改进。
3）时间管理知识
学会撑握时间。产品经理经常要和时间赛跑，让其它人员加班就是产品经理的错，产品经理对于整个产品进度都得把握和计划好，当资源冲突，当多条产品线同时需要研发等情况下，做好时间管理，统筹安排时间。别无谓的加班，也别让别人无谓的加班。
4）团队管理知识
产品经理不是孤军奋斗，你永远会有一个团队在支撑着你。团队协作，团队人员工作协调与调配，为产品努力的每个人员都是团队的一员，不论工作重与轻，多与少，都是团队人员的一名，努力让团队凝聚在一起，是一个团队，同时也是狼性团队培养的开始。

3、核心能力
1）产品规范管理
无规矩不成方圆。产品要有自己的规范，而做为产品经理也需要有自己的产品规范，在互联网环境中，阿里、腾讯、百度等互联网公司对产品经理的产品规范都有自己的认识和理解，因为他们选择适合自己企业的产品规范，做为产品经理一定要有自己的产品规范，可以随着公司的变化改变，但一定要形成有自己产品规范的产品经理，同时是可以随时转换适合企业需要的产品经理。
2）产品需求管理
产品经理主要功能之一就是需求分析及整理，市场、BOSS、运营等会提出形形色色的需求，而产品经理则需要将这些需求重新整理与分析，产品核心功能的挖掘一定是出自于需求。产品经理需要与市场、BOSS、运营等确定需求，改进需求，提炼需求，功能重整，这是产品经理对产品需求的管理。需求核心的把握产品经理对需求的提炼及对功能确定的根本。
3）产品项目管理
产品经理是产品的直接接口人，同也是产品关系最密切的人，不论是UED、开发、测试等都是产品经理的直接面对人。产品项目管理需要进行多方面的协调，产品经理做的就是桥梁，同时对于产品的控制，进度的控制，质量的控制，人员的控制等，产品经理做的是一个产品，产品从无到有，再到它被市场淘汰，整个产品过程，产品的项目管理，注重的过程，看更多的产品经理想看的是结果，控制好产品项目管理，结果让用户去骂吧。
4）产品生命周期管理
每个产品都有生命，有它形成、成长、成熟、衰退这样的周期。所有的产品都有这样的周期，产品经理对于产品生命周期的管理直接影响着这个产品在市场上的口碑及市场地位，没有永远的胜者，产品经理可以是屠夫，当不再适合产品发展时，要有果断的“宰杀”自己的产品的勇气，将不能落地的idea“扼杀”于摇篮里。
5）产品品牌管理
一个产品经理如何将产品打造成一个品牌？如何让用户使用时记起这款产品经理是你？这对于很多产品经理来说是非常不可思议的一件事，乔布斯做到了，而更多的时候我们希望我们亲手做出来的产品让最多的用户去使用，而没形成品牌意识，但对于一个企业来说，产品代表着企业，企业有个让人随时记起的品牌产品这体现产品的成功，同时也是企业的成功。产品经理对于产品的品牌意识更多的维护，如何创造品牌这也将是产品经理职业发展中的一个重要环节。

产吕经理不是一个光靠嘴说话的忽悠，需要掌握的东西很多，产品经理的“通”只是方法和过程，“专”才是方向和目的。产品经理的“通”应该是业务知识上的要求，“专”则是职位专业上的要求。产品经理应该是既“通”又“专”的真正复合型的人才才对。同时对于软件类的掌握更是必须的，不一定要你懂技术，但一定要学会用软件、图表将自己的产品意识表达清楚。

产品经理的路每个人走法不同，对于产品经理的认识也不同，培养良好的产品经理素质，做一名优秀的产品经理。

本文链接

JAVA 调用 .NET编写的WebService

2011-01-21T08:09:00Z

1..NET编写的WebService源码

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.ComponentModel

<System.Web.Services.WebService(Namespace:="http://tempuri.org/")> _
<System.Web.Services.WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<ToolboxItem(False)> _
<SoapDocumentService(RoutingStyle:=SoapServiceRoutingStyle.RequestElement)> _
Public Class Service1
    Inherits System.Web.Services.WebService

    <WebMethod()> _
   Public Function HelloWorld(ByVal para_in1 As String, ByVal para_in2 As String) As String
        Try
            Dim s As String = "para_in1:" & para_in1.ToString() & ",para_in2=" & para_in2 & vbCrLf
            My.Computer.FileSystem.WriteAllText("c:\ws.txt", s, True)
            Return s
        Catch ex As Exception
            My.Computer.FileSystem.WriteAllText("c:\ws.txt", "ex:" & ex.ToString() & vbCrLf, True)
            Return ex.ToString()
        End Try
        Return "NO"

    End Function
End Class

2.JAVA调用源码:

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->import javax.xml.namespace.QName;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class myMain2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO 自动生成方法存根
        InvokeWebservice();
    }

    public static void InvokeWebservice()
    {
        try
        {
            /**说明:

               http://127.0.0.1:4727/Service1.asmx    表示Dotnet的WebService地址
               http://tempuri.org/     表示命名空间
               HelloWorld             表示调用的函数名
               para_in1                表示 HelloWorld 函数的第一个参数名
               para_in2                表示 HelloWorld 函数的第二个参数名

               另:本源码需要引用三个JAR包(axis.jar, jaxrpc.jar, commons-discovery-0.2.jar);
             * */

            String endpoint = "http://127.0.0.1:4727/Service1.asmx";

            Service service = new Service();

            Call call = (Call) service.createCall();

            call.setTargetEndpointAddress(new java.net.URL(endpoint));

            call.addParameter(new QName("http://tempuri.org/","para_in1"), org.apache.axis.Constants.XSD_STRING,javax.xml.rpc.ParameterMode.IN);
            call.addParameter(new QName("http://tempuri.org/","para_in2"), org.apache.axis.Constants.XSD_STRING,javax.xml.rpc.ParameterMode.IN);
            call.setReturnType(org.apache.axis.Constants.XSD_STRING);

            call.setOperationName(new QName("http://tempuri.org/","HelloWorld"));
            call.setUseSOAPAction(true);
            call.setSOAPActionURI("http://tempuri.org/HelloWorld");

            String para_in1 = "Java_Invoke_DotnetWebservice";
            String para_in2 = "2011-01-21";
            String s = (String)call.invoke(new Object[]{para_in1, para_in2});

            System.out.println("result is " + s);

        }
        catch (Exception e)
        {
            System.err.println(e.toString());
            e.printStackTrace();
        }
    }

}

实例下载: Java_Invoke_DotnetWebservice.rar

本文链接

Java中实现鼠标模拟与键盘映射

2010-10-11T14:35:00Z

Java SDK 1.3以后实现了Robot类。此类用于为测试自动化、自运行演示程序和其他需要控制鼠标和键盘的应用程序生成本机系统输入事件。Robot 的主要目的是便于 Java 平台实现自动测试。
使用该类生成输入事件与将事件发送到 AWT 事件队列或 AWT 组件的区别在于：事件是在平台的本机输入队列中生成的。例如，Robot.mouseMove 将实际移动鼠标光标，而不是只生成鼠标移动事件。
Robot中主要的鼠标和键盘控制方法有：

void keyPress(int keycode) 按下给定的键。
void keyRelease(int keycode) 释放给定的键。
void mouseMove(int x, int y) 将鼠标指针移动到给定屏幕坐标。
void mousePress(int buttons) 按下一个或多个鼠标按钮。
void mouseRelease(int buttons) 释放一个或多个鼠标按钮。
void mouseWheel(int wheelAmt) 在配有滚轮的鼠标上旋转滚轮。

下面就让我们来实战鼠标控制，实现一个简单的鼠标控制程序MouseController。程序功能很简单：随机移动鼠标并点击左键。

代码如下：

import java.awt.AWTException;

import java.awt.Dimension;

import java.awt.Robot;

import java.awt.Toolkit;

import java.awt.event.InputEvent;

import java.util.Random;

/**

* @author Xiaofeng Wang

public class MouseController implements Runnable {

private Dimension dim;

private Random rand;

private Robot robot;

private volatile boolean stop = false;

/** Creates a new instance of Main */

public MouseController() {

dim = Toolkit.getDefaultToolkit().getScreenSize();

rand = new Random();

try {

robot = new Robot();

} catch (AWTException ex) {

ex.printStackTrace();

}

public void run() {

while(!stop) {

int x = rand.nextInt(dim.width);

int y = rand.nextInt(dim.height);

robot.mouseMove(x, y);

robot.mousePress(InputEvent.BUTTON1_MASK);

try {

Thread.sleep(3000);

} catch (InterruptedException ex) {

ex.printStackTrace();

}

public synchronized void stop() {

stop = true;

}

/** * @param args the command line arguments */

public static void main(String[] args) {

MouseController mc = new MouseController();

Thread mcThread = new Thread(mc);

System.out.println("Mouse Controller start");

mcThread.start();

try {

Thread.sleep(60000);

} catch (InterruptedException ex) {

ex.printStackTrace();

}

mc.stop();

System.out.println("Mouse Controller stoped");

}

当然键盘映射也类似，无非是使用void keyPress(int keycode)。

现在实现了控制鼠标和键盘，接下了我们要获取操作后的效果（屏幕截图）。好在Robot类也提供了一个方法：BufferedImage createScreenCapture(Rectangle screenRect)；可以直接将全屏幕或某个屏幕区域的像素拷贝到一个BufferedImage对象中。

好，下面实战使用robot截屏，实现Capture程序，每隔１秒截屏一次。

代码如下：

public class Capture extends javax.swing.JFrame implements Runnable {

/** Creates new form Capture */

public Capture() {

initComponents();

try {

robot = new Robot();

} catch (AWTException ex) {

ex.printStackTrace();

}

dim = Toolkit.getDefaultToolkit().getScreenSize(); }

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

// <editor-fold desc=" 生成的代码 " defaultstate="collapsed"></editor-fold>

private void initComponents() {

screenCanvas = new java.awt.Canvas();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

stop = true;

setResizable(false);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(screenCanvas, javax.swing.GroupLayout.PREFERRED_SIZE, 519, javax.swing.GroupLayout.PREFERRED_SIZE) );

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(screenCanvas, javax.swing.GroupLayout.PREFERRED_SIZE, 434, javax.swing.GroupLayout.PREFERRED_SIZE)

);

pack();

}//

/** * @param args the command line arguments */

public static void main(String args[]) {

final Capture capture = new Capture();

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

capture.setVisible(true);

}

});

Thread cutThread = new Thread(capture);

cutThread.start();

}

public void run() {

stop = false;

while(!stop) {

BufferedImage bImage = robot.createScreenCapture(new Rectangle(dim.width, dim.height));

Graphics g = this.screenCanvas.getGraphics();

g.drawImage(bImage, 0, 0, this);

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {

ex.printStackTrace();

}

private synchronized void stop() {

stop = true;

}

// 变量声明 - 不进行修改

private java.awt.Canvas screenCanvas;

// 变量声明结束

private volatile boolean stop;

private Robot robot;

private Dimension dim;

}

本文链接

Win7下轻松注册VS2008

2010-09-23T01:48:00Z

方法一:(安装后的注册升级)

1 打开“控制面板--程序和功能”
2 找到“Microsoft Visual Studio Team System 2008 专业版-简体中文”，右击-- 卸载/更改;（不同版本名称可能不同）
3 进入vs2008维护模式，加载完安装组件之后点下一步，即，出现“添加或删除功能”，“修复/重新安装”，“卸载Microsoft Visual Studio 2008” 界面，停在此界面，继续下面的操作；
4 打开补丁程序（要用管理员身份运行，不然，它没有任何反映），点击“升级”按钮，稍等片刻，再回到卸载界面，即可看到XP下的“注册码输入框和升级按钮”。

(点击下载:注册用的小补丁程序)

方法二:(安装前准备)

1 用虚拟光驱（PowerISO）修改VS2008ISO安装文件：到这个目录下找setup\ setup.sdb 文件
2 用记事本打开找到 [Product Key] 一项,并替换序列号为 PYHYPWXB3BB2CCMV9DX9VDY8T,最后保存,再安装.

本文链接

Windows7 下的VPC

2010-08-07T10:16:00Z

很多人不敢马上升级到 Windows7 除了部分硬件配置较低外，另一个最主要的原因就是怕 Windows7 的兼容性不能很好的运行现在一些只能在 XP 中才能正常使用的软件了。

其实在 Windows7 的专业版或旗舰版中，微软已经给我们提供了一个叫做 Windows XP Mode 的功能！它可以轻松地从 Windows 7 上直接运行多一个 Windows XP SP3 的操作系统，你可以安装和运行许多只能运行于XP的应用程序。其实说白了就是微软给我们提供了一个装好了XP的虚拟机，相比传统的安装双系统，使用虚拟机的好处就是不用重启即可同时运行它们，而且在虚拟化的XP里面的操作不会影响到Win7，可以说是相当的实用……

Windows XP Mode 基于微软的Virtual PC虚拟化技术，结合处理器的硬件虚拟化功能（AMD-V/Intel VT），可在Windows 7 专业版、企业版、旗舰版操作系统内模拟 Windows XP SP3 系统环境，当然其应用条件是 Windows 7 非家庭版和一个~~支持硬件虚拟化的CPU~~(微软已经提供了升级补丁移除硬件限制了)，以及不小于2GB的内存。

Windows XP Mode 其实就是一款专为 Windows 7 特别定制的 Windows Virtual PC，可以看作是 Windows Virtual PC 加送一个合法授权的Windows XP虚拟机。当然，如果你的Win7是家庭版的，就没法使用这个功能了。不过你也可以使用异次元之前介绍过的免费的虚拟机 VirtualBox，然后自己装一个XP即可拥有类似的功能！

当然，这个虚拟XP的性能是无法和独立的正统XP相比，运行一些普通的实用软件没有问题，但如果要进行高性能任务，比如视频压缩，或者玩3D游戏等，那就不适合在虚拟XP模式中运行了。

另外，Windows XP Mode 有一个亮点，就是可以将XP虚拟机内安装的程序“发布”到Windows 7主机上。发布后，用户再运行该程序，将不需要接触Virtual PC界面。这话怎么说呢？其实意思就是，一般虚拟机的程序都运行在虚拟机的窗口里面，那个窗口就像一个显示器一样，你只能在你的显示器的范围内使用你的软件，然而，现在的XP Mode已经可以把在虚拟机里面的程序直接拉出来在Win7的界面中使用！

用户可以在开始菜单选择发布后的IE 6 (注意，是XP中的IE6.0)，用户看到的它就跟普通的Win7上的程序是一样的。而实际上，该程序是运行在后台的Windows XP虚拟机中的，本来应该是显示在XP的窗口里面的，现在被我们拉出来在Win7上用了。这就极大的提高了虚拟机使用时的方便性了！

相关文件下载地址：

软件性质：免费软件
官方网站：访问

PS：安装顺序，先安装Windows XP Mode，再安装 Windows Virtual PC
注意：微软已经提供升级补丁，去除了XP Mode对硬件的限制，任何电脑均可使用了！
下载地址：Windows XP Mode 简体中文版 | 英文、繁体版 | 来自异次元 | Windows Virtual PC 中文版

本文链接

浅谈项目管理能力的提升

2010-07-15T13:46:00Z

在当今信息时代，IT技术的飞速发展，使社会发生了巨大变化。计算机技术和互联网络的广泛应用，极大地推动了社会发展、国家强盛。同时也进一步加剧了行业竞争的激烈程度。

近几十年来，项目管理已成为一个热门的话题，它的广泛应用，是管理史上的一次飞跃。项目管理是一门艺术，一门综合了多学科的艺术，是应用领域专业知识、通用管理技能，以及沟通能力等相互融合后的综合管理。对企业管理、工程建设等有着非常重要的意义。

简单地说，项目管理，就是负责本项目开发、实施中与客户的协调、工作安排、掌握项目进度、提交项目相关报告及成果等。因此，项目管理的计划、组织、协调、执行和控制能力，是衡量项目管理人员的一个重要指标。

一个项目是否成功，关键在于项目目标的实现以及客户的满意度。也就是项目有两个最基本目标：项目能顺利验收和客户满意度。

项目管理体系

项目管理体系包括几个方面的内容：

项目综合管理、项目成本管理、项目进度管理、项目范围管理、项目风险管理、项目团队管理、项目沟通管理、项目质量管理、项目采购管理。这也是项目管理的9大知识领域。

在此，结合我这几年来管理项目的情况，谈谈我个人的一些理解和体会：

其一，综合管理

一般的项目，特别是软件开发项目，通常可以分为以下几个阶段：启动阶段，计划阶段，执行阶段，监控阶段，收尾阶段。在情况允许的情况下，我们可以结合CMMI模型来对项目各阶段进行管理。将项目管理9个方面的内容综合应用于项目活动中。

启动阶段，精心地做好前期准备工作。如在项目初期对于完成项目目标而进行的调研活动，以及根据目标和调研分析而进行的可行性分析和评估。

计划阶段，对范围、工期等进行估计，获得并组织项目人员和相关资源（软硬件网络等），制定周密的、可行的项目计划，对需求/范围进行分析，对任务进行分解工作（WBS）。

执行阶段，严格按照项目计划执行。在执行过程中，各项任务的执行应讲究次序，根据任务轻重缓急，根据项目时间管理中的活动排序，确定各计划活动之间的依赖关系，从而保证计划有条不紊地执行。在这个阶段，将考验项目经理对项目过程的执行力、对项目干系人的控制力、对项目风险的把握和及时变更的能力。

监控阶段，（严格来说，项目监控应该是贯穿整个项目过程的）该阶段的目的是保障项目按计划进行。包括对进度、风险、质量、需求等进行监控。对照目标和计划，检查当前时期任务的完成情况，及时处理出现的问题。如果出现偏差，及时进行纠正，并制定相应的解决措施；识别和规避风险；沟通和协调等。通常，监控的方法和手段有项目日志、周报、月报、项目会议、里程碑会议等。通过多种方式来保证项目经理心中有数，对项目了如指掌。

收尾阶段，对项目情况进行总结，释放项目人员（资源），解散团队，归还设备，提交项目成果等。

其二，范围管理

即需求管理及变更管理。在项目过程中，要经常对照检查本阶段的产品/成果是否与需求保持一致。避免对需求控制不到位，引发项目范围变化，造成项目无法按时完成的情况。

其三，进度控制

或称时间管理。进度控制是项目管理的一个很重要的方面。项目的时间限制是很明确的，如何保证项目在既定的期限内保质保量地完成，需要整个项目团队齐心协力，为实现目标而共同努力。一旦工期延误，将直接影响到项目后续推进。

其四，成本管理

进度如果出现延误或失控，将导致项目的成本上升。并且由于进度延期，靠加班方式来赶进度，会得不偿失。

另一方面，成本管理还体现在团队的稳定上。如果人员变动较多，也会影响到进度。并且，相应的入职培训、业务培训、技能提升等方面的成本将会随之增加。

其五，质量管理

项目质量管理是应该是全面的质量管理，而不仅仅在开发阶段进行质量管理，涉及从前期需求获取、到开发、实施、维护的全过程。在架构设计控制，对开发过程和结果进行检查与评审（如果有质量方面的条件的话，要发挥QA的作用），代码审查，严格测试等。在文档规范作一定的努力和控制。

项目经理本身对项目进度、问题解决、风险控制、成本支出的管理和控制，对项目组成员工作质量的检查等，也是质量保证的一个重要方面。

项目经理要也知道CMMI，ISO等方面的知识。

其六，团队管理

或称(人力)资源管理。包括人力资源、软硬件资源、网络设备等。这重点在于资源的整合。

在项目中,一定要调动所有成员的积极性,才能发挥出团队的力量。在项目会议上，项目经理传达资讯，成员能知道相关事项的进展情况，成员才能知道下一步该如何配合主力，共同推动项目的进展。

有时，有些情况下，把问题摆到桌面上来，大家一起商讨问题解决的办法和措施，会更有利于事情的完美解决。在会议中要问题解决掉，确实不能立即解决的，要详细记录在案，便于会后处理。

团队管理的一项重要工作，就是要善于处理团队管理事务，做好成员的思想工作，激励成员，鼓舞士气，调动积极性，增强责任心和团队的凝聚力，以及项目成功带来的荣誉感。

另一方面，加强沟通和协调，了解各个成员的性格，分析他/她的优势与劣势，胜任哪方面的工作。人尽其才，同心同德，是项目成功的保障。对于项目成员能力不足，或团队合作不强，导致项目中沟通困难，项目管理出现阻力，是造成项目失误的一个常见的现象。这一点项目经理要特别注意。

其七，沟通管理

沟通是关键，项目管理是根本。良好的沟通机制是保证项目顺利实施的前提条件之一，项目经理应建立起有效的沟通渠道。

沟通对象包括客户、公司领导和管理层、团队成员、其他项目干系人。

在与用户的沟通上，要注意沟通的技巧。与客户沟通时，一定要控制好情绪，语气上温和一些，让对方感觉到你的微笑。

项目经理要冷静，要能控制自我。“冲动是魔鬼”。在一些特别情况下，要注意把握好分寸，例如在沟通过程中，出现意见相左，双方都坚持原则和立场，出现僵局时，尤其要注意克制自己，注意自己的情绪和措辞。

沟通管理的另一方面，就是与团队成员的沟通、团队内部的协调。在沟通方式上，项目组例会最常用的方式之一。但一般不局限于会议形式，口头、电话、电子邮件、白板等都可以，如果受空间或地理条件限制，借助于IM工具也可行，只要达到沟通的目的就行。随时进行项目信息沟通，促使成员全力配合主力完成任务，强调整体的运作。

我比较经常的做法是，项目经理主动和团队成员谈话，和坐在他们一起，有问题一起讨论，各抒己见，最后项目经理拿主意，作决定，承担责任。

其八，风险管理

在项目过程中风险是始终伴随的，有些是可预知并且可准备预案的，有些则是突发性的，需要临时寻求解决方案的。

项目当中的风险管理，体现在风险意识，处理和规避风险的能力上。一是项目成员必须有很强的风险意识，采取有效措施（如预案等）来防止和规避风险；二是在意外事件发生、出现了一些未能预料到的情况时，项目经理如何作紧急处理，如何应对，将影响减少到最低。因此，在风险的防止措施和控制措施上，项目经理一定要把好关。

项目经理综合能力

项目管理是一种行动力，也是一种思维方法，不仅对项目管理者目前的工作有利，更会使企业和个人的未来发展受益无穷。

作为项目经理，既要掌握上述项目管理各个方面的知识和技能，同时也要拥有一定的软实力才行。“两手都要硬”，才能真正管好项目。

这些软实力包括：领导力，沟通与协调能力，谈判能力，风险控制能力等，是一个人的综合能力的体现。

此外，我认为，还有两个方面不能忽视。

文档编写能力。一些大中型项目，涉及的项目文档在数量上和要求上都极具挑战性。售前支持、方案撰写、可行性分析研究、项目计划、任务分配、决策支持与分析、问题跟踪、项目报告等，每个阶段/里程碑都要进行控制和检查，都要在文档中体现出来，没有一定的文字功底和项目经验，是很难搞定这些事务的。

学习能力。现在的IT行业的竞争，对每个从业人员都具有非常激烈的挑战。一个人的学习能力显得非常重要。人们为了保持竞争优势，要不断更新知识结构，涉猎前沿技术，了解业界资讯，开阔视野，扩大知识面，强化改善薄弱方面，缩小与他人的差距等努力。

良好的心态，虚心学习的态度，开放的思想观念，借鉴他人成熟经验，掌握新的工具和新的应用。通过学习、实践、再学习，不断提升全面素质。在管理方法、开发技术上保持相对的优势。

最后，再谈一下几点个人感受：

（1）、沟通很重要，重要到直接影响项目的成败。有时客户的意见不一定是百分百正确，在沟通过程中，要注意引导和解释，在沟通技巧上注意把握好分寸。

（2）、项目经理对项目整体的全局把握能力。作为项目经理，要有很强全局观念，要以项目大局为重。要有对项目各方的综合的平衡能力。

（3）、做事情要及时反馈，让对方或相关人员知道事情的进展情况，好采取相应的措施，不要让“工作流”环节在自己这里停滞，注意时效和配合，以利于工作的正常运转。

（4）、项目执行过程中的酸甜苦辣同样也会影响项目经理本人，当无法获取来自其他人的热情鼓励时，必须学会自我激励。我的体会是静下心来，忘掉目前碰到的所有烦恼，将心境投入学习，在书中学会换一种心境、找到解答方法。

本文链接

java多态性详解——父类引用子类对象

2010-07-15T13:33:00Z

Java的多态性

    面向对象编程有三个特征，即封装、继承和多态。

    封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。

    继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？

    方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

    要理解多态性，首先要知道什么是“向上转型”。

    我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过

Cat c = new Cat();
实例化一个Cat的对象，这个不难理解。但当我这样定义时：

Animal a = new Cat();
这代表什么意思呢？

    很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，

定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；

同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

看下面这段程序：

class Father{
    public void func1(){
        func2();
    }
    //这是父类中的func2()方法，因为下面的子类中重写了该方法
    //所以在父类类型的引用中调用时，这个方法将不再有效
    //取而代之的是将调用子类中重写的func2()方法
    public void func2(){
        System.out.println("AAA");
    }
}

class Child extends Father{
    //func1(int i)是对func1()方法的一个重载
    //由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用
    //所以在下面的main方法中child.func1(68)是不对的
    public void func1(int i){
        System.out.println("BBB");
    }
    //func2()重写了父类Father中的func2()方法
    //如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法
    public void func2(){
        System.out.println("CCC");
    }
}

public class PolymorphismTest {
    public static void main(String[] args) {
        Father child = new Child();
        child.func1();//打印结果将会是什么？
    }
}
    上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

    那么该程序将会打印出什么样的结果呢？

    很显然，应该是“CCC”。

    对于多态，可以总结它为：

    一、使用父类类型的引用指向子类的对象；

    二、该引用只能调用父类中定义的方法和变量；

    三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

    四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

****************************************************************************************************************************

多态详解(整理)2008-09-03 19:29多态是通过:
1 接口和实现接口并覆盖接口中同一方法的几不同的类体现的
2 父类和继承父类并覆盖父类中同一方法的几个不同子类实现的.

一、基本概念

多态性：发送消息给某个对象，让该对象自行决定响应何种行为。
通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。
2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。

二、Java多态性实现机制

SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：
一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；
另一个指针指向一块从java堆中为分配出来内存空间。

三、总结

1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

DerivedC c2=new DerivedC();
BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类
a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法

分析：
* 为什么子类的类型的对象实例可以覆给超类引用？
自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
* a.play()将执行子类还是父类定义的方法？
子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。

在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。

2、不能把父类对象引用赋给子类对象引用变量

BaseClass a2=new BaseClass();
DerivedC c1=a2;//出错

在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
c1=(DerivedC)a2; 进行强制转化,也就是向下转型.

3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()）

分析：
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。

4、Java与C++多态性的比较

jvm关于多态性支持解决方法是和c++中几乎一样的，
只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。

Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。

            Java的所有函数，除了被声明为final的，都是用后期绑定。

四.   1个行为,不同的对象,他们具体体现出来的方式不一样,
        比如:     方法重载 overloading 以及方法重写(覆盖)override
                  class Human{
                 void run(){输出人在跑}
                      }
                class Man extends Human{
            void run(){输出男人在跑}
                  }
                 这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子)
                class Test{
            void out(String str){输出 str}
             void out(int i){输出 i}
                }
                这个例子是方法重载,方法名相同,参数表不同

               ok,明白了这些还不够,还用人在跑举例
              Human ahuman=new Man();
              这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象
               意思是说,把 Man这个对象当 Human看了.

               比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "
               这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,
               这个大熊猫对象,你把它当成其父类动物看,这样子合情合理.

              这种方式下要注意 new Man();的确实例化了Man对象,所以 ahuman.run()这个方法输出的   是 "男人在跑 "

               如果在子类 Man下你写了一些它独有的方法比如 eat(),而Human没有这个方法,

在调用eat方法时,一定要注意强制类型转换 ((Man)ahuman).eat(),这样才可以...

对接口来说,情况是类似的...

实例:

package domatic;

//定义超类superA
class superA {
int i = 100;

void fun(int j) {
j = i;
System.out.println("This is superA");
}
}

// 定义superA的子类subB
class subB extends superA {
int m = 1;

void fun(int aa) {
System.out.println("This is subB");
}
}

// 定义superA的子类subC
class subC extends superA {
int n = 1;

void fun(int cc) {
System.out.println("This is subC");
}
}

class Test {
public static void main(String[] args) {
superA a = new superA();
subB b = new subB();
subC c = new subC();
a = b;
a.fun(100);
a = c;
a.fun(200);
}
}
/*
* 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
* c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：
* "为什么(1)和(2)不输出：This is superA"。
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,
* 也就是说被子类覆盖的方法。
* 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
* 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
* 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun()。
* 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
* 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
* 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
* 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
*/
以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法

1.JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
//父类
public class Father{
    //父类有一个打孩子方法
    public void hitChild(){
    }
}
//子类1
public class Son1 extends Father{
    //重写父类打孩子方法
    public void hitChild(){
       System.out.println("为什么打我？我做错什么了！");
    }
}
//子类2
public class Son2 extends Father{
    //重写父类打孩子方法
    public void hitChild(){
       System.out.println("我知道错了，别打了！");
    }
}
//子类3
public class Son3 extends Father{
    //重写父类打孩子方法
    public void hitChild(){
       System.out.println("我跑，你打不着！");
    }
}

//测试类
public class Test{
    public static void main(String args[]){
       Father father;

       father = new Son1();
       father.hitChild();

       father = new Son2();
       father.hitChild();

       father = new Son3();
       father.hitChild();
    }
}
都调用了相同的方法，出现了不同的结果！这就是多态的表现！

本文链接

Java截取字符串的一些常用处理

2010-07-15T13:19:00Z

import java.util.StringTokenizer;

/** *//**

* @author bulktree Email: laoshulin@gmail.com

* @date Jul 31, 2008

public class SplitTest {

public static void main(String[] args) {

SplitTest st = new SplitTest();

// st.splitTest01();

//st.splitTest02();

st.StringTokenizierTest();

}

public void splitTest01() {

String s = "01111:aa:哈哈";

/**//*

* limit 该值用来限制返回数组中的元素个数

String[] s1 = s.split(":");

System.out.println(s1[0]);

/**//*

* -1表示如果为空也能区分出来

String[] s2 = s.split(":", -1);

System.out.println(s2[0]);

String[] s3 = s.split(":", 1);

System.out.println(s3[0]);

}

public void splitTest02() {

// “.”和“|”都是转义字符，必须得加"\\"

String s = "bulktree.oakertree.laoshulin";

String ss = "bulktree|oakertree|laoshulin";

String sss = "bulktree.oakertree|laoshulin";

String[] s1 = s.split("\\.");

System.out.println(s1[0]);

String[] s2 = ss.split("\\|");

System.out.println(s2[0]);

/**//*

* 如果有多个分隔符，可以用"|"作为连字符

String[] s3 = sss.split("\\.|\\|");

System.out.println(s3[1]);

}

/**//*

* 构造字符串的StringTokenizer对象测试

public void StringTokenizierTest() {

String s = "I am a student,bulktree";

StringTokenizer str = new StringTokenizer(s);

// 返回nextToken方法被调用的次数,分隔符的数量

System.out.println(str.countTokens());

// 是否有分隔符

while(str.hasMoreTokens()) {

System.out.println(str.nextToken());

}

本文链接

java类加载的表现形式

2010-07-15T13:15:00Z

java中的类是动态加载的，我们先看一下我们常用的类加载方式，先有一个感性的认识，才能进一步

深入讨论,类加载无非就是下面三种方式。

class A{}

class B{}

class C{}

public class Loader{

public static void main(String[] args) throws Exception{

Class aa=A.class;

Class bb=Class.forName("B");

Class cc=ClassLoader.getSystemClassLoader().loadClass("C");

}

我们先看.class字面量方式，很多人可能不知道这种方式，因为这种用法不是一般java语法。

通过javap我们可以发现，这种方式的大致等价于定义了一个静态成员变量

static Class class$0;(后面的编号是增长的)

你可以试图再定义一个 static Class class$0,应该会收到一个编译错误(重复定义)。

Class aa=A.class;

就相当于

if(class$0==null){

try{

Class.forName("A");

}

cacth(ClassNotFoundException e){

throw new NoClassDefFoundError(e);

}

Class aa=class$0;

可以很清楚的看到，这种类的字面量定义其实不是加载类的方式，而是被编译器处理了，实质上是使用了Class.forName方法，但是使用这种方式有一个很大的好处就是不用处理异常，因为编译器处理的时候如果找不到类会抛出一个NoClassDefFoundError.也许你觉得需要处理 ClassNotFoundException这种异常，事实上99%的情况下我们可以把这种异常认为是一个错误。

所以大部分情况我们使用这种方式会更简洁。

最常用的方式就是Class.forName方式了，这也是一个通用的上层调用。这个方法有两个重载，可能很多人都忽略了第二个方法。

public static Class forName(String name) throws ClassNotFoundException

public static Class forName(String name, boolean initialize,ClassLoader loader) throws ClassNotFoundException

第二个方法后面多了两个参数，第二个参数表示是否初始化，第三个参数为指定的类加载器。

在上面的例子中：

Class bb=Class.forName("B");

等价于

Class bb=Class.forName("B",true,Loader.class.getClassLoader());

这里要详细说一下这个类的初始化这个参数，如果这个参数为false的话，类中的static成员不会被初始化，static语句块也不会被执行。

也就是类虽然被加载了，但是没有被初始化，不过在第一次使用时仍然会初始化。

所以我们有时候会看到Class.forName("XXX")。newInstance()这样的语句，为什么这里要创建一个不用的实例呢？不过是为了保证类被初始化(兼容以前的系统)。

其实第二个方法是比较难用的，需要指定类加载器，如果不指定而且又没有安装安全管理器的化，是无法加载类的，只要看一下具体的实现就明白了。

最本质的方式当然是直接使用ClassLoader加载了，所有的类最终都是通过ClassLoader加载的，Class cc=ClassLoader.getSystemClassLoader()。loadClass("C");这里通过使用系统类加载器来加载某个类，很直接的方式，但是很遗憾的是通过这种方式加载类，类是没有被初始化的(也就是初始化被延迟到真正使用的时候)。不过我们也可以借鉴上面的经验，加载后实例化一个对象Class cc=ClassLoader.getSystemClassLoader()。loadClass("C")。newInstance()。

这里使用了系统类加载器，也是最常用的类加载器，从classpath中寻找要加载的类。

java中默认有三种类加载器：引导类加载器，扩展类加载器，系统类加载器。

java中的类加载有着规范的层次结构，如果我们要了解类加载的过程，需要明确知道哪个类被谁加载，某个类加载器加载了哪些类等等，就需要深入理解ClassLoader的本质。

以上只是类加载的表面的东西，我们还将讨论深层次的东西。

本文链接