精华内容
下载资源
问答
  • 当A中包含B时,B在什么时候初始化呢? 例如: #include using namespace std; class A { public: A() { cout !" ; } }; class B { private: A a; public: B() { a = A(); cout << "B is cons

    当B中包含A类时,A在什么时候初始化呢?

    例如:

    #include<iostream>
    using namespace std;
    class A
    {
    public:
    	A()
    	{
    		cout << "A is constructed!" << endl;
    	}
    };
    class B
    {
    private:
    	A a;
    public:
    	B()
    	{
    		a = A();
    		cout << "B is constructed!" << endl;
    	}
    };
    int main()
    {
    	B b = B{};
    
    	system("pause");
    }
    A是在声明时构造还是在B()中构造呢?运行结果如下

    A is constructed!
    A is constructed!
    B is constructed!
    A构造了两次,说明A在声明时就已经调用了构造函数。

    如何只让A调用一次呢?可以使用指针解决这个问题。在A的构造函数中带有参数时,会给参数传递带来方便。

    #include<iostream>
    using namespace std;
    class A
    {
    public:
    	A()
    	{
    		cout << "A is constructed!" << endl;
    	}
    };
    class B
    {
    private:
    	A *a;
    public:
    	B()
    	{
    		a = new A();
    		cout << "B is constructed!" << endl;
    	}
    	~B()
    	{
    		delete a;
    	}
    };
    int main()
    {
    	B b = B{};
    	system("pause");
    }
    运行结果如下:

    A is constructed!
    B is constructed!



    展开全文
  • 已知一个Person包含的属性home属于Home public class Person { String name; int age; String[] hobby; Home home; 省略get、set方法等。。。 } public class Demo { public static void main(String...
  • 发表一点自己对 《C++ Primer 5th》模板那块的理解, 欢迎指正一对一友好关系在模板与另一个模板(模板或模板函数)间建立对应实例及其友好关系,为了在模板中引用另一个模板或函数的一个特定实例,必须先...

    发表一点自己对 《C++ Primer 5th》模板那块的理解, 欢迎指正

    一对一友好关系

    在类模板与另一个模板(模板类或模板函数)间建立对应实例及其友好关系,为了在类模板中引用另一个类模板或函数的一个特定实例,必须先声明另一个模板:
    方便理解和叙述,将含友元的类称为主类,将要做友元类的模板类称为客类

    //为了在类里面引用 BlobPtr<T> 和 poerator==<T> 现在类之前声明
    template <typename> class BlobPtr;
    template <typename> class Blob; 
    template <typename T>
    bool operator==(const Blob<T>&, const Blob<T>&);
    
    template <typename T>
    class Blob{
    friend class BlobPtr<T>; //客类
    friend bool operator==<T>; //主类
        (const Blob<T>&, const Blob<T>&);
    ....
    };
    
    //模板类友元运算符重载函数定义:
    template <typename T>
    bool operator==<T>(const Blob<T>& lhs, const Blob<T>& rhs)
    {
        ...
    }

    也就是说只有 BlobPtr<int> operator==<int> 才是 Blob<int> 的友元.而 BlobPtr<std::string> 不是 Blob<int> 的友元

    通用和特定的模板友好关系

    1. 将客类的每个实例都声明为主类的友元
    2. 将客类的特定实例声明为主类的友元

    对于第一种情况不需要在模板类前置声明

    template <typename T>
    class C1
    {
        //C1每个实例将拥有相同实例化的Pal声明为友元
        friend class Pal<T>;
        //Pal2所有实例都是 C1 的每个实例的友元 不需前置声明
        template <typename X> friend class Pal2;
    
    };
    

    Pal2<int>, Pal2<std::string> 都是 C1<int> 或者 C1<std::string> 的友元

    第二种情况需要前置声明

    template <typename T> class Pal;
    
    class C2 //C2不是模板类
    {
        //C2每个实例将 用C1类型实例化的Pal 声明为友元
        friend class Pal<C1>;
    
    };

    总结:

    1. 如果想将客类的所有实例作为主类每个实例的友元,那么不需要再主类前声明客类模板,也不需要声明友元时加,并且在主类内部声明客类为主类友元之前要加上客类的模板参数列表,而且还不能和主类参数名一样,如:
    template<typename T> class 主类
    {
        template <typename X> //模板参数和主类不一样
        friend 客类; 
    };
    1. 如果只想将拥有和主类相同实例的客类或模板函数作为主类的友元,那就先在主类前声明客类(带模板参数列表template), 然后在主类中声明客类friend(带模板参数,不带template)并且模板参数<T>需要和主类的参数名相同。
    template<typename > class 客类;
    template<typename T> class 主类
    {
        friend 客类<T>; //模板参数和主类一致
    };
    展开全文
  • C++中一个类包含另一个

    万次阅读 多人点赞 2018-09-18 19:39:29
    一个里面包含另外一个,构造函数调用的先后关系。 1)A的对象是B的私有成员: #include &lt;iostream&gt;  using namespace std; class A { public:  int mInt;  A()  {  cout&lt;&lt...

    一个类里面包含另外一个类,构造函数调用的先后关系。

    1)A类的对象是B类的私有成员:
    #include <iostream> 
    using namespace std;
    class A {
    public:
        int mInt;
        A()
        {
            cout<< "in A Default Constructor:mInt = " << mInt<< endl;
            mInt = 0;
        }
        void setIntVal(int mSet)
        {
            cout<< "in setIntVal:mInt = " << mInt<<"mSet="<< mSet<< endl;
            if (mInt< mSet)
            {
                mInt= mSet;
            }
        }
    };

    class B{
    private:
        int b;
        A aObj;     //A类的对象
    public:
        B()
        {
            cout<< "in B Default Constructor"<< endl;
            b = 10;
            aObj.setIntVal(20);
        }
    };

    int main() 
    {
        B * pB = new B();
        delete pB;
        return 0;
    }

    执行结果:

    在主函数中new B的时候,先调用A的构造函数,再调用B的构造函数。


    2)指向A类对象的指针是B类的私有成员:

    #include <iostream> 
    using namespace std;
    class A {
    public:
        int mInt;
        A()
        {
            cout<< "in A Default Constructor:mInt = " << mInt<< endl;
            mInt = 0;
        }
        void setIntVal(int mSet)
        {
            cout<< "in setIntVal:mInt = " << mInt<<"mSet="<< mSet<< endl;
            if (mInt< mSet)
            {
                mInt= mSet;
            }
        }
    };

    class B{
    private:
        int b;
        A *pA;   //指向A类对象的指针
    public:
        B()
        {
            cout<< "in B Default Constructor"<< endl;
            b = 10;
            pA = new A();
            pA->setIntVal(15);

        }
    };

    int main() 
    {
        B * pB = new B();
        delete pB;
        return 0;
    }

    执行结果:

    在主函数中new B的时候,先调用B的构造函数,B的构造函数中有new A的操作,则调用A的构造函数。

    展开全文
  • Java-之间的关系之包含类之间的关系包含 之间的关系 之间的关系有三种: A is- a B 泛化 (继承 实现) A has-a B 包含 (组合 聚合 关联) A use-a B 依赖 (依赖) 包含 包含关系表现形式...

    Java-类与类之间的关系之包含

    类与类之间的关系

    类与类之间的关系有三种:
    A is- a B 泛化 (继承 实现)
    A has-a B 包含 (组合 聚合 关联)
    A use-a B 依赖 (依赖)

    包含

    包含关系表现形式为:一个类的对象当作另一个类的属性。

    包含又分为:组合,聚合,关联。它们都属于整体和部分的关系,但是有以下区别:

    组合 聚合 关联
    不可分割,要出现都出现,要消亡都消亡 创建时有可能是分开的 可以分割

    举个栗子:
    定义两个类,一个Car类,一个Wheel类,两个类为包含关系。
    Class Car代码如下:

    public class Car {
    	// 属性
    	public String brand;
    	public String type;
    	public String color;
    	public Wheel wheel;
    	
    	// 方法
    	public Car() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    	public Car(String brand, String type, String color, Wheel wheel) {
    		super();
    		this.brand = brand;
    		this.type = type;
    		this.color = color;
    		this.wheel = wheel;
    	}
    
    	public void showCar() {
    		System.out.println("这是一辆" + this.brand + "牌" + this.type + "型号" + this.color + "的小汽车");
    		System.out.println("车上搭载着" + wheel.brand + "牌的" + wheel.size + "尺寸" + wheel.color + "颜色的车轮子");
    		wheel.turn();// 方法调用
    	}
    

    Class Wheel代码如下:

    public class Wheel {
    	// 属性
    	public String brand;
    	public int size;
    	public String color;
    	
    	// 方法
    	public Wheel() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	public Wheel(String brand, int size, String color) {
    		super();
    		this.brand = brand;
    		this.size = size;
    		this.color = color;
    	}
    	
    	public void turn() {
    		System.out.println("车轮子可以旋转");
    	}
    }
    
    

    此时Wheel类被Car类座位属性使用,这就实现了类与类包含的关系。
    我们测试一下:

    import com.excample.pojo.Car;
    import com.excample.pojo.Wheel;
    
    public class CarTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Car car = new Car("BMW", "Z4", "宝石蓝", new Wheel("米其林", 400, "酷黑"));
    		car.showCar();
    		
    	}
    
    }
    

    输出结果为:

    这是一辆BMW牌Z4型号宝石蓝的小汽车
    车上搭载着米其林牌的400尺寸酷黑颜色的车轮子
    车轮子可以旋转
    
    展开全文
  • 1.按在组合的定义中出现的顺序调用内嵌对象的构造函数(与初始化列表中出现的顺序无关) 2.调用本构造函数的函数体 组合构造函数定义的一般形式一般为: 类名::类名(形参表):内嵌对象1(形参表),内嵌...
  • 如果不是静态内部,那没有什么限制! 如果你把静态嵌套当作内部的一种特例,那在这种情况下不可以访问外部的普通成员变量,而只能访问外部中的静态成员 举例: class OuterMyTest { static int i = 1; ...
  • python 之 (一个类包含一个

    千次阅读 2019-05-17 08:56:51
    一个可以作为另一个的元素。 2>.当一个的属性为列表添加另一个类名时,会默认添加另一个的__str__(self)的返回值 #箱子 class Box: #属性 def __init__(self,b_color,b_volumn): self.color = b_...
  • C++ 在包含另一个

    千次阅读 2020-08-05 09:01:27
    除了继承关系外,另一种常用的关系是包含关系,一个包含了另一个实例化的对象作为数据成员。 class Subtarget{ Subtarget(int Parameter1, int Parameter2){}; } //定义一个Subtarget,在其他类中可以像...
  • 内部类包括: 1. 常规(成员)内部类 没有用static修饰且定义在外部类类体中。常规内部类中的方法,可以直接使用外部类的实例变量和实例方法。常规内部类中可以直接使用内部类实例对象。 2. 静态内部类 与类...
  • 包括内部 还可以包含其他类 但是只有一个和文件名一样的
  • 一个内部对象可以访问创建它的外部对象的内容,内部如果不是static的,那么它可以访问创建它的外部对象的所有属性内部如果是static的,即为nested class,那么它只可以访问创建它的外部对象的所有static...
  • 使用ibatis查询,查询生成的实体包含实体的方法: xml代码: <!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" "http://www.ibatis.com/dtd/sql-map-2.dtd">
  • java一个实体类包含多个实体mybatis中怎么书写 1 java实体 TestA public class TestA { private Integer testAId; private String testAName; } 2 TestB public class TestB { private Integer testBId; ...
  • 文章目录1 内部的基本概念1.1 内部的定义1.2 内部的优缺点2 创建内部2.1 在外部外部创建非静态内部2.2 在外部外部创建静态内部2.3 在外部内部创建内部语法3 内部的分类3.1 成员内部3.2 静态...
  • 任何序列化该的尝试都会因NotSerializableException而失败,但这可以通过在Java中为其设置瞬态(trancient)变量来轻松解决。 Java序列化相关的常见问题 Java序列化是一个重要概念,但它很少用作持久性解决方案...
  • 1 内部的概念 内部是定义在另一个中的;下面B是A的内部。即内部对象引用了实例化该内部对象...内部可以对同一个包中的其他类隐藏起来。 当想要定义一个回调函数且不想编写大量代码时,使用匿名内...
  • mybatis 实体包含多个实体

    千次阅读 2019-03-27 20:25:08
    比如Shop实体中有其他的对象 那么我们通过这个shop对象分别也可以得到对应的area.name ,owner.name, shopCategory.name . 这样的话 我们怎么写sql语句呢?创建shopDao接口在Shop对象的mapper上面,怎么才算是与...
  • 画出该的UML图并实现这个。编写一个测试程序,创建两个Time 对象(使用 new Time() 和 new Time(555550000),然后显示它们的小时、分钟和秒。 ——————————————方法块: import java.util.*; /**...
  • 怎样在view里面调用其他自定义里面的函数? 我这样做程序报错: 1在view的头文件里面包含所要调用的include(port,h) 2在view的头文件里添加cport * mp; 3在view的cpp文件里调用mp->portaa(), portaa为自定义...
  • 首先 肯定的一点是一个.java的源文件中是可以包含多个的,但是public只能有一个,并且类名要和文件名相同,如果有两个public 就会报出以下的错误 这个public 类型的test2 一定要定义在其他的文件里 我们把...
  • (1) 创建一个Person的包含id, name, sex等其它的一些属性。并重写Personequals()和hashCode()两个方法,要求通过id来判断对象是否相等。 (2) 编写用户程序TestSet使用Set接口来保存Person对象,并将Set中的...
  • 什么 的概念:是具有相同属性和服务的一组对象的集合。它为属于该的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分。在面向对象的编程语言中,是一个独立的程序单位,它应该有一个...
  • 按参数可分为:有参数方法和无参数方法 按返回值类型可分为:有返回值和无返回值方法 按功能可分为:实例方法、静态方法、构造方法
  • Java 包装什么

    万次阅读 多人点赞 2018-04-26 14:29:49
     包装就是将基本的数据类型以及一些辅助方法封装到中,例如 class IntDemo { private int num; public IntDemo(int num) { this.num = num; } public int intValue() { return this.num; } } Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,885,320
精华内容 1,154,128
关键字:

其他类包括什么