Constructor initialization of instance variables

Question

If I have something like the code below as a constructor, is there a simple, shorthand way to do all the instance variable initializations in one line if all their names are the same as the parameter names?

private Quiz(int id, String name, int creatorId, Date timeCreated,
        int categoryId, boolean randomOrder, boolean multiPage,
        boolean immediateCorrection, boolean allowPractice) {
    this.id = id;
    this.name = name;
    this.creatorId = creatorId;
    this.timeCreated = timeCreated;
    this.categoryId = categoryId;
    this.randomOrder = randomOrder;
    this.multiPage = multiPage;
    this.immediateCorrection = immediateCorrection;
    this.allowPractice = allowPractice;
}

possible duplicate of Can I obtain method parameter name using Java reflection? — Nir Alfasi
– Nir Alfasi, Commented Feb 26, 2015 at 5:36
@alfasin - I was thinking along similar lines.. but this approach will be terribly slow. :) — TheLostMind
– TheLostMind, Commented Feb 26, 2015 at 5:42
if you have More number of instance variable then either you can use builder pattern or you can use Telescoping constructor pattern or JavaBeans pattern. as on effective java builder pattern is better to use. Consider a builder when faced with many constructor parameters — Prashant
– Prashant, Commented Feb 26, 2015 at 5:53

Igor Uzhviev · Accepted Answer · 2015-02-26 05:38:57Z

4

Unfortunately there is no simpler way to initialize instance variable - you have to write such initialization code in a constructor.

However all modern IDE (like IntelliJ IDEA, Eclipse, etc.) can generate such constructors automatically based on instance variables, so you don't have to write such code manually. (For instance in IntelliJ IDEA press Alt+Insert, choose Constructor, select variables which you need and the constructor code will be generated).

Also, if you have so many variables which you need to pass and initialize in the constructor (and especially if not all of them are required) - consider to use patter Builder (unfortunately you will have to write even more code!). Here is an example how to implement Builder: http://www.javacodegeeks.com/2013/01/the-builder-pattern-in-practice.html

answered Feb 26, 2015 at 5:38

Igor Uzhviev

3081 silver badge4 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Community · Accepted Answer · 2017-05-23 10:34:14Z

2

No there is not, but you should refer to the builder approach since there are a lot of parameters / arguments to the constructor in there.

The builder would make the object creation readable, less error prone and assists in thread safety as well.

Take a look at When would you use the Builder Pattern? for details and samples.

edited May 23, 2017 at 10:34

CommunityBot

11 silver badge

answered Feb 26, 2015 at 5:40

Khanna111

3,9612 gold badges26 silver badges30 bronze badges

2 Comments

TheLostMind Over a year ago

I disagree.. Builder pattern is usually used for pluggable components inside a class. I see no such thing here

Khanna111 Over a year ago

Fine, but please take a look at the link as well. All the details are there especially read Mr. Blochs statement excerpted from Effective Java.

DWoldrich · Accepted Answer · 2016-04-01 18:04:38Z

1

Project Lombok has a series of class annotations you can add to your class that will generate constructors of the kind you describe. Take a look at @NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor here:

https://projectlombok.org/features/index.html

The other annotations available in Lombok are similarly magical for removing boilerplate from your classes, take a look. Lombok is fantastic and IntelliJ Idea has good plugin support for debugging and testing Lombok-annotated classes.

answered Apr 1, 2016 at 18:04

DWoldrich

4,0671 gold badge24 silver badges22 bronze badges

Comments

Eamonn O'Brien-Strain · Accepted Answer · 2015-02-26 05:53:35Z

You can use a factory method that acts like a constructor, but actually returns an anonymous subclass of the main class. The methods of the anonymous subclass can access the factory method parameters as long as they are declared final. So this technique can only be used for fields that never change.

import java.util.Date;

abstract class Quiz{

  static Quiz newQuiz(final int id, final String name, final int creatorId, final Date timeCreated,
                      final int categoryId, final boolean randomOrder, final boolean multiPage,
                      final boolean immediateCorrection, final boolean allowPractice) {

    // Return anonymous subclass of Quiz
    return new Quiz(){

      @Override
      public String someMethod() {
        // Methods can access newQuiz parameters
        return name + creatorId + categoryId + timeCreated;
      }

      @Override
      public boolean someOtherMethod() {
        // Methods can access newQuiz parameters
        return randomOrder && multiPage && allowPractice;
      }

    };
  }

  public abstract String someMethod();
  public abstract boolean someOtherMethod();


  public static void main(String[] args) {
    Quiz quiz = Quiz.newQuiz(111, "Fred", 222, new Date(), 333, false, true, false, true);
    System.out.println(quiz.someMethod());
    System.out.println(quiz.someOtherMethod());
  }

}

Collectives™ on Stack Overflow

Constructor initialization of instance variables

4 Answers 4

Comments

2 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related