类的组合
组合：新的类由现有类的对象所组成（复用现有代码的功能，而非它的形式）。
举个例子：
小明没钱，但是想开豪车，想吃火锅，他想到了一个解决方法：把一个富豪绑架到家里，让他给我买个豪车，他就买了，让他给我买火锅，他就买了(组合关系，它包含在我家里了，我就可以使用它的功能了)。这个例子表示的就是类的组合关系。
接下来来看一段代码：
// 定义一个引擎类
class Engine{
// 引擎启动
public void start(){}
// 引擎关闭
public void stop(){}
}
// 定义一个车门类
class Door{
// 车门打开
public void open(){}
// 车门关闭
public void close(){}
}
// 定义一个车窗类
class Window{
// 车窗上滚
public void rollup(){}
// 车窗下滚
public void rolldown(){}
}
// 汽车类
public class Car {
Engine engine=new Engine();
Door door=new Door();
Window window=new Window();
public static void main(String[] args) {
Car car=new Car();
// 启动引擎
car.engine.start();
// 关门
car.door.close();
// 车窗下滚
car.window.rolldown();
}
}在 Java 中，类中域为基本类型时能够被自动初始化为零，对象引用会被初始化为 null。编译器并不是简单地为每一个引用都创建默认对象。若是想初始化对象引用，可以在代码中的下列位置进行：
- 在定义对象的地方。这也意味着它们会在构造器被调用之前被初始化；
- 在类的构造器中；
- 在临近使用这些对象之前，再初始化，这种方式就叫做惰性初始化；
- 使用实例初始化。
类的关联关系
关联体现的是两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。关联可以是单向、双向的。表现在代码层面，为被关联类 B 以类的属性形式出现在关联类 A 中，也可能是关联类 A 引用了一个类型为被关联类 B 的全局变量。
关联关系一般分为两类：
单向关系：单向一对一、单向一对多、单向多对一、单向多对多；
双向关系：双向一对一、双向一对多、双向多对多。
例子：公司和员工的关系。
public class Company{
int size;
String cname;
Employee employee;
public static void main(String[] args) {
Company company = new Company();
company.employee = new Employee();
System.out.println(company.employee.age);
company.employee.skill();
}
}
class Employee{
String name;
int age = 28;
Company company;
public void skill(){
System.out.print("我会开拖拉机");
}
}执行结果：
28
我会开拖拉机实战一：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
圆柱的体积公式：S=πr2h。
/**
* 任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
*/
/********** Begin **********/
// 定义一个圆类，类名为 Circle
class Circle{
// 定义两个量，分别为半径和π值
double r,pi=3.1415926;
// 有参构造器
public Circle(double r){
this.r = r;
}
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
public double area(){
double s;
s = pi*r*r;
return s;
}
}
// 定义一个公开的圆柱类 Cylinder
public class Cylinder
{
// 定义圆柱中的高
double h;
// 引用圆类
Circle c;
// 有参构造
public Cylinder(double h,Circle c)
{
this.h = h;
this.c = c;
}
/**
* 定义一个方法，该方法实现计算圆柱的体积，返回值为double
*/
public double area(){
double v;
v = c.area()*h;
return v;
}
// 定义主方法
public static void main(String[] args) {
// 通过有参构造创建圆对象，将底面半径设置为 20
Circle c = new Circle(20);
// 通过有参构造创建圆柱对象，将圆柱的高设置为 50，将圆对象传入
Cylinder cylinder = new Cylinder(50,c);
// 调用计算圆柱积的方法
double v = cylinder.area();
// 四舍五入格式化不换行输出圆柱的体积，输出格式：
System.out.printf("圆柱的体积为%.2f",v);
}
}实战二：已知圆锥的母线长为 15，底面半径为 8，求圆锥的表面积。
圆锥的表面积公式为：πr2+πrl。
也就是底面积加上圆锥的侧面积。
/**
* 任务：已知圆锥的母线为 15，底面半径为 8，求圆锥的表面积。
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个圆类，类名为 Circle
class Circle
{
// 定义两个量，分别为半径和π值
double r,pi=3.1415926;
// 有参构造器
public Circle(double r)
{
this.r = r;
}
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
public double area()
{
double s;
s = pi*r*r;
return s;
}
}
// 定义一个扇形类，类名为 Sector
class Sector
{
double r,l,pi=3.1415926;
// 有参构造器
public Sector(double r,double l)
{
this.r = r;
this.l = l;
}
// 定义一个方法，实现求圆锥侧面积，将侧面积返回，返回类型为double，
public double area()
{
double s;
s = pi*r*l;
return s;
}
}// 定义一个公开的圆锥类 Cone
public class Cone
{
Circle c;
Sector s;
public Cone(Circle c,Sector s)
{
this.c = c;
this.s = s;
}
/**
* 定义一个方法，该方法实现计算圆锥的表面积，返回值为double
*/
public double area()
{
double sum;
sum = c.area()+s.area();
return sum;
}
// 定义主方法
public static void main(String[] args)
{
// 通过有参构造创建圆对象，将底面半径设置为 8
Circle c = new Circle(8);
// 通过有参构造创建扇形对象，将扇形所需的半径和母线传入
Sector s = new Sector(8,15);
// 通过有参构造创建圆锥对象，将圆对象和矩形对象传入
Cone cone = new Cone(c,s);
// 调用计算圆锥表面积的方法
double sum = cone.area();
// 四舍五入格式化不换行输出圆锥表面积，输出格式：xx
System.out.printf("圆锥的表面积为%.2f",sum);
}
}
/********** End **********/本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
