Private Static Class

Private Static Class

Sign up or log in to customize your list.

more stack exchange communities

company blog

Stack Overflow for Teams
– Start collaborating and sharing organizational knowledge.

Create a free Team
Why Teams?

Asked
9 years, 10 months ago

Modified
9 years, 10 months ago

This question already has answers here :

146 1 1 silver badge 11 11 bronze badges

Highest score (default)

Trending (recent votes count more)

Date modified (newest first)

Date created (oldest first)

47.8k 7 7 gold badges 83 83 silver badges 119 119 bronze badges

481k 98 98 gold badges 873 873 silver badges 1002 1002 bronze badges

3,233 17 17 silver badges 25 25 bronze badges

Stack Overflow

Questions
Help

Products

Teams
Advertising
Collectives
Talent

Company

About
Press
Work Here
Legal
Privacy Policy
Terms of Service
Contact Us
Cookie Settings
Cookie Policy

Stack Exchange Network

Technology

Culture & recreation

Life & arts

Science

Professional

Business

API

Data

Accept all cookies

Customize settings

Find centralized, trusted content and collaborate around the technologies you use most.
Connect and share knowledge within a single location that is structured and easy to search.
In a project that i'm currently working on I found a private static class definition. It was part of a baseclass that derived from Page. The class contains some public static methods which are used in some baseclass methods.
As the original developer of this piece of code is gone, I wonder what the benefit is. The methods only return enum values.
Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.
It falls back to sorting by highest score if no posts are trending.
If you mean a nested class, it might simply be to "namespace" the methods. Rather than have a load of static helper methods cluttering up Intellisense in the parent class, this way you can "group" methods with related functionality together.
This was probably done for encapsulation.
Having a private static class sounds like a helper class - it would make the code in the using class (the base class you are talking about) more concise and meaningful and take some incidental complexity into the private class.
Most a private static class with public static methods is a Extensions-Class which provides functionality you use in your code without making this functionality a member of your Page .
You don't want this functionality to be accessed from outer assemblies.

Site design / logo © 2022 Stack Exchange Inc; user contributions licensed under CC BY-SA . rev 2022.9.6.42960

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy .

class ClassWithPrivateField {
#privateField ;
}

class ClassWithPrivateMethod {
#privateMethod ( ) {
return 'hello world' ;
}
}

class ClassWithPrivateStaticField {
static # PRIVATE_STATIC_FIELD ;
}

class ClassWithPrivateStaticMethod {
static #privateStaticMethod ( ) {
return 'hello world' ;
}
}

class ClassWithPrivateField {
#privateField ;

constructor ( ) {
this . #privateField = 42 ;
delete this . #privateField ; // Syntax error
this . #undeclaredField = 444 ; // Syntax error
}
}

const instance = new ClassWithPrivateField ( )
instance . #privateField === 42 ; // Syntax error

class ClassWithPrivateField {
#privateField ;

constructor ( ) {
this . #privateField = 42 ;
}
}

class SubClass extends ClassWithPrivateField {
#subPrivateField ;

constructor ( ) {
super ( ) ;
this . #subPrivateField = 23 ;
}
}

new SubClass ( ) ;
// SubClass {#subPrivateField: 23}

class ClassWithPrivateStaticField {
static # PRIVATE_STATIC_FIELD ;

static publicStaticMethod ( ) {
ClassWithPrivateStaticField . # PRIVATE_STATIC_FIELD = 42 ;
return ClassWithPrivateStaticField . # PRIVATE_STATIC_FIELD ;
}

publicInstanceMethod ( ) {
ClassWithPrivateStaticField . # PRIVATE_STATIC_FIELD = 42 ;
return ClassWithPrivateStaticField . # PRIVATE_STATIC_FIELD ;
}
}

console . log ( ClassWithPrivateStaticField . publicStaticMethod ( ) ) ; // 42
console . log ( new ClassWithPrivateStaticField ( ) . publicInstanceMethod ( ) ) ; // 42

class BaseClassWithPrivateStaticField {
static # PRIVATE_STATIC_FIELD ;

static basePublicStaticMethod ( ) {
this . # PRIVATE_STATIC_FIELD = 42 ;
return this . # PRIVATE_STATIC_FIELD ;
}
}

class SubClass extends BaseClassWithPrivateStaticField { } ;

let error = null ;

try {
SubClass . basePublicStaticMethod ( ) ;
} catch ( e ) {
error = e ;
}

console . log ( error instanceof TypeError ) ;
// true
console . log ( error ) ;
// TypeError: Cannot write private member #PRIVATE_STATIC_FIELD
// to an object whose class did not declare it

class ClassWithPrivateMethod {
#privateMethod ( ) {
return 'hello world' ;
}

getPrivateMessage ( ) {
return this . #privateMethod ( ) ;
}
}

const instance = new ClassWithPrivateMethod ( ) ;
console . log ( instance . getPrivateMessage ( ) ) ;
// hello world

class ClassWithPrivateAccessor {
#message ;

get #decoratedMessage ( ) {
return ` 🎬 ${ this . #message } 🛑 ` ;
}
set #decoratedMessage ( msg ) {
this . #message = msg ;
}

constructor ( ) {
this . #decoratedMessage = 'hello world' ;
console . log ( this . #decoratedMessage ) ;
}
}

new ClassWithPrivateAccessor ( ) ;
// 🎬hello world🛑

class ClassWithPrivateStaticMethod {
static #privateStaticMethod ( ) {
return 42 ;
}

static publicStaticMethod1 ( ) {
return ClassWithPrivateStaticMethod . #privateStaticMethod ( ) ;
}

static publicStaticMethod2 ( ) {
return this . #privateStaticMethod ( ) ;
}
}

console . log ( ClassWithPrivateStaticMethod . publicStaticMethod1 ( ) === 42 ) ;
// true
console . log ( ClassWithPrivateStaticMethod . publicStaticMethod2 ( ) === 42 ) ;
// true

class Base {
static #privateStaticMethod ( ) {
return 42 ;
}
static publicStaticMethod1 ( ) {
return Base . #privateStaticMethod ( ) ;
}
static publicStaticMethod2 ( ) {
return this . #privateStaticMethod ( ) ;
}
}

class Derived extends Base { }

console . log ( Derived . publicStaticMethod1 ( ) ) ;
// 42
console . log ( Derived . publicStaticMethod2 ( ) ) ;
// TypeError: Cannot read private member #privateStaticMethod
// from an object whose class did not declare it

Web technology reference for developers
Code used to describe document style
Protocol for transmitting web resources
Interfaces for building web applications
Developing extensions for web browsers
Web technology reference for developers
Learn to structure web content with HTML
Learn to run scripts in the browser
Learn to make the web accessible to all
Frequently asked questions about MDN Plus

Class fields are public by default, but private class members can be created
by using a hash # prefix. The privacy encapsulation of these class features is
enforced by JavaScript itself.

Private members are not native to the language before this syntax existed. In prototypical inheritance, its behavior may be emulated with WeakMap objects or closures , but they can't compare to the # syntax in terms of ergonomics.
Private fields include private instance fields and private static fields.

Private instance fields are declared with # names (pronounced
" hash names "), which are identifiers prefixed with # . The
# is a part of the name itself. Private fields are accessible on
the class constructor from inside the class
declaration itself. They are used for declaration of field names as well
as for accessing a field's value.

It is a syntax error to refer to # names from out of scope.
It is also a syntax error to refer to private fields
that were not declared before they were called, or to attempt to remove
declared fields with delete .

Note: Use the in operator to check for potentially missing private fields (or private methods). This will return true if the private field or method exists, and false otherwise.
Like public fields, private fields are added at construction time in a base class, or at the point where super() is invoked in a subclass.
Note: #privateField from the ClassWithPrivateField base class is private to ClassWithPrivateField and is not accessible from the derived Subclass .
Private static fields are added to the class constructor at class evaluation time. Like their public counterparts, private static fields are only accessible on the class itself or on the this context of static methods, but not on the this context of instance methods.

There is a restriction on private static fields: Only the class which
defines the private static field can access the field. This can lead to unexpected behavior when using this .
In the following example, this refers to the SubClass class (not
the BaseClassWithPrivateStaticField class) when we try to call
SubClass.basePublicStaticMethod() , and so causes a TypeError .

Private instance methods are methods available on class instances whose access is
restricted in the same manner as private instance fields.

Private instance methods may be generator, async, or async generator functions. Private
getters and setters are also possible, although not in generator, async, or
async generator forms.

Like their public equivalent, private static methods are called on the class itself,
not instances of the class. Like private static fields, they are only accessible from
inside the class declaration.

Private static methods may be generator, async, and async generator functions.

The same restriction previously mentioned for private static fields holds
for private static methods, and similarly can lead to unexpected behavior when using
this .
In the following example, when we try to call Derived.publicStaticMethod2() ,
this refers to the Derived class (not
the Base class) and so causes a TypeError .

BCD tables only load in the browser
Last modified: Aug 8, 2022 , by MDN contributors
Your blueprint for a better internet.
Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation . Portions of this content are ©1998– 2022 by individual mozilla.org contributors. Content available under a Creative Commons license .

Was this page helpful?
Yes
No

Performance & security by Cloudflare

You cannot access betterprogramming.pub. Refresh the page or contact the site owner to request access.
Copy and paste the Ray ID when you contact the site owner.

Ray ID:

746dd7e9fe240c48

746dd7e9fe240c48 Copy

For help visit Troubleshooting guide

Come write articles for us and get featured
Learn and code with the best industry experts
Get access to ad-free content, doubt assistance and more!
Come and find your dream job with us
Difficulty Level :
Medium Last Updated :
25 Feb, 2022
// Java program to Demonstrate How to
// Implement Static and Non-static Classes
    private static String msg = "GeeksForGeeks" ;
    public static class NestedStaticClass {
        // Only static members of Outer class
        // is directly accessible in nested
        public void printMessage()
            // Try making 'message' a non-static
            // variable, there will be compiler error
                "Message from nested static class: " + msg);
        // Both static and non-static members
        // of Outer class are accessible in
            // Print statement whenever this method is
                "Message from non-static nested class: "
    public static void main(String args[])
        // Creating instance of nested Static class
        OuterClass.NestedStaticClass printer
            = new OuterClass.NestedStaticClass();
        // Calling non-static method of nested
        // Note: In order to create instance of Inner class
        // we need an Outer class instance
        // Creating Outer class instance for creating
        // non-static nested class
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner
            = outer. new InnerClass();
        // Calling non-static method of Inner class
        // We can also combine above steps in one
        // step to create instance of Inner class
        OuterClass.InnerClass innerObject
            = new OuterClass(). new InnerClass();
        // Similarly calling inner class defined method
How to Check the Accessibility of the Static and Non-Static Variables by a Static Method?
Class Loading and Static Blocks Execution Using Static Modifier in Java
Difference Between Static and Non Static Nested Class in Java
Static and non static blank final variables in Java
Understanding "static" in "public static void main" in Java
Difference between static and non-static method in Java
Difference between static and non-static variables in Java
Understanding storage of static methods and static variables in Java
Why non-static variable cannot be referenced from a static method in Java
Java Program to Check the Accessibility of an Static Variable By a Static Method
Java Program to illustrates Use of Static Inner Class
What is Class Loading and Static Blocks in Java?
Illustrate Class Loading and Static Blocks in Java Inheritance
Difference Between Singleton Pattern and Static Class in Java
Shadowing of static functions in Java
Are static local variables allowed in Java?
Assigning values to static final variables in Java
Comparison of static keyword in C++ and Java
Can we Overload or Override static methods in java ?
Static methods vs Instance methods in Java
JAVA Programming Foundation- Self Paced Course
Data Structures & Algorithms- Self Paced Course
Complete Interview Preparation- Self Paced Course
Improve your Coding Skills with Practice Try It!

A-143, 9th Floor, Sovereign Corporate Tower, Sector-136, Noida, Uttar Pradesh - 201305
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy

Got It !
Java allows a class to be defined within another class. These are called Nested Classes . Classes can be static which most developers are aware of, henceforth some classes can be made static in Java. Java supports Static Instance Variables , Static Methods , Static Block , and Static Classes. The class in which the nested class is defined is known as the Outer Class . Unlike top-level classes, Inner classes can be Static . Non-static nested classes are also known as Inner classes .
An instance of an inner class cannot be created without an instance of the outer class. Therefore, an inner class instance can access all of the members of its outer class, without using a reference to the outer class instance. For this reason, inner classes can help make programs simple and concise.
Remember: In static class, we can easily create objects.
Differences between Static and Non-static Nested Classes
The following are major differences between static nested classes and inner classes.
This article is contributed by Chandra Prakash . Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Writing code in comment?
Please use ide.geeksforgeeks.org ,
generate link and share the link here.

Preteen Masturbate
Teen Missionary Anal
Peeing Scat

Private Static Class

Report Page