精华内容
下载资源
问答
  • java类常量和一般常量之间到底有什么区别尼
    2021-03-13 00:58:43

    匿名用户

    1级

    2014-10-24 回答

    变量分类

    1. 类变量

    l 在类定义中使用关键字static修饰的字段

    l 在接口声明中使用或者不使用static修饰的字段

    说明:当准备好类或接口时就会创建一个类变量并将其初始化为一个默认值。当卸载类或接口时,就会有效的使类变量停止存在

    2. 实例变量

    在类声明中不使用关键字static声明的字段

    3. 数组元素(未命名的变量)

    无论何时创建一个作为数组的新对象,都会创建这些变量并将其初始化为默认值。当数组不在被引用时,就会有效地使数组元素停止存在。

    4. 方法参数变量

    对于方法声明中声明的每个参数,当调用该方法时,都会创建一个新的参数变量。新变量会用来方法调用的相应的参数值进行初始化。当方法体执行完成时,就会有效地是方法参数停止存在。

    5. 构造函数参数变量

    对于构造函数中声明的每个参数,每当类实例创建表达式或显示构造函数调用调用该构造函数时,就会创建一个新的参数变量。新变量会用来自创建表达式或构造函数调用的相应的参数值进行初始化。当构造函数体执行完成时,就会有效地使构造函数参数停止存在。、

    6. 异常处理程序参数变量

    每当catch语句或者try语句捕获一个异常时,就会创建一个异常处理程序参数。新变量会用与异常关联的实际对象进行初始化。当与catch子句关联的代码块执行完成时,就会有效地使异常处理程序参数停止存在。

    7. 局部变量

    通过局部变量声明语句声明的变量。局部变量使用前一定要赋值。局部变量不会自动初始化为默认值

    8. Final变量

    Final修饰的变量,只能被赋值一次,除非在赋值之前明确地取消对fianl变量进行赋值,否则,对final变量赋值,将会引发编译时错误。

    变量的初始值

    在使用变量值之前,程序中每个变量都必须有一个值:

    1. 每个类变量、实例变量或数组元素都会在创建时使用默认值对其进行初始化,以下是java中数据类型与其默认值的对应关系

    byte、short、int :0

    long :0L

    float :0.0f

    double :0.0d

    char :空字符(即:/u0000)

    boolean :false

    应用类型 :null

    2. 每个方法的参数都会被初始化为方法调用者提供的对应参数值

    3. 每个构造函数参数都会被初始化为类实例创建表达式或显示构造函数调用提供的对应参数值

    4. 异常处理程序参数将被初始化为抛出一个表示异常的duix

    5. 在使用局部变量之前,必须通过初始化或赋值显示地为其赋值,编译器可以使用明确赋值的规则对这种赋值方式ing验证

    文章出自CSDN,http://blog.csdn.net/shibenjie/article/details/4331693

    更多相关内容
  • 六、C++中私有继承、公有继承的区别? 一、静态成员与非静态成员的区别? ①、名称上的区别 成员变量也叫实例变量;静态变量也叫类变量。 ②、内存存储的区别: 成员变量存储到堆内存的对象...

    文章目录:

    一、静态成员与非静态成员的区别?

    二、静态成员函数与非静态成员函数的区别?

    三、C++中引入静态成员函数有什么意义?

    四、什么是常成员函数?

    五、C++中引入常成员函数有什么意义?

    六、C++中私有继承、公有继承的区别?


    一、静态成员与非静态成员的区别?

    ①、名称上的区别

    成员变量也叫实例变量;静态变量也叫类变量。

    ②、内存存储的区别:

    成员变量存储到堆内存的对象中,静态变量存储到方法区的静态区中。

    ③、生命周期不同:

    1)成员变量随着对象的出现而出现,随着对象的消失而消失。

    2)静态变量随着类的出现而出现,随着类的消失而消失。

     

    二、静态成员函数与非静态成员函数的区别?

    静态成员函数没有this指针,而非静态成员函数有一个指向当前对象的指针this。

    三、C++中引入静态成员函数有什么意义?

    静态成员函数主要为了调用方便,为了不用产生对象就可以调用这个函数。很多常用的代码这样做了之后,既符合面向对象(放到类中),又使用方便(不用先产生对象)。

    class X
    {
    public:
    void MethodA();
    static void MethodB();
    }

    此时MethodB可以直接调用,X::MethodB();MethodA必须先生成类对象才能调用,X x; x.MethodA();

    四、什么是常成员函数?

    常成员函数是指由const修饰符修饰的成员函数,在常成员函数中不得修改类中的任何数据成员的值。非常成员函数不能被常成员函数对象调用,因为它们企图修改常量的数据成员。所以const对象只能调用const成员函数。

    五、C++中引入常成员函数有什么意义?

    我们定义的类的成员函数中,常常有一些成员函数不改变类的数据成员,也就是说,这些函数是"只读"函数,而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识,显然,可提高程序的可读性。其实,它还能提高程序的可靠性,已定义成const的成员函数,一旦企图修改数据成员的值,则编译器按错误处理。

    const成员函数表示该成员函数只能读类数据成员,而不能修改类成员数据,起保护作用。

    六、C++中私有继承、公有继承的区别?

    通常我们使用公有继承,以继承父类中所有的成员变量和函数,但是,只有父类中被声明为private以及protected的成员变量和成员函数在子类中是可见的。而不是说子类只继承父类中的公有成员。而那些在父类中的公有成员被继承至子类后,仍然保持公有,除非我们显式地将其声明为私有。

    class D : public class B
    {};

    B中的public成员protected成员在D中分别为public和protected, B中private成员在D中不可见。

    class D : private class B
    {};

    B中的public成员protected成员在D中均为private, B中private成员在D中不可见。

    展开全文
  • C++的公有私有

    2021-10-13 09:39:12
    C语言中struct 默认是公有成员,C++中class 默认是私有成员 private:除了类内部之外都不可以使用 public:对外暴露的,外界会具有读写操作权限 权限选择:必须要对外界提供的,放在public,其余的都放在private ...

    • C语言中struct 默认是公有成员,C++中class 默认是私有成员
    • private:除了类内部之外都不可以使用 
    • public:对外暴露的,外界会具有读写操作权限

    权限选择:必须要对外界提供的,放在public,其余的都放在private

    class Person
    {
    private:
    	int _age;
    	int _sex;
    	char* _name; //这三个成员属性默认为私有,但可以通过函数接口去使用它们
    public:
    	
    	Person()
    	{
    		cout << "Person()" << endl;
    	}
    	Person(int age)
    	{
    		cout << "Person(int age)" << endl;
    		_age = age;
    		_name = NULL;
    	}
    	int Get_age()  //通过函数接口可以读取年龄值
    	{
    		return _age;
    	}
    	void Set_age(int age) //通过函数接口可以改变年龄值
    	{
    		_age = age;
    	}
    	//但是这样的化_age属性与共有存在没有区别,都可以读或者改变_age的值
    	//所以一般在使用时,我们都会设置访问这些属性的身份,如下:
    	void Set_age(int age, int who)
    	{
    		if (who == 1)
    		{
    			_age = age;
    		}
    	}
    	
    	~Person()
    	{
    		cout << "~Person" << endl;
    		delete[]_name;
    	}
    };
    

    初始化与赋值的区别

    • 初始化:在定义的时候给值,内存划分时候给值
    • 赋值:定义之后给值,内存划分完后之后给值

    初始化列表

    • 只有构造函数有初始化列表
    • 必须初始化的成员需要放在初始化列表,eg:const成员和引用成员必须初始化,所以必须放在初始化列表,因为在编译时期将有引用的的地方都换成了引用底层的解引用
    • 在本对象构造之前需要完成的动作,必须放在初始化列表
    • 拷贝函数依然是构造函数,所以它也应该有初始化列表
    int id;
    class Person
    {
    private:
    	int _age;
    	const int _sex;
    	char* _name; 
    	int& ID;
    public:
    	
    	Person():_sex(1), ID(id) //const与引用都必须在初始化列表
    	{
    		cout << "Person()" << endl;
    	}
    	Person(int age) :_sex(1), ID(id)
    	{
    		cout << "Person(int age)" << endl;
    		_name = NULL;
    	}
    	
    	~Person()
    	{
    		cout << "~Person" << endl;
    		delete[]_name;
    	}
    };
    

    const常对象

    • 常对象只能调用常方法,构造函数,析构函数,静态函数不影响
    • 常方法中只能调用常方法,静态函数不影响
    • 普通对象调用常方法是可以的,常对象不能调用普通方法
    • 哪些成员方法需要写成常方法:1.如果成员方法内不需要改动成员,并且没有对外暴露成员引用或者指针,就可以直接写成常方法  2.如果成员方法内部不需要改动成员,但是会对外暴露成员引用或者指针,就写两个成员方法(const方法和非const方法),形成重载   3.如果成员方法内部需要改动成员,就写成普通函数
    class Person
    {
    private:
    	int _age;
    	int _sex;
    	char* _name; 
    public:
    	
    	Person()
    	{
    		cout << "Person()" << endl;
    	}
    	Person(int age)
    	{
    		cout << "Person(int age)" << endl;
    		_age = age;
    		_name = NULL;
    	}
    
    	Person(const char* name, int age, int sex)
    	{
    		_age = age;
    		_sex = sex;
    		_name = new char[strlen(name) + 1];
    		memset(_name, 0, strlen(name) + 1);
    		for (int i = 0; i < strlen(name); i++)
    		{
    			_name[i] = name[i];
    		}
    	}
    	int get_age()//Person* const this
    	{
    		return _age;
    	}
    	void set_age(int age)
    	{
    		_age = age;
    	}
    	~Person()
    	{
    		cout << "~Person" << endl;
    		delete[]_name;
    	}
    };
    
    int main()
    {
    	const Person p1("xiaohua", 18, 0);//p1是一个常量
    	cout << p1.get_age() << endl;//调用出问题
    	cout << p1.set_age() << endl;//调用出问题
    	//为什么会出问题?
    	//因为参数列表不匹配,this指针不匹配
    	//函数的第一个参数为 Person* const this ,this指针是个常量
    	//指向p1的指针是Person const *p = &p1;对象是个常量
    	//将常量的地址给了一个非常量的指针,暴露了常量的地址
    	return 0;
    }
    

    解决方案如下:

    int get_age()//Person* const this --->Person const * const this,
    {            //解决方案是多加一个const,即让this指针指向的内容不可改变
    		     //如何加又是一个问题?
    	return _age;
    }
    
    //加const之后叫常方法
    int get_age()const  //将const加在后边就等价于Person const * const this
    {                   //还有一个引申出的问题是普通的对象可以调用常方法吗?可以,将一个非常量地址给一个常量指针是可以的,相当于安全性增加
    	return _age;
    }
    int get_age()const  //常方法中不能调用普通函数,因为调用普通函数传入的类型为常方法中this的类型
    {           
    	set_age(10);  //this->set_age(10); 常对象是不能调用普通函数的,又会出现上述那种情况,将一个常指针给一个普通指针   
    	return _age;
    }
    void set_age(int age)
    {
    	_age = age;
    }

    展开全文
  • c++访问私有(private)成员变量的常用方法

    万次阅读 多人点赞 2018-08-27 10:16:40
    类的对象不直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。 在C++中,为了防止某些数据成员成员函数从外部直接访问,可以将它们声明为private,这样编译器会阻止任何来自外部非友元的直接访问。 ...

    原文地址:https://blog.csdn.net/lsh_2013/article/details/45485409
    类的对象不能直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。

    在C++中,为了防止某些数据成员或成员函数从外部被直接访问,可以将它们声明为private,这样编译器会阻止任何来自外部非友元的直接访问。

    私有成员变量的常用访问方法如下:

    (1)通过公共函数为私有成员赋值

    #include <iostream>  
    using namespace std;  
     
    class Test  
    {  
    private:  
    	int x, y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	void print(void)  
    	{  
    		cout<<"x="<<x<<'\t'<<"y="<<y<<endl;  
    	}  
    } ; 
     
    int main()  
    {  
    	Test p1;  
    	p1.setX(1);  
    	p1.setY(9);  
    	p1.print( );  
    	return 0;  
    }  
    

    (2)利用指针访问私有数据成员

    #include <iostream>  
    using namespace std;  
    class Test  
    {  
    private:  
    	int x,y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	void getXY(int *px, int *py)  
    	{  
    		*px=x;    //提取x,y值  
    		*py=y;  
    	}  
    };  
    int main()  
    {  
    	Test p1;  
    	p1.setX(1);  
    	p1.setY(9);  
    	int a,b;  
    	p1.getXY(&a,&b);  //将 a=x, b=y  
    	cout<<a<<'\t'<<b<<endl;  
    	return 0;  
    }  
    

    (3)利用函数访问私有数据成员

    #include <iostream>  
    using namespace std;  
    class Test  
    {  
    private:  
    	int x,y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	int getX(void)  
    	{  
    		return x;   //返回x值  
    	}  
    	int getY(void)  
    	{  
    		return y;   //返回y值  
    	}  
    };  
    int main()  
    {  
    	Test p1;  
    	p1.setX(1);  
    	p1.setY(9);  
    	int a,b;  
    	a=p1.getX( );  
    	b=p1.getY();  
    	cout<<a<<'\t'<<b<<endl;  
    	return 0;  
    }     
    

    (4)利用引用访问私有数据成员

     #include <iostream>  
        using namespace std;  
        class Test  
        {  
        private:  
        	int x,y;  
        public:  
        	void setX(int a)  
        	{  
        		x=a;  
        	}  
        	void setY(int b)  
        	{  
        		y=b;  
        	}  
        	void getXY(int &px, int &py) //引用  
        	{  
        		px=x;    //提取x,y值  
        		py=y;  
        	}  
        };  
        int main()  
        {  
        	Test p1,p2;  
        	p1.setX(1);  
        	p1.setY(9);  
        	int a,b;  
        	p1.getXY(a, b); //将 a=x, b=y  
        	cout<<a<<'\t'<<b<<endl;  
        	return 0;  
        }  
    
    展开全文
  • 三、直接访问私有成员 一、概述 如今关于私有方法是否应该做单元测试的争论正逐渐消停,开发者的普遍实践已经给出事实答案。通过公有方法间接测私有方法在很多情况下难以进行,开发者们更愿意通过修改方法可见性的...
  • go语言中的公有私有

    2019-09-11 16:30:57
    无论是方法名、常量、变量名还是结构体的名称,如果首字母大写,则可以其他的包访问;如果首字母小写,则只能在本包中使用。 可以简单的理解成,首字母大写是公有的,首字母小写是私有的 ...
  • 三种权限: 公共权限 public 类内可以... 类的公有成员函数内部的私有变量是可以访问到的。 类的私有成员变量只能由类的成员函数访问。原因之一:方便修改。 class Person { //姓名 公共权限 public: st...
  • 常量成员 友元成员 静态成员 什么是静态成员 静态成员, 指的是在C++类中声明成员时可以加上static关键字, 这样声明的成员就叫静态成员 静态成员的组成 静态数据成员 静态成员函数 class CBaseBitmap { ...
  • 三:该对象所有数据都不能被修改//这也是必须要初始化的一个原因 四:该对象不允许调用普通成员函数,只允许调用常量成员函数//原因是由于常对象的值不能被修改,但是你又不能保证调用的普通成员函数不会 修改它的...
  • 访问控制(可见性)PHP 中,对类中的成员(属性和方法)的访问控制,是通过以下三个访问修饰符来实现的...被定义为 public 的类成员,可以在任何地方被访问(任何地方可见)。被定义为 protected 的类成员,可以在其...
  • java私有静态方法

    2021-03-16 03:34:01
    这里的公有指的是可以被公有访问,你可以使用这个类所有的可见的东西都是被声明为public的,公有可见且公有被访问的。 private:声明当前被修饰的变量、方法为私有的。这里的私有指的是仅仅可以被私有访问,你在...
  • 包括实例属性、类属性,私有成员公有成员公有方法、私有方法和静态方法。 类似_xxx和__xxx这样的函数或变量就是非公开的,不应该直接引用。如下: # python私有函数 def _abc_1(name): return "Hello, 私有...
  • 一.静态成员 1.类中的静态成员分为两种:①数据,②函数。 2.静态数据成员,不再类内初始化。 class student { ...5.静态数据成员公有,可以用作用域运算符来直接访问:类名::静态数据成员 6...
  • 类的私有属性 和 私有方法,都不通过对象直接访问,但是可以在本类内部访问; 类的私有属性 和 私有方法,都不会被子类继承,子类也无法访问私有属性 和 私有方法 往往用来处理类的内部事情,不通过对象...
  • //主类 以上是第一种调用方法,通过Person类中的set()方法和get()方法设置并获取,在这里我们要注意的是set方法一般无返回值但是有参数(参数来自调用ser方法的类),get方法有返回值但无参数,主要用于向主类中...
  • 展开全部#include #include using .../**-----------------------------------------------------------------------------* 常量声明*----------------------------------------------------------------------...
  • JAVA中定义常量方法

    2021-02-28 07:33:32
    常量被设定后,一般情况下就不允许再进行更改。如可以利用如下的形式来定义一个常量:final double PI=3.1315。在定义这个常量时,需要注意如下内容:一是常量在定义的时候,就需要对常量进行...
  • ❥关于C++之私有继承

    2022-03-17 10:28:56
    使用私有继承,基类的公有成员和保护成员都将成为派生类的私有成员。这意味着基类方法将不会成为派生对象公有接口的一部分,但可以在派生类的成员函数中使用它们。 下面,我们用Student类私有继承标准库中的std::...
  • Go语言没有像其它语言一样有public、protected、private等访问控制修饰符,它是通过字母大小写来控制可见性的,如果定义的常量、变量、类型、接口、结构、函数等的名称是大写字母开头表示能被其它包访问或调用(相当...
  • 目录 静态成员的生命期 静态成员函数 成员常量 常量与静态量 先看一个静态字段的示例: namespace Ch05Ex03 { class Persion { int Mem1;... //私有静态成员 static Persion() { Mem2 ...
  • 之前一直捋不清普通成员和静态成员之间怎么访问,经常忘记,最近学习设计模式的单例模式时,顺便重温《C++ Primer》static关键字,有了一些新的理解,可能不完全正确,如果有误,望读者提出。 2、C++ primer上的...
  • 类的修饰符分为 访问权限修饰符 和 非访问权限修饰符(1)访问权限修饰符:1 public 公共类修饰符,public修饰的类可以同一个包中的类访问,也可以其他包中的类访问。即在此工程下的所有类都可以访问被public修饰...
  • 类的私有成员无法在本类外面直接使用(除了new...私有成员变量在本类外始终无法直接使用,只能在公有方法中当成常量(虽然欠妥,这么说也没什么不可以)来用或者作为返回值拷贝一份出来使用。只能读取,不改值。
  • 静态成员 静态成员变量/属性 用关键字 static 修饰的成员变量/属性,称之为静态成员变量/属性 静态成员变量属于类,而不是...不仅可以用对象名进行访问,还可以使用类名对其进行访问 在类定义中,前面有static...
  • (2)设计一个double型的公有静态常量数据成员pi(其值初始化为3.1415926),以及一个获取该常量公有静态成员函数GetPI。 (3)在构造函数的初始化列表中初始化高度height和底圆半径radius。 (4)设计用于获取...
  • 【简答题】实做一个点类 Point ,包含两个成员变量 x , y 分别表示 x 和 y 坐标,两个构建器 Point() 和 Point(int x0,int y0) ,以及一个 movePoint(int dx,int dy) 方法实现点的位置移动。编写一个程序,创建两个 Poin...
  • 3.Go语言中常量,变量, 及其命名规则以及代码风格
  • 访问控制机制决定了类、接口和成员的可访问性。实体的可访问性是由该实体声明所在的位置,以及该实体声明中所出现的访问修饰符共同决定的。正确地使用这些修饰符对于信息隐藏至关重要。 尽可能地使每个类
  • Java 1.5 发行版本中增加了两个新的引用类型家族:一种新的类称作枚举类型(enum type),一种新...在编程语言还没有引入枚举类型之前,表示枚举类型的常用模式是声明一组具名的 int 常量,每个类型成员一个常量: /...
  • 下面列举了“非类成员访问“类私有成员变量”的3种方法:  1.通过类公有成员函数set(), get()写、读私有成员;  2.通过类公有成员函数get()获取私有成员的指针或引用,对指针或引用操作;  3. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,146
精华内容 10,458
关键字:

私有常量成员能被公有访问吗

友情链接: 10.1.1.54.6607.zip