Take the 2-minute tour ×

I'm trying to figure out when it would be appropriate for a class to have both static and non-static functions. AKA:

$obj = new ClassA;

$something = ClassA::doStaticStuff();

Note: This example is done in PHP, however the question is language agnostic .

It seems that if you have a class that is meant to be instantiated, any functions that can be called statically, most likely belong in another class.

Is there any viable cases where I would have a class that used static AND non-static members?

share|improve this question
Here's a pattern I've seen: class Frob { void tweak() {...} static void tweakIfNotNull(Frob f) { if (f != null) f.tweak(); } } This is mainly convenient when the method is something that needs to be recursively applied to every node in a big tree of data. Like serialize() or dispose(). Each class uses the ifNotNull version on its children. –  Jason Orendorff Jan 30 '10 at 0:48
Another pattern I've seen is where the static methods are basically a facade for the rest of the class. en.wikipedia.org/wiki/Facade_pattern –  Jason Orendorff Jan 30 '10 at 0:48
The notion of "static" isn't language-agnostic, it's quite to specific to a small number of them, and even within that set of languages, the best practice varies. –  skaffman Jan 30 '10 at 10:55
add comment

10 Answers

up vote 7 down vote accepted

One example: when Creation has to happen in a specific way.

class Foo {
  static Foo* Create(...params...);

share|improve this answer
+1: That's a usage pattern I've used several times. I find it clearer to make complex creation procedures as their own methods rather than overload the constructor (e.g. c = C::fromXml(xmldoc) rather than c = new C(xmldoc)). –  Max Shawabkeh Jan 30 '10 at 0:04
You could use a factory in this case –  Samuel Carrijo Jan 30 '10 at 0:07
This pattern is called factory method. I found it heavily used in Objective-C frameworks, although factory method should only be used for convenience constructors IMHO. –  Johannes Rudolph Jan 30 '10 at 11:14
add comment

Consider String class in .NET. It contains a non-static Split method which breaks some instance into a string[] and a static Join method, which takes a string[] and transform it into a string again.

A static method is applicable when you don't need to keep any state. So Math.Sin() just depends on its parameters and, given same parameters, output will always be the same. A non-static method can have different behavior is called multiple times, as it can keep a internal state.

share|improve this answer
add comment

If the functionality provided by static methods is relevant to that class and its objects, why not. It is pretty common.

share|improve this answer
add comment
  • Static method are most often factory methods

    public class MyClass {    
        public static MyClass createMyClass(int a, double b) {..}
        public static MyClass createSubclassOfMyClass(int c, boolean cond) {..}
        public int calculateThis();
        public double calculateThat();
  • Another use is to access some property that is logically bound that that class, but not separately to instances. For example - a cache:

(Note - of course synchronization should be taken into account in this example)

public class MyClass {
    public static final Cache cache = new Cache();
    public static void putInCacheIfNeeded(Object obj) {..}
    public static void replaceInCache(Object obj) {..}

    public void doSomethingCacheDependend(Object obj) {
        if (something) {
        } else {

(Java language for the examples)

share|improve this answer
+1, perfect answer if you'd also add private, stateless utility functions. –  Johannes Rudolph Jan 30 '10 at 11:15
add comment

Imagine your constructor has two overloads that both are strings:

public class XmlDocument
    public static XmlDocument CreateFromFile(string filePath);
    public static XmlDocument CreateFromXml(string xml);
share|improve this answer
This doesn't require static methods. You could create a class for each, or include another parameter, for instance. It's valid, though. –  Samuel Carrijo Jan 30 '10 at 0:05
Yeah, technically you could detect if the string passed in was a valid file path, and if so load from file. –  Chacha102 Jan 30 '10 at 0:06
Why would you want two classes? Also would you really want a constructor like this? public XmlDocument(string filePath, string xml) –  ChaosPandion Jan 30 '10 at 0:06
@Chacha - Does this look like JavaScript to you? :) –  ChaosPandion Jan 30 '10 at 0:07
@Chaos What? Only Javascript gets to have the fun of auto-detection arguments? :) –  Chacha102 Jan 30 '10 at 0:09
show 2 more comments

The static function can provide meaningful name to the constructor.

$dialog = DialogFoo::createOpenDialog();
$dialog = DialogFoo::createDocumentOpenDialog();
$dialog = DialogFoo::createImageOpenDialog();

It could also be used to enforce Singleton pattern.

$dialog = DialogFoo::getInstance()
share|improve this answer
add comment

Static class members are most useful where everything must either be in an object or be in a global scope; they are less useful in a language such as Python that supports module-level scopes.

share|improve this answer
add comment

I use static methods to instantiate new objects when I dont want the to give access to the constructor. I ensure that any necessary preconditions are carried out on the class before creating and object. In this example I have a counter to return how many objects are created, if I have 10 objects I prevent any more from being instantiated.

class foo {
static int count;
foo() {}

static foo bar() {
if (count<=10){
return new foo;
} else {
return null;
share|improve this answer
add comment

Let's assume a class has instance methods, here are some good use case for having static methods too:

For static utility methods

Such methods apply to any instance, for example String.format(String, Object...) in Java.

Use them when you don't want to create a specific instance for the job.

For static factory methods

Factory methods are methods that simply instantiate objects like the getInstance() and valueOf() methods in the Java API. getInstance() is the conventional instantiation method in singletons while valueOf() are often type-conversion methods, like in String.valueOf(int).

Use them to improve performance via object-caching, in interface-based frameworks (like the Collections Framework in Java) where you may want to return a subtype, to implement singletons (cough).

share|improve this answer
add comment

In general, static functions produce functionality highly related to class itself. It may be some helper functions, factory methods etc. In this case all functionality contains in one place, it correspond to DRY principle, increases cohesion and reduces coupling.

share|improve this answer
add comment

Your Answer


