code: public <E extends Model> LazyList<E> include(Class<? extends Model>... classes) {
          //TODO: why cannot call include() more than once?
          if (!includes.isEmpty()) { throw new IllegalArgumentException("Can't call include() more than once!"); }
  
          for (Class<? extends Model> clazz : classes) {
              if(!metaModel.isAssociatedTo(clazz)) throw new IllegalArgumentException("Model: " + clazz.getName() + " is not associated with: " + metaModel.getModelClass().getName());
  
          }
  
          //lets cache included classes and associations for future processing.
          for (Class includeClass : classes) {
              includes.addAll(metaModel.getAssociationsForTarget(includeClass));
          }
  
          return (LazyList<E>)this;
      }
docs: This method includes associated objects. It will eagerly load associated models of
  models selected by the query. For instance, if there are models <code>Author</code>, <code>Post</code>
  and <code>Comment</code>, where <code>Author</code> has many <code>Post</code>s and <code> Post</code>
  has many <code>Comment</code>s, then this query:
  <pre>
  List<Post> todayPosts = Post.where("post_date = ?", today).include(Author.class, Comment.class);
  </pre>
  will generate only three queries to database - one per model. All the dependencies (includes) will be
  eagerly loaded, and iteration via the <code>todayPosts</code> list will not generate any more queries,
  even when a post author and comments are requested. Use this with caution as this method can allocate
  a lot of memory (obviously).
  
  <p></p>
  
  This method will not follow relationships of related models, but rather only relationships of the current
  one.
  
  @param classes list of dependent classes. These classes represent models with which a current model has a
  relationship.
  @return instance of this <code>LazyList</code>