I have the following hierarchy:  class Base {   public Base(string sMessage)   {      //Do stuff   } }  class Derived : Base {   public Derived(string someParams)   {     string sMessage = "Blah " + someParams;     //Here I want to call the base constructor    //base(sMessage);    }  }
20825
If I inherit from a base class and want to pass something from the constructor of the inherited class to the constructor of the base class, how do I do that?  For example, if I inherit from the Exception class I want to do something like this:  class MyExceptionClass : Exception {      public MyExceptionClass(string message, string extraInfo)      {          //This is where it's all falling apart          base(message);      } }   Basically what I want is to be able to pass the string message to the base Exception class.
39994
Had a conversation with a coworker the other day about this.  There's the obvious using a constructor, but what are the other ways there?
58422
What are good reasons to prohibit inheritance in Java, for example by using final classes or classes using a single, private parameterless constructor? What are good reasons of making a method final?
34071
Consider this:  public class TestClass {      private String a;     private String b;      public TestClass()     {     a = "initialized";     }      public void doSomething()     {     String c;          a.notify(); // This is fine     b.notify(); // This is fine - but will end in an exception     c.notify(); // "Local variable c may not have been initialised"     }  }   I don't get it. "b" is never initialized but will give the same run-time error as "c", which is a compile-time error. Why the difference between local variables and members?  Edit: making the members private was my initial intention, and the question still stands...
61737
I would like to use Class.newInstance() but the class I am instantiating does not have a nullary constructor. Therefore I need to be able to pass in constructor arguments. Is there a way to do this?
35959
I've been programming in C# and Java recently and I am curious where the best place is to initialize my class fields.  Should I do it at declaration?:  public class Dice {     private int topFace = 1;     private Random myRand = new Random();      public void Roll()     {        // ......     } }   or in a constructor?:  public class Dice {     private int topFace;     private Random myRand;      public Dice()     {         topFace = 1;         myRand = new Random();     }      public void Roll()     {         // .....     } }   I'm really curious what some of you veterans think is the best practice. I want to be consistent and stick to one approach.
97448
For example:  public class A : A.B {     public class B { } }   Which generates this error from the compiler:     Circular base class dependency   involving 'A' and 'A.B'   I always figured a nested class behaved just like a regular class except with special rules concerning accessing the outer class's private members, but I guess there's some implicit inheritance occurring between the two classes?
80088
When referencing class variables, why do people prepend it with this? I'm not talking about the case when this is used to disambiguate from method parameters, but rather when it seems unnecessary.  Example:  public class Person {             private String name;      public String toString() {         return this.name;     } }   In toString, why not just reference name as name?  return name;   What does this.name buy?   a stackoverflow question whose code has this pre-pending.
101176
How can I call a constructor on a memory region that is already allocated?
87888
I was reading some Java recently and came across something (an idiom?) new to me: in the program, classes with multiple constructors would also always include a blank constructor. For example:   public class Genotype {   private boolean bits[];   private int rating;   private int length;   private Random random;    public Genotype() {              //  &lt;= THIS is the bandit, this one right here     random = new Random();   }    /* creates a Random genetoype */   public Genotype(int length, Random r) {     random = r;     this.length = length;     bits = new boolean[length];      for(int i=0;i&lt;length;i++) {         bits[i] =random.nextBoolean();     }   }    /* copy constructor */   public Genotype(Genotype g,Random r) {     random = r;     bits = new boolean[g.length];     rating = g.rating;     length = g.length;      for(int i=0;i&lt;length;i++) {         bits[i] = g.bits[i];     }    } }   The first constructor doesn't seem to be a "real" constructor, it seems as though in every case one of the other constructors will be used. So why is that constructor defined at all?
78578
I want to know what a "virtual base class" is and what it means.  Let me show an example:  class Foo { public:     void DoSomething() { /* ... */ } };  class Bar : public virtual Foo { public:     void DoSpecific() { /* ... */ } };
3415
In .NET, a value type (C# struct) can't have a constructor with no parameters. According to  this is mandated by the CLI specification. What happens is that for every value-type a default constructor is created (by the compiler?) which initialized all members to zero (or null).  Why is it disallowed to define such a default constructor?  One trivial use is for rational numbers:  public struct Rational {     private long numerator;     private long denominator;      public Rational(long num, long denom)     { /* Todo: Find GCD etc. */ }      public Rational(long num)     {         numerator = num;         denominator = 1;     }      public Rational() // This is not allowed     {         numerator = 0;         denominator = 1;     } }   Using current version of C#, a default Rational is 0/0 which is not so cool.  PS: Will default parameters help solve this for C#&nbsp;4.0 or will the CLR-defined default constructor be called?     answered:     To use your example, what would you want to happen when someone did:   Rational[] fractions = new Rational[1000];       Should it run through your constructor 1000 times?   Sure it should, that's why I wrote the default constructor in the first place. The CLR should use the default zeroing constructor when no explicit default constructor is defined; that way you only pay for what you use. Then if I want a container of 1000 non-default Rationals (and want to optimize away the 1000 constructions) I will use a List&lt;Rational&gt; rather than an array.  This reason, in my mind, is not strong enough to prevent definition of a default constructor.
73206
I have two classes:  public class MyBase {     public virtual void DoMe()     {      } }  public class MyDerived:MyBase {     public override void DoMe()     {         throw  new NotImplementedException();     } }   And I have the following code to instantiate MyDerived:          MyDerived myDerived=new MyDerived();   The thing is how to call DoMe of the base class? If I use myDerived.DoMe(), then the derived method wil be called, resulting in an exception. I tried to cast myDerived to MyBase, yet it is still the derived version of the method that gets called.   Edit: As mentioned in the below comment, I can't change eitehr MyDerived or MyBase because they are not my code.
93400
What is the order in which the destructors and the constructors are called in C++? Using the examples of some Base classes and Derived Classes
27491
Suppose I have this interface  public interface IFoo {     ///&lt;summary&gt;     /// Foo method     ///&lt;/summary&gt;     void Foo();      ///&lt;summary&gt;     /// Bar method     ///&lt;/summary&gt;     void Bar();      ///&lt;summary&gt;     /// Situation normal     ///&lt;/summary&gt;     void Snafu(); }   And this class  public class Foo : IFoo {     public void Foo() { ... }     public void Bar() { ... }     public void Snafu() { ... } }   Is there a way, or is there a tool that can let me automatically put in the comments of each member in a base class or interface?  Because I hate re-writing the same comments for each derived sub-class!
54835
I'm used to writing classes like this:  public class foo {   private string mBar = "bar";   public string Bar {     get { return mBar; }     set { mBar = value; }   }   //... other methods, no constructor ... }   Converting Bar to an auto-property seems convenient and concise, but how can I retain the initialization without adding a constructor and putting the initialization in there?  public class foo2theRevengeOfFoo {   //private string mBar = "bar";   public string Bar { get; set; }   //... other methods, no constructor ...   //behavior has changed. }   You could see that adding a constructor isn't inline with the effort savings I'm supposed to be getting from auto-properties.  Something like this would make more sense to me:  public string Bar { get; set; } = "bar";
81621
If I write the following class:  public class Example {        int j;       int k;        public Example(int j, int k) {            j = j;            k = k;       }        public static void main(String[] args) {            Example exm = new Example(1,2);            System.out.println(exm.j);            System.out.println(exm.k);       }  }   The program compiles, but when I run the program, the main method will print out two 0s. I know that in order to say that I want to initialize the instance variables in the constructor I have to write:  this.j = j; this.k = k;   But if I don't write it, then which variable is evaluated (or considered) in the constructor (on the left and on the write hand side of the expressions)? Is is the argument or the instance variable? Does it make a difference?  Are there other cases where the use of this is obligatory?