精华内容
下载资源
问答
  • 在C++与对象的学校中,可以在中定义其他的对象即为类对象成员,还可以用new为的对象申请动态空间并用delete释放,本文重点分析的就是成员对象与动态对象的用法和注意事项。

    一、类成员对象

    1、类的对象

    简单来说,类成员对象就是在类中定义其他类的实例化对象,并调用其他的成员对象的有参/无参构造函数。

    例如:
    定义三个Room、Chair、Person,
    然后在Person类的定义中,
    再定义Room、Chair的实例化对象room和chair,
    定义Person对象传入3个有参构造函数需要的参数,
    并通过room、chair这两个对象对它们的成员数据进行赋值,
    同时在Person类中引用room、chair对象的数据进行输出。

    2、具体参考代码

    #include <iostream>
    #include <string.h>
    #include <stdlib.h>
    using namespace std;
    
    //定义一个房间类 
    class Room
    {
    public:
    	string room_name;  //定义一个共有成员,字符串类型的名字
    	//定义有参构造函数
    	Room(string name)
    	{
    		room_name= name;
    		cout << "此为Room的构造函数" << endl;
    	} 
    	~Room()
    	{
    		cout << "This is Room function done..." << endl;
    	}
    };
    
    //再定义一个椅子类
    class Chair
    {
    public:
    	string chair_name;  //定义一个共有成员,字符串类型的名字  
    	//定义有参构造函数
    	Chair(string name)
    	{
    		chair_name= name;
    		cout << "此为Chair的构造函数" << endl;
    	} 
    	~Chair()
    	{
    		cout << "This is Chair function done..." << endl;
    	}
    };
     
    //定义一个人的类 
    class Person
    {
    public:
    	
    	//定义有参构造函数
    	
    	//不能直接这样写调用其他类对象的有参构造 
    	/*Person(string p_name, string r_name, string c_name)
    	{
    		//对Person的成员进行赋值
    		per_name= p_name;
    		room.room_name= r_name;
    		chair.chair_name= c_name; 
    	} */
    	
    	//必须使用初始化列表,才可以调用其他类对象的有参构造
    	Person(string p_name, string r_name, string c_name):per_name(p_name), room(r_name), chair(c_name){ 
    	cout << "此为Person的构造函数" << endl;
    	}
    	
    	//定义析构函数 
    	~Person()
    	{
    		cout << "This is Person function done..." << endl;
    	}
    	
    	string per_name;  //定义一个共有成员,字符串类型的名字 
    	//该类的成员中包含两个其他类的对象
    	Room room;  //定义一个Room类的对象room,也就是让一个类的对象作为另一个类的成员 
    	Chair chair;  //定义一个Chair类的对象chair
    	
    	//定义Person的成员函数,输出Person的3个成员数据 
    	void show()
    	{
    		cout << per_name << room.room_name << chair.chair_name << endl;
    	} 
    };
     
    int main()
    {
    	//实例化Person对象,传入三个参数
    	Person p1("Chung", "在520房间", "的椅子上。");
    	p1.show();
    	return 0;
    }
    

    二、动态对象与new、delete

    1、C语言中为类的对象开辟动态空间

    //假如已经定义了一个Box类,则在C语言中如下开辟动态空间:
    void test01()
    {
    	//用malloc申请一段动态内存空间 
    	Box *p= (Box*)malloc(sizeof(Box));    //空间大小为类Box的大小 
    	free(p);  //使用完了释放内存空间 
    } 
    

    2、C++的new开辟动态空间:类型名 *p= new 类型名

    在C++语言中申请普通类型的动态空间:类型名 *p= new 类型名,p2是一个指针 :

    void test02()
    {
    	//申请一段int类型的空间并赋值给p2指针,大小为sizeof(int) 
    	int *p2= new int;  
    	*p2= 99;
    	cout << "*p2= " << *p2 << endl;
    	delete p2;  //使用完了释放内存空间 
    } 
    

    3、请自定义类的动态空间,p3是一个对象指针

    void test03()
    {
    	//申请一段Box类型的空间并赋值给p3指针,大小为sizeof(Box) 
    	Box *p3= new Box; 
    	(*p3).a= 666;
    	cout << "p3对象中的a= " << (*p3).a << endl;
    	delete p3;  //使用完了释放内存空间 
    } 
    

    4、申请数组的动态空间,p4是一个数组

    void test04()
    {
    	int *p4= new int[10];  //申请一段int数组类型的空间,大小为sizeof(int[10]),实际上该指针指向的是数组元素的首地址 
    	//给数组元素赋值
    	for(int i=0; i<10; i++)
    	{
    		p4[i]= i+10;
    	} 
    	//输出数组元素的值 
    	for(int i=0; i<10; i++)
    	{
    		cout << p4[i] << " ";
    	} 
    	cout << endl;
    	//释放内存空间,不能直接delete p4;  这样只是释放了首元素的空间
    	delete []p4; 
    }
    

    5、C++申请动态空间完整练习代码

    #include <iostream>
    #include <string.h>
    #include <stdlib.h>  //需要用到malloc 
    using namespace std;
    
    //定义一个盒子类 
    class Box
    {
    public:
    	Box()  //定义构造函数 
    	{
    		cout << "Box的无参构造" << endl;
    	}
    	~Box()  //定义析构函数 
    	{
    		cout << "Box的析构函数" << endl;
    	}
    	int a;  //私有成员数据 
    };
    
    //在C语言中动态申请空间
    void test01()
    {
    	//用malloc申请一段动态内存空间 
    	Box *p= (Box*)malloc(sizeof(Box));    //空间大小为类Box的大小 
    	free(p);  //使用完了释放内存空间 
    } 
    
    //在C++语言中申请普通类型的动态空间:类型名 *p= new 类型名,p2是一个指针 
    void test02()
    {
    	//申请一段int类型的空间并赋值给p2指针,大小为sizeof(int) 
    	int *p2= new int;  
    	*p2= 99;
    	cout << "*p2= " << *p2 << endl;
    	delete p2;  //使用完了释放内存空间 
    } 
    
    //在C++语言中申请自定义类的动态空间,p3是一个对象指针 
    void test03()
    {
    	//申请一段Box类型的空间并赋值给p3指针,大小为sizeof(Box) 
    	Box *p3= new Box; 
    	(*p3).a= 666;
    	cout << "p3对象中的a= " << (*p3).a << endl;
    	delete p3;  //使用完了释放内存空间 
    } 
    
    //在C++语言中申请数组的动态空间,p4是一个数组 
    void test04()
    {
    	int *p4= new int[10];  //申请一段int数组类型的空间,大小为sizeof(int[10]),实际上该指针指向的是数组元素的首地址 
    	//给数组元素赋值
    	for(int i=0; i<10; i++)
    	{
    		p4[i]= i+10;
    	} 
    	//输出数组元素的值 
    	for(int i=0; i<10; i++)
    	{
    		cout << p4[i] << " ";
    	} 
    	cout << endl;
    	//释放内存空间,不能直接delete p4;  这样只是释放了首元素的空间
    	delete []p4; 
    }
    
    int main()
    {
    	//test01();
    	//test02();
    	test03();
    	test04();
    	return 0;
    }
    

    三、动态对象(传参)

    与上文动态空间的申请同理,只是需要传入参数。
    注意:若申请的是对象数组,则不能实例化带有参数构造函数的类,只能是无参构造函数类。

    #include <iostream>
    #include <string.h>
    #include <stdlib.h>  //需要用到malloc 
    using namespace std;
    
    //定义一个盒子类 
    class Box
    {
    public:
    	Box()  //定义构造函数 
    	{
    		cout << "Box的无参构造" << endl;
    	}
    	//使用初始化列表定义有参构造函数
    	Box(int h, int w, int len):height(h), width(w), length(len)   
    	{
    		cout << "Box的有参构造" << endl;
    	}
    	~Box()  //定义析构函数 
    	{
    		cout << "Box的析构函数" << endl;
    	}
    private:
    	int height;  //私有成员数据 
    	int width;
    	int length;
    };
    
    //定义测试函数
    void test()
    {
    	//申请一段Box类型的动态空间并赋值给p指针,大小为sizeof(Box)
    	//并传入构造函数的参数 
    	Box *p= new Box(1, 2, 3);   
    	delete p;  //释放申请的内存空间 
    	// 
    	//申请动态空间,调用无参构造的对象数组 
    	cout << "-------------------------"  << endl; 
    	Box *p2= new Box[5];   
    	delete []p2;  //释放对象数组的内存空间 
    } 
    
    int main()
    {
    	test();
    }
    

    02

    展开全文
  • C++中的成员可以是另一个中的对象,我们称该成员为 对象成员 例如: class A{}; class B { A a; }; B中有对象A作为成员,A为对象成员 那么当创建B对象时,A与B的构造和析构的顺序谁先谁后? 举例: class ...

    C++类中的成员可以是另一个类中的对象,我们称该成员为 对象成员
    例如:

    class A{};
    class B
    {
        A a;
    };
    
    

    B类中有对象A作为成员,A为对象成员
    那么当创建B对象时,A与B的构造和析构的顺序谁先谁后?

    举例:

    class Phone
    {
    public:
    
        Phone(string pName)
        {
            m_Pname = pName;
        }
    
        //手机品牌名称
        string m_Pname;
    };
    class Person
    {
    public:
        Person(string name, string pName):m_name(name),m_phone(pName)//相当于Phone m_phone = pName,即隐式转换法
        {
           
        }
    
        //姓名
        string m_name;
        //手机
        Phone m_phone;
    };
    
    void test01()
    {
        Person p("ss", "iPhone");
        cout << p.m_name << "拿着" << p.m_phone.m_Pname << endl;
    }
    
    

    运行结果:
    在这里插入图片描述

    那么,先有的人还是先有的手机呢?
    打印输出一下:

    Phone(string pName)
        {
            cout << "Phone的构造函数调用" << endl;
            m_Pname = pName;
        }
    
      Person(string name, string pName):m_name(name),m_phone(pName)//相当于Phone m_phone = pName,即隐式转换法
        {
            cout << "Person的构造函数调用" << endl;
        }
    
    

    再次运行结果:
    在这里插入图片描述
    可以看到,先创建的手机,再创建的人。
    即:当其他类的对象作为本类的成员,在构造时先构造其他类对象,再构造本类对象。
    同理,析构顺序:(可以看出与构造顺序相反)
    在这里插入图片描述

    展开全文
  • C++中的成员可以是另一个的对象,我们称该成员为对象成员 例如: class A{} class B { A a; } B中有对象A作为成员,A为对象成员 那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后? ...

    C++ 类和对象的成员(类成员,静态成员)

    1 类对象作为类成员

    C++类中的成员可以是另一个类的对象,我们称该成员为对象成员
    例如:

    class A{}
    class B
     {
     	A a;
    }
    

    B类中有对象A作为成员,A为对象成员

    那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后?

    #include <iostream>
    #include<string>
    using namespace std;
    
    //类对象作为类成员
    
    //手机类
    class Phone
    {
    public:
    	Phone(string pName)
    	{
    		m_PName=pName;
    	}
    	//手机品牌名称
    	string m_PName;
    };
    
    //人类
    class Person
    {
    public:
    	//Phone m_Phone=pName;//隐士转换法
    	Person(string name, string pName):m_Name(name), m_Phone(pName)
    	{
    
    	}
    	//姓名
    	string m_Name;
    	//手机
    	Phone m_Phone;
    };
    
    void test1()
    {
    	Person p("张三","苹果MAX");
    	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << "手机" << endl;
    }
    int main() 
    {
    	test1();
    	return 0;
    }
    

    在这里插入图片描述
    在这里插入图片描述
    注意手机名字的调用

    p.m_Phone.m_PName
    

    在这里插入图片描述
    我们在调用Person类时,“手机类对象”和“人类对象”的构造顺序是谁先谁后?
    析构函数有谁先谁后呢?

    我们在Phone类和Person类的构造函数和析构函数中分别输出语句调用语句,则结果一目了然

    //手机类
    class Phone
    {
    public:
    	Phone(string pName)
    	{
    		m_PName=pName;
    		cout << "Phone的构造函数调用" << endl;
    	}
    
    	~Phone()
    	{
    		cout << "~Phone的析构函数调用" << endl;
    	}
    	//手机品牌名称
    	string m_PName;
    };
    
    //人类
    class Person
    {
    public:
    	//Phone m_Phone=pName;//隐士转换法
    	Person(string name, string pName):m_Name(name), m_Phone(pName)
    	{
    		cout << "Person的构造函数调用" << endl;
    	}
    
    	~Person()
    	{
    		cout << "~Person的析构函数调用" << endl;
    	}
    
    
    	//姓名
    	string m_Name;
    	//手机
    	Phone m_Phone;//类对象作为类成员
    };
    
    };
    
    
    
    //当其他类对象作为本类成员时
    //构造时候先构造类对象,在构造自身  (创建)
    //析构的顺序与构造相反  (释放)
    void test1()
    {
    	Person p("张三","苹果MAX");
    	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << "手机" << endl;
    }
    int main() 
    {
    	test1();
    	return 0;
    }
    

    运行结果看出
    先打印输出Phone类的构造,再打印输出Person构造
    析构顺序与构造相反
    在这里插入图片描述

    结论:
    当其他类对象作为本类成员时,
    构造时候先构造类对象,再构造自身 (创建),
    (手机是人拥有的一部分,先构造零部件,在构造整体),
    析构的顺序与构造相反 (释放)。

    2 静态成员

    静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员

    静态成员分为:

    静态成员变量
    所有对象共享同一份数据
    在编译阶段分配内存
    类内声明,类外初始化

    静态成员函数
    所有对象共享同一个函数
    静态成员函数只能访问静态成员变量

    #include <iostream>
    #include<string>
    using namespace std;
    
    //静态成员函数
    //所有对象共享同一个函数
    //静态成员函数只能访问静态成员变量
    class Person
    {
    public:
    	//静态成员函数
    	static void func()
    	{
    		m_A = 100;//静态成员函数 可以访问 静态成员变量
    		//m_B = 200;//静态成员函数 不可以访问 非静态成员变量,无法区分到底是哪个对象的m_B
    		cout << "static void func调用" << endl;
    	}
    	static int m_A;//静态成员变量
    	int m_B;
    
    	//静态成员函数也是有访问权限的
    private:
    	static void fun2()
    	{
    		cout << "static void func2调用" << endl;
    	}
    
    };
     int Person:: m_A = 0;//静态成员初始化
    
    //静态成员调用,两种访问
    void test1()
    {
    	//1.通过对象访问
    	Person p;
    	p.func();
    
    	//2.通过类名访问
    	Person::func();
    
    //	Person::func2();
    }
    int main() 
    {
    	test1();
    	return 0;
    }
    

    类外访问不到私有静态成员函数
    在这里插入图片描述

    在这里插入图片描述

    参考:黑马程序员
    哔哩哔哩 黑马程序员

    展开全文
  • title: Java基础语法(9)-面向对象成员blog: CSDNdata: Java学习路线及视频1.面向过程与面向对象面向过程(POP) 与 面向对象(OOP)二者都是一种思想,面向对象是相对于面向过程而言的。面向过程,强调的是功能...

    title: Java基础语法(9)-面向对象之类的成员

    blog: CSDN

    data: Java学习路线及视频

    93b5941cb5a9117be5c03292f466a490.png1.面向过程与面向对象面向过程(POP) 与 面向对象(OOP)二者都是一种思想,面向对象是相对于面向过程而言的。面向过程,强调的是功能行为,以函数为最小单位,考虑怎么做。面向对象,将功能封装进对象,强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。

    面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则,如抽象、分类、继承、聚合、多态等。面向对象的三大特征

    封装 (Encapsulation)

    继承 (Inheritance)

    多态 (Polymorphism)面向过程

    40be362a635977d7c34db90805e3b329.png面向对象

    0c42d0b6bb1cd940a3d8204b3658b9c8.png面向对象的思想概述程序员从面向过程的执行者转化成了面向对象的指挥者

    根据问题需要,选择问题所针对的现实世界中的实体。

    从实体中寻找解决问题相关的属性和功能,这些属性和功能就形成了概念世界中的类

    把抽象的实体用计算机语言进行描述,形成计算机世界中类的定义。即借助某种程序语言,把类构造成计算机能够识别和处理的数据结构。

    将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

    2.类和对象面向对象的概述类(Class)和对象(Object)是面向对象的核心概念。

    类是对一类事物的描述,是抽象的、概念上的定义

    对象是实际存在的该类事物的每个个体,因而也称为实例(instance)。

    “万事万物皆对象”(女朋友)

    27965e420315d18831ac85c069487d11.png类的语法格式修饰符 class  类名 {

    属性声明;

    方法声明;

    }

    说明:修饰符public:类可以被任意访问类的正文要用{  }括起来public class Person{

    private int age ;//声明私有变量 age

    public void showAge(int i) { //声明方法showAge( )

    age = i;

    }

    }

    3.对象的创建和使用创建对象语法类名 对象名 = new 类名();Animal xb=new Animal();对象的使用对象名.对象成员的方式访问对象成员(包括属性和方法)Java中的类和对象//Animal类

    public class Animal {

    public int legs;

    public void eat(){

    System.out.println(“Eating.”);

    }

    public viod move(){

    System.out.println(“Move.”);

    }public class Zoo{

    public static void main(String args[]){

    //创建对象

    Animal xb=new Animal();

    xb.legs=4;//访问属性

    System.out.println(xb.legs);

    xb.eat();//访问方法

    xb.move();//访问方法

    }

    }

    42fdccb5ae6102348fc634a20bba993a.png4.类的成员之一: 属性语法格式

    修饰符  数据类型  属性名 = 初始化值 ;说明1: 修饰符常用的权限修饰符有:private、缺省、protected、public    其他修饰符:static、final (暂不考虑)

    说明2: 数据类型任何基本数据类型(如int、Boolean) 或 任何引用数据类型。

    说明3:属性名属于标识符,符合命名规则和规范即可。public class Person{

    private int age;//声明private变量 age

    public String name = “Lila”;//声明public变量 name

    }变量的分类:成员变量与局部变量

    b814cc00a21ca4f44c2c035288f049ea.pngclass Person{

    //1.属性

    String name;//姓名--成员变量

    int age = 1;//年龄

    boolean isMale;//是否是男性

    public void show(String nation){

    //nation:局部变量

    String color;//color:局部变量

    color = "yellow";

    }

    }

    //测试类

    class PersonTest{

    public static void main(String[] args){

    Person p = new Person();

    p.show(“USA”);

    }

    }对象属性的默认初始化赋值

    784efe2665bf8195db88953d1bc50a33.png5.类的成员之二: 方法什么是方法(method、函数):方法是类或对象行为特征的抽象,用来完成某个功能操作。在某些语言中也称为函数或过程。

    将功能封装为方法的目的是,可以实现代码重用,简化代码

    Java里的方法不能独立存在,所有的方法必须定义在类里。public class Person{

    private int age;

    public int getAge()  { //声明方法getAge()

    return age;

    }

    public void setAge(int i) {      //声明方法setAge

    age = i;//将参数i的值赋给类的成员变量age

    }

    }方法的声明格式:修饰符 返回值类型 方法名(参数类型 形参1, 参数类型 形参2, ….){

    方法体程序代码

    return 返回值;

    }

    修饰符:public,缺省,private, protected等方法的分类无返回值有返回值无形参void 方法名(){}返回值的类型 方法名(){}

    有形参void 方法名(形参列表){}返回值的类型 方法名(形参列表){}注意方法被调用一次,就会执行一次

    没有具体返回值的情况,返回值类型用关键字void表示,那么方法体中可以不必使用return语句。如果使用,仅用来结束方法。

    定义方法时,方法的结果应该返回给调用者,交由调用者处理。

    方法中只能调用方法或属性,不可以在方法内部定义方法。

    方法的重载在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。

    与返回值类型无关,只看参数列表,且参数列表必须不同。(参数个数或参数类型)。调用时,根据方法参数列表的不同来区别。//返回三个整数的和

    int add(int x,int y,int z){

    return x+y+z;

    }方法中的可变个数形参声明格式:方法名(参数的类型名 ...参数名)

    方法参数部分指定类型的参数个数是可变多个:0个,1个或多个

    可变个数形参的方法与同名的方法之间,彼此构成重载

    可变参数方法的使用与方法参数部分使用数组是一致的

    方法的参数部分有可变形参,需要放在形参声明的最后

    在一个方法的形参位置,最多只能声明一个可变个数形参//可变参数

    public void test(String a,int... b){

    for (int i : b) {

    Log.i("test:","b:" + i);

    }

    }

    6.类的成员之三: 构造器构造器的特征它具有与类相同的名称

    它不声明返回值类型。(与声明为void不同)

    不能被static、final、synchronized、abstract、native修饰,不能有return语句返回值

    构造器的作用创建对象;给对象进行初始化Person p = new Person(“Peter”,15);语法格式修饰符类名 (参数列表) {

    初始化语句;

    }//创建Animal类的实例

    //调用构造器,将legs初始化为4。

    public class Animal {

    private int legs;

    // 构造器

    public Animal() {

    legs = 4;

    }

    public void setLegs(int i) {

    legs = i;

    }

    public int getLegs() {

    return legs;

    }注意Java语言中,每个类都至少有一个构造器

    默认构造器的修饰符与所属类的修饰符一致

    一旦显式定义了构造器,则系统不再提供默认构造器

    一个类可以创建多个重载的构造器

    父类的构造器不可被子类继承

    7.类的成员之四: 代码块代码块的作用:对Java类或对象进行初始化

    代码块的分类:一个类中代码块若有修饰符, 则只能被static修饰,称为静态代码块(static block),没有使用static修饰的,为非静态代码块

    静态代码块:用static修饰的代码块可以有输出语句。

    可以对类的属性、类的声明进行初始化操作。

    不可以对非静态的属性初始化。即:不可以调用非静态的属性和方法。

    若有多个静态的代码块,那么按照从上到下的顺序依次执行。

    静态代码块的执行要先于非静态代码块。

    静态代码块随着类的加载而加载,且只执行一次。

    非静态代码块:没有static修饰的代码块可以有输出语句。

    可以对类的属性、类的声明进行初始化操作。

    除了调用非静态的结构外,还可以调用静态的变量或方法。

    若有多个非静态的代码块,那么按照从上到下的顺序依次执行。

    每次创建对象的时候,都会执行一次。且先于构造器执行。class Person {

    public static int total;

    static {

    total = 100;

    System.out.println("in static block!");

    }

    }

    public class PersonTest {

    public static void main(String[] args)

    {

    System.out.println("total = " + Person.total);

    System.out.println("total = " + Person.total);

    }

    }

    程序中成员变量赋值的执行顺序

    c73c82e524445796bb0caaef56547c08.png8.类的成员之五: 内部类内部类概念当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类。

    在Java中,允许一个类的定义位于另一个类的内部,前者称为内部类,后者称为外部类。

    内部类的名字不能与包含它的外部类类名相同;分类成员内部类(static成员内部类和非static成员内部类)

    局部内部类(不谈修饰符)、匿名内部类成员内部类作为类的成员的角色和外部类不同,Inner class还可以声明为private或protected;

    可以调用外部类的结构

    Inner class 可以声明为static的,但此时就不能再使用外层类的非static的成员变量;成员内部类作为类的角色可以在内部定义属性、方法、构造器等结构

    可以声明为abstract类 ,因此可以被其它的内部类继承

    可以声明为final的

    编译以后生成OuterClass$InnerClass.class字节码文件(也适用于局部内部类)注意非static的成员内部类中的成员不能声明为static的,只有在外部类或static的成员内部类中才可声明static成员。

    外部类访问成员内部类的成员,需要“内部类.成员”或“内部类对象.成员”的方式

    成员内部类可以直接使用外部类的所有成员,包括私有的数据

    当想要在外部类的静态成员部分使用内部类时,可以考虑内部类声明为静态的class Outer {

    private int s;

    public class Inner {

    public void mb() {

    s = 100;

    System.out.println("在内部类Inner中s=" + s);

    }

    }

    public void ma() {

    Inner i = new Inner();

    i.mb();

    }

    }

    public class InnerTest {

    public static void main(String args[]) {

    Outer o = new Outer();

    o.ma();

    }

    }

    9.结语

    62f1f43be77d23a95e5480fa80ad7d77.png

    2020-3-31:  Java基础语法(6)-注释

    2020-3-31: Java基础语法(7)-数组今日好文推荐一篇文章掌握整个JVM,JVM超详细解析!!!

    两篇文章了解进程与线程( 基础篇 )

    今日资料推荐我的Java自学之路

    展开全文
  • c++中的成员可以是另一个的对象,我们称该成员为 对象成员 当其他对象作为本类对象成员,构造时候先构造对象,再构造自身,析构的顺序则相反 class A() class B { A a; } B中有对象A作为成员,A为对象...
  • 静态成员的使用让对象之间能够共享数据,友元的使用破坏了的封装性,却给了的“朋友”对本类成员访问的特权。但是,有时候要求数据在能共享的前提下还不能被修改,也就是要实现数据的保护。常变量就是使程序...
  • 包含对象成员类

    2021-11-09 19:23:20
    将学生简化成姓名和一组考试分数后,可以使用一个包含两个成员来表示它:一个成员用于表示姓名,另一个成员用于表示分数。对于姓名,可以使用字符数组束表示,但这将限制姓名的长度。当然,也可以使用char指针和...
  • 如以下代码,当class A中有数据成员是class B时,我们在A中定义成员变量的时候,是应该使用B的指针类型、引用类型还是直接使用类型B呢? class B{ public: int _int_elem;; double _double_elem; }; // 方式一 /...
  • 点操作符:通过对象类类型的变量)访问成员函数,点操作符左侧为对象,右侧为成员(包括成员变量和成员函数)。 箭头操作符:通过指针访问成员函数,箭头操作符左侧为指针变量,右侧为成员(包括成员变量和成员...
  • C++中的成员可以是另一个的对象,我们成改成员为 对象成员; 例如: class A { } class B { A a; } B中有对象A作为成员,A为成员对象; 那么当创建B对象时,A与B 的构造和析构的顺序是谁先谁后? //手机...
  • C++不仅可以在外引用对象的公用数据成员,还可以调用对象的公用成员函数,但同样必须指出对象名,应该注意所访问的成员是公用的还是私有的,只能访问public成员,而不能访问 private成员。 stu.number=101; //假设...
  • C++允许一个对象作为另一个成员变量,但是这时其构造函数与析构函数是怎样调用的呢。 不妨写一段代码来考究一下。 class A { public: A() { cout << "A的构造函数的调用" << endl; } ~A()...
  • C++对象成员的使用

    2021-06-08 10:04:12
    对象成员的使用 在程序中经常需要访问对象中的成员,访问对象中的成员可以有三种方法: (1) 通过对象名和成员运算符访问对象中的成员; (2) 通过指向对象的指针访问对象中的成员; (3) 通过对象的引用变量访问...
  • 2.2 指向对象成员的指针 对象有地址,存放对象起始地址的指针变量就是“指向对象的指针变量”。对象中的成员也有地址,存放对象成员地址的指针变量就是“指向对象成员的指针变量”。 1.2.1 指向对象成员变量的...
  • ##创建一个 class aun(): a=8 ##测试代码 def text1(): a_text = aun() b_text = aun() aun.a =10 print("1 " + str(a_text.a)) print("2 " + str(b_text.a)) print("3 " + str(aun.a)) a_text.a =5 b_...
  • 本文实例讲述了Python面向对象程序设计变量与成员变量、方法与成员方法用法。分享给大家供大家参考,具体如下:变量与成员变量在中声明的变量我们称之为变量[静态成员变量],在init()函数中声明的变量并且...
  • ①、作用:用于描述对象的成员函数,可使用该的成员函数获取对象成员函数的信息。 ②、该拥有如下成员:  enum MethodType{Method, Signal, Slot, Constructor} 此枚举用于描述函数的类型,即:普通成员函数...
  • Java面向对象——成员摘要:本文主要介绍了的常见成员。属性属性称为成员变量,一般来讲不用赋值,因为有默认值,另外显式赋值没有意义会导致所有由此类创建对象都是此值。默认值Boolean类型成员变量的默认值...
  • 我正在制作两个不同的相关(store和item)。想法是将商店实例中销售的商品关联起来:class store:def __init__(self, co_loc_i, co_loc_ref_i, lat, lon, items=None):self.lat = latself.lon = lonself.co_loc_i = ...
  • 私有成员变量的概念,在脑海中的现象是,以private关键字声明,是的实现部分,不对外公开,不能在对象外部访问对象的私有成员变量.然而,在实现拷贝构造函数和赋值符函数时,在函数里利用对象直接访问了私有成员...
  • C++函数返回对象的引用一、代码例题二、返回引用三、返回对象 一、代码例题 #include <iostream> using namespace std; class machine; ostream& operator<<(ostream& o,const ...
  • 该getName()方法用于获取由类对象表示的实体的名称,例如接口,,数组,void等。这些名称以字符串形式返回。使用getName()方法获取成员对象名称的程序如下所示-示例importjava.lang.reflect.Constructor;import...
  • 指向对象成员函数的指针 对象的成员函数是一个函数,那么,我们可以定义一个函数指针,指向对象的成员函数。但是,该函数指针变量的定义,与普通的函数指针变量定义不同。 首先,我们先看看指向“普通函数”的...
  • java中对象调用成员变量与成员的方法介绍发布时间:2020-05-06 10:03:53来源:亿速云阅读:838作者:...使用对象访问中的成员对象名.成员变量;对象名.成员方法();成员变量的默认值:(免费学习视频教程分享:j...
  • 文章目录1、对象1.1、养猫小案例1.1.1、使用现有技术解决1.1.2、现有...对象的内存分配机制2、成员方法2.1、方法使用2.2、方法的调用机制原理2.3、成员方法的好处2.4、成员方法的定义2.5、成员方法的注意事项...
  • 对象成员变量和方法的使用
  • 方法共用的内存图
  • 使用对象访问中的成员对象名.成员变量;对象名.成员方法();成员变量的默认值:(免费学习视频教程分享:java视频教程)具体实例代码:public class StudentTest_01 {public static void main(String[] args) {//...
  • 一个成员变量如果是另一个对象,就称之为“成员对象”。包含成员对象叫封闭(enclosed class)。封闭构造函数的初始化列表当封闭对象生成并初始化时,它包含的成员对象也需要被初始化,这就会引发...
  • 1.类对象在另一个里做成员 class Date { int year; int month; }; class Student{ string name; Date t; }; 2.类对象在结构体中做成员 类对象可以在结构体中做成员。不过对象不能在联合体中做成员。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,249,380
精华内容 499,752
关键字:

类对象成员