In order to use @Rule, you require a class that implements TestRule(preferred) or MethodRule, as can be read here. Whereas @Before and @After require a new method to be written in every test case, @Rule does not because it is only an instantiation of already existing code.

So, if you would use @Before and @After for setUp() and tearDown() that you'll be using in many test cases, it is actually a better idea to use @Rule because of code reuse. If you have a test case that requires a unique @Before and/or @After, then these annotations are preferable.

For a bit more elaborate answer with a couple examples, take a look here. Ajit explains it very well.

Indeed, as @Quwin suggested, accoridng to JUnit 4.12 API doc,

TestRule can do everything that could be done previously with methods annotated with @Before, @After, @BeforeClass, or @AfterClass, but TestRules are (1) more powerful, and (2) more easily shared between projects and classes.

Ways that TestRules are more powerful:

There are known implementing classes of the TestRule, which are some usefuls rules you can use out-of-the-box,

For examples of how this can be useful, see these provided TestRules, or write your own:

• ErrorCollector: collect multiple errors in one test method
• ExpectedException: make flexible assertions about thrown exceptions
• ExternalResource: start and stop a server, for example
• TemporaryFolder: create fresh files, and delete after test
• TestName: remember the test name for use during the method
• TestWatcher: add logic at events during method execution
• Timeout: cause test to fail after a set time
• Verifier: fail test if object state ends up incorrect

Another benefit of rules, is that multiple rules can be used in a single test case. You may want to use RuleChain to specify the order in which the rules should be run.