Archive for 编程语言

Notepad++插件之FunctionList-for PHP development

One thing I really love about Notepad++ is the plugin’s that are available. One of such plugins that I enjoy is the Function List plugin to automatically search my code to pull classes, functions and much more into an easy to see pane on the right side of my screen. I had previously posted tutorials on another site but now I have made the process for “installing” these new rules easier by posting the XML as well as adding more features. Once you have followed the below steps the Function List plugin will show all of the following:

  • PHP classes
  • PHP class variables – (public, protected and private)
  • PHP functions – already does this by default
  • CodeIgniter Views
  • CodeIgniter Helpers
  • CodeIgniter Libraries
  • CodeIgniter Models
  • PHP include()
  • PHP include_once
  • PHP require()
  • PHP require_once()

Update: I updated the instructions based on a comment below to close Notepad++ while editing the .xml file

Step 1: Close Notepad++
Step 2: Navigate to C:\Program Files\Notepad++\plugins\Config – This is the default installation folder, it may be different on your system.
Step 3: Open the FunctionListRules.xml file in your favorite editor other than Notepad++. The settings may not save if you open this file in Notepad++.
Step 4: Do a search for the following line: (This will more than likely be at the end of the file.)

<Language name="PHP" imagelistpath="">

Step 5: Add the following code between the opening and closing Language tags:

<Group name="Classes" subgroup="Functions" icon="0" child="0" autoexp="4" matchcase="1" fendtobbeg="" bbegtobend="\{" keywords="">
            <Rules regexbeg="class" regexfunc="[\w_ ]+" regexend="" bodybegin="\{" bodyend="\}" sep="" />
        </Group>
        <Group name="Class Variables" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="public\ " regexfunc="\$.*[^;]" regexend=".*;" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg="protected\ " regexfunc="\$.*[^;]" regexend=".*;" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg="private\ " regexfunc="\$.*[^;]" regexend=".*;" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Functions" subgroup="" icon="0" child="0" autoexp="4" matchcase="1" fendtobbeg="" bbegtobend="\{" keywords="">
            <Rules regexbeg="function[\s&amp;]+" regexfunc="[\w_]+" regexend="\s*\(.*\)" bodybegin="\{" bodyend="\}" sep=";" />
        </Group>
        <Group name="CodeIgniter Views" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;view\([&apos;&quot;]' regexfunc='[&quot;\/\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="CodeIgniter Helpers" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="\$this-&gt;(.*)load-&gt;helper\(array\(" regexfunc='[&apos;,&quot;\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;helper\([&apos;&quot;]' regexfunc='[&quot;\w_]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="CodeIgniter Libraries" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="\$this-&gt;(.*)load-&gt;library\(array\(" regexfunc='[&apos;,&quot;\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;library\([&apos;&quot;]' regexfunc='[&quot;\w_]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="CodeIgniter Models" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="\$this-&gt;(.*)load-&gt;model\(array\(" regexfunc='[&apos;,&quot;\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;model\([&apos;&quot;]' regexfunc='[&quot;\w_]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Include" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='include\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Include Once" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='include_once\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Require" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='require\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Require Once" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='require_once\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>

My full section including the Language tags looks like this:

<Language name="PHP" imagelistpath="">
        <CommList param1="#" param2="" />
        <CommList param1="//" param2="" />
        <CommList param1="/\*" param2="\*/" />
        <Group name="Classes" subgroup="Functions" icon="0" child="0" autoexp="4" matchcase="1" fendtobbeg="" bbegtobend="\{" keywords="">
            <Rules regexbeg="class" regexfunc="[\w_ ]+" regexend="" bodybegin="\{" bodyend="\}" sep="" />
        </Group>
        <Group name="Class Variables" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="public\ " regexfunc="\$.*[^;]" regexend=".*;" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg="protected\ " regexfunc="\$.*[^;]" regexend=".*;" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg="private\ " regexfunc="\$.*[^;]" regexend=".*;" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Functions" subgroup="" icon="0" child="0" autoexp="4" matchcase="1" fendtobbeg="" bbegtobend="\{" keywords="">
            <Rules regexbeg="function[\s&amp;]+" regexfunc="[\w_]+" regexend="\s*\(.*\)" bodybegin="\{" bodyend="\}" sep=";" />
        </Group>
        <Group name="CodeIgniter Views" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;view\([&apos;&quot;]' regexfunc='[&quot;\/\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="CodeIgniter Helpers" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="\$this-&gt;(.*)load-&gt;helper\(array\(" regexfunc='[&apos;,&quot;\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;helper\([&apos;&quot;]' regexfunc='[&quot;\w_]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="CodeIgniter Libraries" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="\$this-&gt;(.*)load-&gt;library\(array\(" regexfunc='[&apos;,&quot;\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;library\([&apos;&quot;]' regexfunc='[&quot;\w_]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="CodeIgniter Models" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg="\$this-&gt;(.*)load-&gt;model\(array\(" regexfunc='[&apos;,&quot;\w_ ]+' regexend="" bodybegin="" bodyend="" sep="" />
            <Rules regexbeg='\$this-&gt;(.*)load-&gt;model\([&apos;&quot;]' regexfunc='[&quot;\w_]+' regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Include" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='include\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Include Once" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='include_once\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Require" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='require\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
        <Group name="Require Once" subgroup="" icon="0" child="0" autoexp="4" matchcase="0" fendtobbeg="" bbegtobend="" keywords="">
            <Rules regexbeg='require_once\([&apos;&quot;]' regexfunc="*.*[\w]" regexend="" bodybegin="" bodyend="" sep="" />
        </Group>
    </Language>

Step 6: Save and close, then open up a PHP file in Notepad++ to see if it shows the desired output in the Function List tool.

英文原文:http://www.danielkassner.com/2010/01/22/using-notepads-function-list-plugin-for-php-development

关于javascript的闭包

前言

闭包~~我一直都忽视了他的重要性,
因为以前用的java中是不支持这个概念的~
java7 小组还在讨论要不要加入这个特性。我想 一旦加入了这个特性,那么java就不是原来的java了~
最近接触javascript,必须把closure弄明白,好像和垃圾回收有很大关系。
嗯~我在网上搜了下关于闭包有好多描述:
描述1:
闭包是一个拥有许多变量和绑定了这些变量的环境的表达式(通常是一个函数),因而这些变量也是该表达式的一部分。
描述2:
JavaScript中所有的function都是一个闭包(这个不算是定义。。)
描述3:
ECMAscript允许适用内部函数-即 函数定义和函数表达式 位于另一个函数体内。

闭包的特点:
1.作为一个函数变量的一个引用,当函数返回时,其处于激活状态。
2.一个闭包就是当一个函数返回时,一个没有释放资源的栈区。
简单的说,javascript允许使用内部函数—即函数定义和函数表达式位于另一个函数的函数体内。而且,这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数和声明的其他内部函数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时,就会形成闭包。
function closure(){
   var str = "I'm a part variable.";
   return function(){
     alert(str);
   }
}
var fObj = closure();
fObj();

在上面代码中,str是定义在函数closure中局部变量,若str在closure函数调用完成以后不能再被访问,则在函数执行完成后str将被释放。但是由于函数closure返回了一个内部函数,且这个返回的函数引用了str变量,导致了str可能会在closure函数执行完成以后还会被引用,所以str所占用的资源不会被回收。这样closure就形成了一个闭包。
事实上,当我们给自定义的javascript类中的私有变量添加get/set函数时,已经用到了闭包。

function Class1(){
  var vari;
  this.getVari = function(){return vari;}
  this.setVari = function(_vari){vari = _vari;}
}
var cls = new Class1();
cls.setVari(“test variable”);
alert(cls.getVari());
 在这个例子中,构造器中定义了变量vari,构造器执行结束后如果vari没有被其他外部能够应用的成员方法所引用时,这个变量将被回收。但是我们给它定义了get/set函数以后,由于这两个内部函数可以被包含他们的函数Class1(类)的外部所访问,且变量vari被这两个函数所引用,因此vari不会被回收。这样就形成了闭包。

Javascript垃圾回收的原则是:如果一个对象不再被引用,那么这个对象会被垃圾回收器回收。如果两个对象无干扰的互相引用,那么这两个对象也会被回收。

大多数时候所谓的“闭包”:
嵌套的function所产生的闭包更为强大,也是大部分时候我们所谓的“闭包”。看下面这段代码:

function a() {
   var i = 0;
   function b() {
     alert(++i);
   }
   return b;
}
var c = a();
c();这段代码有两个特点:

函数b嵌套在函数a内部;函数a返回函数b。
这样在执行完var c=a()后,变量c实际上是指向了函数b,b中用到了变量i,再执行c()后就会弹出一个窗口显示i的值(第一次为1)。这段代码其实就创建了一个闭包,为什么?因为函数a外的变量c引用了函数a内的函数b
就是说:
当函数a的内部函数b被函数a外的一个变量引用的时候,就创建了一个我们通常所谓的“闭包”。
让我们说的更透彻一些。所谓“闭包”,就是在构造函数体内定义另外的函数作为目标对象的方法函数,而这个对象的方法函数反过来引用外层函数体中 的临时变量。这使得只要目标 对象在生存期内始终能保持其方法,就能间接保持原构造函数体当时用到的临时变量值。尽管最开始的构造函数调用已经结束,临时变量的名称也都消失了,但在目标对象的方法内却始终能引用到该变量的值,而且该值只能通这种方法来访问。即使再次调用相同的构造函数,但只会生成新对象和方法,新的临时变量只是对应新 的值,和上次那次调用的是各自独立的。

闭包有什么作用和效果?


      简而言之,闭包的作用就是在a执行完并返回后,闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源,因为a的内部函数b的执行需要依赖a中的变量。这是对闭包作用的非常直白的描述,不专业也不严谨,但大概意思就是这样,理解闭包需要循序渐进的过程。
在上面的例子中,由于闭包的存在使得函数a返回后,a中的i始终存在,这样每次执行c(),i都是自加1后alert出i的值。

那么我们来想象另一种情况,如果a返回的不是函数b,情况就完全不同了。因为a执行完后,b没有被返回给a的外界,只是被a所引用,而此时a也只会 被b引用,因此函数a和b互相引用但又不被外界打扰(被外界引用),函数a和b就会被GC回收。

为了更深刻的理解闭包,下面让我们继续探索闭包的作用和效果。
如果要更加深入的了解闭包以及函数a和嵌套函数b的关系,我们需要引入另外几个概念:

函数的执行环境(excution context)、活动对象(call object)、作用域(scope)、作用域链(scope chain)。

以函数a从定义到执行的过程为例阐述这几个概念。

当定义函数a的时候,js解释器会将函数a的作用域链(scope chain)设置为定义a时a所在的“环境”,如果a是一个全局函数,则scope chain中只有window对象。
当执行函数a的时候,a会进入相应的执行环境(excution context)。
在创建执行环境的过程中,首先会为a添加一个scope属性,即a的作用域,其值就为第1步中的scope chain。即a.scope=a的作用域链。
然后执行环境会创建一个活动对象(call object)。活动对象也是一个拥有属性的对象,但它不具有原型而且不能通过JavaScript代码直接访问。创建完活动对象后,把活动对象添加到a的作用域链的最顶端。此时a的作用域链包含了两个对象:a的活动对象和window对象。
下一步是在活动对象上添加一个arguments属性,它保存着调用函数a时所传递的参数。
最后把所有函数a的形参和内部的函数b的引用也添加到a的活动对象上。在这一步中,完成了函数b的的定义,因此如同第3步,函数b的作用域链被设置为b所被定义的环境,即a的作用域。
到此,整个函数a从定义到执行的步骤就完成了。此时a返回函数b的引用给c,又函数b的作用域链包含了对函数a的活动对象的引用,也就是说b可以访问到a中定义的所有变量和函数。函数b被c引用,函数b又依赖函数a,因此函数a在返回后不会被GC回收。

当函数b执行的时候亦会像以上步骤一样。因此,执行时b的作用域链包含了3个对象:b的活动对象、a的活动对象和window对象,如下图所示:

当在函数b中访问一个变量的时候,搜索顺序是:

先搜索自身的活动对象,如果存在则返回,如果不存在将继续搜索函数a的活动对象,依次查找,直到找到为止。
如果函数b存在prototype原型对象,则在查找完自身的活动对象后先查找自身的原型对象,再继续查找。这就是Javascript中的变量查找机制。
如果整个作用域链上都无法找到,则返回undefined。
小结,本段中提到了两个重要的词语:函数的定义与执行。文中提到函数的作用域是在定义函数时候就已经确定,而不是在执行的时候确定(参看步骤1和3)。用一段代码来说明这个问题:

function f(x) {
var g = function () { return x; }
return g;
}
var h = f(1);
alert(h());这段代码中变量h指向了f中的那个匿名函数(由g返回)。

假设函数h的作用域是在执行alert(h())确定的,那么此时h的作用域链是:h的活动对象->alert的活动对象->window对象。
假设函数h的作用域实在定义时确定的,就是说h指向的那个匿名函数在定义的时候就已经确定了作用域。那么在执行的时候,h的作用域链为:h的活动对象->f的活动对象->window对象。
如果第一种假设成立,那输出值就是undefined;如果第二种假设成立,输出值则为1。

运行结果证明了第2个假设是正确的,说明函数的作用域确实是在定义这个函数的时候就已经确定了。

闭包的应用场景

保护函数内的变量安全。以最开始的例子为例,函数a中i只有函数b才能访问,而无法通过其他途径访问到,因此保护了i的安全性。
在内存中维持个变量。依然如前例,由于闭包,函数a中i的一直存在于内存中,因此每次执行c(),都会给i自加1。
通过保护变量的安全实现JS私有属性和私有方法(不能被外部访问)推荐阅读:http://javascript.crockford.com/private.html
私有属性和方法在Constructor外是无法被访问的
function Constructor(…) {
   var that = this;
   var membername = value;
   function membername(…) {…}
}

以上3点是闭包最基本的应用场景,很多经典案例都源于此。

Javascript的垃圾回收机制

在Javascript中,如果一个对象不再被引用,那么这个对象就会被GC回收。如果两个对象互相引用,而不再被第3者所引用,那么这两个互相引用的对象也会被回收。因为函数a被b引用,b又被a外的c引用,这就是为什么函数a执行后不会被回收的原因。

实际应用

闭包在javascript编程中有重要的作用,如果使用恰当,可以为某些问题的解决带来很多方便。但是如果使用不恰当,也会带来很多麻烦。
1.为执行的函数提供参数。  

setTimeout可以延迟执行某个函数,原型如下: setTimeout(code,millisec)。其中第一个参数为需要执行的函数或者代码,第二个参数是延迟的毫秒数。常见用法:

function sayHello(){
alert(“hello world”);
}
setTimeout(sayHello,1000);
  但是可能我们会需要一个通用一些的函数,而不仅仅是只会说“hello world”。我们写一个say()函数,给say传递一个需要说的内容的参数。但是在setTimeout中我们无法给需要延迟执行的函数传递参数。使用闭包,我们可以这样做:

function say(words){
return function(){
alert(words)
}
}
setTimeout(say(“hello word”),1000);
setTimeout(say(“I’m hungry,I’m need some food!”),2000);

  这样可以在调用setTimeout时给需要延迟执行的函数传递参数了。

2.将对象的方法与其他实例关联
比如我们在做一个多文件上传的程序,要求可以动态添加和删除文件:

function addFile(){
var fileInput = document.createElement(“input”);
fileInput.type = “file”;
fileInput.name = “file”;

var btnDel = document.createElement(“input”);
btnDel.type = “button”;
btnDel.value = “删除”;

btnDel.onclick = (function(){
//删除文件
return function(){
var c = _(“fileContent”);
c.removeChild(fileInput);
c.removeChild(btnDel);
}
})();

var fContent = _(“fileContent”)
fContent.appendChild(fileInput);
fContent.appendChild(btnDel);
}

  在这个例子中,我们在删除按钮的点击时间关联的函数中删除对应的上传表单和按钮本身。由于表单和按钮都是动态生成,在事先并不知道删除按钮点击后需要删除的内容是什么。但是我们可以使用javascript闭包的特性,在上传表单和按钮生成的时候将按钮的点击事件与上传表单实例及和按钮实例进行关联。

3.模拟静态私有变量
Javascript本身并不支持面向对象的特性。但是我们可以通过javascript的一些特性模拟实现javascript面向对象。
  比如我们需要定义一个类,并且模拟静态私有变量。

var Class2 = (function(){
var s_var = 0; //静态私有变量
return function(){
this.getInstanceCount = function(){
return s_var;
}
//constructor
s_var++;
}
})()

var cls1 = new Class2();
alert(cls1.getInstanceCount()); //1

var cls2 = new Class2();
alert(cls1.getInstanceCount()); //2
alert(cls2.getInstanceCount()); //2

var cls3 = new Class2();
alert(cls1.getInstanceCount()); //3
alert(cls3.getInstanceCount()); //3

  在这个例子中,我们用s_var记录Class2被实例化的次数,使用闭包,我们可以将s_var模拟为一个静态私有变量,每次Class2被实例化的时候将s_var加1。

上例中我们使用了这样形式的一段代码,其中定义在外层函数内,内层函数外的成员类似于静态成员。所以这样形式的代码我们可以把他叫做“静态封装环境”。

(function(){
return function(){
}
})()

我随便总结一下:JS的闭包说的就是JS中函数的闭包,闭包就是一个被外部函数引用的内部变量的延迟释放。。。。。

参考文章地址:
http://www.cnblogs.com/zhangle/archive/2010/07/02/1770206.html
http://baike.baidu.com/view/648413.htm
http://www.cnblogs.com/yangjian/archive/2009/09/24/1573176.html
http://www.cnblogs.com/chongzi/
http://www.360doc.com/content/09/1227/11/370235_12087397.shtml
http://softbbs.pconline.com.cn/9497825.html

推荐阅读:

http://www.slideshare.net/hymanroth/closures-in-javascript

http://wenku.baidu.com/view/6da338b069dc5022aaea005c.html

AAuto的table用法测试

Aauto这个蛮有意思的~是国产的编程语言~一鹤5年力作~~~基于Lua JIT的?

前天发现的~昨天用aauto写了个98顶贴机器~还蛮好用的~相当的方便~写点小程序比java方便多了~~响应速度极快~整个环境就几兆而已~恩~

近期打算写个校内的分享机器~营销的绝佳利器~~

table是AAuto的唯一的数据结构 感觉设计的相当不错,用起来很方便。。今天写点TC~~稍微熟悉一下这个数据结构吧~

table  的下标是从1 开始的 呵呵~~这款中文编程语言还是面向大众的。

<code>

import win;
//打开控制台
io.open()

t={};
//table插入元素
table.insert(t,”windows”);
table.insert(t,”linux”);
table.insert(t,”unix”);

for(k,v in t){
io.print(k,v);
//io.print();
}

t1={};
t1[1]=11;
t1[2]=22;
t1[3]=33;
t1[3000]=333;
//范型输出table元素 针对稀疏数组 效率高
for(k,v in t1){
io.print(v);
}

//关等待闭响应
win.loopMessage();

</code>

Read more

深入理解JVM(新)

1   Java技术与Java虚拟机

说起Java,人们首先想到的是Java编程语言,然而事实上,Java是一种技术,它由四方面组成: Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。它们的关系如下图所示:

图1   Java四个方面的关系

运行期环境代表着Java平台,开发人员编写Java代码(.java文件),然后将之编译成字节码(.class文件)。最后字节码被装入内存, 一旦字节码进入虚拟机,它就会被解释器解释执行,或者是被即时代码发生器有选择的转换成机器码执行。从上图也可以看出Java平台由Java虚拟机和 Java应用程序接口搭建,Java语言则是进入这个平台的通道,用Java语言编写并编译的程序可以运行在这个平台上。这个平台的结构如下图所示:

Read more

try、return、finally里面的诡计

与大多数高级语言一样,Java通过return语句实现函数的带值返回功能。如:

Java代码
public static String test(){
    String str = "Hello world";
    return str;
}

与C/C++的处理方式不同,Java在编写代码时,不允许return语句之后还是其它语句存在。如:

Java代码
public static String test(){
    String str = "Hello world";
    return str;
    str = "Hello world!"; // 编译错误。
}

但是这种语法规则又不是绝对的。如:

Java代码
public static String test(){
    String str = "try";
    try {
        return str;
    }finally {
        str = "finally";
    }
}
 Read more

Java面试过程中会遇到的问题

转自:http://hxraid.javaeye.com/blog/749507

1、abstract的method是否可同时是static,是否可同时是native,是否可同时是synchronized?

abstract的method 不可以是static的 ,因为抽象的方法是要被子类实现的,而static与子类扯不上关系!
abstract的method 不可以是native的, native方法表示该方法要用另外一种依赖平台的编程语言实现的,不存在着被子类实现的问题,所以,它也不能是抽象的,不能与abstract混用。例 如,FileOutputSteam类要硬件打交道,底层的实现用的是操作系统相关的api实现,例如,在windows用c语言实现的,所以,查看 jdk 的源代码,可以发现FileOutputStream的open方法的定义如下:
private native void open(String name) throws FileNotFoundException;
如果我们要用java调用别人写的c语言函数,我们是无法直接调用的,我们需要按照java的要求写一个c语言的函数,又我们的这个c语言函数去调用别人 的c语言函数。由于我们的c语言函数是按java的要求来写的,我们这个c语言函数就可以与java对接上,java那边的对接方式就是定义出与我们这个 c函数相对应的方法,java中对应的方法不需要写具体的代码,但需要在前面声明native。
abstract的method 不可以是synchronized的, 在我几年的学习和开发中,从来没见到过这种情况,并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且,方法上的synchronized同步所使用的同步锁对象是this,而抽象方法上无法确定this是什么。

2、super.getClass()方法调用
下面程序的输出结果是多少?

Java代码
import java.util.Date;
public  class Test extends Date{
    public static void main(String[] args) {
        new Test().test();
    }

    public void test(){
        System.out.println(super.getClass().getName());
    }
}
 Read more

Java 虚拟机体系结构

众所周知,Java源代码被编译器编译成class文件。而并不是底层操作系统可以直接执行的二进制指令(比如Windows OS的.exe文件)。因此,我们需要有一种平台可以解释class文件并运行它。而做到这一点的正是Java 虚拟机(JVM)。

实际上,JVM是一种解释执行class文件的规范技术。各 个提 供商都可以根据规范,在不同的底层平台上实现不同的JVM。

下面是JVM实现的基本结构框图。其中类装载子系统、运行时数据区、执行引擎等 是JVM的必须要解决的几大问题。

★ 类装载器子系统

Read more

Class文件内容及常量池

JVM运行Java程序的时候,它会加载对应的class文件,并提取class文件中的信息存放在JVM开辟出来的方法区 内存中。那么这个class文件里面到底有些什么内容呢?

一、class文件内容概述

class文件是由8bits的字节流组成,全部字节构成了15个有意义的项目。这些项目之间没有任何无意义的字节,因此class文件非常紧凑。占据多字节空间的项目按照高位在前的顺序存放。下面我们详细讨论这些项目:

★ magic(魔数) 每个class文件的前4个字节称为魔数,值为0xCAFEBABE。作用在于轻松的辨别class文件与非class文件。

★ minor_version、major_version(次、主版本号) 各占2个字节。随着Java技术的发展,class文件的格式会发生变化。版本号的作用在于使得虚拟机能够认识当前加载class的文件格式。从而准确的提取class文件信息。

★ constant_pool_count 、constance_pool(常量池) 从这里开始的字节组成了常量池 。 存储了诸如符号常量、final常量值、基本数据类型的字面值等内容。JVM会将每一个常量构成一个常量表,每个常量表都有自己的入口地址。而实际上在 JVM会将这些常量表存储在方法区中一块连续的内存空间中,因此class文件会根据常量表在常量池中的位置对其进行索引。比如常量池中的第一个常量表的 索引值就是1,第二个就是2。有的时候常量表A需要常量表B的内容,则在常量表A中会存储常量表B的索引值x。而constant_pool_count 就记录了有多少个常量表,或则所有多少个索引值。实际上,常量池中没有索引值为0的常量表,但这缺失的索引值也被记录在 constant_pool_count中,因此 constant_pool_count等于常量表的数量加1。关于常量池的具体内容,我们会在下面详细讲述,并用一个例子来显示整个class文件的内容。

Read more

偷窥JAVA字符串三姐妹-String、StringBuffer、StringBuilder

builder最佳 单线程就用StringBuilder吧~~ 她技巧最好~最忠诚~让你一个人爽翻天~~~

多线程就用StringBuffer吧~~ 她就是一Bus = =~ 可供多人使用~多P必备~

要是你只是存取下数据String最常用了 她长得最漂亮~看看足矣!~YY专用~

每次上网冲杯Java时,都能看到关于String无休无止的争论。还是觉得有必要让这个讨厌又很可爱的String美眉,赤裸裸的站在我们这些Java色狼面前了 :o 。嘿嘿….
众所周知,String是由字符组成的串,在程序中使用频率很高。Java中的String是一个类,而并非基本数据类型。 不过她却不是普通的类哦!!!

【偷窥镜头1】 String对象的创建
1、关于类对象的创建,很普通的一种方式就是利用构造器,String类也不例外:String s=new String(“Hello world”); 问题是参数”Hello world”是什么东西,也是字符串对象吗?莫非用字符串对象创建一个字符串对象?

2、当然,String类对象还有一种大家都很喜欢的创建方式:String s=”Hello world”; 但是有点怪呀,怎么与基本数据类型的赋值操作(int i=1)很像呀?

在开始解释这些问题之前,我们先引入一些必要的知识:

★ Java class文件结构 和常量池
我们都知道,Java程序要运行,首先需要编译器将源代码文件编译成字节码文件(也就是.class文件)。然后在由JVM解释执行。
class文件是8位字节的二进制流 。这些二进制流的涵义由一些紧凑的有意义的项 组成。比如class字节流中最开始的4个字节组成的项叫做魔数 (magic),其意义在于分辨class文件(值为0xCAFEBABE)与非class文件。class字节流大致结构如下图左侧。

Read more

温故知新-java中equals和==的区别

值类型:是存储在内存中的堆栈(以后简称栈  ou  shit 很久以前老是把堆栈和堆等同~英文不就很好区分吗! stack  heap!!~~我擦~)。

引用类型:变量在栈中仅仅是存储引用类型变量的地址,而其本身则存储在堆中。

==操作比较的是两个变量的值是否相等,对于引用型变量表示的是两个变量在堆中存储的地址是否相同,即栈中的内容是否相同。

equals操作表示的两个变量是否是对同一个对象的引用,即堆中的内容是否相同。

==比较的是2个对象的地址,而equals比较的是2个对象的内容。
显然,当equals为true时,==不一定为true;

一、String中的equals和==
1、
public class TestString {
public static void main(String[] args) {
String s1 = “Monday”;
String s2 = “Monday”;
}
}

Read more

无觅相关文章插件,快速提升流量