1、安装PlantUML

2、安装Graphviz

brew install Graphviz               

3、uml类图用法

4、文档下载

@startuml
title uml类图用法

/'
 + 表示 public
 - 表示 private
 # 表示 protected
 ~ 表示 package private
'/
    
/'
    abstract        抽象
    abstract class  抽象(等同abstract)
    annotation      注解
    circle          圆
    ()              圆缩写形式
    class           类
    diamond         菱形
    <>              菱形写形式
    entity          实例
    enum            枚举
    interface       接口
    {static}        static

'/
  
/'
 类的关系有泛化(继承)、实现、依赖、关联等，其中关联又分为一般关联、聚合、组合。
'/
ClassA <|-- ClassB: 泛化
ClassA <|.. ClassB: 实现
ClassA <.. ClassB : 依赖
ClassA <-- ClassB : 关联
ClassA o-- ClassB : 聚合
ClassA *-- ClassB : 组合

' 泛化关系（继承关系），带三角箭头的实线，箭头从子类指向父类
/'
    class Person {
    public:
        void talk(){}
    };

    class Teacher : public Person {
    public:
        void teach(){}
    };
'/
namespace 泛化关系 #orange{
class Person {
    + void talk()
}
class Teacher {
    + void teach()
}
Person <|--[#red] Teacher
}
' 实现关系，带三角箭头的虚线，箭头从实现类指向接口类
/'
    class Runnable {
    public:
        virtual void run() = 0;
    };
    class TimeTask : public Runnable {
    public:
        void run(){}
    };
    class PeriodTask : public Runnable {
    public:
        void run(){}
    };
'/
namespace 实现关系 #green{
class Runnable<<任务>> {
    + virtual void run()
}
class TimeTask<<定时任务>> {
    + void run()
}
class PeriodTask<<周期任务>> {
    + void run()
}
Runnable <|.. TimeTask
Runnable <|.. PeriodTask
}

' 依赖关系：类A的变化会引起类B的变化，则说类B依赖于类A。
' 带箭头的虚线表示，箭头从使用类指向被依赖的类
/'
    class Car {
    public:
        void move(){}
    };
    class Driver {
    public:
        void drive(Car* car) {
            car->move();
        }
    };
'/
namespace 依赖关系 #gray{
class Car {
    + void move()
}
class Driver {
    + void drive()
}
Car <.. Driver
}

' 关联关系：对象之间一种引用关系
' 带箭头的实线表示，箭头从使用类指向被关联的类，可以是单向和双向的。
/'
    class Person {
    private:
        IdCard idcard;
    }
    class IdCard {
    private:
        int id;
        String snum;
    }
'/
namespace 单向关联关系 #yellow{
class Person {
    - IdCard idcard
}

class IdCard {
    - int id
    - String snum
}

IdCard "1" <-- "1" Person
}

/'
    class Customer;
    class Product {
    private:
        Customer* customer;
    }
    class Customer {
    private:
        std::vector<Product*> products;
    }
'/
namespace 双向关联关系 #yellow{
class Product {
    - Customer* customer
}

class Customer {
    - std::vector<Product*> products
}

Product "N" <--> "1" Customer
}

' 聚合关系：整体和部分的关系，成员关系是整体对象的一部分，但是成员对象可以脱离整体对象独立存在。
' 如：车和轮胎是整体和部分的关系
' 带空心菱形的实线表示，菱形指向整体。
/'
    class Car {
    private:
        Tire tire;
    }
    class Tire {
    private:
        double radius;
        double perimeter;
    }

'/
namespace 聚合关系 #pink{
class Car {
    - Tire tire
}
class Tire {
    - double radius
    - double perimeter
}
Car o-- Tire
}
' 组合关系：整体和部分的关系，部分和整体具有统一的生存期，部分不能脱离整体存在。
' 如：身体和鼻子
' 带实心菱形的实线表示，菱形指向整体。
/'
    class Body {
    private:
        Nose nose;
    private:
        class Nose {
        }
    }
'/
namespace 组合关系 #purple{
class Body {
    - Nose nose
}

class Nose {
}

Body *-- Nose
}

@enduml

原文地址：http://www.cnblogs.com/wandaren/p/16825426.html