Private Constructor

Private Constructor
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
        Console.WriteLine( "Private Constructor" );
        // This line raise error because
        // the constructor is inaccessible
    // Creating private Constructor
        Console.WriteLine( "Welcome to Private Constructor" );
    public Geeks( string a, int b) {
        // This line raises error because
        // the constructor is inaccessible
        // Geeks obj1 = new Geeks();
        // Here, the only default
        // constructor will invoke
        Geeks obj2 = new Geeks( "Ankita" , 2);
        // Here, the data members of Geeks
        // class are directly accessed
        // because they are static members
        // and static members are accessed
        // directly with the class name
        Console.WriteLine(Geeks.name + ", " + Geeks.num);
C# | Difference between Static Constructors and Non-Static Constructors
Demonstrating Transactions Using Interface Through C#
C# Program to Count Punctuation Characters in a String
Implementing Binary Reader Using C#
Data Structures & Algorithms- Self Paced Course
Complete Interview Preparation- Self Paced Course
Practice Problems, POTD Streak, Weekly Contests & More!
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 !
Prerequisite: Constructors in C# Private Constructor is a special instance constructor present in C# language. Basically, private constructors are used in class that contains only static members. The private constructor is always declared by using a private keyword.
Note: If we don’t use any access modifier to define a constructor, then the compiler takes that constructor as a private.
prog.cs(40, 13): error CS0122: `Geeks.Geeks()’ is inaccessible due to its protection level
Explanation: In the above example, we have a class named as Geeks. Geeks class contains the private constructor, i.e. private Geeks() . In the Main method, when we are trying to access private constructor using this statement Geeks obj = new Geeks(); , the compiler will give an error because the constructor is inaccessible.
Explanation: The above example contains a class named as Geeks . This Geeks class contains two static variables, i.e. name , and num and two constructors one is a private constructor, i.e. private Geeks() and another one is default constructor with two parameters, i.e. public Geeks(string a, int b) . In the Main method, when we try to invoke private constructor using this statement Geeks obj1 = new Geeks(); will give an error because the private constructor does not allow to create instances of Geeks class. The only default constructor will invoke.
Writing code in comment?
Please use ide.geeksforgeeks.org ,
generate link and share the link here.

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
11 years, 8 months ago

Modified
5 years, 10 months ago

This question already has answers here :

1,137 2 2 gold badges 15 15 silver badges 27 27 bronze badges

Highest score (default)

Trending (recent votes count more)

Date modified (newest first)

Date created (oldest first)

9,132 146 146 gold badges 84 84 silver badges 118 118 bronze badges

74.2k 16 16 gold badges 160 160 silver badges 175 175 bronze badges

72.6k 46 46 gold badges 171 171 silver badges 229 229 bronze badges

3,986 3 3 gold badges 30 30 silver badges 39 39 bronze badges

58.2k 11 11 gold badges 116 116 silver badges 159 159 bronze badges

382k 64 64 gold badges 462 462 silver badges 594 594 bronze badges

11.3k 1 1 gold badge 28 28 silver badges 41 41 bronze badges

6,256 3 3 gold badges 34 34 silver badges 55 55 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.
Where do we need private constructor? How can we instantiate a class having private constructor?
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.
Private constructor means a user cannot directly instantiate a class. Instead, you can create objects using something like the Named Constructor Idiom , where you have static class functions that can create and return instances of a class.
The Named Constructor Idiom is for more intuitive usage of a class. The example provided at the C++ FAQ is for a class that can be used to represent multiple coordinate systems.
This is pulled directly from the link. It is a class representing points in different coordinate systems, but it can used to represent both Rectangular and Polar coordinate points, so to make it more intuitive for the user, different functions are used to represent what coordinate system the returned Point represents.
There have been a lot of other responses that also fit the spirit of why private constructors are ever used in C++ (Singleton pattern among them).
Another thing you can do with it is to prevent inheritance of your class , since derived classes won't be able to access your class' constructor. Of course, in this situation, you still need a function that creates instances of the class.
One common use is in the singleton pattern where you want only one instance of the class to exist. In that case, you can provide a static method which does the instantiation of the object. This way the number of objects instantiated of a particular class can be controlled.
private constructor are useful when you don't want your class to be instantiated by user. To instantiate such classes, you need to declare a static method, which does the 'new' and returns
the pointer.
A class with private ctors can not be put in the STL containers, as they require a copy ctor.
It is reasonable to make constructor private if there are other methods that can produce instances. Obvious examples are patterns Singleton (every call return the same instance) and Factory (every call usually create new instance).
It's common when you want to implement a singleton. The class can have a static "factory method" that checks if the class has already been instantiated, and calls the constructor if it hasn't.
For example, you can invoke a private constructor inside a friend class or a friend function.
Singleton pattern usually uses it to make sure that nobody creates more instances of the intended type.
One common use is for template-typedef workaround classes like following:
Obviously a public non-implemented constructor would work aswell, but a private construtor raises a compile time error instead of a link time error, if anyone tries to instatiate MyLibrariesSmartPointer instead of MyLibrariesSmartPointer::type , which is desireable.

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 .

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
> CHECK OUT THE COURSE

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
>> CHECK OUT THE COURSE

Learning to build your API with Spring ?

The canonical reference for building a production grade API with Spring

THE unique Spring Security education if you’re working with Java today

Focus on the Core of Spring Security 5

Focus on the new OAuth2 stack in Spring Security 5

From no experience to actually building stuff

The full guide to persistence with Spring Data JPA

The guides on building REST APIs with Spring

The high level overview of all the articles on the site.

Private constructors allow us to restrict the instantiation of a class . Simply put, they prevent the creation of class instances in any place other than the class itself.
Public and private constructors, used together, allow control over how we wish to instantiate our classes – this is known as constructor delegation.
There are several patterns and benefits to restricting explicit class instantiation, and we'll go through the most common ones in this tutorial:
Let's see how to define a private constructor :
We define private constructors similarly to public constructors; we’ve simply changed the public keyword to private .
The singleton pattern is one of the most common places we'll encounter the use of a private constructor. The private constructor allows us to restrict class instantiation to a single object instance :
We can create an instance by calling SingletonClass.getInstance() – this either returns an existing instance or creates one if this is the first instantiation. We can only instantiate this class by using the getInstance() static method.
Another common use case for private constructors is to provide a means of constructor delegation. Constructor delegation allows us to pass parameters through several different constructors while restricting initialization to specific places .
In this example, ValueTypeClass allows initialization with a value and type – but we only want to allow it for a subset of types. The general constructor must be private to ensure that only permitted types are used:
We can initialize ValueType Class via two different public constructors: one accepts an int , and the other a boolean . Each of these constructors then calls a common private constructor to complete the object initialization.
Uninstantiable classes are classes that we cannot instantiate. In this example, we'll create a class that simply contains a collection of static methods :
The StringUtils class contains a couple of static utility methods and can't be instantiated due to the private constructor.
Really, there's no need to allow object instantiation since static methods don't require an object instance to be used.
The builder pattern allows us to construct complex objects step by step, rather than having several constructors providing different ways to create the object. A private constructor restricts initialization, allowing the builder to manage object creation instead .
In this example, we've created an Employee class that holds the name , age , and department of an employee:
As we can see, we've made the Employee constructor private – therefore, we cannot instantiate the class explicitly.
We'll now add an inner Builder class to the Employee class:
The builder can now create different employees with a name , age , or department – there's no constraint on how many fields we must provide:
We've created an Employee with a name of “ baeldung ” and a department of “ Builder Pattern “. Age is not provided, so the default primitive int value of 0 will be used.
Another possible use for private constructors is to prevent subclassing of a class. If we tried to create such as subclass, it would be unable to call the super constructor . However, it's important to note that we'd normally make a class final to prevent subclassing rather than using a private constructor .
The primary use of private constructors is to restrict the instantiation of classes. Private constructors are especially useful when we want to restrict the external creation of a class .
Singletons, factories, and static method objects are examples of how restricting object instantiation can be useful to enforce a certain pattern.
Constants classes and static method classes also dictate that a class should not be instantiable. It's important to remember that we can also combine private constructors with public constructors to allow code sharing inside different public constructor definitions .
The code for these examples can be found over on GitHub .

Post

An Article

A Blog

A News

A Video

An EBook

An Interview Question

Pankaj Patel

Updated date Sep 16, 2020

79k

5

19

facebook
twitter
linkedIn
Reddit
WhatsApp

Email
Bookmark
Print
Other Artcile

Expand

Background Wha
Mature Skin
Nasty Potion For Tifa
Naked Little Pussy

Private Constructor

Report Page