本文目录一览:
- 1、静态方法和实例方法的区别
- 2、类实例方法,静态方法的使用与区别
- 3、javascript中什么时候用静态方法什么时候用实例方法,规则是什么,各好在哪儿?
- 4、类方法、实例方法和静态方法的区别
- 5、js代码如何封装
- 6、js公有,私有,静态属性和方法的区别
静态方法和实例方法的区别
静态方法和实例方法的区别主要体现在两个方面:
在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。
静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制。
下面几个例子展示了这一区别。
1、调用静态方法示例。
//-----------hasStaticMethod.java-----------------
public class hasStaticMethod{
//定义一个静态方法
public static void callMe(){
System.out.println("This is a static method.");
}
}
下面这个程序使用两种形式来调用静态方法。
//-----------invokeStaticMethod.java-----------------
public class invokeStaticMethod{
public static void main(String args[]){
hasStaticMethod.callMe(); //不创建对象,直接调用静态方法
hasStaticMethod oa = new hasStaticMethod(); //创建一个对象
oa.callMe(); //利用对象来调用静态方法
}
} 程序两次调用静态方法,都是允许的,程序的输出如下:
This is a static method.This is a static method.
允许不创建对象而调用静态方法,是Java为了减少程序员调用某些常用方法时的麻烦,而允许程序员按照传统的C语言中使用函数的方式来使用方法。典型的例子是前面某些程序中使用"Math.ramdon()"来获取随机数。
还有一个很典型的代表就是数组的处理工具Arrays
2、静态方法访问成员变量示例。
//-----------accessMember.java-----------------
class accessMember{
private static int sa; //定义一个静态成员变量
private int ia; //定义一个实例成员变量
//下面定义一个静态方法
static void statMethod(){
int i = 0; //正确,可以有自己的局部变量sa = 10;
//正确,静态方法可以使用静态变量
otherStat();
//正确,可以调用静态方法
ia = 20; //错误,不能使用实例变量
insMethod(); //错误,不能调用实例方法
}
static void otherStat(){}
//下面定义一个实例方法
void insMethod(){
int i = 0; //正确,可以有自己的局部变量
sa = 15; //正确,可以使用静态变量
ia = 30; //正确,可以使用实例变量
statMethod(); //正确,可以调用静态方法
}
}
本例其实可以概括成一句话:静态方法只能访问静态成员,实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量,是因为实例成员变量是属于某个对象的,而静态方法在执行时,并不一定存在对象。同样,因为实例方法可以访问实例成员变量,如果允许静态方法调用实例方法,将间接地允许它使用实例成员变量,所以它也不能调用实例方法。基于同样的道理,静态方法中也不能使用关键字this。
main()方法是一个典型的静态方法,它同样遵循一般静态方法的规则,所以它可以由系统在创建对象之前就调用。
希望多多交流,多多关注,共同成就梦想
类实例方法,静态方法的使用与区别
静态方法是用来操作这个类型的,方法被该类的所有实例共享。
而实例方法用来操作单个实例,不被该类所有实例共享。
静态方法中不能调用实例方法,也不能访问实例变量。
实例方法可以调用静态方法,也能访问静态变量。
总之静态方法对应的是类型,即Class,类。但是实例方法对应的是实例,即object,对象。
javascript中什么时候用静态方法什么时候用实例方法,规则是什么,各好在哪儿?
script type="text/javascript"
/*一、静态方法和属性( 类、方法、属性都为静态类型; 不能创建实例访问)*/
var staticFunc = function(){};
staticFunc.today = new Date(); //添加静态属性
staticFunc.weather = "sunny";
staticFunc.show = function(){ //添加静态方法
alert(this.today + " weather is " + this.weather);
};
staticFunc.show(); //静态方法和属性直接访问,不能通过实例访问
alert(staticFunc.today + " is " + staticFunc.weather);
//new staticFunc().show(); //这里对staticFunc实例化会导致错误,如下图
//alert(new staticFunc().today); //这里也会发生同样的错误
/*二、普通对象,同时拥有静态和非静态属性、方法
(可以用实例化 * 注意:1.静态方法/属性使用类名访问 2.非静态方法/属性使用实例名访问 )*/
function Person(name){
this.name = name; //非静态属性
this.showName = function(){ //添加非静态方法(添加到“类”的实例上)
alert("my name is " + this.name + ".");
}
Person.run = function(){ //添加静态方法(直接添加到“类”上)
alert("I am runing... ...");
}
}
/*通过prototype关键字添加非静态属。每个人的爱好可能不一样
【1.具有相同的行为就用静态方法或属性,如人类都有一张嘴;2. 具体到每个“类”的每个实体,如每个人的兴趣爱好可能不一样,就用实例方法或属性】*/
Person.prototype.hobby = "movie,music,programming,reading.";
//添加静态属性
Person.hand = 2;
var me = new Person("zhangsan");
//非静态方法或属性必须通过实例来访问
me.showName();
alert("my hobby has " + me.hobby);
//静态方法必须通过“类”来访问
Person.run();
alert("I have " + Person.hand + " hands.");
/script
类方法、实例方法和静态方法的区别
类方法:
1.类方法只能访问‘类变量’的方法
2.类方法需要使用@classmethod装饰器定义
3.类方法的第一个参数是类实例,约定写为cls
说明:
类(实例)和对象(实例)都可以调用类方法,类方法不能调用实例变量
静态方法:@staticmethod
1.静态方法是普通函数,静态方法定义在类的内部,只能凭借该类或实例调用。
2.静态方法需要使用@staticmethod装饰器定义
3.静态方法写普通函数定义相同,不需要传入self和cls参数
说明:
类和实例都可以调用静态方法
静态方法不能访问类变量和实例变量
js代码如何封装
1. 定义js类
js并不是一种面向对向的语言, 没有提供对类的支持, 因此我们不能像在传统的语言里那样 用class来定义类, 但我们可以利用js的闭包封装机制来实现js类, 我们来封装一个简的Shape类.
代码如下:
function ShapeBase() {
this.show = function(){
alert("ShapeBase show");
};
this.init = function(){
alert("ShapeBase init");
};
}
这个类里定义了两个方法:show和init, 需要注意的是这里用到了this来声明, 而不是var, 因为用var是用来定义私有方法的.
另外, 我们还可以用prototype属性来定义Shape的方法.
代码如下:
ShapeBase.prototype.show=function()
{
alert("ShapeBase show");
}
ShapeBase.prototype.init=function()
{
alert("ShapeBase init");
}
上面这种写法看起来不太直观,我们可以将所有的方法写在一起.
代码如下:
ShapeBase.prototype={
show:function(){
alert("ShapeBase show");
},
init:function() {
alert("ShapeBase init");
}
};
现在, 类是写好了, 让我们写个js来测试下, 看看结果是不是跟我们想象的一样呢?
代码如下:
function test(src){
var s=new ShapeBase();
s.init();
s.show();
}
看到了吧, 其调用方式和C#一模一样, 而结果也如我们所料.
到目前为止, 我们学会了如何创建js的类了, 但还只是实例方法,要是实现跟C#中的静态方法要怎么做呢?
其实, 实现js的静态方法很简单, 看下面如何实现:
代码如下:
//静态方法
ShapeBase.StaticDraw = function()
{
alert("method draw is static");
}
2. 实现JS类抽象和继承
同样, js中也不支持类继承机制,但我们可以通过将父类prototype中的成员方法复制到子类的prototype中来实现.
和类的继承一样,JavaScript也没有任何机制用于支持抽象类.但利用JavaScript语言本身的性质.可以实现自己的抽象类.
首先来看看js中的虚方法, 在传统语言中虚方法是要先定义的, 而包含虚方法的类就是抽象类,不能被实例化,而在JavaScript中,虚方法就可以看作该类中没有定义的方法,但已经通过this指针使用了.
和传统面向对象不同的是,这里虚方法不需经过声明,而直接使用了, 并且类也可以被实例化.
先定义object的extend方法, 一个为静态方法,一个为实例方法, 这两个方法用于实现继承的prototype复制
代码如下:
Object.extend = function(destination, source) {
for (property in source) {
destination[property] = source[property];
}
return destination;
}
Object.prototype.extend = function(object) {
return Object.extend.apply(this, [this, object]);
}
接下来我们实现一个继承类Rect, 这里先用一种简单的方法来实现。
代码如下:
function Rect() { }
Rect.prototype = ShapeBase.prototype; //只这一句就行了
//扩充新的方法
Rect.prototype.add=function() {
alert("Rect add");
}
这种方法不能用于重写,如果改变了show方法, ShapeBase的show也会指向同一函数可能是由于prototype赋值只是简单的改变指向地址.
如果上面也定义了:
Rect.prototype.show=function() {
alert("Rect show");
}
那么执行结果如下:
function test(){
var s=new ShapeBase();
s.show(); //结果:Rect show
var r=new Rect();
r.show(); //结果:Rect show
r.add();
}
我们再使用object.extend实现继承, 并实现一个oninit虚方法, 修改ShapeBase如下:
代码如下:
ShapeBase.prototype={
show:function()
{
alert("ShapeBase show");
},
initialize:function () {
this.oninit();
}
};
实现Rect类继承.
代码如下:
Rect.prototype=(new ShapeBase).extend({
//添加新的方法
add:function() {
alert("Rect add");
},
//使用这种方法可以重写show方法
show:function() {
alert("Rect show");
},
//实现虚方法
oninit:function() {
alert("Rect oninit");
}
})
js公有,私有,静态属性和方法的区别
html
head
titleJavaScript 对象方法 类方法 原型方法的区别;私有属性 公有属性 公有静态属性的区别/title
script language="javascript" type="text/javascript"
//定义Person类
function Person(name){
//私有属性MyTime、ID
var MyTime = " 2010-12-12";
var ID="773C0D35-298A-4660-B803-9EADC250ED61";
//公有属性MyName
this.MyName = name;
//对象方法(实例化后才能调用) 位置:Person类的内部 语法格式:this.方法名称 = function([参数...]){ 语句行; }
this.ShowMyName = function() {
alert("My name is " + this.MyName + MyTime );
}
//this.Init();
}
//类方法(实际是静态方法直接调用) 位置:Person类的外部 语法格式:类名称.方法名称 = function([参数...]){ 语句行; }
Person.EnglishandFrench = function() {
//访问静态属性 语法格式:类名称.公有静态属性;或者使用语法格式:this.公有静态属性;
alert(Person.NAME + " can speak " + this.ENGLISH +" and "+ Person.prototype.FRENCH);
}
//原型方法(实例化后调用或者直接调用) 位置:Person类的外部 语法格式:类名称.prototype.方法名称 = function([参数...]){ 语句行; }
Person.prototype.ChineseandFrech = function() {
//编写一个原型方法相当扩充了一个对象方法,稍作变化可复制到类的内部成为一个对象方法;
//访问公有属性 语法格式:this.公有属性;
//访问公有静态属性 语法格式:类名称.公有静态属性;
alert(this.MyName + " can speak " + Person.CHINESE + " and " + this.FRENCH+", "+ Person.prototype.FRENCH +" do better.");
}
//只有原型方法执行后内部扩充到Person类的属性才能生效
Person.prototype.Init = function() {
//定义公有属性PersonNo
this.PersonNo = "";
//定义公有数组属性 [] 等价于 new Array();它现在是几维数组或是混合数组要根据赋值后才知道
this.ArrInfo = [];
//定义一个json对象属性
this.jsonData = {};
}
//公有静态属性 位置:Person类的外部
Person.NAME="Jack";
Person.ENGLISH="in english";
Person.CHINESE="in chinese";
//原型属性(当作公有静态属性使用 语法格式:类名称.prototype.公有静态属性;不能使用语法格式:this.公有静态属性;)
//原型属性(当作公有属性使用 语法格式:类名称.prototype.公有属性; 或者使用语法格式:this.公有属性;)
Person.prototype.FRENCH="in french";
var p = new Person("Rose");//实例化
p.ShowMyName();
Person.EnglishandFrench();
p.ChineseandFrech();
//ChineseandFrech()当作静态方法直接调用,请注意 MyName是对象属性 原型方法内不能调用它
//当作静态方法直接调用时内部成员必须都是静态属性,下面这样调用是错误的;
Person.prototype.ChineseandFrech();
//使用this.Init();这行代码放在定义Person类内部也一样初始化
p.Init();
p.PersonNo = "A1B2C3";
alert(p.PersonNo);
p.ArrInfo[0]='123';
alert(p.ArrInfo[0]);
p.ArrInfo[1]=["111","222","333"];
alert(p.ArrInfo[1][2]);
p.jsonData = { flash_url : "../swfupload/swfupload.swf",
custom_settings : {
upload_target : "divFileProgressContainer"
},
debug: false };
alert(p.jsonData.flash_url+" "+p.jsonData.custom_settings.upload_target);
/script
/head
body
divE-mail:zhengzizhi@yahoo.com.cn/div
div尽量将方法定义为原型方法,原型方法避免了每次调用构造函数时对属性或方法的构造,节省空间,创建对象快./div
/body
/html