Package scope is for when other classes that are part of your package need access to a particular method or member, but the general public does not. Packages are intended to work together as a unit, with the individual classes in a package having finer-grained responsibilities. Some information and processing needs to be shared among the classes to make the package as a whole operate, but that stuff doesn't necessarily need to be seen by the user of the package.
I think one of the more common uses for protected is when you're developing an abstract class or other simple/generic/basic class that you expect others to extend, but the extending classes won't be in the same package as your class. The protected methods or memebers (I try to go with protected methods, and keep the members private when possible) would be used by the extending class, but not by the general public. My GOF book is a whole five feet away, so I'm too lazy to look, but I think the Algorithm pattern may be such a case:
package com.mycompany.mypackage;
public abstract class HighLevelAlgorithm {
public Something doIt() {
Something x new Something();
doStep1(x);
doStep2(x);
return x;
}
protected abstract void doStep1(Something x);
protected abstract void doStep2(Something x);
}
package com.othercompany.theirpackage;
import com.mycompany.mypackage.HighLevelAlgorithm;
public class AlgorithmImplementation extends HighLevelAlgorithm {
protected void doStep1(Something x) {
// othercompany's particular implementation of that step.
}
// ... etc. for step 2
}
A general user of HighLevelAlgorithm only needs to know about doIt(), not about the intermediate steps, so doStep1 and 2 are not public. However, since the implementation class is not in the same package as your abstract class, but does need to share doStep1 and 2 with the abstract class, they are protected.