Operações numéricas nas concatenações entre Strings e numeros

Em java, qual a diferença no que seria impresso em cada um dos seguintes exemplos:

1) System.out.println("são " + 20 + 20 + 6);

2) System.out.println("são " + (20 + 20 + 6) );

?

Sim, existe diferença. 
Ao começar a fazer a concatenação de uma string, a operação de concatenação é feita até o final. Se for concatenada uma string com um número, esse número deixará de ser visto como um valor numérico e passará a ser visto como String. Assim também se dará com qualquer número que apareça no restante daquela concateação. Assim, se existem núemros com os quais se deseja trabalhar realmente como sendo números, é preciso fazer tais operações antes de fazer uma concatenação desejada com alguma String. Pode-se utilizar de parênteses para definir essa precedência nas operações.

No primeiro exemplo, ao colocar "são"+20 , isso já geraria um início de concatenação, por estar colocando uma string na soma. Logo, a partir daí, ia ir concatenando tudo até o final.
A saída de 1) seria: 20206

No segundo caso, um parênteses é colocado mudando a precedência: a primeira coisa a ser lida é 20+20+6. Apenas números, então serão realmente somados. Depois, seguindo a precedência, vai ser feito o "são "+ 46. 
A saída de 2) seria:46

JUnit #3

É importante nos testes abranger também as situações que precisam gerar exceções, para testar se as exceções que precisavam ser disparadas em determinado momento realmente serão.

No JUnit, como isso pode ser feito?



No JUnit isso pode ser feito colocando ao lado da anotação @Test um (expected=nomeDaException.class)

Fazendo isso, o teste será bem sucedido se em qualquer lugar dentro do método de caso de teste acontecer a exceção esperada.

Se eu preciso na verdade conferir se a exceção acontece até antes de uma linha em particular, posso colocar fail(); em alguma linha e o teste é considerado falho se a exceção não acontecer até antes daquele ponto. O teste será bem sucedido se a exceção citada em (expected=nomeDaException.class) ocorrer antes daquele ponto.


ex:

@Test (expected=nomeDaException.class)
public void exemploTesteJUnit(){

try{
obj.metodo(-1);
fail();

} catch (Exception e){
//bla bla bla
}

}


Se é esperado que a linha obj.metodo(-1) lance a exceção do tipo nomeDaException.class, caso essa exceção seja disparada por esta linha o método será considerado bem sucedido, devido ao (expected=nomeDaException.class) indicado ao lado da anotação @Test. 
Mas se chegar na linha onde está o método fail() e a exceção esperada não tiver ainda sido lançada, o teste terá falhado.

Sobre acoplamento

Acoplamento é um princípio muito importante na engenharia de software.

Acoplamento significa o quanto as classes são dependentes entre si para funcionar. Quanto maior a dependência entre as classes, maior o acoplamento.

Um alto acoplamento é algo indesejado para a arquitetura de um software, pois pode acarretar uma série de problemas de manutenção e gerenciamento, fazendo com que mudanças e evoluções feitas em determinada parte do código repercutam em diversos outros lugares. 

Para evitar chamadas desordenadas de mensagens entre objetos e consequente criação de dependências e acoplamento excessivos, podemos utilizar algumas regras para restringir essa chamada de mensagens entre objetos de modo a evitar muito acoplamento. O ideal seria que um método de um objeto faça invocações apenas dos seguintes tipos:

- pode-se chamar métodos dos objetos do tipos dos atributos da classe (não seria um problema porque a dependência com tais classes já está explicitada porque a classe já usa objetos dessas outras classes como atributos)

- pode chamar métodos dos objetos passados como parâmetro para o método (não seria um problema porque a dependência com as classes desses objetos já está explicitada por tais objetos serem pedidos como parâmetros para o método)

- pode a colaboração de outros métodos da mesma classe (ou seja, usando o this)

- pode chamar classes do próprio java (String, Calendar, etc)

Estar com essas regras em mente facilita a criação do código já com baixo acoplamento e evita que o trabalho de diminuição do acoplamento precise ser feito posteriormente quando o código talvez se mostrar problemático.