1.知识点:
 
  1>.一个类可以作为另一个类的元素。
 
  2>.当一个类的属性为列表添加另一个类名时，会默认添加另一个类的__str__(self)的返回值
 
#箱子
class Box:
#属性
    def __init__(self,b_color,b_volumn):
        self.color = b_color
        self.volumn = b_volumn
        self.rest_volumn = b_volumn
        self.b_toys = []
#方法
    def add_toys(self,toy):
        self.b_toys.append(toy.name)
        self.rest_volumn -= toy.size
    def __str__(self):
        return"箱子类:箱子颜色%s,箱子大小:%d,箱子剩余大小%d"%(self.color,self.volumn,self.rest_volumn)
    def get_toys(self):
        print(str(self.b_toys))
#玩具
class Toys:
#属性
    def __init__(self,t_name,t_size):
        self.size = t_size
        self.name = t_name
#方法
    def __str__(self):
        return"玩具的名字:%s,玩具大小:%d"%(self.name,self.size)
green_Box = Box("蓝色",100)
print(green_Box)
cat_toy = Toys("猫",15)
print(cat_toy)
green_Box.add_toys(cat_toy)
green_Box.get_toys()

 
 

除了继承关系外，另一种常用的关系是包含关系，一个类中包含了另一个类实例化的对象作为数据成员，即在类中含有类类型的数据成员。有两种包含类的方法：
 
方法一： 将数据成员定义成类的指针；
 
方法二： 直接将数据成员定义成类的实例。
 
class Subtarget{ 
    Subtarget(int Parameter1, int Parameter2){};
}  //定义一个类Subtarget，在其他类中可以像使用内置类型一样将该类的对象作为成员对象  

class Target{
    
    std::shared_ptr<Subtarget> subtarget_=nullptr; //方法一 （优选）
    Subtarget subtarget{4,8}；//方法二 （直观方法）

}
 
方法二比较直观，像使用内置类型一样直接实例化Subtarget类型。成员对象必须被初始化，内置类型初始化往往不需要输入参数，比较简洁，但自定义的类的构造函数往往需要输入参数，在构造函数初始值列表中输入大量参数并不方便。相比而言，方法一将类定义成类的指针（使用shared_ptr是为了更安全，防止使用指针时可能产生的内存泄漏），在类的声明中可以先初始化为nullptr，这样将数据成员定义成类的指针实现将类型的初始化推迟到函数定义中：
 
subtarget_.reset(new Subtarget(4,8));
 
将数据成员定义成类的指针更重要的好处是使用 多态 机制。在定义中也可以将subtarget_绑定到Subtarget的派生类中，从而实现多态。

一个类里面包含另外一个类，构造函数调用的先后关系。
 
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的构造函数。

编写一个类实现银行账户Account的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率rate”、“最小余额”，定义封装这些属性的方法。账号要自动生成。编写主类，使用银行账户类，输入、输出3个储户的上述信息。考虑：哪些属性可以设计成static属性。
 
Account.java
 

public class Account {
	private int account_number;//账号
	private int password;//密码
	private double deposit_balance;//存款余额
	private double interest_rate;//利率
	private double min_balance;//最小余额
	static int final_number=2019001;
	{
		account_number = final_number;
		System.out.printf("账号为:%d\n", account_number);
		final_number++;
	}
	
	public int getAccount_number() {
		return account_number;
	}

	public void setAccount_number(int account_number) {
		this.account_number = account_number;
	}

	public int getPassword() {
		return password;
	}

	public void setPassword(int password) {
		this.password = password;
	}

	public double getDeposit_balance() {
		return deposit_balance;
	}

	public void setDeposit_balance(double deposit_balance) {
		this.deposit_balance = deposit_balance;
	}

	public double getInterest_rate() {
		return interest_rate;
	}

	public void setInterest_rate(double interest_rate) {
		this.interest_rate = interest_rate;
	}

	public double getMin_balance() {
		return min_balance;
	}

	public void setMin_balance(double min_balance) {
		this.min_balance = min_balance;
	}

	@Override
	public String toString() {
		return "Account [账号" + account_number + ", 密码" + password + ", 存款余额"
				+ deposit_balance + ", 利率" + interest_rate + ", 最小余额" + min_balance + "]";
	}

}

 
MainClass.java
 
import java.util.Scanner;

public class MainClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner reader = new Scanner(System.in);
		Account user1 = new Account();	
		Account user2 = new Account();
		Account user3 = new Account();
		System.out.println("设置密码：");
		user1.setPassword(reader.nextInt());
		user2.setPassword(reader.nextInt());
		user3.setPassword(reader.nextInt());
		System.out.println("输入存款：");
		user1.setDeposit_balance(reader.nextDouble());
		user2.setDeposit_balance(reader.nextDouble());
		user3.setDeposit_balance(reader.nextDouble());
		System.out.println("输入利率：");
		user1.setInterest_rate(reader.nextDouble());
		user2.setInterest_rate(reader.nextDouble());
		user3.setInterest_rate(reader.nextDouble());
		System.out.println("输入最小余额：");
		user1.setMin_balance(reader.nextDouble());
		user2.setMin_balance(reader.nextDouble());
		user3.setMin_balance(reader.nextDouble());
		System.out.println(user1.toString()+'\n'+user2.toString()+'\n'+user3.toString());
	}

}

 
运行结果：
 
 
没得考虑，直接另外设置一个整数变量为static int 类型，在把值赋值给限制变量。