精华内容
下载资源
问答
  • 变量为我们提供了程序...实例变量-实例变量在类中声明,但在方法外部。为堆中对象分配空间时,将为每个实例变量值创建一个插槽。实例变量包含必须由整个类中必须存在多个方法,构造函数或块或对象状态必不可少...

    变量为我们提供了程序可以操纵的命名存储。Java提供了三种类型的变量。类变量-类变量也称为静态变量,是在类中但使用方法,构造函数或块之外使用static关键字声明的。每个类每个类变量只有一个副本,而不管从中创建了多少个对象。

    实例变量-实例变量在类中声明,但在方法外部。为堆中的对象分配空间时,将为每个实例变量值创建一个插槽。实例变量包含必须由整个类中必须存在的多个方法,构造函数或块或对象状态必不可少的部分引用的值。

    局部变量-局部变量在方法,构造函数或块中声明。输入方法,构造函数或块时将创建局部变量,并且一旦退出方法,构造函数或块,该变量将被销毁。

    示例

    public class VariableExample{

    int myVariable;

    static int data = 30;

    public static void main(String args[]){

    int a = 100;

    VariableExample obj = new VariableExample();

    System.out.println("Value of instance variable myVariable: "+obj.myVariable);

    System.out.println("Value of static variable data: "+VariableExample.data);

    System.out.println("Value of local variable a: "+a);

    }

    }

    输出结果Value of instance variable myVariable: 0

    Value of static variable data: 30

    Value of local variable a: 100

    展开全文
  • 成员变量:成员变量是定义在类中,方法体之外的变量。 特点:创建对象的时候实例化、成员变量可以被类中方法、构造函数、和特定类的语句块访问 例:下面代码块的s3 类变量:类变量也声明在类中,方法体之外,但...
    1. 局部变量:在方法、构造函数或者语句块中定义的变量被称为局部变量。
      特点:变量的声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
      例:下面代码块的s2

    2. 成员变量:成员变量是定义在类中,方法体之外的变量。
      特点:创建对象的时候实例化、成员变量可以被类中方法、构造函数、和特定类的语句块访问
      例:下面代码块的s3

    3. 类变量:类变量声明在类中,方法体之外,但必须声明为static类型
      例:下面代码块的s1

    public class Demo3 {
        //类变量
       static int s1 = 0;
        //成员变量
        int s2 = 1;
        public static void main(String[] args) {
            //局部变量
            int s3 = 2;
        }
    }
    
    展开全文
  • Java中类成员变量定义了类属性。例如,一个学生类中一般需要有姓名、性别和年龄等属性,这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下: [public|protected|private][static][final]<...

    在 Java 中类的成员变量定义了类的属性。例如,一个学生类中一般需要有姓名、性别和年龄等属性,这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下:

    [public|protected|private][static][final]<type><variable_name>

    各参数的含义如下。

    • public、protected、private:用于表示成员变量的访问权限。
    • static:表示该成员变量为类变量,也称为静态变量。
    • final:表示将该成员变量声明为常量,其值无法更改。
    • type:表示变量的类型。
    • variable_name:表示变量名称。


    可以在声明成员变量的同时对其进行初始化,如果声明成员变量时没有对其初始化,则系统会使用默认值初始化成员变量。

    初始化的默认值如下:

    • 整数型(byte、short、int 和 long)的基本类型变量的默认值为 0。
    • 单精度浮点型(float)的基本类型变量的默认值为 0.0f。
    • 双精度浮点型(double)的基本类型变量的默认值为 0.0d。
    • 字符型(char)的基本类型变量的默认值为 “\u0000”。
    • 布尔型的基本类型变量的默认值为 false。
    • 数组引用类型的变量的默认值为 null。如果创建了数组变量的实例,但没有显式地为每个元素赋值,则数组中的元素初始化值采用数组数据类型对应的默认值。


    定义类的成员变量的示例如下:

    
     
    1. public class Student {
    2. public String name; // 姓名
    3. final int sex = 0; // 性别:0表示女孩,1表示男孩
    4. private int age; // 年龄
    5. }

    上述示例的 Student 类中定义了 3 个成员变量:String 类型的 name、int 类型的 sex 和 int 类型的 age。其中,name 的访问修饰符为 public,初始化值为 null;sex 的访问修饰符为 friendly(默认),初始化值为 0,表示性别为女,且其值无法更改;age 的访问修饰符为 private,初始化值为 0。

    例 1

    下面以一个简单的例子来介绍成员变量的初始值,代码如下所示。

    
     
    1. public class Counter {
    2. static int sum;
    3. public static void main(String[] args) {
    4. System.out.println(sum);
    5. }
    6. }

    在这里用静态的方法来修饰变量 sum,输出结果是 int 类型的初始值,即:0。

    展开全文
  • C++中类中的静态变量成员与静态成员函数 声明为static类成员(成员数据或成员函数)称为静态成员特性 : 静态成员为所有类对象所共享,不属于某个具体事例 静态成员即可用类名::静态成员或者对象....

    C++中类中的静态变量成员与静态成员函数

    声明为static的类成员(成员数据或成员函数)称为类的静态成员特性 :

    • 静态成员为所有的类对象所共享,不属于某个具体的事例
    • 静态成员即可用类名::静态成员或者对象.静态成员所访问
    • 静态成员变量必须在类外所定义,定义时不能添加static关键字
    • 静态成员函数没有默认的this指针,因为它里面不能使用任何非静态成员
    • 静态成员和普通的类成员一样,也有public protected private 三种访问级别,也可以具有返回值,const修饰符等参数

    静态变量成员

    静态变量成员的初始化

    对于静态变量成员的初始化,不能在构造函数的初始化列表中直接进行初始化

    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            ,day(d) //直接在初始化列表中对静态变量成员day进行初始化
        {}
    
        friend ostream& operator<<(const Date&, ostream&);//
    
    private :
        int year;
        int month;
        static int day;
    };
    
    //错误    C2438   “day”: 无法通过构造函数初始化静态类数据 7.28    d:\code\7.28\7.28\main.cpp  227 
    

    直接在构造函数的初始化列表中进行操作会发生编译错误
    要对static修饰的成员变量进行操作必须在类外先对其进行初始化,初始化的格式为 :(静态变量成员数据类型)(类名):: (变量名) = (要初始数据值)

    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            //,day(d)
        {}
    
        friend ostream& operator<<(const Date&, ostream&);//
    
    private :
        int year;
        int month;
        static int day;
    };
    
    int Date::day = 14; //初始化

    在类外初始化完成之后可以用成员函数或者友元函数对其进行访问与操作

    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            //,day(d)
        {
            day = d;
        }
    
        friend ostream& operator<<(const Date&, ostream&);//
    
    private :
        int year;
        int month;
        static int day;
    };
    
    int Date::day = 14;
    
    ostream& operator<<(const Date& d, ostream& os)
    {
        os << d.year << " " << d.month << " " << d.day;
        return os;
    }

    静态成员函数

    静态成员函数是指以static关键字修饰的类中的成员函数

    • 不可以调用类的非静态成员。
    • 静态成员函数不含this指针。 静态成员函数属于这个类,不再仅仅属于具体的对象。

    因此类的静态成员函数和类的普通成员函数的区别是:

    • 静态成员函数不包含指向具体对象的this指针;
    • 普通成员函数包含一个指向具体对象的this指针。

    接下来讨论静态成员函数,静态变量成员调用与被调用的关系

    例1(静态成员函数调用静态成员变量)

    #include <iostream>
    using namespace std;
    
    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            //,day(d)
        {
            day = 16;
        }
    
        static void Print()
        {
            cout << "this is the static function ..." << "day :" << day << endl;
        }
    
        friend ostream& operator<<(const Date&, ostream&);//
    
    private :
        int year;
        int month;
        static int day;
    };
    
    int Date::day = 14;
    
    ostream& operator<<(const Date& d, ostream& os)
    {
        os << d.year << " " << d.month << " " << d.day;
        return os;
    }
    
    int main()
    {
        Date d1;
        d1.Print();
        //d1<<cout;
        return 0;
    }

    运行结果
    这里写图片描述
    结论 : 静态成员函数可以调用静态成员变量

    例2(静态成员变量调用非静态成员变量)

    #include <iostream>
    using namespace std;
    
    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            //,day(d)
        {
            day = 16;
        }
    
        static void Print()
        {
            cout << "this is the static function ..." << "day :" << day <<"unstatic : "<<year<< endl;
        }
    
        friend ostream& operator<<(const Date&, ostream&);//
    
    private :
        int year;
        int month;
        static int day;
    };
    
    int Date::day = 14;
    
    ostream& operator<<(const Date& d, ostream& os)
    {
        os << d.year << " " << d.month << " " << d.day;
        return os;
    }
    
    int main()
    {
        Date d1;
        d1.Print();
        //d1<<cout;
        return 0;
    }

    编译结果 :
    错误 C2597 对非静态成员“Date::year”的非法引用 7.28d:\code\7.28\7.28\main.cpp 233

    结论 : 静态成员函数无法调用非静态成员变量

    例3(非静态成员函数调用静态成员变量)

    #include <iostream>
    using namespace std;
    
    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            //,day(d)
        {
            day = 16;
        }
    
        static void Print()
        {
            cout << "this is the static function ..." << "day :" << day << endl;
        }
    
        friend ostream& operator<<(const Date&, ostream&);//
        void Add()
        {
            year++;
            month++;
            day++;
        }
    
    private :
        int year;
        int month;
        static int day;
    };
    
    int Date::day = 14;
    
    ostream& operator<<(const Date& d, ostream& os)
    {
        os << d.year << " " << d.month << " " << d.day;
        return os;
    }
    
    int main()
    {
        Date d1;
        d1<<cout;
        d1.Add();
        d1 << cout;
        return 0;
    }

    运行结果 :
    这里写图片描述
    结论 : 非静态成员可以访问与操作静态成员变量

    例4(探测静态成员函数是否含有this指针)

    #include <iostream>
    using namespace std;
    
    class Date
    {
    public :
        Date(int y = 1998, int m = 2, int d = 15)
            :year(y)
            ,month(m)
            //,day(d)
        {
            day = 16;
        }
    
        static void Print()
        {
            //cout << "this is the static function ..." << "day :" << day << endl;
            cout << "this " << this << endl;
        }
    
        friend ostream& operator<<(ostream&, const Date&);//
        void Add()
        {
            year++;
            month++;
            day++;
        }
    
    private :
        int year;
        int month;
        static int day;
    };
    
    int Date::day = 14;
    
    ostream& operator<<(ostream& os,const Date& d)
    {
        os << d.year << " " << d.month << " " << d.day;
        return os;
    }
    
    int main()
    {
        Date d1;
        d1.Print();
        //cout << d1 << endl;
        //d1.Add();
        //cout << d1 << endl;
        return 0;
    }

    编译结果 :
    错误 C2355 “this”: 只能在非静态成员函数或非静态数据成员初始值设定项的内部引用 7.28 d:\code\7.28\7.28\main.cpp 234

    结论 : 静态成员函数是没有this指针存在的,所以无法对非静态成员变量进行操作

    展开全文
  • Java 中类成员变量定义了类属性。例如,一个学生类中一般需要有姓名、性别和年龄等属性,这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下: [public|protected|private][static][final]<...
  • Java中类成员变量定义了类属性。例如,一个学生类中一般需要有姓名、性别和年龄等属性,这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下:[public|protected|private][static][final]各参数...
  • 同一文件中声明多个-最多将其中一个public 声明static嵌套或内部 声明匿名(内部) 但这并不仅限于此: JLS充满了惊喜。 我最近了解到,可以任何块(包括方法)中声明类。 这称为本地声明(第...
  • 定义类其实就是定义类中的成员。成员:成员变量<-->属性,成员函数<-->行为。  局部变量在方法内部声明,并且只能方法内部使用,外层方法被调用时被分配内存,请求方法执行完毕后...
  • 这种变量称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。 当一个对象被实例化之后,每个实例变量的值就跟着确定; 实例变量在对象创建的时候创建,在对象被销毁的时候销毁; 实例变量的值应该...
  • 转自:西瓜汁拌面 ...实例方法:在类中声明的方法,例如:my(self),必须实例化之后才可以使用,否则会报错。 类变量:公共的变量,每个实例都可以用。 类方法 1、不用实例化就可以直接调用。 ...
  • 每个类中的变量根据它们声明的位置以及限定符的不同可划分为: 1.类变量:必须在类中声明,并且用static关键字修饰,也称为静态变量。类变量在类加载时就完成初始化工作,类变量在一个运行系统中只有一份供整个...
  • //类变量(静态变量)//类变量称为静态变量在类中以 static 关键字声明,但必须在方法之外。//无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。//静态变量除了被声明为常量外很少使用,静态变量是指声明为...
  • Android studio 中报错如下 一,首先了解一下什么是内部类  java中,将一个类定义另一个类里面或者是方法里面,这样类被称为是内部类内部类。... 局部内部类和匿名内部类中只能访问局部fi...
  • 类的成员变量在PHP本质上是一个变量,只是这些变量都归属于某个,并且给这些变量是有访问控制类的成员变量称为成员属性,它是现实世界实体属性抽象,是可以用来描述对象状态数据。 类的成员方...
  • Java实例变量类变量(静态变量)定义: ...3、在声明成员变量时,用关键字 static 给予修饰的称为 类变量 ,否则称为 实例变量 ; 如下代码演示: test 属于 类变量 ; testone 属于 实例变量 ; public ...
  • 变量的分类

    2018-12-17 16:14:11
    java 从整体上可将变量划分为局部变量,成员变量(也称为实例变量) 和静态变量      1. 局部变量  方法或语句块内部定义的变量 生命周期是从声明位置开始到方法或语句块执行完毕为止。局部变量使用前...
  • 在声明成员变量时,用关键字static给予修饰称作类变量,否则成为实例变量类变量称为static变量、静态变量),例如: class Person { int x; //实例变量 static int y; //类变量 } 上述Person...
  • 局部变量与全局变量

    2019-07-27 16:09:20
    直接在类中声明的变量称为全局变量或成员变量 public class Text{ static int a; static double b; static char c; static boolen d; static String z; public void static main(String[...
  • 类变量(静态变量

    2018-03-22 22:16:13
    变量(静态变量)类变量称为静态变量在类中以static关键字声明,但必须在方法构造方法和语句块之外。无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。静态变量除了被声明为常量外很少使用。常量是指...
  • 1.从语法区别上说:变量声明时前面加了static关键字的变量为静态变量又称为类变量,反之变量声明时没加static修饰的变量为实例变量。 2.变量的隶属:静态变量是该的所有对象所共享的,即该变量属于该,而不属于...
  • 变量的存储类型是指存储变量值的内存类型。...凡是任何代码块之外声明的变量总是存储于静态内存,也就是不属于堆栈的内存,这类变量称为静态变量。对于这变量,你无法为他们指定其他存储类型。静态变
  • java变量的分类

    2019-11-08 11:32:02
    局部变量是方法或语句块内部定义的变量,其生命周期是从声明位置开始到方法或语句块执行完毕为止。局部变量使用前必须先声明并初始化(赋值),否则会出错。 局部变量的初始化有两种方式,一种是先定义再初始化,...
  • java中的变量

    2018-07-27 14:38:00
    局部变量:在方法、构造方法或语句块中定义的变量...成员变量:在类里面,方法体之外的变量称为成员变量。成员变量在创建对象的时候就会被实例化。成员变量可以被类中的方法、构造方法和特定类的语句块访问。 ...
  • 变量称为静态变量在类中以 static 关键字声明,但必须在方法之外。 无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。 静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和...
  • java 类的成员变量

    2014-03-08 15:42:45
     类的静态变量在内存只有一个,JVM加载类的过程对静态变量类变量)分配内存。其位于方法区,被类的所有实例所共享。静态变量可以直接通过类名被访问。例如 Math.PI。类变量的声明周期取决于类的
  • 类中的成员变量 - 这些被称为字段 方法或代码块中的变量 - 这些被称为局部变量 方法声明的变量 - 这些被称为参数 Bicycle类使用以下代码行来定义其字段:public int cadence; public int gear; public int speed;...
  • 1.函数和定义之外声明的变量。作用域为定义的模块,从定义位置开始直到模块结束。 2.全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。 3.全局变量一般做常量使用。 4.函数内要改变全局变量的值...
  • 变量称为静态变量在类中以static关键字声明,但必须在方法、构造方法和语句块之外。 -无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。 -静态变量除了被声明为常量外很少使用。常量是指声明为public...
  • Java类变量(静态变量

    千次阅读 2019-02-28 11:33:23
    -类变量称为静态变量在类中以static关键字声明,但必须在方法、构造方法和语句块之外。 -无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。 -静态变量除了被声明为常量外很少使用。常量是指声明为public/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,569
精华内容 627
关键字:

在类中声明的变量称为