#include <iostream>
#include <string>

template<typename OutputPolicy, typename LanguagePolicy>
class HelloWorld: private OutputPolicy, private LanguagePolicy {
	using OutputPolicy::print;
	using LanguagePolicy::message;

public:
// Behaviour method
	void run() const {
// Two policy methods
		print(message());
	}
};

class OutputPolicyWriteToCout {
protected:
	template<typename MessageType>
	void print(MessageType const &message) const {
		std::cout << message << std::endl;
	}
};

class LanguagePolicyEnglish {
protected:
	std::string message() const {
		return "Hello, World!";
	}
};

class LanguagePolicyGerman {
protected:
	std::string message() const {
		return "Hallo Welt!";
	}
};

int main() {
	/* Example 1 */
	typedef HelloWorld<OutputPolicyWriteToCout, LanguagePolicyEnglish> HelloWorldEnglish;

	HelloWorldEnglish hello_world;
	hello_world.run(); // prints "Hello, World!"

	/* Example 2
	 * Does the same, but uses another language policy */
	typedef HelloWorld<OutputPolicyWriteToCout, LanguagePolicyGerman> HelloWorldGerman;

	HelloWorldGerman hello_world2;
	hello_world2.run(); // prints "Hallo Welt!"
}

import ...
public aspect TraceAspect {
        private Logger logger = Logger.getLogger(TraceAspect.class);
        
        pointcut inDomainType()
                                         : within(ajia.domain..*);
        pointcut inControllerType()
                                         : within(ajia.web..*);
        pointcut inRepositoryType()
                                         : within(ajia.repository..*);
        pointcut inTracedType()
                                         : inDomainType() || inControllerType() || inRepositoryType();
        pointcut traced()
                                         : (execution(* *(..)) || execution(new(..))) && inTracedType();
                                       
        ... advice to traced() ...
}

Dynamic crosscutting in AspectJ modifies the behavior of the modules and consists of both pointcut and advice constructs. The advice constructs provide a way to express actions at before, after, or around the desired join points. With context-collecting pointcuts, advice can support static typing that is natural to a Java programmer. The reflection support in AspectJ provides access to the join point’s static and dynamic information through a small number of interfaces. You can use this context to tailor the advice based on the actual values (method parameters or return value) being used at runtime. Alternatively, you can use this information in tracing aspects to gain more insight into the system’s inner workings. The dynamic and static information together can produce an enriched log output with a simple tracing aspect. Although dynamic crosscutting forms a major part of support for crosscutting functionality, elegant solutions need to modify the static structure of the system.