Implement Mixin In Java? [closed]

Answer 1

Default Methods

I know the question said Java 6, but in Java 8 we'll have a pretty decent alternative: default methods.

We'll be able to add 'default' implementations of interface methods, so we can add new methods without breaking every class that implements the interface.

As long as your mixin doesn't need state, you can write code in an interface. Then your class can implement as many of these interfaces as it wants and boom, you've got mixins.

Is this an abuse of the system? A little bit, but it doesn't get into any multiple inheritance issues because there's no state.

Of course, that's also the biggest disadvantage with this approach.

Answer 2

The simplest approach is to use static imports. It allows for code reuse that 'looks' like it's part of the class, but is really defined elsewhere.

Pros:

• really easy
• you can 'mixin' as many static imports as you like

Cons:

• the static methods won't have access to 'this', so you'd have to pass it in manually
• no state: your static methods can't have their own instance fields. They can only define their own static fields, which are then shared by any object calling the static method.
• can't define public methods on the client class (the one with code being mixed into it). In Ruby, importing a mixin will actually define those public methods as public methods on your class. In Java, inheritance would be a better solution in this case (assuming you don't need to extend multiple classes)

Example:

import static my.package.MyHelperUtility.methodDefinedInAnotherClass;

public class MyNormalCode {
    public void example() {
        methodDefinedInAnotherClass();
    }
}

Answer 3

Not sure exactly what features from mixins you're looking for but much of it can be done using the decorator pattern.

http://en.wikipedia.org/wiki/Decorator_pattern#Java

Answer 4

You can do Mixins with Java now (ie 5,6,7) using AspectJ ITDs. Java 8 of course will add better capabilities with its defender methods.

Answer 5

An answer to an old question.

I took a look at Apache Zest. Maybe it was just me but I find the examples a little bit cumbersome. And I couldn't quite get the point. Another alternative may be object teams.

But I suggest you may take a look at this repo:

https://github.com/Mashashi/javaroles/

It might partially cover what you want to do. It seems simple.

Here is an example:

Defining the interface for the roles:

public interface Human {
String hello(); 
String die(String age);  
String eat();
String dance();
}

public interface Monkey {String hello(); String eat();}

Defining rigid type AnimalRoles...

public class AnimalRoles implements Human, Monkey{

public static final String HALLO = "Default hallo";
public static final String DIE = "Default they kill me...";
public static final String EAT = "Default eat...";

@ObjectForRole public Human human;

@ObjectForRole public Monkey monkey;

public AnimalRoles(Human human, Monkey monkey){
    this.human = human;
    this.monkey = monkey;
    if(this.human!=null){
        ((Portuguese)this.human).core = this;
    }
}

@Override
public String hello() {
    return HALLO;
}

@Override
public String die(String age) {
    return DIE+age;
}

@Override
@TurnOffRole
public String eat() {
    return EAT;
}

@Override
public String dance() {
    return "Just dance";
}

public String notInRole(){
    return "Oh oh";
}
}

Defining class role Bonobo...

public class Bonobo implements Monkey{
public Bonobo() {}

@Override
public String hello(){
    return "Ugauga";
}

@Override
public String eat() {
    return "Nhamnham";
}

}

Defining class role Portuguese...

@RoleObject(types = { AnimalRoles.class })
public class Portuguese implements Human{

public static final String HALLO = "Hey there";
public static final String DIE = "They killed me";
public static final String EAT = "Eating boiled pork now";

public AnimalRoles core;

public Portuguese() {}

@Override
public String hello() {
    return HALLO;
}

@Override
public String die(String age) {
    return DIE+age;
}

@Override
public String eat() {
    return EAT;
}

@Override
public String dance() {
    return core.dance()+" modified!";
}

}

Running the test...

new RoleRegisterComposition().registerRools();
AnimalRoles a = new AnimalRoles(new Portuguese(), new Bonobo());
System.out.println(a.hello());
System.out.println(a.dance());

Would print...

"Hey there"
"Dance modified!"