import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil; //导入依赖的package包/类
private void chooseDirectoryAndMove(Project project, PsiFile myFile) {
  try {
    PsiDirectory directory = MoveClassesOrPackagesUtil.chooseDestinationPackage(project, myTargetPackage, myFile.getContainingDirectory());

    if (directory == null) {
      return;
    }
    String error = RefactoringMessageUtil.checkCanCreateFile(directory, myFile.getName());
    if (error != null) {
      Messages.showMessageDialog(project, error, CommonBundle.getErrorTitle(), Messages.getErrorIcon());
      return;
    }
    new MoveClassesOrPackagesProcessor(
            project,
            ((PsiJavaFile) myFile).getClasses(),
            new SingleSourceRootMoveDestination(PackageWrapper.create(JavaDirectoryService.getInstance().getPackage(directory)), directory), false,
            false,
            null).run();
  }
  catch (IncorrectOperationException e) {
    LOG.error(e);
  }
}
 

import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil; //导入依赖的package包/类
@NotNull
protected UsageInfo[] findUsages() {
  LOG.assertTrue(myTargetContainer != null);

  Collection<PsiReference> innerClassRefs = ReferencesSearch.search(myInnerClass).findAll();
  ArrayList<UsageInfo> usageInfos = new ArrayList<UsageInfo>(innerClassRefs.size());
  for (PsiReference innerClassRef : innerClassRefs) {
    PsiElement ref = innerClassRef.getElement();
    if (!PsiTreeUtil.isAncestor(myInnerClass, ref, true)) { // do not show self-references
      usageInfos.add(new UsageInfo(ref));
    }
  }

  final String newQName;
  if (myTargetContainer instanceof PsiDirectory) {
    final PsiDirectory targetDirectory = (PsiDirectory)myTargetContainer;
    final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(targetDirectory);
    LOG.assertTrue(aPackage != null);
    newQName = aPackage.getQualifiedName() + "." + myNewClassName;
  }
  else if (myTargetContainer instanceof PsiClass) {
    final String qName = ((PsiClass)myTargetContainer).getQualifiedName();
    if (qName != null) {
      newQName = qName + "." + myNewClassName;
    }
    else {
      newQName = myNewClassName;
    }
  }
  else {
    newQName = myNewClassName;
  }
  MoveClassesOrPackagesUtil.findNonCodeUsages(mySearchInComments, mySearchInNonJavaFiles,
                                              myInnerClass, newQName, usageInfos);
  return usageInfos.toArray(new UsageInfo[usageInfos.size()]);
}
 

import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil; //导入依赖的package包/类
@Override
public void prepareMovedFile(PsiFile file, PsiDirectory moveDestination, Map<PsiElement, PsiElement> oldToNewMap) {
  final GroovyFile groovyFile = (GroovyFile)file;
  GroovyChangeContextUtil.encodeContextInfo(groovyFile);
  for (PsiClass psiClass : groovyFile.getClasses()) {
    oldToNewMap.put(psiClass, MoveClassesOrPackagesUtil.doMoveClass(psiClass, moveDestination));
  }
}
 

import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil; //导入依赖的package包/类
@Override
public List<UsageInfo> findUsages(PsiFile psiFile, PsiDirectory newParent, boolean searchInComments, boolean searchInNonJavaFiles) {
  final List<UsageInfo> result = new ArrayList<UsageInfo>();
  final PsiPackage newParentPackage = JavaDirectoryService.getInstance().getPackage(newParent);
  final String qualifiedName = newParentPackage == null ? "" : newParentPackage.getQualifiedName();
  for (PsiClass aClass : ((GroovyFile)psiFile).getClasses()) {
    Collections.addAll(result, MoveClassesOrPackagesUtil
      .findUsages(aClass, searchInComments, searchInNonJavaFiles, StringUtil.getQualifiedName(qualifiedName, aClass.getName())));
  }
  return result.isEmpty() ? null : result;
}
 

import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil; //导入依赖的package包/类
@Override
@NotNull
protected UsageInfo[] findUsages() {
  List<UsageInfo> usageInfos = Arrays.asList(MoveClassesOrPackagesUtil.findUsages(myClass, false, false, null));
  final List<UsageInfo> usages = new ArrayList<UsageInfo>();
  PsiReference reference;
  PsiClass psiClass;

  for (int i = 0; i < usageInfos.size(); i++) {
    reference = usageInfos.get(i).getReference();
    if (reference != null) {
      psiClass = PsiTreeUtil.getParentOfType((PsiElement)reference, PsiClass.class);
      if (psiClass != null) {
        usages.add(new UsageInfo(psiClass));
      }
    }
  }

 /* final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(myClass);
  if (interfaceMethod != null && isMoved(interfaceMethod)) {
    FunctionalExpressionSearch.search(myClass).forEach(new Processor<PsiFunctionalExpression>() {
      @Override
      public boolean process(PsiFunctionalExpression expression) {
        usages.add(new UsageInfo(expression));
        return true;
      }
    });
  }*/

  return usages.toArray(new UsageInfo[usages.size()]);
}