1 – Cite e descreva os 3 níveis de acesso de uma classe:

------------------------------------------------------------------------------------

Os três níveis de acesso de uma classe em linguagens de programação como Java são:

1-Acesso público (public): Uma classe declarada como pública pode ser acessada de qualquer lugar,
tanto dentro do mesmo pacote quanto em pacotes diferentes. Isso significa que outras classes e objetos
podem criar instâncias dessa classe, chamar seus métodos e acessar seus membros sem restrições.

public class MinhaClasse {

// código da classe

2-Acesso protegido (protected): Uma classe com acesso protegido só pode ser acessada por outras
classes no mesmo pacote ou por subclasses dessa classe em qualquer pacote. Isso permite que as
subclasses herdem os membros e métodos da classe protegida e os utilizem, enquanto outras classes
fora do pacote não têm acesso direto a eles.

protected class MinhaClasse {

// código da classe

3-Acesso padrão (padrão ou package-private): Se uma classe não possui um modificador de acesso
explícito, ela é considerada com acesso padrão. Nesse caso, a classe pode ser acessada apenas por
outras classes dentro do mesmo pacote. Classes em pacotes diferentes não têm acesso direto a ela, a
menos que sejam subclasses dessa classe.

class MinhaClasse {

// código da classe

2 – Descreva e exemplifique Overloading e Override

------------------------------------------------------------------------------------
Overloading (sobrecarga) e Override (sobreposição) são conceitos importantes em programação
orientada a objetos. Ambos envolvem a redefinição de métodos em classes, mas com finalidades
diferentes.

Overloading (sobrecarga):

A sobrecarga ocorre quando uma classe possui vários métodos com o mesmo nome, mas com
parâmetros diferentes. Isso permite que um método seja usado com diferentes combinações de
argumentos, fornecendo flexibilidade ao programador.

Exemplo de sobrecarga de método em Java:

public class MinhaClasse {

public void somar(int a, int b) {

int resultado = a + b;

System.out.println("Soma: " + resultado);

public void somar(double a, double b) {

double resultado = a + b;

System.out.println("Soma: " + resultado);

No exemplo acima, a classe "MinhaClasse" possui dois métodos chamados "somar", um que recebe dois
inteiros e outro que recebe dois números de ponto flutuante. Ambos os métodos têm o mesmo nome,
mas aceitam tipos diferentes de parâmetros. Assim, podemos chamar o método "somar" passando
inteiros ou números de ponto flutuante, e o compilador selecionará o método apropriado com base nos
argumentos fornecidos.

MinhaClasse minhaClasse = new MinhaClasse();

minhaClasse.somar(2, 3); // Chama o método somar(int a, int b)

minhaClasse.somar(2.5, 3.7); // Chama o método somar(double a, double b)

Override (sobreposição):

A sobreposição ocorre quando uma classe herda um método de sua classe pai (superclasse) e redefine
esse método em sua própria implementação. A finalidade da sobreposição é fornecer uma
implementação personalizada do método na classe filha (subclasse) que substitua o comportamento da
classe pai.

Exemplo de sobreposição de método em Java:

public class Animal {

public void fazerSom() {

System.out.println("O animal faz um som genérico.");

public class Cachorro extends Animal {

@Override

public void fazerSom() {

System.out.println("O cachorro late.");

No exemplo acima, a classe "Cachorro" herda o método "fazerSom()" da classe "Animal" e o redefine
para imprimir a mensagem "O cachorro late". A anotação @Override é usada para indicar que o método
está sendo sobreposto, o que ajuda a detectar erros de digitação ou assinatura do método.

Animal animal = new Animal();

animal.fazerSom(); // Imprime "O animal faz um som genérico."

Cachorro cachorro = new Cachorro();

cachorro.fazerSom(); // Imprime "O cachorro late."

Ao chamar o método "fazerSom()" em um objeto do tipo "Cachorro", a implementação específica da
classe "Cachorro" é executada em vez da implementação genérica da classe "Animal". Isso demonstra a
sobreposição do método na hierarquia de herança.

3 – O que é uma interface? O que ela define e o que ela não define? O
Método implements: comente sua relação com classes concretas e
abstratas.

------------------------------------------------------------------------------------
Uma interface em programação orientada a objetos é uma coleção de métodos abstratos (sem
implementação) e constantes que definem um contrato para as classes que a implementam. Ela define
os métodos que uma classe deve implementar, sem especificar como eles devem ser implementados.

Uma interface pode ser vista como um contrato que uma classe concorda em cumprir ao implementar
essa interface. Ela define o que uma classe pode fazer, mas não como ela faz. Dessa forma, as interfaces
fornecem um meio de definir comportamentos esperados sem se preocupar com a implementação
interna de cada classe.

Uma interface pode incluir os seguintes elementos:

Métodos abstratos: São métodos sem implementação definidos na interface. Eles são declarados, mas
não são implementados. As classes que implementam a interface devem fornecer a implementação
desses métodos.

Constantes: São constantes (variáveis finais) que podem ser usadas pelas classes que implementam a
interface.

Uma interface não pode incluir:

Métodos com implementação: Uma interface não pode fornecer implementações de métodos. Ela
apenas define a assinatura (nome, parâmetros e tipo de retorno) dos métodos que devem ser
implementados pelas classes.

Variáveis de instância: Interfaces não podem ter variáveis de instância. Elas só podem ter constantes
(variáveis finais) declaradas.

A palavra-chave "implements" é usada em uma classe para indicar que ela está implementando uma ou
várias interfaces. Uma classe concreta (ou classe normal) deve fornecer implementações para todos os
métodos abstratos definidos na interface. A classe concreta deve seguir o contrato definido pela
interface e fornecer a lógica de implementação para os métodos abstratos.
4 – Cite e descreva Os conceitos de:

• Herança:

• Associação

• Agregação

• Composição

• Encapsulamento

• Polimorfismo

------------------------------------------------------------------------------------
Herança:

A herança é um conceito fundamental na programação orientada a objetos, que permite que uma classe
herde características (atributos e métodos) de outra classe, chamada classe pai ou superclasse. A classe
que herda é chamada de classe filha ou subclasse. A herança permite que a classe filha reutilize e
estenda a funcionalidade da classe pai. Isso ajuda a promover a reutilização de código, a estruturação
hierárquica e a modelagem de relacionamentos "é um".

Associação:

A associação é um relacionamento entre classes onde uma classe faz referência a outra, indicando que
elas estão relacionadas de alguma forma. Essa relação pode ser de dependência, onde uma classe usa
objetos de outra classe como parte de suas operações, mas sem uma dependência direta e permanente.
A associação também pode ser de agregação ou composição (descritas abaixo), onde uma classe possui
uma instância de outra classe como parte de sua estrutura.

Agregação:

A agregação é uma forma de associação que indica que uma classe possui uma relação "tem um" com
outra classe. Nesse tipo de relacionamento, uma classe é composta por outras classes que podem existir
independentemente dela. A classe que contém a instância de outra classe é chamada de classe
agregadora e a classe contida é chamada de classe agregada. A agregação é uma relação de todo-parte,
onde a parte pode ser compartilhada por várias classes agregadoras.

Composição:

A composição é uma forma mais forte de associação que também indica uma relação de "todo-parte".
Nesse tipo de relacionamento, a parte (classe agregada) faz parte essencial da estrutura do todo (classe
agregadora). Em outras palavras, a classe agregada não pode existir sem a classe agregadora. A
composição implica uma relação de dependência forte e duradoura entre as classes envolvidas. Quando
a classe agregadora é destruída, as instâncias da classe agregada também são destruídas.

Encapsulamento:

O encapsulamento é um princípio que combina dados e métodos relacionados em uma única unidade,
chamada de classe, e oculta os detalhes internos dessa unidade do mundo externo. Isso significa que os
atributos de uma classe são protegidos de acesso direto e só podem ser manipulados por métodos
definidos na própria classe. O encapsulamento promove a segurança, a modularidade e a reutilização do
código, permitindo que as classes controlem o acesso aos seus membros.

Polimorfismo:

O polimorfismo é a capacidade de um objeto se comportar de maneiras diferentes em diferentes

contextos. Isso significa que um objeto de uma classe pode ser tratado como um objeto de uma classe
diferente, desde que haja uma relação de herança ou uma interface comum entre as classes envolvidas.
O polimorfismo permite que o mesmo método seja implementado de maneiras diferentes nas classes
relacionadas, permitindo chamadas de método polimórficas e substituição de comportamento. Isso
promove flexibilidade, extensibilidade e simplicidade no código.

5 – Apresente um comando para criar o Banco de dados chamado

MANUTENCAO

------------------------------------------------------------------------------------
CREATE DATABASE MANUTENCAO;

6 – Apresente o comando para a criação das Tabelas:

------------------------------------------------------------------------------------
CREATE TABLE Usuarios (

id INT,

nome VARCHAR(100),

cpf VARCHAR(11),

supervisor_id INT,

PRIMARY KEY (id)

);

CREATE TABLE Servicos (

id INT,

descricao VARCHAR(100),

preco DECIMAL(10, 2),

PRIMARY KEY (id)

);

CREATE TABLE Comprovantes (

id INT,

usuario_id INT,

servico_id INT,

data_comprovante DATE,

PRIMARY KEY (id),

FOREIGN KEY (usuario_id) REFERENCES Usuarios(id),

FOREIGN KEY (servico_id) REFERENCES Servicos(id)

);
CREATE TABLE Oficinas (

id INT,

nome VARCHAR(100),

endereco VARCHAR(100),

PRIMARY KEY (id)

);

7 – Insira 5 Usuarios, 5 serviços, 5 comprovantes, 5 oficinas (Podem

usar valores aleatórios, o que será validado é a sintaxe do comando)

Ex,.: INSERT INTO Empregados VALUES (1, “José Silva”, 1500, 1);

------------------------------------------------------------------------------------
INSERT INTO Usuarios VALUES (1, 'José Silva', '12345678901', 1);

INSERT INTO Usuarios VALUES (2, 'Pedro Santos', '98765432109', 1);

INSERT INTO Usuarios VALUES (3, 'Maria Souza', '45678912301', 2);

INSERT INTO Usuarios VALUES (4, 'Ana Oliveira', '65432198709', 2);

INSERT INTO Usuarios VALUES (5, 'João Pereira', '78912345601', 3);

INSERT INTO Servicos VALUES (1, 'Serviço A', 100.00);

INSERT INTO Servicos VALUES (2, 'Serviço B', 200.00);

INSERT INTO Servicos VALUES (3, 'Serviço C', 150.00);

INSERT INTO Servicos VALUES (4, 'Serviço D', 120.00);

INSERT INTO Servicos VALUES (5, 'Serviço E', 180.00);

INSERT INTO Comprovantes VALUES (1, 1, 1, '2023-06-01');

INSERT INTO Comprovantes VALUES (2, 2, 2, '2023-06-02');

INSERT INTO Comprovantes VALUES (3, 3, 3, '2023-06-03');

INSERT INTO Comprovantes VALUES (4, 4, 4, '2023-06-04');

INSERT INTO Comprovantes VALUES (5, 5, 5, '2023-06-05');

INSERT INTO Oficinas VALUES (1, 'Oficina A', 'Rua A, 123');

INSERT INTO Oficinas VALUES (2, 'Oficina B', 'Rua B, 456');

INSERT INTO Oficinas VALUES (3, 'Oficina C', 'Rua C, 789');

INSERT INTO Oficinas VALUES (4, 'Oficina D', 'Rua D, 321');

INSERT INTO Oficinas VALUES (5, 'Oficina E', 'Rua E, 654');

8 – Selecione:

a) Nome e CPF do supervisor que responde pelo usuário perigorock

b) Nome e CPF do motorista que responde pelo usuário juliusrock

c) A validade do extintor dos veículos da marca ‘FORD’

d) A soma do preço total manutenções, cujo serviço foi descrito como

‘RETIFICA’

------------------------------------------------------------------------------------
a) Nome e CPF do supervisor que responde pelo usuário "perigorock":

SELECT u.nome, u.cpf

FROM Usuarios u

JOIN Usuarios s ON u.supervisor_id = s.id

WHERE u.nome = 'perigorock';

b) SELECT u.nome, u.cpf

FROM Usuarios u

JOIN Servicos s ON u.id = s.id

WHERE s.descricao = 'juliusrock';

c) SELECT v.validade_extintor

FROM Veiculos v

JOIN Marcas m ON v.marca_id = m.id

WHERE m.nome = 'FORD';

d) SELECT SUM(s.preco)

FROM Servicos s

WHERE s.descricao = 'RETIFICA';

9 – Atualize o nome do usuário de código 171 para ‘doidodomato’

------------------------------------------------------------------------------------
UPDATE Usuarios

SET nome = 'doidodomato'

WHERE id = 171;

10 – Delete todas as rotas anteriores a 23/04/2009

------------------------------------------------------------------------------------
DELETE FROM Rotas

WHERE data < '2009-04-23';

------------------------------------------------------------------------------------
PARTE 2 DO TRABALHO--

PARTE 3 DO TRABALHO--

Herança:

A herança permite que uma classe herde características e

comportamentos de outra classe. Veja um exemplo de implementação
em Java:

------------------------------------------------------------------------------------
class Animal {

protected String nome;

public Animal(String nome) {

this.nome = nome;

}
 public void comer() {

System.out.println(nome + " está comendo.");

class Cachorro extends Animal {

public Cachorro(String nome) {

super(nome);

public void latir() {

System.out.println("Au au!");

Animal animal = new Animal("Animal");

animal.comer();

Cachorro cachorro = new Cachorro("Rex");

cachorro.comer();

cachorro.latir();

Associação:

A associação representa a relação entre duas ou mais classes. Veja um

exemplo de implementação em Java:
------------------------------------------------------------------------------------
class Carro {

private Motor motor;

public Carro(Motor motor) {

this.motor = motor;

class Motor {

private int cilindradas;

public Motor(int cilindradas) {

this.cilindradas = cilindradas;

Motor motor = new Motor(2000);

Carro carro = new Carro(motor);

Agregação:

A agregação é um tipo de associação onde uma classe contém

referências a outra classe, mas a classe agregadora não é responsável
pela criação ou destruição dos objetos agregados. Veja um exemplo de
implementação em Java:
------------------------------------------------------------------------------------
class Departamento {

private List<Funcionario> funcionarios;

public Departamento() {

funcionarios = new ArrayList<>();

public void adicionarFuncionario(Funcionario funcionario) {

funcionarios.add(funcionario);

class Funcionario {

private String nome;

public Funcionario(String nome) {

this.nome = nome;

Departamento departamento = new Departamento();

Funcionario funcionario1 = new Funcionario("João");

Funcionario funcionario2 = new Funcionario("Maria");

departamento.adicionarFuncionario(funcionario1);
departamento.adicionarFuncionario(funcionario2);

Composição:

A composição é um tipo de associação onde uma classe é composta

por outras classes e é responsável pela criação e destruição dos
objetos compostos. Veja um exemplo de implementação em Java:

------------------------------------------------------------------------------------
class Casa {

private Quarto quarto;

public Casa() {

quarto = new Quarto();

class Quarto {

// Implementação do quarto

Casa casa = new Casa();

Encapsulamento:

O encapsulamento é o conceito de esconder os detalhes internos de

uma classe e fornecer uma interface pública para interagir com ela.
Veja um exemplo de implementação em Java:

------------------------------------------------------------------------------------
class ContaBancaria {

private double saldo;

public void depositar(double valor) {

saldo += valor;

public void sacar(double valor) {

if (valor <= saldo) {

saldo -= valor;

public double getSaldo() {

return saldo;

ContaBancaria conta = new ContaBancaria();

conta.depositar(100.0);

conta.sacar(50.0);

double saldo = conta.getSaldo();

System.out.println("Saldo: " + saldo);

Polimorfismo:

O polimorfismo permite que objetos de diferentes classes sejam

tratados de maneira uniforme por meio de uma classe base ou
interface. Veja um exemplo de implementação em Java:

------------------------------------------------------------------------------------
abstract class Animal {

public abstract void fazerSom();

class Cachorro extends Animal {

@Override

public void fazerSom() {

System.out.println("Au au!");

abstract class Animal {

public abstract void fazerSom();

class Cachorro extends Animal {

@Override

public void fazerSom() {

System.out.println("Au au!");

}
class Gato extends Animal {

@Override

public void fazerSom() {

System.out.println("Miau!");

Animal animal1 = new Cachorro();

Animal animal2 = new Gato();

animal1.fazerSom();

animal2.fazerSom();

class Gato extends Animal {

@Override

public void fazerSom() {

System.out.println("Miau!");

Animal animal1 = new Cachorro();

Animal animal2 = new Gato();

animal1.fazerSom();

animal2.fazerSom();