版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Yes_butter/article/details/79238147
Java构造方法测试
class Child extends Father {//子类
public int ID = 0;
public Child()
{
super();//默认是一定会调用父类的构造方法的,不可以不调用
ID=1;//这个是自己的ID,父类的ID可以通过super来访问
System.out.println("我是子类的构造方法");
System.out.println("我的ID是:"+ID+"\n我父类的ID:"+super.ID);
}
public Child(Child child)
{
//默认调用了super();
this.ID=child.ID;
System.out.println("我是子类的拷贝方法");
System.out.println("我的ID是:"+ID+"\n我父类的ID:"+super.ID);
}
public int GetFatherID()//获取父类ID的方法
{
return super.ID;
}
}
public class Father {
public int ID = 0;
public Father() {
System.out.println("我是父类的构造方法");
}
public Father(Father father) {
this.ID=father.ID;
System.out.println("我是父类的拷贝构造方法");
}
static void Roleplay()
{
Father father1=new Father();
System.out.println("------------------------我是华丽的分割线------------------");
Father father2=new Father(father1);
System.out.println("------------------------我是华丽的分割线------------------");
Father father3;
father3=father1;//调用了浅拷贝构造方法,好像是类似起了一个别名的方法。类似与c++的引用
father3.ID=3;
System.out.println("Father3ID:"+father3.ID+"\nFtaher1ID:"+father1.ID);
System.out.println("------------------------我是华丽的分割线------------------");
Child child1=new Child();
System.out.println("------------------------我是华丽的分割线------------------");
Child child2=new Child(child1);
System.out.println("------------------------我是华丽的分割线------------------");
Child child3;
child3=child1;
child3.ID=18;//同样的也是调用浅拷贝构造方法,类似起了一个别名。
System.out.println("Child1的ID是:"+child1.ID+"\tChild3的父类的ID是:"+child1.GetFatherID());
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Roleplay();
}
}
关于父类的构造方法结论:
- 1.调用那个构造方法使用那个构造方法
- 2.用对象初始化对象的时候Java不会调用拷贝构造方法,而是采用了一种引用方法,给father1起了了名字叫father3,没有新的对象生成。
关于子类的构造方法结论:
1.默认调用父类的构造方法,会父类同名参数和,同名函数。可以通过super来进行对父类的内容访问。
2.用对象初始化对象的时候Java不会调用拷贝构造方法,而是采用了一种引用方法,给child1起了了名字叫child3,没有新的对象生成。
Java equals补充:
public boolean equals(Father father)
{
if(this.ID==father.ID)
return true;
else
return false;
}
public boolean equals(Object obj)
{
return true;
}
static void Equalplay()
{
Father father1=new Father();
Father father2=new Father();
System.out.println(father1==father2);
if(father1.equals(father2))
System.out.println("Yes");
}
调用之后发现实际没有覆盖==运算符,如果单纯调用.equals实现了覆盖!!!
运行结果是:
false
Yes
C++
#include<iostream>
using namespace std;
class Father
{
public:
int ID = -1;
Father()
{
ID = 0;
cout << "我是父类无参的构造函数" << endl;
}
Father(int ID)
{
this->ID = ID;
cout << "我是父类有参的构造函数" << endl;
}
Father(const Father &father)//需要传来一个引用
{
ID = father.ID;
cout << "我是父类拷贝构造方法" << endl;
}
~Father()
{
cout << ID<<":我是父类析构函数" << endl;
cout << "-------------------我是华丽的分割线--------------------" << endl;
}
};
class Child :public Father
{
public:
int ID = -2;
Child(int ID=0):Father(188)
{
if (ID == 0) {
ID = 0;
cout << "我是子类无参的构造函数" << endl;
}
else
{
this->ID = ID;
cout << "我是子类有参的构造函数" << endl;
}
}
Child(const Child &child)//默认调用无参数的父类构造函数
{
ID = child.ID;
cout << "我是子类的拷贝构造函数" << endl;
}
~Child()
{
cout <<ID<< ":我是子类的析构函数" << endl;
}
};
void RolePlay()
{
Father father1(1);//调用有参构造函数
cout << "-------------------我是华丽的分割线--------------------" << endl;
Father father2(father1);//调用拷贝构造函数
father2.ID = 2;
cout << "-------------------我是华丽的分割线--------------------" << endl;
Father father3 = father1;//调用拷贝构造函数
cout << "Father3ID:" << father3.ID << endl;
father3.ID = 3;
cout << "-------------------我是华丽的分割线--------------------" << endl;
Father father4;//调用无参构造函数,如果不写无参构造函数,则会默认生成
cout << "Father4ID:" << father4.ID << endl;
father4 = father1;//调用 运算符重载的 ‘=’,实现赋值,详细向后看!!!
cout << "Father4ID:" << father4.ID << endl;
father4.ID = 4;
cout << "-------------------我是华丽的分割线--------------------" << endl;
Child child1(11);//先调用父类的构造函数,如果不写调用父类构造函数,默认调用无参构造函数,然后调用子类有参构造函数
cout << "-------------------我是华丽的分割线--------------------" << endl;
Child child2(child1);//调用父类构造函数,同上,然后调用子类构拷贝构造函数
child2.ID = 12;
cout << "-------------------我是华丽的分割线--------------------" << endl;
Child child3 = child1;//调用拷贝构造函数。同Child child3(child1)
cout << "Child3ID:" << child3.ID << endl;
child3.ID = 13;
cout << "-------------------我是华丽的分割线--------------------" << endl;
Child child4;//调用父类构造函数,调用子类无参构造函数。
cout << "Child4ID:" << child4.ID << endl;
child4 = child1;//调用 运算符重载的 '=',实现赋值,详细向后看!!!
cout << "Child4ID:" << child4.ID << endl;
child4 .ID= 14;
cout << "-------------------我是华丽的分割线--------------------" << endl;
/*根据构造的顺序,逆序析构生成对应的对象*/
}
int main()
{
RolePlay();
system("pause");
return 0;
}
关于基(父)类构造函数结论:
- 1.调用那个构造方法使用那个构造方法
- 2.用对象初始化对象的时候c++调用拷贝构造方法,等同使用拷贝构造函数!!!
关于派生(子)类构造函数结论:
1.默认调用父类的构造方法,会覆盖父类同名参数和,同名函数。也可以通过 作用域名字来访问基类的内容。
2.用对象初始化对象的时候c++调用拷贝构造方法,等同使用拷贝构造函数!!!
C++神秘的运算符重载
//父类写一个等号重载,可以实现连等赋值调用!!!
Father& operator=(Father &father)
{
this->ID = 9999;
cout << "我是运算符=重载" << endl;
cout << "----------------------------------------------------------" << endl;
return *this;
}
结论:
- 相当于实现了等号的重新定义,可以增加相对应的功能。同时又增加了作用域的概念。相当于扩大等号的威力!!!