Boa noite. Estou aprendendo agora como funciona a parte de orientação e objetos, surgindo várias dúvidas. Uma delas é o seguinte: Qual a diferença em criar uma nova classe com um método no mesmo arquivo que contém a classe main e em um arquivo diferente, sem nenhum código?
Classe main ou método main? Classe sem nenhum código? Está se referindo a pacotes? A sua pergunta, a meu ver está mal formulada, no sentido de confusa. Sugiro que explique melhor a sua dúvida.
Hmmm. Vou tentar rs.
Imagine um arquivo java que, quando aberto na IDE, mostra pra gente uma classe1 qualquer. E para eu criar agora uma outra classe2, que possa interagir com a classe1, eu poderia criar tanto nesse mesmo arquivo que contém a classe1, quanto em um outro arquivo java, certo? Se sim, queria entender a diferença em criar a classe no mesmo ou num diferente arquivo
cara não sei se isso vai ajudar:
existe herança/composição que você vai poder fazer essa interação ex:
public abstract class Funcionario implements Autenticar {
public String getCodFuncionario() {
return codFuncionario;
}
public String getMatricula() {
return matricula;
}
public void setMatricula(String matricula) {
this.matricula = matricula;
}
public void setCodFuncionario(String codFuncionario) {
this.codFuncionario = codFuncionario;
}
public Departamento getDepartamento() {
return departamento;
}
public void setSalario(Double salario) {
this.salario = salario;
}
public void setDepartamento(Departamento departamento) {
this.departamento = departamento;
}
/*
public Endereco getEndereco() {
return endereco;
}
public void setEndereco(Endereco endereco) {
this.endereco = endereco;
}*/
public Double getSalario() {
return salario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getRg() {
return rg;
}
public void setRg(String rg) {
this.rg = rg;
}
public String getUsuario() {
return usuario;
}
public void setUsuario(String usuario) {
this.usuario = usuario;
}
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
public Date getDataEntrada() {
return dataEntrada;
}
public void setDataEntrada(Date dataEntrada) {
this.dataEntrada = dataEntrada;
}
public Date getDataSaida() {
return dataSaida;
}
public void setDataSaida(Date dataSaida) {
this.dataSaida = dataSaida;
}
public Date getDataNascimento() {
return dataNascimento;
}
public void setDataNascimento(Date dataNascimento) {
this.dataNascimento = dataNascimento;
}
}
nessa classe funcionario tenho esse metodos
e vamos dizer que tenho uma classe : Secretaria que é um funcionario (é uma herança), assim você poupa tempo de criar meotdos e etc
vc pode fazer
public class Secretaria extends funcionario{}
e no seu main
Funcionario secretaria= new Secretaria();
e então vc pode acessar todos os metodos de funcionario ex:
secretaria.setNome("xd);
também tem composição ex:
temos classe departamento:
public class Departamento {
private string nome
public void setNome(String nome){
this.nome=nome;
}
}
Agora vamos dizer ( todo funcionario tem apenas um departamento, e um departamento possui varios funcionarios)
public abstract class Funcionario implements Autenticar {
private Departamento departamento; // i
public void setDepart(Departamento departamento){
this.departamento = departamento
}
public Departamento getDepartamento() {
return departamento;
}
}
assim ao vc fazer no main
Funcionario secretaria = new Secretaria(); (herda secretar)
Departamento dep = new Departamento();
dep.setNome("xd");
secretaria.setNome("vania");
secretaria.setDepart(dep);
System.out.println(secretaria.getDepartamento.getNome()); //vai mostrar o nome do departamento
vc agr vai dizer que essa secretaria faz parte do departamento xd
secretaria.
Outra maneira
Você tem uma classe DAO que precisa chamar em um controller como fazer isso?
vamos lá:
public class PadraoDAO {
public <T> List<T> listarTodos(Class<T> tipo) {
EntityManager em = Manager.getInstance().getEm();
return em.createQuery("FROM " + tipo.getSimpleName(), tipo).getResultList();
}
}
e no main vc vai chamar o metodo public List listarTodos(Class tipo)
public static void main(String[] args) {
PadraoDAO padrao = new PadraoDAO();
List<Departamento> todasAsPessoas = padrao.listarTodos(Departamento.class);
System.out.println(todasAsPessoas);
}
creio que seja isso 
uma boa leitura:
https://www.caelum.com.br/apostila-java-orientacao-objetos/pacotes-organizando-suas-classes-e-bibliotecas/#null
Então, creio que a sua pergunta seja esteja mais ligadas aos aspectos formais da POO do que funcional.
1 - Uma classe pode conter outra. Nesse caso a classe mais externa é a classe de nível superior (top-level) e a classe mais interna é uma classe subordinada (inner-class). Além disso uma classe interna pode ser ainda anônima (sem nome). As classes aninhadas (internas) e sua variação anônima são usadas quando o tipo que gera (classes fornecem tipos de dados) são uados uma única vez e pontualmente;
2 - Em geral, costuma-se diminuir a responsabilidade das classes (quantas coisas ela faz no programa) a fim de facilitar a leitura do código, a reutilização de código e facilidade de manutenção. Por isso, em muitos livros (por essas ideias e por questão didática), indicam uma classe que manipula uma frame, por exemplo, e outra que funciona como classe de inicialização da classe que manipula o frame (que tem o método main);
3 - As classes podem se relacionar de variadas maneiras:
3[A] - Associação: simplesmente uma relação existente entre duas classes. Nesse caso, uma da classes trabalha com instancias (objetos) de uma outra;
Exemplo:
3[B] - Associação por Agregação Simples: é uma forma de associação em que um ou mais dos atributos de uma classe são do tipo de uma outra classe. Nesse caso, a classe que tem tipos de outra forma o todo e as classes que são atributos da classe todo são as classes parte. Note que as partes têm existência em si mesmas, não precisando de da classe todo para fazer sentido no domínio do sistema (abstração/regra de negócio).
Exemplo:
Nesse caso a luta tem como atributos instâncias de lutador.
public class Luta{
private boolean aprovada;
private short rounds;
private Lutador desafiante,
desafiado;
}
3[C] - Associação por Agregação Composta: é um tipo de agregação em que o o todo só existe pelas partes que o compõe. Se o todo é destruído ou deixa de existir (obrigatoriamente) as partes também são destruídas ou deixam de fazer sentido;
Exemplo:
public class CasaUmComodo{
public CasaUmComodo(){
paredeEsquerda = new Parede();
paredeDireita = new Parede();
paredereFundo = new Parede();
paredeFundo = new Parede();
teto = new Teto();
janelaPE = new Janela();
janelaPD = new Janela();
janelaPFdo = new Janela();
janelaPFte = new Janela();
portaFrente = new Porta();
portaFundo = new Porta();
}
}
public class Parede{
}
public class Teto{
}
public class Janela{
}
public class Porta{
}
3[D] - Herança: é quando uma ou mais classes são subtipos de uma outra classe. Nesse caso essa classe é a classe mãe, pai superclasse ou progenitora daquelas classes. Estas classes são classes filhas, folhas, derivadas ou subclasses daquela classe. Na herança, obrigatoriamente as classes filhas devem gerar novo tipos de dados co base na classe mãe. Como as classes filhas derivam ou especializam a classe mãe (entregam mais informações sobre os dados fornecidos pela classe mãe) diz-se que as classes filhas especializam a classe mãe ou que a classe mãe generaliza as classes filhas.
Exemplo:
Não está totalmente certo. O correto mesmo é que exista apenas uma definição de classe pública para cada arquivo. Quando várias classes são criadas no mesmo arquivo, normalmente isso é chamado de inner classes e é geralmente usada para eventos ou encapsulamento de alguma lógica.
Tenha o hábito de criar uma classe pública por arquivo e deixe as responsabilidades bem definidas (isso no métodos).
Você só pode ter uma classe pública por arquivo.
Você pode criar mais classes no mesmo arquivo, mas somente uma pode ser pública.
De qualquer forma, é melhor criar um arquivo por classe pois torna seu código mais organizado.
O que você pode fazer é criar inner-classes (classes declaradas dentro de outra classe), estas sim podem ser públicas.
Inner class é quando uma classe é declarada dentro de outra.
O Java permite que classes não públicas sejam declaradas no mesmo arquivo que a classe pública, mas não é uma boa prática.
2 curtidas