public class A{   
        public B getB(C c, D d){   
        E e = new E();   
        B b = new B(c, d, e);   
        }   
    } 

F:关联是一种结构关系，说明一个事物的对象与另一个事物的对象相联系。给定一个连接两各类的关联，可以从一个类的对象导航到另一个类的对象。
关联可以有方向，即导航。一般不作说明的时候，导航是双向的，不需要在线上标出箭头。大部分情况下导航是单向的，可以加一个箭头表示。关联在代码中一般表示为属性（成员变量），例如下面例子中 class A与B关联
 
public class A{  
    private B b;  
}  
如果B也关联到A，那么它们就是双向的关联。
public class B{  
    private A a;  
} 

G:聚合关系(Aggregation)：是关联关系的一种，是强的关联关系。聚合是整体与个体之间的关系。如汽车类与引挚类，轮胎类之间的关系就是整体与个体的关系。
与关联关系一样，聚合关系也是通过实例变量来实现的。

***关联关系所涉及的两个类是处于同一层次上的，而在聚合关系中，两个类处在不平等的层次上的，一个代表整体，一个代表部分。（关联与聚合仅仅从语法上是区分不开的，需要察所涉及的类之间的逻辑关系。）

H:组成关系(Composition)：是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表的对象负责代表部分的对象的生命周期，合成关系是不能共享的。
代表整体的对象需要负责保持对象的存活，在一些情况下负责将代表部分的对象湮灭掉。代表整体的对象可以将代表部分的对象传递给另一个对象，由后者负责此对象的生命周期。换言之，

*******代表部分的对象在每一个时刻只能与一个对象发生合成关系，由后者排它的负责其生命周期。

1、 泛化(Generalization)

很简单，就是我们常说的继承。是说子类获得父类的功能的同时，还可以扩展自己的功能。 如图:
  

Java代码中表现为：extends 和 implements

2、 依赖(Dependency)

两个相对独立的咚咚(A和B)，当A负责构造B时，A与B形成依赖关系，即A使用B。如图：

<v:shape id="_x0000_i1026" style="WIDTH: 378pt; HEIGHT: 81.75pt" type="#_x0000_t75"><v:imagedata o:title="Dependency" src="file:///D:\DOCUME~1\Yaogao\LOCALS~1\Temp\msohtml1\01\clip_image003.wmz"></v:imagedata></v:shape>

Java代码中：表现为局部变量，方法的参数，以及对静态方法的调用

3、 关联(Association )

   两个相对独立的咚咚(A和B)，当A对象持有B对象的时候，形成关联关系。

关于分为有两种特殊的形式，聚合（Aggregation）和组合（Composition），聚合和组合只有概念上的区别，在Java中的代码实现上没有区别。

聚合：指的是整体与部分的关系，如图：

组合：表示类之间整体和部分的关系，但是组合关系中部分和整体具有统一的生存期,即整体对象不存在，部分对象也将不存在，如图：

Java代码中：表现为成员变量。

4、 总结

在Java中，应该尽量优先使用组合，而不是继承，因为继承会使得类关系过于复杂化，破坏了封装性，使用组合一样可以获得已有类的功能，而且会使新类更加稳固。

实际上，从依赖 -----〉聚合--------〉组合，类与类之间的关系更加紧密，互相之间的影响越来越大，其实我们平常比较少去区分这些关系，而且事实上这东西的定义不太好理解，所以肯定会导致认识上的偏差，所以我们使用这些东西的时候，尽量靠近大家都认同的做法，这样容易让别人理解。

 java.util.ArrayList;

 java.util.List;

{
     private  String name;

     public   void  setName(String name)  {
         this .name  =  name;
    }

     public  String getName()  {
         return  name;
    }
}

{
     public   static   void  main(String[] args)  {
         //  /用泛型的效果--list的get方法取出来的对象不需要强制转换
        Fan fan1  =   new  Fan();
        fan1.setName( " fanTest1 " );
        Fan fan2  =   new  Fan();
        fan2.setName( " fanTest2 " );

        List < Fan >  list  =   new  ArrayList();
        list.add(fan1);
        list.add(fan2);

        System.out.println(list.get( 0 ).getName());
        System.out.println(list.get( 1 ).getName());

         //  /不用泛型的效果--list的get方法取出来的对象需要强制转换
        List no_list  =   new  ArrayList();
        no_list.add(fan1);
        no_list.add(fan2);

        System.out.println(((Fan) list.get( 0 )).getName());
        System.out.println(((Fan) list.get( 1 )).getName());

    }
}

首先给一个我在CSDN里查到的我们常用的例子，这个基本上天天都会用，但是从来没仔细的考虑过中间的含义，惭愧。

规则和限制
　　1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
　　2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
　　3、泛型的类型参数可以有多个。
　　4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。
　　5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(java.lang.String);

package  com.Gavin.fanxing;

public   class  GenDemo  {
     public   static   void  main(String[] args)  {
         //  定义泛型类Gen的一个Integer版本
        Gen < Integer >  intOb  =   new  Gen < Integer > ( 88 );
        intOb.showTyep();
         int  i  =  intOb.getOb();
        System.out.println( " value=  "   +  i);
        System.out.println( " ---------------------------------- " );
         //  定义泛型类Gen的一个String版本
        Gen < String >  strOb  =   new  Gen < String > ( " Hello Gen! " );
        strOb.showTyep();
        String s  =  strOb.getOb();
        System.out.println( " value=  "   +  s);
    }
}

class  Gen < T >   {
     private  T ob;  //  定义泛型成员变量

     public  Gen(T ob)  {
         this .ob  =  ob;
    }

     public  T getOb()  {
         return  ob;
    }

     public   void  setOb(T ob)  {
         this .ob  =  ob;
    }

     public   void  showTyep()  {
        System.out.println( " T的实际类型是:  "   +  ob.getClass().getName());
    }
}

package  com.Gavin.fanxing;

class  Gen2  {
     private  Object ob;  //  定义一个通用类型成员

     public  Gen2(Object ob)  {
         this .ob  =  ob;
    }

     public  Object getOb()  {
         return  ob;
    }

     public   void  setOb(Object ob)  {
         this .ob  =  ob;
    }

     public   void  showTyep()  {
        System.out.println( " T的实际类型是:  "   +  ob.getClass().getName());
    }
}

public   class  NoGenDemo  {
     public   static   void  main(String[] args)  {
         //  定义类Gen2的一个Integer版本
        Gen2 intOb  =   new  Gen2( new  Integer( 88 ));
        intOb.showTyep();
         int  i  =  (Integer) intOb.getOb();
        System.out.println( " value=  "   +  i);
        System.out.println( " ---------------------------------- " );
         //  定义类Gen2的一个String版本
        Gen2 strOb  =   new  Gen2( " Hello Gen! " );
        strOb.showTyep();
        String s  =  (String) strOb.getOb();
        System.out.println( " value=  "   +  s);
    }
}