Anonymní profil NotBeginer – Programujte.com

Osobně já doporučuji Učebnice Jazyka Java od Pavla Herouta, zdá se mi nejlepší ale je to rok 2008 takže je to Java6. Ale v Javě se toho přechodem na Javu7 z těch elementárních věcí nic nezměnilo. Ten jeho druhý díl s GUI není špatný, sice je tam java.awt.* ale přechod na JFrame je triviální a z něj na JavaFX2. A ten tředí díl týkající se dynamický polí(kolekcí) je taky super. ( - toto máš tak na rok života pro plné pochopení)

Jinak dobrá kniha je Java7 vyukový kurz - ta taky není špatná (ale dle mě je Herout lepší )

Myslíme v Jazyku Java - je sice stará, ale člověk co se tam naučí za konstrukce je fakt super ( ale nedoporučuji pro začátečníky )

Učebnice Objektové architektury - té se vyhni obloukem, tu vlastním a je to taková sra**a, že nechápu jak něco takového mohly vytisknout.

Po prostudování dvou,tří cz knih přejdi na zahraniční knihy ( těch je na internetu spousta ), čti API,....

   Ty a nechybí ti tam nějaká logická podmínka? Třeba taková která by porovnávala řetezce?   Načteny řetezec a uložené heslo a pokud by sedělo tak by se přerušil cyklus nebo zavolal nějakou metodu.

PS. doporučuji momentálně více se toho naučit a přečíst. Je dobré že se snažíš psát ale chce to ještě nastudovat teorii.

Zde je nějaký easy zdrojak, snad ti to helpne

Samozřejmě je nutné změnit název obrázku a správně nastavit cestu.

import java.awt.*;
import java.io.*;
import javax.imageio.*;
import javax.swing.*;
public class H11_JFramePozadi extends JFrame {
	private static final long serialVersionUID = 7357954185642642965L;
	static {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());	} 
        catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
        	ex.printStackTrace();	}	}
	private H11_JFramePozadi() {	//	konstruktor
		try	{
			super.setTitle("Program na nacteni obrazku jako pozadi");
			JLabel obrazek = new JLabel(new ImageIcon(ImageIO.read(new File("kocka.jpg"))));
			this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			this.setContentPane(obrazek);
			this.setLayout(null);
			JLabel text = new JLabel("Hello from the foreground");
			text.setForeground(Color.RED);
			text.setBounds(20,50,200,150);
			JButton tlacitko = new JButton("OK-test");
			tlacitko.setBounds(20,250,200,150);
			this.add(text);
			this.add(tlacitko);
			this.pack();
			this.setLocationRelativeTo(null);	} 
		catch (IOException | HeadlessException exp) {
			exp.printStackTrace();	}	}
	public static void main(String [] args) {
		new H11_JFramePozadi().setVisible(true);	}
}

Přečetl jsem tvůj popis 3xkrát a nechápu "vo co go??". Buď sem hoď zdroják nebo to přehledně popiš.

JFrame je potomek třídy Frame. Jedná o grafický kontejner nejvyšší úrovně (tvz. top-level komponet ). Všechny ostatní GUI komponenty (např. JPanel,JButton,JLabel ) musíš vkládat do něj. Proto je vždycky největší a ohraničuje ostatní komponenty.

např.
JFrame frame = new JFrame();
JPanel panel = new JPanel();
JLabel popis = new JLabel("Text");
panel.add(popis);
frame.add(panel);

V žádném případě nepopírám co jsem napsal. Věta " Podle mě by celé vlákno mělo projet komplet " netvrdí nic o tom, že vlakna neběží vedle sebe. To je nějaká tvoje či vaše doměnka. To, že jsem v kontextu mé věty provedl náznak ustoupení bylo projevem zdvořilosti. Prosil bych soustředte se na psaný text. Evidetně se ukazuje že i kluci v IT mají problém pochopením psaného textu.

Ve spoustě literatuře např. Herout Učebnice jazyka Java str 351  cituji " Každé vlákno má nastaveno svoji prioritu, podle které se řídí plánovač běhu vláken. Znamená to, že jsou-li běhuschopná dvě vlákna, bude vždy předáno řízení vláknu s vyšší prioritou."

- samozřejmě se nabízí možnost že Herout se v tomto náhodném případě mohl zmýlit. Podle pochopení daného citátu, by plánovač vláken se měl rozhodoval během vykonávání instrukcí v metodě run() a vždycky by se měl spustit vlákno s nejvyšší prioritou a tudíž by mělo první skončit vlákno4(proběhnout komplet celé).

Taktéž i jinde se píše ale už si nevzpomenu kde jsem to četl že proběhnout má celé vlákno( myšleno celý run() ) s nejvyšší prioritou.

PS. vzhledem k tomu, že diskuze na dané téma se ubírá úplně odlišným směrem, místo toho abychom si zde předvedli nějaké funkční kódy na priority vláken, považoval bych to asi za ukončené. V každém případě díky, že jste mi tu řekli, že ty priority vláken fungují nesystematicky(prakticky nefungují vůbec a tudíž jsou přesné paralelní algorytmy nepoužitelné).

#6 KIIV
 

Špatně jsi pochopil můj text "vlákno mělo projet komplet" není myšleno že běží sériově za sebou. Ok, nezpochybňuji, že vlákna běží vedle sebe, nicméně priorita je prostě priorita. Procesor či OS by měl toto brát v potaz a při přepínání vláken by měly nejdřív proběhnout vlákna s vyšší prioritou. Proto jsem na svém dvoujádru udělal vláken 6 s různými prioritami. Ať se to někomu líbí či nikoliv v mém pokusu musí proběhnout první komplet vlákno4 vedle něj vlákno3 a pak až přijde řada na ostatní tak ten zbytek vlaken s nižší prioritou.

#4 zlz
Takové typy příspěvků si strč do prdele. Buď se vyjádři konstruktivně anebo radši drž hubu. Nejsem na tento typ neinformace vůbec zvědav.

Win7 Prof - 32 bit - verze ENG

Java 7 update 21

Ahojte hrál jsem si s prioritami vláken a nefunguje to správně. Můj zdroj si myslím, že mám tak jednoduchý že v něm chyba není. Podle mě je špatně naprogramována Java. Kód jsem si naprogramoval v takové logice kdy vlakna s určitou prioritou by měla proběhnout a nikoliv se uprostřed po instrukcích přepínat. ( žádnou metodu yield() v kódu nemám) . Přesto výpis

class Vlakna11 extends Thread {
	private String s;
	protected Vlakna11(String s,int priorita) {
		super(s);
		System.out.println("Konstruktor od vlakna\t"+s);
		this.setPriority(priorita);
		this.s=s;	}
	public void run() { 
		System.out.println(Thread.currentThread()+"\t"+s);   						
		int [] pole = new int [10000000];
		for(int i=0;i<pole.length;i++){
			pole[i]=i+i+i+i+i+i+i+i+i+i+i+i;	}
		System.out.println("Zde je vysledna hodnota :"+pole[9999999]+"\t vlakno :\t"+s);	}
}
public class Q_15VlaknaPriorita {
	public static void main(String [] args) {
		System.out.println("Zacatek programu");
		Vlakna11 vlakno1 = new Vlakna11("vlakno1",4);
		Vlakna11 vlakno2 = new Vlakna11("vlakno2",6);
		Vlakna11 vlakno3 = new Vlakna11("vlakno3",8);
		Vlakna11 vlakno4 = new Vlakna11("vlakno4",10);
		Vlakna11 vlakno5 = new Vlakna11("vlakno5",5);
		Vlakna11 vlakno6 = new Vlakna11("vlakno6",6);
		vlakno6.start();vlakno5.start();vlakno4.start();
		System.out.println("Testovaci vypis 1");
		vlakno3.start();vlakno2.start();vlakno1.start();
		System.out.println("Testovaci vypis 2");
		try {										
			vlakno1.join();vlakno2.join();
			vlakno3.join();vlakno4.join();
			vlakno5.join();vlakno6.join();} 
		catch (InterruptedException e) {
			e.printStackTrace();	}
		System.out.println("Konec programu");	}
}

Kromě toho že se výpis mění jak kdy, podle naprosto neznámé logiky, je to skutečně fascinující. Přikládám i výpis. Podle mě by celé vlákno mělo projet komplet a nikoliv se přepínat a to samozřejmě i včetně výpisu.

Zacatek programu

Konstruktor od vlakna vlakno1

Konstruktor od vlakna vlakno2

Konstruktor od vlakna vlakno3

Konstruktor od vlakna vlakno4

Konstruktor od vlakna vlakno5

Konstruktor od vlakna vlakno6

Thread[vlakno6,6,main] vlakno6

Testovaci vypis 1

Thread[vlakno3,8,main] vlakno3

Thread[vlakno4,10,main] vlakno4

Thread[vlakno2,6,main] vlakno2

Testovaci vypis 2

Thread[vlakno5,5,main] vlakno5

Zde je vysledna hodnota :119999988 vlakno : vlakno6

Zde je vysledna hodnota :119999988 vlakno : vlakno4

Zde je vysledna hodnota :119999988 vlakno : vlakno3

Thread[vlakno1,4,main] vlakno1

Zde je vysledna hodnota :119999988 vlakno : vlakno2

Zde je vysledna hodnota :119999988 vlakno : vlakno5

Zde je vysledna hodnota :119999988 vlakno : vlakno1

Konec programu

#13 lukber
Tak za prvé. Pokud použiješ pouze druhou část mého zdroje není možné aby se zobrazilo stejné číslo. Kolekce Set<> nic takového neumožnuje.  Za druhé použití iteratoru není iterace. Iterátor = cyklus pro průchod kolekcí, a iterace = provádění matematické operace v numerických metodách kdy se snažíš konvergovat(česky = přibližovat) k přesnému řešení. 

#11 KIIV
Já si myslím, že to zadání je špatně pochopené, již zadavatelem. Podle triviálnosti úlohy se jedná rozhodně o školský příklad a to pochybuji, že ve škole mu řekli, že by nesměl mít opakující se čísla. Nebo si snad myslíš že po něm chtěli kolekce nebo komplikované cykly s porovnáváním hodnot v daném poli na úrovni studenta ? Mýlit se samozřejmě mohu. 

Taky přihodím troškou do mlýna. ( programuji v Javě cca 2 roky ) - neprofesionálně. Taky jsem si všiml, že různí autoři z různých knih to vysvětlují trochu jinak.(pravděpodobně chybná terminologie, která většinou vede k chybnému pochopení) Já to tedy chápu takto.   OBJEKT = INSTANCE = STRUKTUROVANÝ DATOVÝ TYP (složený např. primitivních datových typu nebo při kompozici z objektů).  Třída je class, která určuje schopnosti a možnosti jednotlivých objektů( např. metody,proměnné objektu).

   Můžeš zkusit např. nějaké warez fora a hledat nascenovanou literaturu, nebo na uloz.to jsem zahledl nascenovaného Herouta, ale toho starého. Či můžeš skusit koupit nějaké knihy z aukra. Pokud nechceš utrácet peníze tak přes google těch Java knih nalezneš gigabajty ovšem v Angličtině. Ale rozhodne doporučuji mít nějaké knížky a psát, a psát a psát programy. A abych nezapoměl opět psát a psát v IDE programy. Já osobně jsem si 3/4 Herouty koupil a nelituji.

A pokud bys trval tedy na tom ze skutečně potřebuješ aby se čisla neopakovala což porušuje základní principy random ( náhody ) pak je použití kolekce - Set taky docela vhodné 

import java.util.*;
public class A_035_NaplniPoleRandom {
	public static void main(String [] args){
		int [] pole = new int [7];		// deklarujes a alokujes pole v o velikosti 7 => pole[0],pole[1],...,pole[6]
		for(int i=0;i<pole.length;i++){ // cyklus for = pro kazde pole proved
			pole[i]=(int)(Math.random()*50.0);	// do prvku pole vloz cislo od 0 do 50
			System.out.println("Pole ["+(i+1)+"] ="+pole[i]);	} // proved vypis daneho prvku pole
		// a pro pripad ze by se nemeli opatkovat
		HashSet<Integer> mnozina = new HashSet<Integer>();
		do{		// provadej toto dokola
			mnozina.add((int)(Math.random()*50.0));
		} while ( mnozina.size() !=7);	// dokud nebude velikost kolekce rovna 7
		for(Iterator<Integer> iter = mnozina.iterator(); iter.hasNext();){ // iterator pro pruchod kolekci
			System.out.println("Cislo :"+iter.next());	}	}
}

Proč do toho tahat kolekce? Toto je trivialnější 

public class A_035_NaplniPoleRandom {
	public static void main(String [] args){
		int [] pole = new int [7];		// deklarujes a alokujes pole v o velikosti 7 => pole[0],pole[1],...,pole[6]
		for(int i=0;i<pole.length;i++){ // cyklus for = pro kazde pole proved
			pole[i]=(int)(Math.random()*100.0);	// do prvku pole vloz cislo od 0 do 100
			System.out.println("Pole ["+(i+1)+"] ="+pole[i]);	} // proved vypis daneho prvku pole
	}
}