Konstantin's Blog

informative read.. I'm all new to JAVA develop...

2012-02-28T04:05:45.496-08:00

informative read.. I'm all new to JAVA developer community and so was looking around stuff that may acquaint me with JAVA programming. I'm enrolled in http://www.wiziq.com/course/1617-core-java-for-beginners-icse-students and people out there asked me to surf around that may help in visualizing a larger picture worldwide.

Congratulations Konstantin ! It gets even more aw...

2011-12-02T01:18:30.622-08:00

Congratulations Konstantin !

It gets even more awesome !

Just cast one of the 3 arguments to Object, Serial...

2011-11-30T06:16:07.523-08:00

Just cast one of the 3 arguments to Object, Serializable or Comparable.

The warning means something like 'I can't figure the type of T between these 3 possibilities'.

Casting one of the arguments to a "lowest com...

2011-11-22T12:15:58.552-08:00

Casting one of the arguments to a "lowest common denominator", such as (Object) "1", or (Serializable) 2 eliminates the warning.

Interestingly, the JavaC compiler does not emit a warning on the given code. Compiler bug? Language ambiguity?

public static void main( String[] args ) { Object...

2011-11-21T03:38:18.251-08:00

public static void main( String[] args )
{
Object[] items = new Object[]{"1", 2, new BigDecimal( "3.5")};
list( items );
}

private static List list( T... items )
{
return Arrays.asList( items );
}

You should choose a type. I'm not sure you ca...

2011-11-21T01:16:43.806-08:00

You should choose a type. I'm not sure you can do that without class qualification:

JavaLanguagePuzzle3.<Object>list( "1", 2, new BigDecimal( "3.5" ) );

You can choose any common super type this way.

Remove the Generic Type <T>, and replace wit...

2011-11-20T13:58:21.190-08:00

Remove the Generic Type <T>, and replace with a common supertype - in this case it would have to be "Object":

private static List<Object> list(Object... items )
{
return Arrays.asList( items );
}

I love it! Congratulations!!

2011-10-08T11:36:14.354-07:00

I love it!

Congratulations!!

I just verified that my guess was correct. The fol...

2011-06-27T20:33:23.788-07:00

I just verified that my guess was correct. The following works:

Entity entity = Entity.class.newInstance();
Factory factory = Factory.class.getConstructor(Entity.class).newInstance(entity);
Entity otherEntity = factory.create();

Add the "static" modifier to the inner F...

2011-06-27T15:57:41.972-07:00

Add the "static" modifier to the inner Factory class.

Make the Factory class static so that you don'...

2011-06-27T15:13:51.898-07:00

Make the Factory class static so that you don't need an instance of Entity to create it.

public static class Factory

InstanciationException is thrown because Factory i...

2011-06-27T15:01:03.326-07:00

InstanciationException is thrown because Factory is a inner class of Entity and therefore it can only be instanciated inside a non-static method of Entity. That code can be fixed by converting Factory to a static class.

Factory isn't a static class, needs an instanc...

2011-06-27T14:49:34.509-07:00

Factory isn't a static class, needs an instance of Entity in order to instantiate it. Possibly make it static, possibly use Constructor.newInstance() and supply an Entity.

non-static inner classes need to be instanced from...

2011-06-27T14:31:20.612-07:00

non-static inner classes need to be instanced from an instance of their outer class, since they keep a reference to the outer class in a compiler-generated field called "outer".
In this case, you could either:

- Create a Factory instance from an Entity object: new Entity().new Factory()
- change the inner class to be static, so it doesn't require an instance of the outer class to be instantiated

package puzzle; public class Entity { private...

2011-06-27T13:34:51.777-07:00

package puzzle;

public class Entity
{
private Entity()
{
}

public static class Factory
{
public Entity create()
{
return new Entity();
}
}

public static void main( String[] args ) throws Exception
{
Factory.class.newInstance();
}
}

It's because there is no Enclosing instance of...

2011-06-27T13:26:45.462-07:00

It's because there is no Enclosing instance of type Entity. You can make Factory static, but that might not be what's desired.

If you replace Factory.class.newInstance() with new Factory(), you can see this as a compile time error. You can use new Entity().new Factory().

If you want to leave Factory as a non-static inner class and still use reflection to instantiate it... well I'm not sure how to do that... looking forward to the answer.

Creating an instance of Factory requires an enclos...

2011-06-27T13:12:39.382-07:00

Creating an instance of Factory requires an enclosing instance of Entity.

Perhaps the intent was to make Factory a static inner class?

My guess: As the factory class is a non-static inn...

2011-06-27T13:04:22.813-07:00

My guess: As the factory class is a non-static inner class, it needs an instance of the outer class to exist. The main-method doesn't create an entity object. If you want to create a Factory instance in a "regular" way, by calling the constructor, you would need an Entity object and call the Factory constructor from there (e.g entity.new Factory()). To instantiate the inner class via reflection, I guess you have to get a suitable constructor using Factory.class.getConstructors() and get pass an instance of the outer class when calling it.

My guess would be that the exception is thrown bec...

2011-06-27T12:48:49.787-07:00

My guess would be that the exception is thrown because Factory is a non-static inner class and therefore a Factory instance is bound to an Entity instance. Because there is no instance in the static main method, no Factory can be created.

The solution is simply to declare the Factory class static.

Because Factory is an inner class and there's ...

2011-06-27T12:40:52.164-07:00

Because Factory is an inner class and there's no enclosing Entity instance?

The new instance is missing an enclosing instance ...

2011-06-27T12:19:05.130-07:00

The new instance is missing an enclosing instance of Entity, unless Factory is declared as a static class.

changing the factory declaration to this seems to ...

2011-06-27T12:18:30.395-07:00

changing the factory declaration to this seems to work.

public static class Factory

I suppose the "reason" is that the static method of "main" can only reach other static declarations. If factory where its own top-level class, then it wouldn't need static.

Non-static inner class Factory is only reachable v...

2011-06-27T12:15:45.019-07:00

Non-static inner class Factory is only reachable via an enclosing instance of Entity.

Fix by:
a) declaring inner class Factory as static
b) create Factory instance via an enclosing instance of entiy (but that would defeat the factories purpose)

Entity x = new Entity();
x.new Factory();

Hi Chris, Thanks for the congrats! Regarding val...

2011-03-19T13:50:41.800-07:00

Hi Chris,

Thanks for the congrats!

Regarding validation in Sapphire, you annotate properties with declarative constraints or attach custom validation logic. The framework takes care of managing validation state as it manages the property value. If value is changed, validation is refreshed. Validation state is cached so that you aren't constantly re-validating if value hasn't changed.

On the UI side, each part has validation state, which it can display locally and passes upward the parts tree. For property editor part, the validation state is tied to validation result of the property. For a section, the validation result is the combined state of all contained property editors. Etc...

Property editors display validation state with a field assist decorator that you can click on to get access to problem texts and quick fixes. Content outline nodes display their validation state with a decorator overlay.

Did I answer your question?

Hi Tom, That's sounds like it could be a very...

2011-03-19T13:39:01.647-07:00

Hi Tom,

That's sounds like it could be a very informative exercise. I will send you an e-mail and we can work out a time.