Manipulação de arquivos

Programação Java
#1

ALGUÉM ME AJUDA, POR FAVOOOOOOOOR. Tentei várias vezes e não consigo fazer, estou dando voltas em círculos…

  1. Crie uma classe que implementa os dois métodos estáticos definidos na interface
    ManipulaArquivos: um que exibe o conteúdo de um arquivo texto, e outro que escreve no
    arquivo um texto informado pelo usuário, via teclado. Utilize o método main (programa principal)
    para testar a classe criada. A interface não deve ser modificada.

public interface ManipulaArquivos {
public static void leitor(String path) throws IOException{};
public static void escritor(String path) throws IOException{};
}

#2

Moleza.

Você precisa ter mais duas classes… a classe que implementa a interface e a classe principal.

O que você já fez, além dessa interface?

#3

Estava tentando fazer a classe que implementa a interface e a classe principal, rodei rodei mas não deu em nada (essa matéria não entra na minha cabeça, daí complica mais ainda pra mim)

#4

image
image.png1440×900 91.1 KB

#5

essa parte fiz olhando por um site que tinha esse metodo e o outro também, daí eu tava lendo e tentando entender cada pedacinho, mas…

#6

Remova “static” dos métodos, esse deve ser um dos seus erros.

#7

huuuuuuum, entendi. Só que tipo, esse método não tem que estar desse jeito mesmo?

#8

ok, vamos passo a passo…

Sabe a diferença de String para StringBuilder?

Ao invés de usar o padrão de InputStream … Buffered… etc., por que não usar a classe File, pra ser mais simples?

Já que você está estudando a abertura de arquivos, vou te dar um exemplo para salvar - com outra forma de pensar. Tenta explicar aqui item a item desse código abaixo, porque aí podemos ajudar nas dúvidas pontuais:

String arquivoPasta;
String arquivoNome
String arquivoExtensao;
StringBuilder arquivoConteudo;

    try {
        FileWriter arquivo;
        arquivo = new FileWriter(arquivoPasta + arquivoNome + arquivoExtensao);
        arquivo.write(arquivoConteudo);
        arquivo.close();
        System.out.println("Salvo em " + caminho);
    } catch (Exception e) {
        System.out.println(e.getMessage());
        JOptionPane.showMessageDialog(null, "Não foi possível salvar o arquivo");
    }
#9

Só se você fosse executar ele sem instanciar o objeto, então seria um método da classe, não do objeto.

#10

Eu creio que sim, seja isso

#11

Então, (sou um completo desastre em desenvolvimento de sistemas, me desculpe se eu estiver “boiando”) entendi mais ou menos o funcionamento deste programinha. Porém, ainda não entendi completamente, questão de interpretar e de alguns códigos (Ai Jesus). Daí no meu programa eu vou fazer basicamente isso?

#12

image
image.png1440×900 95.3 KB

Minha classe principal tá assim, só que daí meu professor disse que é menor que isso, algo assim:
public static void main(String[] args) {
String fileName = “IOTest.txt”;
try {
Implementacao.escritor(fileName);
Implementacao.leitor(fileName);
} catch (IOException e) {
e.printStackTrace();
}
}
(Eu basicamente copio tudo que o meu prof. fala ou faz pra enttender um pouco melhor, mas …)

#13

Interface:

public interface ManipulaArquivos {
    public void leitor(String path) throws IOException{};
    public void escritor(String path) throws IOException{};
}

Implementação:

public class ManipulaArquivosImpl implements ManipulaArquivos {
    @Override 
    public void leitor(String path) throws IOException {
        //TODO Implementar lógica de ler arquivo
    }

    @Override 
    public void escritor(String path) throws IOException {
        //TODO Implementar lógica de escrever arquivo
    }
}

Main:
Essa é a main de acordo com o que seu professor pediu

public class Main {
    public static void main(String[] args) {
        ManipulaArquivos impl = new ManipulaArquivosImpl();
        String fileName = “IOTest.txt”;
        try {
            impl.escritor(fileName);
            impl.leitor(fileName);
        } catch (IOException e) {
           e.printStackTrace();
        }
}

Aí você só precisa focar na classe ManipulaArquivosImpl.
Fazendo a leitura e escrita lá.

1 curtida
#14

O grande problema deste exercicio é que ele já começa errado te pedindo para implementar os métodos estáticos de uma interface sendo que não possível implementar métodos estáticos.

Mesmo assim, com bastante boa vontade, dá pra gente tentar ignorar e resolver assim:

interface ManipulaArquivos {
  public static void leitor(String path) throws IOException {};
  public static void escritor(String path) throws IOException {};
}

class Manipulador implements ManipulaArquivos {
  private static final Scanner scan = new Scanner(System.in);

  public static void leitor(String path) throws IOException {
    byte[] content = Files.readAllBytes(Paths.get(path));
    String str = new String(content);
    System.out.println(str);
  };

  public static void escritor(String path) throws IOException {
    String content = scan.nextLine();
    Files.write(Paths.get(path), content.getBytes());
  };

  public static void main(String... args) throws IOException {
    Manipulador.leitor("hello.txt");
    Manipulador.escritor("hello.txt");
  }
}

Como métodos estático das interfaces podem ter corpo, vc nem precisava de uma classe, podia fazer isso direto na interface mesmo.

1 curtida
#15

Sim, esse é o problema kkk. Entendi! Obrigada pela ajuda, sucesso pra ti e muita luz na tua vida, Deus abençoe você :blush:

1 curtida
#16

kkkkkk, tá bom. Entendi mais ou menos, mas obrigada :blush:

1 curtida
#17

Meu deus, mas quem criou esse exercício?

Métodos estáticos em uma interface já não fazem muito sentido (aliás, antes do Java 8 nem era permitido). Criar uma classe que “implementa um método estático de uma interface” faz menos sentido ainda.

Bom, como você deu a entender que ainda está começando, então talvez seja um tópico avançado demais, mas fica aqui para você ler no futuro: Em orientação a objetos, por que interfaces são úteis?

Mas pra resumir: uma interface serve para estabeler um contrato (tenho esses métodos, que recebem dados X e Y, e retornam Z). Em uma classe você só implementa métodos não-estáticos de uma interface. Exemplo:

public interface ManipulaArquivos {
    public void lerArquivo(String nomeArquivo); // método não-estático, e sem corpo
}

// classe que implementa a interface
public class LeitorDeArquivos implements ManipulaArquivos {
    public void lerArquivo(String nomeArquivo) {
        // código que lê o arquivo
    }
}

Repare que o método não-estático da interface não tem corpo (não tem o { }), pois ele só serve para dizer “eu faço isso” (eu tenho um método lerArquivo que recebe uma String e lê o conteúdo dele). Mas quem vai de fato fazer a leitura é a classe que implementar a interface.

E tem um detalhe importante: como eu disse que a classe LeitorDeArquivos implementa a interface ManipulaArquivos, ela tem que obrigatoriamente implementar todos os métodos da interface, senão o código nem sequer compila.

Já com um método estático, nada disso acontece, pois um método estático deve obrigatoriamente ter um corpo, caso contrário ele nem compila:

public interface ManipulaArquivos {
    public static void leitor(String path) throws IOException { // método estático tem que ter um corpo
        System.out.println("manipulador de arquivo");
    };
}

public class LeitorDeArquivo implements ManipulaArquivos {
    public static void leitor(String path) throws IOException {
        System.out.println("Leitor de arquivo");
    }
}

Só que o método estático em LeitorDeArquivo não está implementando a interface (na verdade ele nem é obrigatório para que o código compile). Na verdade você está criando dois métodos estáticos diferentes, sem relação entre si (não há uma implementação da interface, não há ganho nenhum em fazer isso na verdade).

Ou seja, esse exercício está - na minha humilde opinião - desensinando. Ao usar interfaces de forma completamente desnecessária, ainda usa um recurso de uso questionável (métodos estáticos em uma interface, que raramente são úteis - não faz tanta diferença se estivessem em uma classe), e ainda manda fazer algo de forma errada (com métodos estáticos você não está implementando a interface).

Mas enfim, para satisfazer o exercício, bastaria fazer algo como o @wldomiciano já indicou.

2 curtidas
#18

Eita lasqueira, entendi. Obrigada :blush:

#19

Então, sou eu de novo (tive que trocar de conta), tentei de tudo mas não deu certo não. Tentei os programinhas daqui e o que eu tinha achado num site aí e continuou dando erro.

image
image.png1440×900 93.4 KB

#20

image
image.png1440×900 94 KB

A classe principal