<p>Sou o primeiro parágrafo</p>
<p>Sou o segundo parágrafo</p>

<script type="text/javascript">
<!--
  function definirInnerHTML(){
    var texto = "<b>Veja este texto</b>";
	
    // define o conteúdo para os elementos P
    $('p').html(texto);
  }
//-->
</script>

public static String getCaminho(String caminho);

package estudos;

import java.io.File;

public class Main {
  public static void main(String[] args) {
    // define um caminho e nome de arquivo
    String caminho = "C:\\temporario\\Java\\dica.txt";

    // vamos retornar apenas o caminho do arquivo, ou seja, retirar o
    // nome do arquivo
    String caminhoFinal = getCaminho(caminho);

    // vamos mostrar o resultado
    System.out.println("O caminho do arquivo é: " + caminhoFinal);
  }

  public static String getCaminho(String caminho){
    // vamos obter o índice da última ocorrência do separador de caminho
    int pos = caminho.lastIndexOf(File.separatorChar);
    if (pos > -1) {
       return caminho.substring(0, pos);
    }

    // por padrão vamos retornar uma string vazia
    return "";
  }
}

try{
  // código que pode provocar erros
}
catch(Tipo_Exceção nome){
  // tratamento do erro
}

import java.io.*;

public class Estudos{
  public static void main(String[] args){
    try{
      DataInputStream in = new DataInputStream(
        new BufferedInputStream(
          new FileInputStream("conteudo.txt")));
        
      while(in.available() != 0)
        System.out.print((char) in.readByte());
    } 
    catch(IOException e){
      System.out.print(e.getMessage());
    }

    System.exit(0);
  }
}  

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    String palavra = "Java";    

    Scanner in = new Scanner(System.in);
    
    System.out.print("Informe um inteiro: ");
    int indice = in.nextInt();

    try{
      System.out.println("O caractere no índice " + 
        "informado é " + palavra.charAt(indice));
    }
    catch(StringIndexOutOfBoundsException e){
      System.out.println("Erro:" + e.getMessage());
    }
  }
}

<?
  function obter_conexao_php_mysql(){
    // Parâmetros de conexão
    $server = "localhost";
    $usuario = "root";
    $senha = "osmar1234";
    $base = "estudos";
      
    // Tenta efetuar a conexão
    $conexao = mysql_connect($server, $usuario, $senha);
 
    // Testa se a conexão foi efetuada com sucesso
    if(!$conexao)
      die('Falha ao conectar: ' . mysql_error());
   
    // conexão efetuada com sucesso. Podemos definir qual
    // base de dados será usada
    $db_selected = mysql_select_db($base, $conexao);
     
    // testa se a base foi selecionada com sucesso.
    if(!$db_selected)
      die("Falha ao selecionar o banco: " . mysql_error());
       
    return $conexao;
  }
   
  function fechar_conexao_php_mysql($conn){
    mysql_close($conn);
  }
?>

<?
  require("conexao.php");
   
  // obtém a conexão com o banco MySQL
  $conexao = obter_conexao_php_mysql();
   
  /*
    Outros códigos de manipulação dos dados
    no banco de dados vão aqui
  */
   
  // fecha a conexão
  fechar_conexao_php_mysql($conexao);
?>

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // vamos declarar um array de 10 elementos
    int valores[] = new int[10];
    
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos pedir ao usuário para informar os valores para o vetor
    for(int i = 0; i < valores.length; i++){
      System.out.print("Informe o valor do elemento " + i + ": ");
      valores[i] = Integer.parseInt(entrada.nextLine()); 
    }

    // vamos mostrar o array informado
    System.out.println("\nO array informado foi:\n");
    for(int i = 0; i < valores.length; i++){
      System.out.print(valores[i] + "  ");
    }
    
    // vamos ordenar o vetor usando a ordenação Quicksort
    quickSort(valores, 0, valores.length - 1);
    
    System.out.println("\n\nO array ordenado é:\n");
    for(int i = 0; i < valores.length; i++){
      System.out.print(valores[i] + "  ");
    }
    
    System.out.println("\n\n");
  }

  // função de implementação da ordenação Quicksort
  public static void quickSort(int vetor[], int inicio, int fim) {
    // o início é menor que o fim?
    if (inicio < fim) {
      // vamos obter o novo índice da partição
      int indiceParticao = particionar(vetor, inicio, fim);

      // efetuamos novas chamadas recursivas
      quickSort(vetor, inicio, indiceParticao - 1);
      quickSort(vetor, indiceParticao + 1, fim);
    }
  }
  
  // função que retorna o índice de partição
  private static int particionar(int vetor[], int inicio, int fim) {
    // para guardar o pivô
    int pivot = vetor[fim];
    int i = (inicio - 1);
 
    for (int j = inicio; j < fim; j++) {
      if (vetor[j] <= pivot) {
        i++;

        // fazemos a troca
        int temp = vetor[i];
        vetor[i] = vetor[j];
        vetor[j] = temp;
      }
    }

    // efetua a troca
    int temp = vetor[i + 1];
    vetor[i + 1] = vetor[fim];
    vetor[fim] = temp;

    return i + 1;
  }
}