PROJETO: Terminal
Desenvolvedor: Henrique
Data: 09/04/2026
DESCRIÇÃO:
Este projeto consiste em um terminal desenvolvido em Java, criado com o objetivo de simular o comportamento de um console interativo, permitindo a execução de comandos e a integração com diferentes partes de um sistema. Ele foi projetado para oferecer uma solução prática, leve e altamente personalizável, possibilitando que desenvolvedores utilizem o terminal tanto para aprendizado quanto para aplicações reais.
A principal função do projeto é servir como uma interface de interação entre o usuário e o sistema, onde comandos podem ser digitados, processados e executados de forma organizada. Além disso, o terminal permite que diferentes classes do sistema imprimam mensagens diretamente na interface, com suporte a cores e estilos configuráveis. Isso facilita a visualização de informações importantes, como erros, avisos, mensagens informativas e operações envolvendo arquivos.
O projeto também foi pensado para facilitar a automação de tarefas, testes de funcionalidades e gerenciamento de fluxos de trabalho. Sua estrutura modular separa claramente as responsabilidades entre interface (Terminal), lógica de comandos (Commands) e configurações visuais (TerminalConfiguration), o que torna o sistema mais organizado, escalável e fácil de manter.
Do ponto de vista de implementação, o terminal foi desenvolvido utilizando Java Swing para a interface gráfica, com um componente de texto estilizado que permite controlar cores, fonte e comportamento do usuário. Foram adicionados mecanismos para impedir a edição de comandos anteriores, manter um prompt fixo (“JV: ”) e garantir uma experiência semelhante a terminais reais. Além disso, foi implementado um sistema de configuração centralizado, onde todas as cores são definidas via RGB, permitindo total liberdade de personalização.
Outro ponto importante é a capacidade de expansão do sistema. A arquitetura modular permite adicionar novos comandos facilmente, integrar com outras classes e até evoluir o projeto para algo mais complexo, como um terminal completo com suporte a navegação de diretórios, execução de scripts e automações avançadas.
Seja para fins educacionais ou como base para projetos maiores, este terminal em Java se destaca pela simplicidade, desempenho e flexibilidade, atendendo desde iniciantes até desenvolvedores mais experientes que desejam uma solução personalizável e eficiente.
FERRAMENTAS:
O desenvolvimento do terminal em Java foi realizado utilizando um conjunto de ferramentas e tecnologias que garantem simplicidade, desempenho e facilidade de manutenção:
☕ Java
A linguagem principal do projeto. Foi escolhida por sua portabilidade, robustez e amplo suporte para desenvolvimento de aplicações desktop.
🖥️ Java Swing
Utilizada para a construção da interface gráfica do terminal. Permite criar janelas, componentes visuais e manipular eventos do usuário de forma eficiente.
🧾 JTextPane
Componente essencial para o terminal, pois possibilita:
* Inserção de texto formatado
* Aplicação de cores diferentes
* Controle detalhado do conteúdo exibido
🎨 RGB Color Model
Utilizado para definir as cores do terminal de forma personalizada, permitindo total controle visual e fácil adaptação de temas.
⚙️ JDK
Conjunto de ferramentas necessário para compilar e executar o projeto Java.
CÓDIGO FONTE:
Classe: Terminal
// Classe principal
import javax.swing.*;
import javax.swing.text.*;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
public class Terminal {
private JFrame frame;
private JTextPane textPane;
private StyledDocument doc;
private final String PROMPT = "JV: ";
private int commandStartPosition = 0;
// Instância global
private static Terminal instance;
public Terminal() {
instance = this;
frame = new JFrame("JV Terminal");
textPane = new JTextPane();
doc = textPane.getStyledDocument();
textPane.setBackground(TerminalConfiguration.BACKGROUND);
textPane.setFont(TerminalConfiguration.FONT);
textPane.setCaretColor(TerminalConfiguration.COLOR_NORMAL);
JScrollPane scrollPane = new JScrollPane(textPane);
frame.add(scrollPane);
frame.setSize(800, 500);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
appendPrompt();
textPane.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int caretPosition = textPane.getCaretPosition();
if (caretPosition < commandStartPosition) {
textPane.setCaretPosition(doc.getLength());
}
if (e.getKeyCode() == KeyEvent.VK_BACK_SPACE &&
caretPosition <= commandStartPosition) {
e.consume();
}
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
e.consume();
processCommand();
}
}
});
}
private void appendPrompt() {
try {
doc.insertString(doc.getLength(), PROMPT,
TerminalConfiguration.getStyle(TerminalConfiguration.MessageType.NORMAL));
commandStartPosition = doc.getLength();
textPane.setCaretPosition(doc.getLength());
} catch (Exception e) {
e.printStackTrace();
}
}
private void processCommand() {
try {
int length = doc.getLength();
String command = doc.getText(commandStartPosition, length - commandStartPosition).trim();
// Enter vazio
if (command.isEmpty()) {
doc.insertString(doc.getLength(), "\n", null);
appendPrompt();
return;
}
doc.insertString(doc.getLength(), "\n", null);
String result = Commands.execute(command);
if (result == null) {
appendMessage("\n Comando não reconhecido\n\n\n",
TerminalConfiguration.MessageType.ERROR);
} else if (result.equals("[CLEAR]")) {
textPane.setText("");
} else if (result.equals("[EXIT]")) {
System.exit(0);
} else {
appendFormatted(result + "\n");
}
appendPrompt();
} catch (Exception e) {
e.printStackTrace();
}
}
private void appendMessage(String message, TerminalConfiguration.MessageType type) {
try {
doc.insertString(doc.getLength(), message,
TerminalConfiguration.getStyle(type));
} catch (Exception e) {
e.printStackTrace();
}
}
private void appendFormatted(String message) {
TerminalConfiguration.MessageType type = TerminalConfiguration.MessageType.NORMAL;
if (message.startsWith("[ERROR]")) {
type = TerminalConfiguration.MessageType.ERROR;
message = message.replace("[ERROR]", "");
} else if (message.startsWith("[INFO]")) {
type = TerminalConfiguration.MessageType.INFO;
message = message.replace("[INFO]", "");
} else if (message.startsWith("[FILE]")) {
type = TerminalConfiguration.MessageType.FILE;
message = message.replace("[FILE]", "");
}
appendMessage(message, type);
}
// MÉTODO GLOBAL
public static void print(String message, TerminalConfiguration.MessageType type) {
if (instance != null) {
instance.appendMessage(message + "\n", type);
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(Terminal::new);
}
}
Classe: Commands
//Classe que verifica e executa os comandos dados pelo o usuário
public class Commands {
public static String execute(String command) {
String cmd = command.trim().toLowerCase();
switch (cmd) {
case "help":
return "[INFO] Comandos disponíveis: help, clear, exit, carregar";
case "clear":
return "[CLEAR]";
case "exit":
return "[EXIT]";
case "carregar":
SistemaArquivo.carregarArquivo();
return "[INFO] Processo finalizado\n\n\n";
default:
return null;
}
}
}
Classe: TerminalConfiguration
// Classe que gerencia as configurações de exibição do terminal
import java.awt.Color;
import java.awt.Font;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
public class TerminalConfiguration {
// Fundo e fonte
public static final Color BACKGROUND = new Color(0, 0, 0); // preto
public static final Font FONT = new Font("Consolas", Font.PLAIN, 16);
// Cores por tipo (RGB)
public static final Color COLOR_NORMAL = new Color(255, 255, 255); // branco
public static final Color COLOR_ERROR = new Color(255, 0, 0); // vermelho
public static final Color COLOR_INFO = new Color(255, 255, 0); // amarelo
public static final Color COLOR_FILE = new Color(0, 200, 255); // azul/ciano
public enum MessageType {
NORMAL,
ERROR,
INFO,
FILE
}
public static SimpleAttributeSet getStyle(MessageType type) {
SimpleAttributeSet style = new SimpleAttributeSet();
switch (type) {
case ERROR:
StyleConstants.setForeground(style, COLOR_ERROR);
break;
case INFO:
StyleConstants.setForeground(style, COLOR_INFO);
break;
case FILE:
StyleConstants.setForeground(style, COLOR_FILE);
break;
default:
StyleConstants.setForeground(style, COLOR_NORMAL);
break;
}
return style;
}
}
Classe: SistemaArquivo
// Exemplo de uso
public class SistemaArquivo {
public static void carregarArquivo() {
Terminal.print("\n Iniciando leitura...\n",
TerminalConfiguration.MessageType.INFO);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Terminal.print(" arquivo.tif carregado com sucesso\n",
TerminalConfiguration.MessageType.FILE);
}
}