have been searching around for this but it's a little hard to describe so i'll just ask in here. Is it possible to call void as a string?
I think an example would describe it better:
//list of voids in the other class
string[] voids = {"expand()", "show()", "yolo()"};
anotherclass class = new anotherclass();
//call to the void named expand inside the other class
class.voids[0]; //??????
Why use string array, use function pointer array!
Two good links:
link1
link2
Related
I will explain the two use-cases here:
Static method which uses an object and perform some operations and returns the same object:
// Lets assume here SomeObject contains a function putInt which store a HashMap.
public static SomeObject createIntEvent(SomeObject objectName,
final String eventName,
final int value){
objectName.putInt(eventName, value);
return objectName;
}
Static method which creates an object and perform some operations and returns the created Object:
// Lets assume here SomeObject contains a function putInt which store a HashMap.
public static SomeObject createIntEvent(final String eventName,
final int value){
SomeObject objectName = new SomeObject();
objectName.putInt(eventName, value);
return objectName;
}
For the above two examples, For Case 2 we should have createIntEvent as a synchronized method because we are creating a new object and if it is not thread safe it could cause unwanted problems. But for the case 1, I wasn't certain if the same logic applies.
Can someone please explain why the first Case should or shouldn't be synchronized?
I tried creating a sample program to do the same thing, didn't face any issue. But was wondering if there is some Design pattern which advocates this.
Thank you for your time.
In Objects in Kotlin: Create safe singletons in one line of code (KAD 27) Antonio Leiva states:
In fact, an object is just a data type with a single implementation.
I would expect to see the term instance rather than implementation used here. Is there some nuance that I am missing?
Sure it does have a single instance after all, but I believe what they meant to say is that whatever you write in an object is final and you can not override it. Even if you make it open(for argument purpose), you can not make an anonymous object out of it since the anonymous class can't be used on a SingleTon instance.
So " data type with a single implementation" means, whatever you write is the final implementation. An instance is, after all, a result of some implementation.
For reference, I am adding a decompiled code of object declaration.
public final class Test {
#NotNull
private static final String testMember = "Test";
public static final Test INSTANCE;
#NotNull
public final String getTestMember() {
return testMember;
}
private Test() {
}
static {
Test var0 = new Test();
INSTANCE = var0;
testMember = "Test";
}
}
I encountered the situation mentioned in the topic now more than once and now I want to ask in here for
other opinions, hints, explanations, why someone should/would/ do things like this:
There is an object of class A, which implements the interface I_1o
This object has a static member, a collection, typed by interface I_1.
The class A has an interface-implemented method, which is called get_instance ( key-params ).
It looks inside the collection for a specified object fitting the key params and returns the
relevant object.
Is there a name for this (design pattern, whatever), a reason, a "best practice" explanation, why this seems to be a singleton but on the other hand it is not, just recursive object holding?
If no one understands, what I mean, just let me know, I will try to clarify it then.
This sounds an awful lot like an Object Pool design pattern. Documentation here.
This looks something like this:
public class Pool
{
private static int MAX_ELEMS = 10;
private static List<Object> instances;
private static void initialise()
{
if(instances == null) {
instances = new ArrayList<Object>();
// Initialise all the objects in the list.
}
}
public static Object getInstance(String key)
{
for(Object instance : instances) {
if(instance.equals(key)) { // Just an example
return instance;
}
}
}
}
The reason for this design pattern is to avoid the expensive re-instanciation of objects. If you have a load of, for example, Server connection objects, and you want to limit the amount of connections to the server, then you implement a pattern like this. It will mean that no more than MAX_ELEMS objects exist at one time, and it also means that they are not created during use of the program; they are built during some loading period in the program.
This looks like a Registry or IdentityMap.
I'm going to preface this by saying that this is by no means a major issue, more of something I haven't really heard talked about in terms of programming language design, and I was wondering if anyone had any interesting solutions.
The crux of the problem is this. Sometimes in an object-oriented language, I want to be able to modify an object via one of its methods, but return the object itself instead of what that method returns.
to give a java example:
class MyClass{
public MyClass(List<Integer> list){
//do constructor stuff
}
public MyClass(Integer i){
//what I would like to be able to do
this((new LinkedList<Integer>).add(i));
}
}
I can't create a temporary list in the second constructor, because this() must be the first line. Obviously there are a lot of ways to do this by changing the implementation, like creating an add() method that returns the object, making it the responsibility of the function constructing the object to make the list, etc.
But, considering a lot of the time you can't/don't want to modify or create a subclass (for LinkedList) and you might not want to muddy up the calling code, being able to modify and return an object in the style of ++x could be really useful. Something like
this(#(new LinkedList).add(i) to signify you want to object, not the method return. Does anyone know of a language that allows this is some concise syntactic way? If not, would this be useful at all or am I missing something fundamental here?
Wouldn't this work?
public class MyClass{
public MyClass(List<Integer> list){
//do constructor stuff
}
public static MyClass create(Integer i) {
List<Integer> list = new new LinkedList<Integer>();
list.add(i);
MyClass myClass = new MyClass(list);
return myClass;
}
}
This is somewhat common design pattern called Factory Pattern.
I think the cleanest way to solve this is to have an initialize method called from the constructors.
class MyClass
{
public MyClass(List list){
init(list);
}
public MyClass(Integer i){
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(i);
init(list);
}
protected init(List<Integer> list)
{
// do init stuff here
}
}
Say I am calling a third-party API which returns a Post, and I want to take that and transfer properties from it into my own Post class. I have in the past had a method like public static my.Post build(their.Post post) which maps the properties how I want.
However, is it better/valid to have a constructor that accepts their.Post and does the property mapping in there? Or should there always be a separate class that does the converting, and leaves my.Post in a more POJO state?
Thanks for your thoughts!
These answers always starts with "it depends."
People generally argue against using public static methods, based on the fact that it is hard to mock them (I don't buy into that bandwagon).
This comes down to design, do you want their post to be part of your class? If you add it as a "copy" constructor then it will now be part of your class and you are dependent on changes to post. If they change their post, your code has to adapt.
The better solution is to decouple it. You would need to find some extenal method to map the two. One way is to use a static builder method (like you mentioned) or if you want to take it a step further, a more complicated solution would be to extract the information you want from their post into some type of generic collection class. Then create a constructor that will accept that constructor class. This way if they change their design your class stays in tact and all you have to do is update the mappings from their post to your generic representation of it.
public class MyPost{
public MyPost(ICollectionOfProperties props){
//copy all properties.
}
}
public static class TheirPostExtensions{
public static ICollectionOfProperties ExtractProperties(this TheirPost thePost){
return new CollectionOfProperties(){
A = thePost.PropA,
B = thePost.PropB
};
}
}
public class Example{
public Example(){
TheirPost tp = new TheirPost();
ICollectionOfProperties props = tp.ExtractProperties();
MyPost mp = new MyPost(props);
}
}