Static Members

In simple words#

Learning objectives#

• Explain instance vs static members
• Use static fields for shared data and constants
• Write static factory and utility methods
• Know the limits and risks of static state

Explanation#

Instance members belong to each object: every Order has its own amount. Static members belong to the class: Order.count is one number shared by all orders.

Call static members on the class, not on an object: Order.count, Math.max(), not order.count.

Good uses: constants (Order.TAX_RATE), counters and ID generators, factory methods (Order.fromCsv(line)) and utility classes (MathUtil.clamp).

A static method cannot use this to reach an object’s data, because it is not called on any object.

In C#, a static class (static class MathUtil) can only contain static members and cannot be instantiated. Be careful with mutable static state in web apps — it is shared by every request and every user.

Syntax#

1public class Order
2{
3    private static int _nextId = 1;           // shared by all orders
4    public const decimal TaxRate = 0.18m;      // constant (implicitly static)
5

6    public int Id { get; } = _nextId++;
7

8    public static Order FromCsv(string line) => new Order();   // factory
9}
10

11public static class MathUtil
12{
13    public static int Clamp(int v, int min, int max) => Math.Min(Math.Max(v, min), max);
14}

Code example: Order IDs, counters and helpers#

1class Order {
2  static #nextId = 1;        // private, shared
3  static count = 0;          // public, shared
4  static TAX_RATE = 0.18;    // constant
5

6  constructor(amount) {
7    this.id = Order.#nextId++;
8    this.amount = amount;
9    Order.count++;
10  }
11

12  get totalWithTax() {
13    return Math.round(this.amount * (1 + Order.TAX_RATE));
14  }
15

16  static fromCsv(line) {     // factory method
17    const [amount] = line.split(',');
18    return new Order(Number(amount));
19  }
20}
21

22class MathUtil {
23  static clamp(value, min, max) {
24    return Math.min(Math.max(value, min), max);
25  }
26}
27

28const a = new Order(100);
29const b = new Order(250);
30const c = Order.fromCsv('400,INR');
31

32console.log(a.id, b.id, c.id);
33console.log('Orders created:', Order.count);
34console.log(b.totalWithTax);
35console.log(a.count);
36console.log(MathUtil.clamp(150, 0, 100));

1 2 3
Orders created: 3
295
undefined
100

Step-by-step explanation#

1. Order.#nextId is shared, so each new order gets the next number.
2. Order.count is incremented by every constructor call — one counter for all orders.
3. fromCsv is a static factory: it builds an Order from text, called on the class.
4. a.count is undefined because count lives on the class, not on each object.
5. MathUtil only groups helper functions; it never needs an instance.

Real-world use case#

Common mistakes#

Best practices#

• Use static for constants, pure helpers and factory methods
• Avoid mutable static state
• Call static members through the class name
• Prefer dependency-injected services for anything with side effects

Remember this#

Practice exercise#

1class Temperature {
2  static FREEZING = 0;
3  constructor(celsius) { this.celsius = celsius; }
4  static fromFahrenheit(f) { return new Temperature(((f - 32) * 5) / 9); }
5}
6const t = Temperature.fromFahrenheit(212);
7console.log(t.celsius);                          // 100
8console.log(t.celsius > Temperature.FREEZING);   // true

Mini quiz#

class Hit { static total = 0; constructor() { Hit.total++; } }
new Hit(); new Hit(); new Hit();
console.log(Hit.total);

Want more? Practise all OOP Concepts MCQs · OOP Concepts interview questions

Related topics#

My notes#

Saved in this browser.