精华内容
下载资源
问答
  • 对象可以分为类的哪些成员
    千次阅读
    2022-04-30 15:55:10

    类中的成员可以分为三种类型,分别为public成员、protected成员、public成员。
    类中可以直接访问自己类的public、protected、private成员,但类对象只能访问自己类的public成员。

    C++中派生类对基类成员的访问形式主要有以下两种:

    1、内部访问:由派生类中新增成员对基类继承来的成员的访问。
    2、对象访问:在派生类外部,通过派生类的对象对从基类继承来的成员的访问。

    public继承
    此时基类的public成员,protected成员,private成员对于派生类来说变为public成员,protected成员,private成员。
    protected继承
    此时基类的public成员,protected成员,private成员对于派生类来说变为protected成员,protected成员,private成员。

    private继承
    此时基类的public成员,protected成员,private成员对于派生类来说变为private成员,private成员,private成员。

    派生类及派生类对象对基类成员的访问权限如下:
    在这里插入图片描述

    更多相关内容
  • C++对象(下)——初始化列表、static成员和友元

    千次阅读 多人点赞 2021-03-08 09:23:18
    C++对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++对象的学习 C++对象(上)——的基本概念、的限定符及封装和类成员函数的this指针 C++...


    关于C++类和对象的学习
    C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    一、再谈构造函数

    1.1 构造函数整体赋值

    在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类

    class Date
    {
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    

    虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化因为初始化只能初始化一次,而构造函数体内可以多次赋值

    1.2 初始化列表

    <1>为什么有初始化列表?

    对于我们定义的日期类,当类中出现以下成员时,如果只用构造函数则无法完成变量的初始化了,以下的成员变量需要在定义的时候就需要初始化

    • 引用成员变量
    • const成员变量
    • 自定义类型的成员变量

    在这里插入图片描述
    其次对于自定义的类成员变量,不使用初始化列表会调用多次构造函数
    在这里插入图片描述

    <2> 如何使用初始化列表

    初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式
    注意:每个成员变量在初始化列表中只能出现一次

    //1.2.2
    class Time
    {
    public:
    	Time(int hour = 1, int minute=1,int second = 1)
    		:_hour(hour)
    		,_minute(minute)
    		,_second(second)
    	{
    		cout << "Time(int hour = 1, int minute=1,int second = 1)" << endl;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	//初始化列表写法
    	Date(int year=1900, int month=1, int day=1,int hour=1,int minute=1,int second=1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    		,_n(10)
    		,_ref(day)
    		,_t(hour,minute,second)
    	{
    		cout << "Date(int year, int month, int day,int hour,int minute,int second)" << endl;
    
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	//定义的时候需要初始化
    	int& _ref;	//引用
    	const int _n; //const成员变量
    	Time _t;	//自定义类型的成员变量
    };
    
    void Test2()
    {
    	Date d1(2021,3,9,2,2,2);
    }
    

    结果在这里插入图片描述

    <3> 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

    如下代码的运行结果是什么?

    //1.2.3
    class A
    {
    public:
    	A(int a)
    		:_a1(a)
    		, _a2(_a1)
    	{}
    	void Print() {
    		cout << _a1 << " " << _a2 << endl;
    	}
    private:
    	int _a2;
    	int _a1;
    };
    
    void Test2()
    {
    	A aa(1);
    	aa.Print();
    }
    

    结果

    在这里插入图片描述

    1.3 explicit关键字

    <1> 匿名对象

    匿名对象顾名思义就是没有名字,其作用域只在一行中有效,例如下面的代码

    //1.3.1
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{
    		cout << "B(int b = 0)" << endl;
    	}
    
    	//析构函数
    	~B()
    	{
    		cout << "~B()" << endl;
    	}
    private:
    	int _b;
    };
    
    int main()
    {
    	B bb(10);	//生命周期在main函数域
    	B(2);	//匿名对象生命周期在这一行
    	return 0;
    }
    

    在这里插入图片描述
    在这里插入图片描述

    <2> 为什么有explicit关键字?

    对于c++来说,构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用

    当我们定义一个类进行初始化时,如果我们采取下面这种定义方式,编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造

    //1.3.2
    class C 
    {
    public:
    	C(int c)
    		:_c(c)
    	{
    		cout << "C()" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    <3> 如何使用explicit关键字?

    用explicit修饰构造函数,将会禁止单参构造函数的隐式转换

    //1.3.3
    class C 
    {
    public:
    	explicit C(int c)
    		:_c(c)
    	{
    		cout << "explicit C(int c)" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    在这里插入图片描述

    二、static成员

    2.1 概念

    声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态的成员变量一定要在类外进行初始化

    面试题:实现一个类,计算程序中创建出了多少个类对象?这个时候我们就可以使用static成员变量和static成员函数来实现

    //2.1 实现一个类,计算程序中创建出了多少个类对象。
    class A
    {
    public:
    	//构造函数
    	A()
    	{
    		++_scount;
    	}
    	//拷贝构造函数
    	A(const A& a)
    	{
    		++_scount;
    	}
    	
    	static int GetAcount()
    	{
    		return _scount;
    	}
    private:
    	static int _scount;
    };
    
    //初始化在类外
    int A::_scount = 0;
    
    void TestA()
    {
    	cout << A::GetAcount() << endl;
    	A aa;
    	A bb;
    	A cc(bb);
    	cout << A::GetAcount() << endl;
    }
    

    在这里插入图片描述

    2.2 特性

    <1> 静态成员为所有类对象所共享,不属于某个具体的实例

    <2> 静态成员变量必须在类外定义,定义时不添加static关键字

    在这里插入图片描述

    <3> 类静态成员即可用类名::静态成员或者对象.静态成员来访问

    在这里插入图片描述

    <4> 静态成员函数没有隐藏的this指针,不能访问任何非静态成员

    在这里插入图片描述

    <5>静态成员和类的普通成员一样,也有public、protected、private3种访问级别,也可以具有返回值

    Q1: 静态成员函数可以调用非静态成员函数吗?

    不可以,因为静态成员函数没有隐藏的this指针

    Q2:非静态成员函数可以调用类的静态成员函数吗?

    可以,因为非静态成员函数含有this指针,指定了静态成员函数的类域
    在这里插入图片描述

    三、C++11的成员初始化新玩法

    3.1 为什么?

    对于C++98而言,类内自定义的内置类型,编译器会进行初始化,而其他内置类型不会,因此出现则会中初始化方法。
    具体查看这篇博客的2.2.7节内容
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    3.2 怎么用?

    C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值

    //3.C++11的成员初始化新玩法
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{}
    	int _b;
    };
    class A
    {
    public:
    	void Print()
    	{
    		cout << a << endl;
    		cout << b._b << endl;
    		cout << p << endl;
    	}
    private:
    	// 非静态成员变量,可以在成员声明时给缺省值。
    	int a = 10;
    	B b = 20;
    	int* p = (int*)malloc(4);
    	//静态成员不可以
    	static int n;
    };
    int A::n = 10;
    
    int main()
    {
    	A a;
    	a.Print();
    	return 0;
    }
    

    在这里插入图片描述

    四、友元

    • 友元分为:友元函数友元类
    • 友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用

    4.1 友元函数

    问题:现在我们尝试去重载operator<<,然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话,又会导致类外没办法访问成员,那么这里就需要友元来解决。operator>>同理

    //4.1
    class Date
    {
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d(2017, 12, 24);
    	d << cout;
    	return 0;
    }
    

    在这里插入图片描述
    友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

    //4.1
    class Date
    {
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator >> (istream& _cin, Date& d);
    
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    ostream& operator<<(ostream& _cout, const Date& d)
    {
    	_cout << d._year << "-" << d._month << "-" << d._day << endl;
    	return _cout;
    }
    
    istream& operator >> (istream& _cin, Date& d)
    {
    	_cin >> d._year >> d._month >> d._day;
    
    	return _cin;
    }
    
    int main()
    {
    	Date d(2017, 12, 24);
    	cout<<d;
    	//Date d1;
    	cin >> d;
    	cout << d;
    	return 0;
    }
    

    在这里插入图片描述

    4.2 友元类

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

    • 友元关系是单向的,不具有交换性。
      比如下面Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
    • 友元关系不能传递
      如果B是A的友元,C是B的友元,则不能说明C时A的友元。
    class Date; // 前置声明
    class Time
    {
    	friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
    public:
    	Time(int hour=0, int minute=0, int second=0)
    		: _hour(hour)
    		, _minute(minute)
    		, _second(second)
    	{}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    
    	void SetTimeOfDate(int hour, int minute, int second)
    	{
    		// 直接访问时间类私有的成员变量
    		_t._hour = hour;
    		_t._minute = minute;
    		_t._second = second;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	Time _t;
    };
    

    五、内部类

    概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

    注意:内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

    特性:

    1. 内部类可以定义在外部类的public、protected、private都是可以的。
    2. 注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。
    3. sizeof(外部类)=外部类,和内部类没有任何关系
    class A
    {
    private:
    	static int k;
    	int h;
    public:
    	class B
    	{
    	public:
    		void foo(const A& a)
    		{
    			cout << k << endl;//OK
    			cout << a.h << endl;//OK
    		}
    	};
    };
    int A::k = 1;
    int main()
    {
    	A::B b;
    	b.foo(A());
    	return 0;
    }
    
    展开全文
  • 成员可以包括什么?

    千次阅读 2020-12-27 22:26:25
    对象可以说是一个抽象与具体的例子吧,将一个具有共同属性的集合高度概括为一个抽象的“(Class)”,在创建一个Class后可以将它实例化为许多具体的“对象”。我们借用对象来实现我们所需要的功能。 创建...

    首先:创建类以及实例化对象的基本语法如下:

    // 创建类
    class <class_name>{ 
      field;//也叫字段/属性/成员变量(field)
      method;//成员方法
    }
    // 实例化对象
    <class_name> <对象名> = new <class_name>();
    

    Q:类的成员可以包括什么?
    A:类的成员可以包含:字段、方法、代码块、内部类和接口等。

    "示例:"
    public class Person {
      //1--字段、属性,成员变量"
      public String name;  
      public int age;
      public static String STATIC_FIELD = "静态属性";
      
      //2--代码块分为普通代码块 静态代码块 构造代码块" 
      //"2.1构造代码块"
      {
            System.out.println("第一构造块");
      }
     // "构造方法"
      public Person (int i) {
            System.out.println("第" + i + "次调用" + "构造方法");
        }
        
      //"2.2静态代码块"
        static {
            System.out.println(STATIC_FIELD);
            System.out.println("静态代码块1");
        }
        
      //"3--方法"
      public void show() {
      	//"2.3普通代码块"
     	System.out.println("我叫" + name + ", 今年" + age + "岁");
      }
      
      //4--内部类
      class Draw {     
            public void drawShape() {
                System.out.println("draw");
            }
        }
       //5--接口
       public interface Eat {
            public String info();
        }
      
      //main()方法
     public static void main(String[] args) {
        Person person = new Person();//创建对象
        //使用new 关键字用于创建一个对象的实例;
        //使用 . 来访问对象中的属性和方法.;同一个类可以创建多个实例。
        System.out.println(person.name);
        person.show();//调用方法
    }
    
    • 类Draw是类Person的一个成员,Person称为外部类。成员内部类Draw可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)
    • 需要注意,内部接口不管有没有声明static,都是静态的。这不同于成员内部类,成员内部类需要依赖其所在类实现的对象

    ——————————————————————————————————

    字段(field)

    • 初始化的三种方式:
      ①就地初始化,public String name = "张三";
      ②默认初始化public String name; 默认值为null;
      ③类外初始化。类外初始化在项目工程中使用频繁。
      对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值;

    默认值规则
    1、对于各种数字类型, 默认值为 0.
    2、对于 boolean 类型, 默认值为 false.
    3、对于引用类型(String, Array, 以及自定制类), 默认值为 null

    方法 (method)

    • 语法规则
      1.方法名称必须与类名称相同
      2.构造方法没有返回值类型声明
      3.每一个类中一定至少存在一个构造方法(没有明确定义,则系统自动生成一个无参构造)

    • 方法中还有一种特殊的方法称为 构造方法 (construction method)
      在使用关键字new实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于完成对象的初始化操作.

      这里就不得不提到new 执行过程,总共分为2步:
      1、为对象分配内存空间
      2、调用对象的构造方法

    • 注意事项
      1、如果类中没有提供任何的构造函数,那么编译器会默认生成一个不带有参数的构造函数
      2、若类中定义了构造方法,则默认的无参构造将不再生成.
      3、构造方法支持重载. 规则和普通方法的重载一致

    关键字static
           关于static修饰的属性和方法都使用类名.方法/属性来调用;因为静态的方法和属性就已经不依赖于对象了。同一个类的不同实例共用同一个静态属性.例如如下代码:

    class TestDemo{
      public int a;
      public static int count;  //静态成员变量
    }
    public class Main{
     
    public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);//1
        System.out.println(TestDemo.count);//1
        //实例化多个对象
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;//使用类名.属性来调用
        //无需创建实例对象 就可以调用
        System.out.println(t2.a);//1
        System.out.println(TestDemo.count);//2 
        //因为是共用的所以count从1变到2
     }
    }
    

    注:static可以修饰属性、修饰方法、代码块、修饰类

    修饰限定符 private/ public 这两个关键字表示 “访问权限控制”
    被 public 修饰的成员变量或者成员方法,可以直接被类的调用者使用.
    被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用

    类和对象

           类和对象可以说是一个抽象与具体的例子,将一个具有共同属性的集合高度概括为一个抽象的“类(Class)”,在创建一个Class后可以将它实例化为许多具体的“对象”。我们借用类和对象来实现我们所需要的功能。

    class Person {
      public int age;//实例变量  
      public String name;//实例变量
      public String sex;//实例变量均存放在对象内
      public static int count;//类变量也叫静态变量,编译时已经产生,属于类本身,且只有一份。存放在方法区
      public final int SIZE = 10;//被final修饰的叫常量,也属于对象。 被final修饰,后续不可更改,存放在对象内
      public static final int  COUNT = 99;//静态的常量,属于类本身,只有一份 被final修饰,后续不可更,存放在方法区//实例成员函数
      public void eat() {
       int a = 10;//局部变量
       System.out.println("eat()!"); 
     }
     
      //实例成员函数
      public void sleep() {
       System.out.println("sleep()!"); 
     }
     
      //静态成员函数
      public static void staticTest(){
        //不能访问非静态成员
        //sex = "man"; error
        System.out.println("StaticTest()");
      }
    }
    
    public class Main{
    public static void main(String[] args) {
        //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null
        //System.out.println(person.count);//会有警告!
        //正确访问方式:
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结:所有被static所修饰的方法或者属性,全部不依赖于对象。
        person.eat();
        person.sleep();
    }
    }
    

    下图为数据属性的内存布局:
    在这里插入图片描述

    展开全文
  • 中的成员可以分为三种类型,分别为public成员、protected成员、public成员。中可以直接访问自己的public、protected、private成员,但类对象只能访问自己的public成员。 public继承 派生可以访问基类的...

    类中的成员可以分为三种类型,分别为public成员、protected成员、public成员。类中可以直接访问自己类的public、protected、private成员,但类对象只能访问自己类的public成员。

    public继承

    派生类可以访问基类的public、protected成员,不可以访问基类的private成员;
    派生类对象可以访问基类的public成员,不可以访问基类的protected、private成员。

    protected继承

    派生类可以访问基类的public、protected成员,不可以访问基类的private成员;
    派生类对象不可以访问基类的public、protected、private成员。

    private继承

    派生类可以访问基类的public、protected成员,不可以访问基类的private成员;
    派生类对象不可以访问基类的public、protected、private成员。

    在这里插入图片描述

    展开全文
  • 成员函数存放在代码区,数据成员分为静态变量和非静态变量,静态变量在定义的时候,就分配好了,存放在数据区,然后非静态变量时在构造对象的时候,存放在堆栈中。 的大小实际上只是数据部分的大小(包括虚...
  • 成员的访问权限_Java语言程

    千次阅读 2021-03-17 10:29:14
    成员的访问权限_Java语言程4.7.2 成员的访问权限Java将成员(成员变量和成员方法)的访问权限(可见性)划分为4种情况,按照访问权限的范围大小从小到大列出如下。·私有(private)成员:仅在本内中的...
  • 很多人都知道C++是由结构体发展得来的,所以他们的成员变量(C语言的结构体只有成员变量)的内存分配机制... 类分为成员变量和成员函数,我们先来讨论成员变量。 一个类对象的地址就是所包含的这一片内存空间的
  • 在python中,可以通过class关键字定义,然后通过定义的来创建实例对象。语法格式如下: calss 类名: 体 注意事项 在python中使用class关键字来定义,定义时需要注意以下几个事项: (1)代码块以...
  • 运算符的种类C语言的运算符可分为以下几:1.算术运算符用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算,%)、自增(++)、自减(--)共七种。2.关系运算符用于比较运算。包括大于(>)、小于(=)...
  • java成员对象

    千次阅读 2016-11-28 16:16:05
    最简单地复用某个的方式就是直接使用该的一个对象,此外也可以将那个的一个对象置于某个新中。我们称其为“创建一个成员对象”。新的类可以由任意数量、任意类型的其他对象以任意可以实现新的中想要的功能...
  • Python——成员变量和变量

    千次阅读 2021-12-06 16:29:12
    中的变量分为两种类型:一种是成员变量(实例属性),另一种是变量(属性)。 成员变量是在构造方法__init__()中定义的,通过 self 参数引用; 变量是在中方法之外定义的变量。 在的外部,成员变量属于对象,只能...
  • 内部与外部之间的访问

    千次阅读 2022-04-14 17:54:16
    私有的成员内部,外界就无法直接创建其对象,可以通过外部的方法访问 局部内部,在外界没有直接创建其对象的语法 局部内部访问外部的局部变量: 1.内部与外部 将一个A 定义到另一个B的内部,....
  • 中默认的六个成员函数 构造函数 析构函数 拷贝构造函数 赋值操作符重载 取地址和const取地址操作符重载 const成员函数 1. 中默认的六个成员函数 首先看看下面代码 class A{ }; int main(){ A a; return 0; } ...
  • 对象的关系

    千次阅读 2021-08-24 16:30:10
    一、(1)的概念:是一组相关属性和行为的集合,可以看成是一事物的模板,使用事务特征和行为特征来描述该事物 属性(是什么):名字,体重,年龄,颜色 行为(做什么):走,跑,叫 (2)对象的概念:...
  • java编程中的成员方法是什么?

    千次阅读 2021-02-12 15:00:33
    一个对象可以有多个成员方法,对象通过执行它的成员方法对传来的消息作出响应,完成特定的功能。成员方法一旦定义,便可在不同的程序段中多次调用,故可增强程序结构的清晰度,提高编程效率。1 成员方法的分类 ...
  • 看了一下,现在的CSDN大多都是Python2来编写例子,今天边学习,边进行修改为Python3,大家互相学习 面向对象是一种编程方式,此编程方式的实现是基于对 对象 的...成员可以分为三大:字段、方法和属性...
  • Java对象の内部

    千次阅读 多人点赞 2022-04-03 22:15:43
    对于实例内部,静态内部,局部内部的一些解释
  • 对象与接口概念

    千次阅读 2019-02-21 23:14:27
    ​ 一个定义在另外一个的内部,分为成员内部(定义在外部的成员位置)和局部内部(定义在外部的方法里面) 成员内部 class Outer{ class Inner{} } 成员内部的特点 1、成员内部类可以直接访问外部的...
  • 我们首先看一段程序: class A { private : ...这个程序非常的简单,但我们仔细一瞅会发现一个有趣的问题:private的变量i怎么直接可以通过对象访问了!...其他对象的数据成员可以通过引用或指针间接指明)
  • C++之对象数组+对象成员+拷贝构造函数(深/浅)

    千次阅读 多人点赞 2017-03-03 15:47:42
    对象数组实例(栈中实例化和堆中实例化):class Coordinate { public: int m_iX; int m_iY; };int main() { Coordinate coord[3];//栈中实例化 coord[1].m_iX = 10; Coordinate *p = new Coordinate[3];//堆中...
  • 【C++】什么是对象?什么是

    千次阅读 多人点赞 2021-03-27 18:47:32
    “有对象吗?没有! new 一个。”当第一次接触面向程序设计语言Java时,大家...当然可以这样理解,但是世界这么大,我也想去看看万物世界,在看世界的过程中,我们在现实中能看到的每一个能叫出来名字的都可以被理解为对.
  • 成员方法和实例方法

    千次阅读 多人点赞 2019-07-22 19:14:51
    成员变量:中方法外声明变量 分类: 变量:使用static修饰符修饰的成员变量。 实例变量:未使用static修饰符修饰的成员变量。 变量与实例变量的区别? 变量: 使用static修饰符修饰; 变量是的...
  • C++习题03_对象

    千次阅读 2021-01-26 12:23:36
    C++习题03_对象 习题03(01)计算器 题目描述 下面是一个计算器的定义,请完成该类成员函数的实现,并编写main()。 class Counter { public: Counter(int num); void increament(); //给原值增1 void ...
  • 3. 对象的初始化和清理3.1 构造函数和析构函数3.2 构造函数的分类及调用3.3 拷贝构造函数调用时机3.4 构造函数调用规则3.5 深拷贝与浅拷贝3.6 初始化列表3.7 类对象作为类成员4.2.8 静态成员 3. 对象的初始化和清理 ...
  • JVM 加载机制、对象的创建过程

    千次阅读 2020-06-03 11:48:51
    目录加载的过程加载器加载机制加载时机加载方式对象的创建过程对象的内存布局对象的访问方式   加载:jvm读取.class文件,解析获取的信息,生成对应的Class对象。   加载的过程 主要分为...
  • java面向对象编程——对象

    千次阅读 多人点赞 2021-11-13 19:48:17
    传送门点击跳转 写在前面 对象 对象初识 面向对象编程思想 的实例化 成员 成员变量/属性/字段 成员方法 构造方法 注意事项 `static`关键字 封装 `private`关键字实现封装 `getter和setter`方法 ...
  • Java 内部成员类、局部、匿名

    万次阅读 多人点赞 2016-10-11 17:49:15
    Java各种称呼详解Java有各种各样,内部、嵌套成员类、局部(本地)、静态、匿名、文件以及这些组合起来的称呼成员内部成员匿名成员嵌套,本地匿名等,真是多的不行,但有些其实...
  • C++ 实验四 对象(二)

    千次阅读 多人点赞 2018-04-19 11:11:40
    1.定义学生,包括学号、姓名、性别、成绩,学生分为,课程门数不同,并将课程成绩全部初始化为0;假设有n个学生,由键盘输入学生信息; 2.定义类成员函数,完成修改学生的信息,统计所有学...
  • C/C++面试:static修饰类成员函数

    千次阅读 2018-07-24 14:03:58
    总结 在中,static可以用来修饰静态数据成员和静态成员方法 静态数据成员 (1)静态数据成员可以实现多个数据之间的数据共享,它是的所有对象的共享成员,它在内存中只占用一份空间,如果改变它的值,则各对象...
  • 中包含几种成员,分别是什么?

    万次阅读 2015-08-31 16:22:13
    中有两种成员成员变量以及成员函数。其中成员变量分为静态的成员变量以及非静态的成员变量;成员函数分为静态的成员函数以及非静态的成员函数。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 251,872
精华内容 100,748
热门标签
关键字:

对象可以分为类的哪些成员