Why is it best practice to initialize the instance variable within the constructor? Clarity. Because it makes it easy to see at a glance all of the attributes of the class. If you initialize the variables in multiple methods, it becomes difficult to understand the complete data structure without reading every line of code. Initializing … Read more
Using the static initialization order problem as an excuse to not introducing this feature to the language is and always has been a matter of status quo – it wasn’t introduced because it wasn’t introduced and people keep thinking that initialization order was a reason not to introduce it, even if the order problem has … Read more
The access specifier of the primary constructor follows the name and type parameters of the type: type ValidString private (value: string) = …
@ConstructorProperties is used by some serialization frameworks to associate constructor parameters with corresponding fields and their getter and setter methods. To do this, it relies on the same common naming conventions that is used when naming getter and setter methods for fields: Getter and setter method names are usually created by capitalizing the field’s name … Read more
When talking about non-local static objects there are not many guarantees. As you already know (and it’s also been mentioned here), it should not write code that depends on that. The static initialization order fiasco… Static objects goes through a two-phase initialization: static initialization and dynamic initialization. The former happens first and performs zero-initialization or … Read more
In other words, your @ViewScoped bean behaves like a @RequestScoped bean. It’s been recreated from scratch on every postback request. There are many possible causes for this, most of which boils down that the associated JSF view is not available anymore in the JSF state which in turn is by default associated with the HTTP … Read more
This is called the placement new operator. It allows you to supply the memory the data will be allocated in without having the new operator allocate it. For example: Foo * f = new Foo(); The above will allocate memory for you. void * fm = malloc(sizeof(Foo)); Foo *f = new (fm) Foo(); The above … Read more
var myMockBOC = new Mock<BusinessObjectContext>(null, null); This will pass nulls in for your two parameters. Another approach would be to create an internal constructor meant for test usage only, and use InternalsVisibleTo to allow your test assembly to use it. Unfortunately this has a big drawback in that if you sign your assemblies, Moq is … Read more
I agree with everyone else that you should use exceptions, but if you do really need to use NULL for some reason, make the constructor private and use a factory method: static CMyClass* CMyClass::create(); This means you can’t construct instances normally though, and you can’t allocate them on the stack anymore, which is a pretty … Read more
The point of getters and setters, regardless of language, is to hide the underlying variable. This allows you to add verification logic when attempting to set a value – for example, if you had a field for a birth date, you might only want to allow setting that field to some time in the past. … Read more