AdrianoSiqueira

Aparentemente o NetBeans ainda não suporta o Java 18, veja.

Essa é a sintaxe para a criação de anotações, é assim que o Java diferencia anotações de interfaces. Exatamente, isso é o polimorfismo do Java. O que eu queria saber é o porquê do Java não permitir a mesma lógica quando assunto é anotações, afinal Person usa a anotação MyAnnotation.

E aí pessoal, beleza? Estou fazendo alguns testes com anotações personalizadas e estou com uma dúvida sobre se é possível usar polimorfismo para passá-las como argumento. Desenvolvi o seguinte código, mas recebo um erro de compilação na parte onde tento usar polimorfismo. Segue o código: import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; public class Main { public static void main(String[] args) { Person person = new Person(); requiresAnnotation(person); // Required: MyAnnotation Provided: Person requiresInterface(person); // Works just fine } private static void requiresAnnotation(MyAnnotation annotation) {} private static void requiresInterface(MyInterface _interface) {} @Retention(value = RetentionPolicy.RUNTIME) @Target(value = ElementType.TYPE) private @interface MyAnnotation {} private interface MyInterface {} @MyAnnotation private static class Person implements MyInterface {} } Não entendi o porquê de não ter funcionado, se alguém puder esclarecer ficarei grato.

Interessante, testei aqui e tive esse problema. Usando a interface RandomGenerator também resultou na mesma coisa. Vai saber o que acontece por debaixo dos panos do Java....

Veja se isso te ajuda: package teste.cdh.shellsort; import java.util.Comparator; public class ShellSort<T> { /** * Based on: https://www.tutorialspoint.com/java-program-for-shellsort */ public void sort(T[] array, Comparator<T> comparator) { int length = array.length; for (int gap = length / 2; gap > 0; gap /= 2) { for (int i = gap; i < length; i += 1) { T temp = array[i]; int j; for (j = i; j >= gap && comparator.compare(array[j - gap], temp) > 0; j -= gap) array[j] = array[j - gap]; array[j] = temp; } } } /** * From: https://www.tutorialspoint.com/java-program-for-shellsort */ public void sort(int[] array) { int length = array.length; for (int gap = length / 2; gap > 0; gap /= 2) { for (int i = gap; i < length; i += 1) { int temp = array[i]; int j; for (j = i; j >= gap && array[j - gap] > temp; j -= gap) array[j] = array[j - gap]; array[j] = temp; } } } } package teste.cdh.shellsort; public class Person { public String name; public int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; if (age != person.age) return false; return name.equals(person.name); } @Override public int hashCode() { int result = name.hashCode(); result = 31 * result + age; return result; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } } package teste.cdh.shellsort; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import java.util.Comparator; class ShellSortTest { @Test void sort_SortsTheIntArray_WhenSuccessful() { int[] array = {5, 4, 3, 2, 1}; new ShellSort<Integer>() .sort(array); Assertions.assertThat(array) .isEqualTo(new int[]{1, 2, 3, 4, 5}); } @Test void sort_SortsTheIntegerArrayWithComparator_WhenSuccessful() { Integer[] array = {5, 4, 3, 2, 1}; Comparator<Integer> comparator = Integer::compareTo; new ShellSort<Integer>() .sort(array, comparator); Assertions.assertThat(array) .isEqualTo(new Integer[]{1, 2, 3, 4, 5}); } @Test void sort_SortsThePersonArrayWithComparator_WhenSuccessful() { Person[] array = { new Person("D", 2), new Person("D", 1), new Person("C", 3), new Person("B", 4), new Person("A", 5) }; Person[] expectedResult = { new Person("A", 5), new Person("B", 4), new Person("C", 3), new Person("D", 1), new Person("D", 2) }; // sort by name in alphabetical order // if the names are equals then sort by age ascending Comparator<Person> comparator = Comparator.comparing((Person o) -> o.name) .thenComparingInt(o -> o.age); new ShellSort<Person>() .sort(array, comparator); Assertions.assertThat(array) .isEqualTo(expectedResult); } @Test void sort_SortsTheStringArrayWithComparator_WhenSuccessful() { String[] array = {"5", "4", "3", "2", "1"}; Comparator<String> comparator = String::compareTo; new ShellSort<String>() .sort(array, comparator); Assertions.assertThat(array) .isEqualTo(new String[]{"1", "2", "3", "4", "5"}); } }

A partir da versão 11 do Java, o JDK não traz mais o JavaFX, sendo necessário baixá-lo separadamente no site do gluon. Eu não uso o NetBeans, mas parece que depois de adicionar a biblioteca do JavaFX, é necessário configurar o NetBeans para reconhecê-la (assim como diz a mensagem). Nesse vídeo é usado o JavaFX 16, mas o procedimento é praticamente a mesma coisa. Alternativamente, você pode criar um projeto Maven e usá-lo para obter as dependências do JavaFX. Segue um vídeo demonstrando o procedimento. Documentação oficial do JavaFX: link.

Vê se ajuda: https://github.com/angelocavallet/BuscaBidirecional https://stackoverflow.com/questions/38674659/implementation-of-the-bidirectional-graph-search

Sobre a exceção ArrayIndexOutOfBoundsException, ela é lançada quando se tenta acessar uma posição inexistente no vetor. No seu caso, na primeira implementação você está tentando acessar a posição -1. Sua primeira implementação está gerando um resultado errado, mesmo corrigindo o problema da exceção mencionada. A segunda implementação aparentemente está funcionando conforme o esperado. Obs.: Não é uma boa ideia fechar coisas que você não abriu. Em ambas implementações você fecha o scanner que está usando o System.in. Isso pode acarretar em problemas no futuro se você tentar usar esse stream novamente. A JVM abriu esse stream, então deixe para ela a responsabilidade de fechar. Sobre a exceção FileNotFoundException, essa exceção é lançada quando se tenta acessar um arquivo que não existe, ou que não foi apontado corretamente, em ambas as situações o arquivo não será encontrado e por isso a exceção será lançada. A forma ideal de apontar um arquivo, é usando o caminho absoluto. Usar um caminho relativo pode funcionar, ou não, dependendo de como se está executando o programa. É complicado de explicar, mas tem a ver com o Working directory, que executando dentro do IDE terá um valor, mas se executar pela linha de comando, terá outro. O código abaixo mostra suas duas implementações, e usa o caminho relativo para acessar o arquivo. Para funcionar corretamente, o arquivo deve estar dentro do mesmo pacote que a classe. Aproveite também para comparar os resultados de ambas as implementações. package cdh.pesquisador; import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class Main { private static String nomePacote = Main.class.getPackage().getName().replace('.', '/'); private static String nomeArquivo; public static void main(String[] args) { nomeArquivo = "src/" + nomePacote + "/"; for (int i = 0; i < args.length; i++) { nomeArquivo += args[i]; if (i + 1 < args.length) nomeArquivo += " "; } System.out.println("Implementação 1"); implementacao1(); System.out.println("\n\n\n"); System.out.println("Implementação 2"); implementacao2(); } private static void implementacao1() { File inputFile = new File(nomeArquivo); Scanner str = new Scanner(System.in); System.out.println(" Digite a palavra a ser buscada:"); String palavra = str.nextLine(); // Não pode fechar esse Scanner ou vai fechar um stream padrão do sistema // str.close(); try { Scanner scanner = new Scanner(inputFile); while (scanner.hasNextLine()) { String linha = scanner.nextLine(); String[] palavras = linha.split(" "); // Não existe posição -1 for (int i = 0; i < palavras.length; i++) { if (palavras[i].equals(palavra)) { System.out.println(" A palavra " + palavra + " aparece na linha " + i); } } } scanner.close(); System.out.print(""); } catch (FileNotFoundException e) { e.printStackTrace(); } } private static void implementacao2() { File inputFile = new File(nomeArquivo); System.out.println(inputFile); Scanner str = new Scanner(System.in); System.out.println(" Digite a palavra a ser buscada:"); String palavra = str.nextLine(); // Não pode fechar esse Scanner ou vai fechar um stream padrão do sistema // str.close(); int j = -1, numLinha = 0; try { Scanner scanner = new Scanner(inputFile); while (scanner.hasNextLine()) { String linha = scanner.nextLine(); j++; String[] palavras = linha.split(" "); for (int i = 0; i < palavras.length; i++) { if (palavras[i].equals(palavra)) { numLinha = j; System.out.println(" A palavra " + palavra + " aparece na linha " + numLinha); } } } scanner.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } } }

O problema está relacionado com o objeto spritesheet. Está faltando essa classe, ou o código simplesmente não está completo. Remova toda as referências para esse objeto e o código irá compilar e executar. Além disso, seu código está cheio de erros relacionados com o fechamento incorreto de chaves. Modifiquei o código para ficar dentro de uma classe só, apenas para ficar mais fácil de postar aqui. import javax.swing.*; import java.awt.*; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.awt.image.BufferStrategy; import java.util.ArrayList; import java.util.List; public class Game extends Canvas implements Runnable, KeyListener { public static int WIDTH = 480; public static int HEIGHT = 480; public Player player; public World world; public Game() { this.addKeyListener(this); this.setPreferredSize(new Dimension(WIDTH, HEIGHT)); player = new Player(32, 32); world = new World(); } public static void main(String[] args) { Game game = new Game(); JFrame frame = new JFrame(); frame.add(game); frame.setTitle("Zelda as Aventuras de Mike"); frame.setLocationRelativeTo(null); frame.pack(); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); new Thread(game).start(); } public void render() { BufferStrategy bs = this.getBufferStrategy(); if (bs == null) { this.createBufferStrategy(3); return; } Graphics g = bs.getDrawGraphics(); g.setColor(Color.black); g.fillRect(0, 0, WIDTH, HEIGHT); player.render(g); world.render(g); bs.show(); } public void tick() { player.tick(); } @Override public void keyPressed(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_RIGHT) { player.right = true; } else if (e.getKeyCode() == KeyEvent.VK_LEFT) { player.left = true; } if (e.getKeyCode() == KeyEvent.VK_UP) { player.up = true; } else if (e.getKeyCode() == KeyEvent.VK_DOWN) { player.down = true; } } @Override public void keyReleased(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_RIGHT) { player.right = false; } else if (e.getKeyCode() == KeyEvent.VK_LEFT) { player.left = false; } if (e.getKeyCode() == KeyEvent.VK_UP) { player.up = false; } else if (e.getKeyCode() == KeyEvent.VK_DOWN) { player.down = false; } } @Override public void keyTyped(KeyEvent e) {} @Override public void run() { while (true) { tick(); render(); try { Thread.sleep(1000 / 60); } catch (InterruptedException e) { e.printStackTrace(); } } } private static class Blocks extends Rectangle { public Blocks(int x, int y) { super(x, y, 32, 32); } public void render(Graphics g) { g.setColor(Color.MAGENTA); g.fillRect(x, y, width, height); g.setColor(Color.black); g.drawRect(x, y, width, height); } } private static class Player extends Rectangle { public int spd = 4; public boolean right; public boolean up; public boolean down; public boolean left; public Player(int x, int y) { super(x, y, 32, 32); } public void render(Graphics g) { g.setColor(Color.blue); g.fillRect(x, y, width, height); } public void tick() { if (right && World.isFree(x + spd, y)) { x += spd; } else if (left && World.isFree(x - spd, y)) { x -= spd; } if (up && World.isFree(x, y - spd)) { y -= spd; } else if (down && World.isFree(x, y + spd)) { y += spd; } } } private static class World { public static List<Blocks> blocos = new ArrayList<>(); public World() { for (int xx = 0; xx < 15; xx++) { blocos.add(new Blocks(xx * 32, 0)); } for (int xx = 0; xx < 15; xx++) { blocos.add(new Blocks(xx * 32, 480 - 32)); } for (int yy = 0; yy < 15; yy++) { blocos.add(new Blocks(0, yy * 32)); } for (int yy = 0; yy < 15; yy++) { blocos.add(new Blocks(480 - 32, yy * 32)); } } public static boolean isFree(int x, int y) { for (int i = 0; i < blocos.size(); i++) { Blocks blocoAtual = blocos.get(i); if (blocoAtual.intersects(new Rectangle(x, y, 32, 32))) { return false; } } return true; } public void render(Graphics g) { for (int i = 0; i < blocos.size(); i++) { blocos.get(i).render(g); } } } }

Se você puder postar o código das classes mencionadas, talvez eu possa ajudar.

Verifique se seu código não contém erros. Erros de compilação geralmente são avisados pelo IDE, verifique se você não deixou nada passar.

Difícil ajudar sem saber o erro. Eu criei a estrutura do seu código, mas estão faltando as classes: Spritesheet Player Sem elas não dá para executar o programa para depurar.

Um jeito de fazer, é usando um objeto atômico: import java.util.concurrent.atomic.AtomicInteger; public class App { public static void main(String[] args) { for (int i = 1; i <= 5; i++) { new Thread(new MyRunnableSynchronized(), "Thread-" + i).start(); //new Thread(new MyRunnable(), "T-" + i).start(); } } private static class MyRunnable implements Runnable { private static AtomicInteger objetoAtomico = new AtomicInteger(0); @Override public void run() { System.out.println(Thread.currentThread().getName() + ": " + objetoAtomico.get()); objetoAtomico.set(objetoAtomico.get() + 1); } } private static class MyRunnableSynchronized implements Runnable { private static AtomicInteger objetoAtomico = new AtomicInteger(0); @Override public void run() { synchronized(objetoAtomico) { System.out.println(Thread.currentThread().getName() + ": " + objetoAtomico.get()); objetoAtomico.set(objetoAtomico.get() + 1); } } } }

É um jeito de fazer, mas sincronizar a classe toda pode causar gargalos, se duas threads tentarem acessar recursos diferentes que em teoria não teria problema, apenas uma vai poder acessar porque a classe foi bloqueada. Talvez sincronizando apenas a variável i possa dar um resultado melhor.

Muito estranho, aqui funcionou corretamente em todas as vezes que eu executei. Segue as implementações que eu fiz: package code; public class OriginalRunnable implements Runnable { public static int i = -1; private String nome; private int tempo; public OriginalRunnable(String nome, int tempo) { this.nome = nome; this.tempo = tempo; Thread t = new Thread(this); t.start(); } @Override public synchronized void run() { i++; System.out.println(Thread.currentThread().getName() + ":" + i); } } package code; public class MyRunnable implements Runnable { private static int counter = -1; @Override synchronized public void run() { ++counter; System.out.println(Thread.currentThread().getName() + " " + counter); } } package code; public class Main { public static void main(String[] args) { myImplementationWithObject(); myImplementationWithoutObject(); originalImplementation(); } private static void myImplementationWithObject() { Runnable runnable = new MyRunnable(); new Thread(runnable, "Thread 0").start(); new Thread(runnable, "Thread 1").start(); new Thread(runnable, "Thread 2").start(); new Thread(runnable, "Thread 3").start(); } private static void myImplementationWithoutObject() { new Thread(new MyRunnable(), "Thread 0").start(); new Thread(new MyRunnable(), "Thread 1").start(); new Thread(new MyRunnable(), "Thread 2").start(); new Thread(new MyRunnable(), "Thread 3").start(); } private static void originalImplementation() { OriginalRunnable r1 = new OriginalRunnable("Thread #1", 500); OriginalRunnable r2 = new OriginalRunnable("Thread #2", 500); OriginalRunnable r3 = new OriginalRunnable("Thread #3", 500); OriginalRunnable r4 = new OriginalRunnable("Thread #4", 500); } }

Provavelmente está entrando no if porque o valor de limiteAtual não foi definido, dessa forma ele é iniciado com 0, causando um bug na lógica. Sem o código completo para depurar fica difícil apontar o erro com exatidão, mas deve ser isso. Tente iniciar a variável com o mesmo valor de limiteInicial.

Como você comprou em Janeiro, ainda está na garantia, acione-a através do fabricante, mas será necessário a posse da nota fiscal do produto.

A tabela login não tem coluna "nome".

A classe tem que ser pública e o nome dela deve coincidir com o nome do arquivo.

Procure por exemplos de "Matriz de transposição". É isso o que você tem que desenvolver.

Percorra o vetor comparando todas as posições com elas mesmas calculando a diferença entre os valores, quando achar a diferença desejada, incrementa um contador.

Para jogar contra o PC, você vai ter que implementar algum algoritmo de inteligência artificial, não precisa ser algo complexo de ficção científica, apenas o suficiente para entender a jogada do usuário e dar um jeito de contra atacar. Por exemplo, você poderia detectar quando o usuário marcou duas casas e está indo para completar a terceira, e você programa o PC para fazer a jogada nessa terceira casa, bloqueando o usuário.

Qual a dúvida?

Qual a dúvida?

Segue uma possível solução usando Stream: import java.util.Arrays; import java.util.DoubleSummaryStatistics; import java.util.random.RandomGenerator; public class NollyApp implements Runnable { private static final int QUANTIDADE = 10; @Override public void run() { double[] alturas = new double[QUANTIDADE]; int[] sexos = new int[QUANTIDADE]; RandomGenerator generator = RandomGenerator.getDefault(); for (int i = 0; i < QUANTIDADE; i++) { // Gera alturas entre 1.75 e 1.90 alturas[i] = generator.nextDouble(1.75, 1.91); // Gera sexos entre 1 e 2 sexos[i] = generator.nextInt(1, 3); } // Obtém estatísticas automaticamente através de Stream DoubleSummaryStatistics estatisticas = Arrays.stream(alturas) .summaryStatistics(); // Exibe o relatório System.out.println("Alturas: " + Arrays.toString(alturas)); System.out.println(" Sexos: " + Arrays.toString(sexos)); System.out.println("Maior altura: " + estatisticas.getMax()); System.out.println("Menor altura: " + estatisticas.getMin()); System.out.println("Média altura: " + estatisticas.getAverage()); } } E uma usando métodos convencionais: import java.util.Arrays; import java.util.Scanner; public class NollyApp implements Runnable { private static final int QUANTIDADE = 3; private double acharMaiorAltura(double[] alturas) { double resultado = alturas[0]; for (double altura : alturas) { if (altura > resultado) { resultado = altura; } } return resultado; } private double acharMenorAltura(double[] alturas) { double resultado = alturas[0]; for (double altura : alturas) { if (altura < resultado) { resultado = altura; } } return resultado; } private double calcularMediaAltura(double[] alturas) { double resultado = 0.0; for (double altura : alturas) { resultado += altura; } return resultado / alturas.length; } @Override public void run() { Scanner scanner = new Scanner(System.in); double[] alturas = new double[QUANTIDADE]; int[] sexos = new int[QUANTIDADE]; for (int i = 0; i < QUANTIDADE; i++) { System.out.print("Digite a altura: "); alturas[i] = scanner.nextDouble(); System.out.print("Digite o sexo [ 1 -> F / 2 -> M ]: "); sexos[i] = scanner.nextInt(); } double maiorAltura = acharMaiorAltura(alturas); double menorAltura = acharMenorAltura(alturas); double mediaAltura = calcularMediaAltura(alturas); System.out.println("alturas = " + Arrays.toString(alturas)); System.out.println(" sexos = " + Arrays.toString(sexos)); System.out.println("maiorAltura = " + maiorAltura); System.out.println("menorAltura = " + menorAltura); System.out.println("mediaAltura = " + mediaAltura); } }