精华内容
下载资源
问答
  • 成员方法

    千次阅读 2008-04-27 19:32:00
    4.4成员方法成员方法描述对象所具有的功能或操作,反映对象的行为,是具有某种相对独立功能的程序模块。它与过去所说的子程序、函数等概念相当。一个类或对象可以有多个成员方法,对象通过执行它的成员方法对传来的...
    4.4
    




    成员方法描述对象所具有的功能或操作,反映对象的行为,
    是具有某种相对独立功能的程序模块。它与过去所说的子程序、
    函数等概念相当。一个类或对象可以有多个成员方法,对象通过
    执行它的成员方法对传来的消息作出响应,完成特定的功能。成
    员方法一旦定义,便可在不同的程序段中多次调用,故可增强程
    序结构的清晰度,提高编程效率。例如,下面的成员方法可完成
    两个整数的求和运算,一旦完成了它的编写和调试,便可在程序
    中随时调用该方法,传递不同的参数来完成任意两个整数的求和
    运算。
    第4章 类 与 对 象
    int add(int x,int y)
    { int z;
    z=x+y;
    return(z);
    }
    第4章 类 与 对 象
    4.4.1
    成员方法的分类
    为了便于理解,我们先来看看成员方法的分类。我们可以
    从不同的角度出发,对成员方法进行分类。
    从成员方法的来源看,可将成员方法分为:
    (1) 类库成员方法。这是由Java类库提供的,用户只需要按
    照Java提供的调用格式去使用这些成员方法即可。
    (2) 用户自己定义的成员方法。这是为了解决用户的特定
    问题,由用户自己编写的成员方法。程序设计的主要工作就是
    编写用户自定义类、自定义成员方法。
    第4章 类 与 对 象
    从成员方法的形式看,可将成员方法分为:
    (1) 无参成员方法。例如,void printStar( ){ ……}
    (2) 带参成员方法。例如,int add(int x,int y){ …… }
    当然,还可以从成员方法的功能上将其分为数学运算方法、
    字符处理方法、图形方法等。介绍上面分类的主要目的是为了
    帮助我们理解类库成员方法、带参成员方法等几个最常用的名
    词。实际上,类库成员方法可以是无参成员方法,也可以是带
    参成员方法。同样,某个带参成员方法既可能是类库成员方
    法,也可能是用户自已定义的成员方法。
    第4章 类 与 对 象
    4.4.2
    声明成员方法的格式
    在Java程序中,成员方法的声明只能在类中进行,格式如
    下:
    [修饰符] 返回值的类型 成员方法名(形式参数表)throw
    [异常表]
    {
    说明部分
    执行语句部分
    }
    第4章 类 与 对 象
    成员方法的声明包括成员方法头和方法体两部分,其中:
    成员方法头确定成员方法的名字、形式参数的名字和类型、返
    回值的类型、访问限制和异常处理等;方法体由包括在花括号
    内的说明部分和执行语句部分组成,它描述该方法功能的实现。
    第4章 类 与 对 象
    在成员方法头中:
    (1) 修饰符。修饰符可以是公共访问控制符public、私有访
    问控制符private、保护访问控制符protected等访问权限修饰
    符,也可以是静态成员方法修饰符static、最终成员方法修饰符
    final、本地成员方法修饰符native、抽象成员方法修饰符abstract
    等非访问权限修饰符。访问权限修饰符指出满足什么条件时该
    成员方法可以被访问。非访问权限修饰符指明数据成员的使用
    方式。
    第4章 类 与 对 象
    (2) 返回值的类型。返回值的类型用Java允许的各种数据类
    型关键字(例如,int,float等)指明成员方法完成其所定义的功
    能后,运算结果值的数据类型。若成员方法没有返回值,则在
    返回值的类型处应写上void关键字,以表明该方法无返回值。
    (3) 成员方法名。成员方法名也就是用户遵循标识符定义
    规则命名的标识符。
    第4章 类 与 对 象
    (4) 形式参数表。成员方法可分为带参成员方法和无参成
    员方法两种。对于无参成员方法来说则无形式参数表这一项,
    但成员方法名后的一对圆括号不可省略;对于带参成员方法来
    说,形式参数表指明调用该方法所需要的参数个数、参数的名
    字及其参数的数据类型,其格式为:
    (形式参数类型1 形式参数名1,形式参数类型2 形式参数
    名2,……)
    (5) throw [异常表]。它指出当该方法遇到一些方法的设计
    者未曾想到的问题时如何处理。
    第4章 类 与 对 象
    4.4.3
    方法体中的局部变量
    方法体描述该方法所要完成的功能,它由变量声明语句、
    赋值语句、流程控制语句、方法调用语句、返回语句等Java允许
    的各种语句成分组成,是程序设计中最复杂的部分,几乎会用
    到我们已经学习过的和将要学习的绝大多数内容。本着由浅入
    深、循序渐进的原则,这里先提请大家注意:
    (1) 在方法体内可以定义本方法所使用的变量,这种变量是
    局部变量,它的生存期与作用域是在本方法内。也就是说局部
    变量只在本方法内有效或可见,离开本方法则这些变量被自动
    释放。
    第4章 类 与 对 象
    (2) 方法体内定义变量时,变量前不能加修饰符。
    (3) 局部变量在使用前必须明确赋值,否则编译时会出错。
    (4) 在一个方法内部,可以在复合语句中定义变量,这些
    变量只在复合语句中有效,这种复合语句也被称为程序块。下
    面的示例程序C4_11.java中指出了这一问题。
    第4章 类 与 对 象
    【示例程序c4_10.java】 局部变量及其用法。
    public class c4_10
    {
    public static void main(String[ ] args)
    { int a=2,b=3;
    int f=add(a,b); //调用add方法
    System.out.println("f="+f);
    //System.out.println("z="+z);错,z在add方法内,离开add则被清除
    }
    第4章 类 与 对 象
    static int add(int x,int y)
    { //public int zz;错误的语句,在局部变量zz前误加了public修饰符
    int z,d; //本方法中定义的变量z,d
    z=x+y; //若写成 z=x+d;就会出错,因为d还没有赋值就使用
    return z;
    }
    }
    第4章 类 与 对 象
    【示例程序c4_11.java】 复合语句中声明的局部变量。
    public class c4_11
    {
    public static void main(String[ ] args)
    { int a=2,b=3;
    { int z=a+b; //复合语句中声明的变量z
    System.out.println("z="+z);
    }
    // System.out.println("z="+z);错,z只在复合语句中有效
    }
    }
    第4章 类 与 对 象
    4.4.4
    成员方法的返回值
    若方法有返回值,则在方法体中用return语句指明要返回的
    值。其格式为:
    return 表达式;
    或 return(表达式);
    其中表达式可以是常量、变量、对象等,且上述两种形式
    是等价的。此外,return语句后面表达式的数据类型必须与成员
    方法头中给出的“返回值的类型”一致。
    第4章 类 与 对 象
    例如:
    return z;
    return(z);
    return(x>y?x:y);
    if(x>y) return true;
    else return(false);
    都是合法的,且“return z;”与“return(z);”等价。
    第4章 类 与 对 象
    4.4.5
    形式参数与实际参数
    一般来说,可通过如下的格式来引用成员方法:
    成员方法名(实参列表)
    但在引用时应注意下述问题:
    (1) 对于无参成员方法来说,是没有实参列表的,但方法名
    后的括弧不能省略。
    (2) 对于带参数的成员方法来说,实参的个数、顺序以及它
    们的数据类型必须与形式参数的个数、顺序以及它们的数据类
    型保持一致,各个实参间用逗号分隔。实参名与形参名可以相
    同也可以不同。
    第4章 类 与 对 象
    (3) 实参也可以是表达式,此时一定要注意使表达式的数据
    类型与形参的数据类型相同,或者使表达式的类型按Java类型转
    换规则达到形参指明的数据类型。
    (4) 实参变量对形参变量的数据传递是“值传递”,即只能由
    实参传递给形参,而不能由形参传递给实参。程序中执行到引
    用成员方法时,Java把实参值拷贝到一个临时的存储区(栈)中,
    形参的任何修改都在栈中进行,当退出该成员方法时,Java自动
    清除栈中的内容。
    下面我们通过一个程序来说明上述各点。
    第4章 类 与 对 象
    【示例程序c4_12.java】
    public class c4_12
    {
    static void add(double x,double y)
    { double z;
    z=x+y;
    System.out.println("z="+z);
    x=x+3.2;y=y+1.2;
    System.out.println("x="+x+"/ty="+y);
    }
    第4章 类 与 对 象
    static double add1(double y1,double y2)
    { double z;
    z=y1+y2+2.9;
    return z;
    }
    public static void main(String[ ] args)
    { int a=2,b=7;
    double f1=2,f2=4,f3;
    add(a,b);// 按Java的类型转换规则达到形参类型
    System.out.println("a="+a+"/tb="+b);
    第4章 类 与 对 象
    // f3=add1(f1, f2, 3.5);错,实参与形参参数个数不一致
    f3=2+add1(f1,f2);
    System.out.println("f1="+f1+"/tf2="+f2+"/tf3="+f3);
    }
    }
    该程序的运行结果如下:
    z=9.0
    x=5.2 y=8.2
    a=2 b=7
    f1=2.0 f2=4.0 f3=10.9
    第4章 类 与 对 象
    【示例程序c4_13.java】
    public class c4_13
    {
    static void add(double x,double y)
    { double z;
    z=x+y;
    System.out.println("z="+z);
    }
    static double add1(double y1,double y2)
    { double z;
    z=y1+y2+2.9;
    return z;
    }
    第4章 类 与 对 象
    public static void main(String[ ] args)
    { int a=2,b=7;
    double f1=2,f2=4,f;
    add(a,add1(f1,f2));
    }
    }
    运行结果:
    10.9
    第4章 类 与 对 象
    4.4.6
    成员方法的引用方式
    成员方法的引用可有下述几种方式。
    1
    .方法语句
    成员方法作为一个独立的语句被引用。例如, 程序
    c4_12.java中的“add(a,b);”语句就是这种形式。
    2
    .方法表达式
    成员方法作为表达式中的一部分,通过表达式被引用。例
    如,程序c4_12.java中的“f3=2+add1(f1,f2);”语句就是这种形式。
    第4章 类 与 对 象
    3
    .方法作为参数
    一个成员方法作为另一个成员方法的参数被引用。例如,
    程序c4_13.java中的“add(a,add1(f1,f2));”语句就是这种形式的
    代表。更为典型的是,在递归的成员方法中,一个成员方法作
    为它自身的参数被引用。
    第4章 类 与 对 象
    4
    .通过对象来引用
    这里有两重含义,一是通过形如“对象名.方法名”的形式来
    引用对象,二是当一个对象作为成员方法的参数时,通过这个
    对象参数来引用对象的成员方法。例如,程序c4_3.java的
    “Dane.ShowDog(g,25,25);”语句,成员方法ShowDog( )本身通过
    对象Dane来引用;同时,通过作为参数的对象g引用了
    Graphics类的成员方法drawString( )。
    第4章 类 与 对 象
    4.4.7
    引用成员方法时应注意的事项
    首先,当一个方法引用另一个方法时,这个被引用的方法
    必须是已经存在的方法。除了这个要求之外,还要视被引用的
    成员方法存在于何处而做不同的处理。
    (1) 如果被引用的方法存在于本文件中,而且是本类的方
    法,则可直接引用。我们前面列举的例子基本上都是这种情况。
    (2) 如果被引用的方法存在于本文件中,但不是本类的方
    法,则要考虑类的修饰符与方法的修饰符来决定是否能引用。
    第4章 类 与 对 象
    (3) 如果被引用的方法不是本文件的方法而是Java类库的方
    法,则必须在文件的开头处用import 命令将引用有关库方法所
    需要的信息写入本文件中。例如,前几章用来在屏幕指定位置
    上显示一个字符串的drawString( ) 方法是Java类库Graphics类中
    的一个方法,而Graphics类存放在java.awt包中,因此,我们在
    程序文件的开头处写上了“import java.awt.*;”语句,指出awt包
    中的方法在本文件中要引用。
    (4) 如果被引用的方法是用户在其他的文件中自己定义的方
    法,则必须通过加载用户包的方式来引用。这部分内容将在5.5
    节“接口与包”中讲述。
    第4章 类 与 对 象
    4.4.8
    成员方法的递归引用
    我们前面讲述的程序都以严格的层次方式在一个方法中调
    用另一个方法。然而,对于某些实际问题,方法调用自身会使
    程序更为简洁清晰,而且会使程序的执行逻辑与数理逻辑保持
    一致。例如,数学中对于N!的定义是:
    1 (当N=0时)
    N!=
    N*(N-1)! (当N>0时)
    第4章 类 与 对 象
    这个定义是递归的,即在N!=N*(N-1)!中,(N-1)!实际上
    是N!的减1递推。对于这样的问题,我们可以构造循环来求
    解,即用1*2*3*……*(n-1) *n的算式求得结果。但是,由于它
    的定义本身是递归的,用递归算法实现则更符合数理逻辑。例
    如,求4!的过程可表示成图4.9所示的形式。
    第4章 类 与 对 象
    图4.9 求4!的递归过程
    4!
    4*3!
    3*2!
    2*1!
    1*0!
    第4章 类 与 对 象
    成员方法的递归引用就是指在一个方法中直接或间接引用
    自身的情况。例如:
    int f1(int n)
    {
    int p;
    p=f1(n-1)
    return p;
    }


    第4章 类 与 对 象
    在这个例子中,方法f1( )中引用了f1( )本身,这种引用是直
    接引用。
    int f1(int n) int f2(int m)
    { {
    int p; int s;
    p=f2(n-1); s=f1(m+2);
    return p; return s;
    } }




    第4章 类 与 对 象
    【示例程序c4_14.java】 编程计算4!的值。
    public class c4_14
    { static int fac(int n)
    { int fa;
    if(n==0)
    fa=1;
    else
    fa=n*fac(n-1); //递归引用自身
    return fa;
    }
    第4章 类 与 对 象
    public static void main(String[ ] args)
    { int n=4;
    int f1=fac(n); //引用fac( )方法
    System.out.println("4!="+f1);
    }
    }
    该程序的输出结果是:
    4!=24
    第4章 类 与 对 象
    图4.10 计算4!的成员方法fac递归引用关系
    第4章 类 与 对 象
    从图中可以看到求4!时,main方法引用fac(4)方法,fac(4)
    引用fac(3),fac(3) 引用fac(2),fac(2)引用fac(1),fac(1)引用
    fac(0),fac(0)方法得到确定值1,回归得到fac(1)=1,再回归得
    到fac(2)=2,再回归得到fac(3)=6,最后再回归得到fac(4)=24,
    fac( )方法共被引用了5次。
    第4章 类 与 对 象
    【示例程序c4_15.java】 编程求出Fibonacci数列的第8项
    public class c4_15
    {
    public static void main(String[ ] args)
    { int n=8; int f8=fibo(n); System.out.println("f8="+f8); }
    static int fibo(int n)
    { if(n==1)return 1;
    else if(n==2)return 1;
    else return (fibo(n-1)+fibo(n-2));
    }
    }
    程序的执行结果为:
    f8=21
    第4章 类 与 对 象
    4.4.9 static
    修饰的静态方法
    用static修饰符修饰的方法被称为静态方法,它是属于整个
    类的类方法。不用static修饰符限定的方法,是属于某个具体类
    对象的方法。static方法使用特点如下:
    (1) static方法是属于整个类的,它在内存中的代码段将随
    着类的定义而分配和装载。而非static的方法是属于某个对象的
    方法,当这个对象创建时,在对象的内存中拥有这个方法的专
    用代码段。
    (2) 引用静态方法时,可以使用对象名做前缀,也可以使
    用类名做前缀;
    第4章 类 与 对 象
    (3) static方法只能访问static数据成员,不能访问非static数
    据成员,但非static方法可以访问static数据成员。
    (4) static方法只能访问static方法,不能访问非static方法,
    但非static方法可以访问static方法。
    (5) static方法不能被覆盖,也就是说,这个类的子类,不
    能有相同名、相同参数的方法。
    (6) main方法是静态方法。在Java的每个Application程序
    中,都必须有且只能有一个main方法,它是Application程序运
    行的入口点。
    第4章 类 与 对 象
    例如:
    class f
    { int d1;
    static int d2;
    void me( ){ ┅ }
    static void me1( ){ ┅ }
    static void me2( )
    { me1( ); //合法引用
    d1=34; //错,引用了非static数据成员
    me( ); //错,引用了非static方法
    第4章 类 与 对 象
    d2=45; //合法
    }
    }
    class f1 extends f
    {
    void me1( ){┅} //错,不能覆盖类的方法
    }
    第4章 类 与 对 象
    4.4.10
    数学函数类方法
    作为static方法的典型例子,我们来看看Java类库提供的实现
    常用数学函数运算的标准数学函数方法,这些方法都是static方
    法。标准数学函数方法在Java.lang.Math类中,使用方法比较简
    单,格式如下:
    类名.数学函数方法名( 实参表列 )
    Java.lang.Math类提供的数学函数方法见表4.1。
    第4章 类 与 对 象
    表4.1 Java.lang.Math
    类提供的数学函数方法
    函 数 方 法功 能
    public static double sin(double a) 正弦函数
    public static double cos(double a) 余弦函数
    public static double tan.(double a) 正切函数
    public static double asin(double a) 反正弦函数
    public static double acos(double a) 反余弦函数
    public static double atan(double a) 反正切函数
    public static double toRadians(double a) 将度转换为弧度
    public static double toDegrees(double a) 将弧度转换为度
    public static double exp(double a) 指数函数
    public static double log(double a) 自然对数
    public static double sqrt(double a) 平方根
    第4章 类 与 对 象
    表4.1 Java.lang.Math
    类提供的数学函数方法
    public static double IEEEremainder(double f1,double
    f2)
    两个数相除的余数
    public static double ceil(double a)
    获取不小于指定double数的最小双精度
    实数
    public static double floor(double a) 获取不大于指定double数的最小双精度
    实数
    public static double rint(double a) 获取最接近指定double数的整数
    public static double atan2(double a,double b) 获取指定double数相除的反正切值
    public static double pow(double a,double b) a的b次方
    public static int round(float a) 获取最接近指定数的整数
    public static long round(double a) 获取最接近指定数的数
    public static double random(double a) 获取一个大于等于0且小于1的随机数
    public static int abs(int a) 取绝对值
    第4章 类 与 对 象
    表4.1 Java.lang.Math
    类提供的数学函数方法
    public static long abs(long a) 取绝对值
    public static float abs(float a) 取绝对值
    public static double abs(double a) 取绝对值
    public static int max(int a,int b) 获取两个指定数的最大值
    public static long max(long a,long b) 获取两个指定数的最大值
    public static float max(float a,float b) 获取两个指定数的最大值
    public static double max(double a,double b) 获取两个指定数的最大值
    public static int min(int a,int b) 获取两个指定数的最小值
    public static long min(long a,long b) 获取两个指定数的最小值
    public static float min(float a,float b) 获取两个指定数的最小值
    public static double min(double a,double b) 获取两个指定数的最小值
    第4章 类 与 对 象
    【示例程序c4_16.java】
    public class c4_16
    { public static void main(String[ ] args)
    {double a=2,b=3;
    double z1=Math.pow(a,b); //引用Math类的pow方法求a的b次方
    double z2=Math.sqrt(9); //引用Math类的sqrt方法求9的平方根
    System.out.print("z1="+z1);
    System.out.println("/tz2="+z2);
    }
    }
    程序的运行结果为:
    z1=8.0 z2=3.0
    第4章 类 与 对 象
    4.4.11 final
    修饰的最终方法
    在面向对象的程序设计中,子类可以利用重载机制修改从
    父类那里继承来的某些数据成员及成员方法,这给程序设计带
    来方便的同时,也给系统的安全性带来了威胁。为此,Java语
    言提供了final修饰符来保证系统的安全。用final修饰符修饰的
    方法称为最终方法,如果类的某个方法被final修饰符所限定,
    则该类的子类就不能覆盖父类的方法,即不能再重新定义与此
    方法同名的自己的方法,而仅能使用从父类继承来的方法。可
    见,使用final修饰方法,就是为了给方法“上锁”,防止任何继
    承类修改此方法,保证了程序的安全性和正确性。
    第4章 类 与 对 象
    【示例程序c4_17.java】
    class a1
    {
    final int add(int x,int y) //用final修饰符修饰的最终方法
    { return(x+y); }
    int mul(int a,int b)
    { int z=0;
    z=add(1,7)+a*b;
    return z;
    }
    }
    public class c4_17 extends a1 //由类c4_17是类a1的子类
    {
    第4章 类 与 对 象
    /* int add(int x,int y)
    { return(x+y+2); } 子类c4_17企图覆盖父类a1的final方法,这是非法的 */
    public static void main(String[ ] args)
    { int a=2,b=3,z1,z2;
    c4_17 p1=new c4_17( );
    z1=p1.add(a,b); //子类可以引用父类的final方法
    z2=p1.mul(a,b);
    System.out.println("z1="+z1);
    System.out.println("z2="+z2);
    }
    }
    运行结果:
    z1=5 z2=14
    第4章 类 与 对 象
    4.4.12 native
    修饰的本地方法
    修饰符native修饰的方法称为本地方法,此方法使用的目的
    是为了将其他语言(例如C、C++、FORTRAN、汇编等)嵌入
    到Java语言中。这样Java可以充分利用已经存在的其他语言的程
    序功能模块,避免重复编程。
    在Java程序中使用native方法时应该特别注意平台问题。由
    于native方法嵌入其他语言书写的模块是以非Java字节码的二进
    制代码形式嵌入Java程序的,而这种二进制代码通常只能运行
    在编译生成它的平台之上,所以整个Java程序的跨平台性能将
    受到限制或破坏,除非native方法引入的代码也是跨平台的。详
    细内容本书不再介绍,有兴趣者请参阅Java手册
    展开全文
  • 成员方法中调用成员变量语法格式 : …self .变量名 例: 成员方法中调用成员方法格式 : …self . 方法名(实参1 , 实参2, …) 例 : self : 仅出现在成员方法中 , 指代执行该方法的对象 ...

    成员方法中调用成员变量语法格式 :
    …self .变量名
    例:
    在这里插入图片描述

    成员方法中调用成员方法格式 :
    …self . 方法名(实参1 , 实参2, …)
    例 :
    在这里插入图片描述

    self : 仅出现在成员方法中 , 指代执行该方法的对象

    展开全文
  • Java成员变量与成员方法

    千次阅读 2019-05-27 10:28:49
    学而时习之,温故而知新. 成员变量: 在Java中对象的属性成为成员变量, 有时候很多人也喜欢把成员变量等同于全局变量, ...在Java中使用成员方法来对应与类对象的行为,在类中,除了变量外的都是成员方法。 一个案...

    学而时习之,温故而知新.

    成员变量:

    在Java中对象的属性成为成员变量, 有时候很多人也喜欢把成员变量等同于全局变量, 因为成员变量在某一个类中都有效

    (成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。)

    成员方法:

    在Java中使用成员方法来对应与类对象的行为, 在类中,除了变量外的都是成员方法。

    一个案例 来标记成员变量与成员方法 

    package me;
    
    public  class Me {
        private  String name; //成员变量
        
        public String getName() { //成员方法
            return name;
        }
    
        public void setName(String name) {//成员方法
            this.name = name;
        }
    
        
    }

     

    展开全文
  • 定义成员方法

    千次阅读 2018-02-18 17:38:14
    成员方法的生存周期 数据成员的调用方法 要点: 成员方法只能在类中定义,在方法体内定义方法所使用的变量,要注意生存周期与作用域是在本方法内,离开本方法则这些变量自动释放,在方法外调用方法时编译出错...

    研究问题:

    1. 成员方法的生存周期
    2. 数据成员的调用方法

    要点:

    • 成员方法只能在类中定义,在方法体内定义方法所使用的变量,要注意生存周期与作用域是在本方法内,离开本方法则这些变量自动释放,在方法外调用方法时编译出错。
    • 局部变量的定义不受数据成员的影响,他们可以重名;不同作用域内局部变量的定义只能按照由内到外的先后顺序进行定义。
    • 默认情况下,被引用的局部变量是本作用域中的局部变量,而不是其他作用域的局部变量。
    • 作用域内局部变量的引用,只能由内到外引用。外层不能引用内层作用域,而内层却能引用外层作用域。

    截图展示区:


    • 这里写图片描述
    • 在局部作用域内引用成员变量时,如果没有和该成员同名的局部变量,则可以使用1》,2》两种方法,否则只能使用1》。
      1》通过类名调用数据成员
      2》直接调用数据成员
      这里写图片描述
    • 成员方法返回值
      这里写图片描述
    展开全文
  • 1.静态数据成员我们在了解普通成员方法和静态成员方法之前,先了解一下静态变量。在我们函数栈上定义一个普通变量之后,它的生存周期就是随着函数执行完,栈帧的回退释放掉。优点是封装了数据变量。全局变量的生存...
  • java成员方法

    千次阅读 2020-04-13 18:19:45
    //成员方法 //第一种写法,无参数无返回值 例子:speak方法,输出我是一个好人 //第二种写法,无参数有返回值 例子:jisuan方法,计算1-1000的和 ,返回运行结果,结果的数据类型为int //第三种 有参数 有返回值 ...
  • 构造方法和成员方法的区别

    万次阅读 2017-08-02 20:32:25
    作用不同: 构造方法用于创建类的实例并对实例的成员变量进行初始化;成员方法实现对类中成员变量的操作,提供某些功能。调用方式不同: 构造方法通过new运算符调用,成员方法通过对象调用。
  • Java 构造方法与成员方法的区别

    千次阅读 多人点赞 2019-05-27 10:48:30
    认定构造方法是,类名与构造方法相同,这个方法就是构造方法,这个类中除了构造方法以外的方法都是构造方法,原因是在类中,除了变量外的基本都是成员方法。 看一个小案例 package me; public class Me { private ...
  • Python的静态方法和类成员方法 Python的静态方法和类成员方法都可以被类或实例访问,两者概念不容易理清,但还是有区别的: 1)静态方法无需传入self参数,类成员方法需传入代表本类的cls参数; 2...
  • Java构造方法和成员方法

    万次阅读 2017-10-25 20:57:56
    构造方法和成员方法 1:构造方法 1:构造方法作用概述 给对象的数据进行初始化 2:构造方法格式 方法名与类名相同 没有返回值类型,连void都没有 没有具体的返回值 3:构造方法注意事项 如果...
  • Java 成员变量和成员方法

    万次阅读 多人点赞 2018-12-07 10:25:44
    在 Java 语言中对象的属性以成员变量的形式存在,对象的方法以成员方法的形式存在。 成员变量 在 Java 中对象的属性也称为成员变量。为了了解成员变量,首先定义一个图书类,成员变量对应于类对象的属性,在 Book 类...
  • 声明成员方法可以定义类的行为,行为表示一个对象能够做的事情或者能够从一个对象取得的信息。类的各种功能操作都是用方法来实现的,属性只不过提供了相应的数据。一个完整的方法通常包括方法名称、方法主体、方法...
  • 彻底搞懂Python数据成员和成员方法

    千次阅读 多人点赞 2020-03-30 22:49:22
    属于对象的数据成员一般在构造方法__init__()中定义,当然也可以在其他成员方法中定义,在定义和在实例方法中访问数据成员时以self作为前缀,同一个类的不同对象(实例)的数据成员之间互不影响; 属于类的数据成员...
  • this关键字调用成员变量和成员方法

    千次阅读 2018-06-02 20:32:15
    this 关键字可以调用类的成员变量和成员方法
  • java成员方法概念知识

    万次阅读 2015-04-02 20:41:44
    java成员方法基本概念
  • Java中成员变量和成员方法的使用

    千次阅读 2016-10-16 21:56:56
    package g.practise_myself;... 功能:成员变量和成员方法的使用  */ import java.io.*; public class Object  { public static void main(String[] args) { //创建一个人的对象 Person p1=new
  • 类的组成:成员变量,成员方法,构造方法成员方法成员方法 根据返回值: void类型 非void类型 形式参数: 空参方法 非空参方法 代码展示class Student { public String getString() { return "he
  • 成员方法 类方法成员变量:包括实例变量和类变量,用static修饰的是类变量,不用static修饰的是实例变量,所有类的成员变量可以通过this来引用。类变量:静态域,静态字段,或叫静态变量,它属于该类所有实例共有的...
  • package dmeo1; public class student { // 定义一个学生事物,其中就有两个组成部分 ... * 行为(成员方法):吃饭睡觉学习 * 成员变量: * String name; * int age; * 成员方法: * public void...
  • Java —— 类、对象、类方法、成员方法、构造方法

    千次阅读 多人点赞 2019-02-13 18:22:08
    1.类的定义 package 包名; class 类名 extend 父类 implements 接口名{ ... 成员方法; } 2.类的对象 类名 对象名 = new 类名(); // 类的创建 对象名.属性名 // 访问类的成员属性  3. 类的成员方法...
  • <script type="text/javascript"...//成员方法 this.setName=function(_name){ name=_name; } this.logName=function(){ console.log(name); } } //追加成员变量成员方法 Js.proto...
  • Java-----构造方法和成员方法的区别

    万次阅读 多人点赞 2018-11-02 19:54:45
    构造方法和成员方法的区别 1.构造方法  构造方法作用概述  给对象的数据进行初始化  构造方法格式  方法名与类名相同  没有返回值类型,连void都没有  没有具体的返回值  构造方法注意事项  如果你...
  • 一.类的基本定义语法,使用关键字class去定义一个... 成员方法声明 } 一.访问控制符 包含:public ,private ,protected 二.类名要有意义,且首字母大写 三.花括号内为类的主体,类体中一般包括3个部分,成员变量...
  • 修饰成员方法 修饰代码块 synchronized本质是一种独占锁,即某一时刻仅能有一个线程进入临界区,其他线程必须等待,处于block状态。下面以几个例子分别看下不同场景下的synchronized 修饰static方法 public class ...
  • PHP 成员方法和类的调用

    万次阅读 2015-06-27 14:59:30
    1、PHP成员方法详解: ...当我们把一个函数写到 某个类中,则该函数称为成员方法; 成员方法的基本语法: 访问修饰符号 function 函数名(参数列表)\ { 函数体 return 语句; } */ class Person {
  • 本文实例讲述了Python面向对象程序设计类变量与成员变量、类方法与成员方法用法。分享给大家供大家参考,具体如下: 文章目录类变量与成员变量1、若类变量与成员同时存在并且同名2、若类变量存在,成员变量不存在,3...
  • 被static修饰的成员变量和成员方法独立于该类的任何对象。 被类所有的实例所共享。 当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例对象共用同一个static变量。这也就是说不管创建多少对象,...
  • 成员方法 之前我们说了php类的定义与实例化方法,举了个例子,创建了一个人的类。 但是人不单单有属性,还有行为方式,比如人可以跑步,可以跳舞,可以唱歌,可以吃饭等等。那么,我们改如何去实现这些行为呢?接...
  • java中static修饰成员方法

    千次阅读 2016-11-03 09:25:06
    static修饰方法(静态的成员方法): 访问方式: 方式一:可以使用对象进行访问。 对象.静态的函数名(); 方式二:可以使用类名进行访问。 类名.静态函数名字。 推荐使用是类名直接访问静态的成员。 静态函数要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,433,139
精华内容 573,255
关键字:

成员方法