czwartek, 22 grudnia 2011

Spring - pierwszy projekt

Spring
Spring składa się z pliku XML i Beanów.
Bean:
Jest to klasa zgodna ze specyfikacją JavaBeans.
Przykładowy program na bazie Springa.

HelloWorld.java
package hello;

public class HelloWorld {
    public void hello() {
 System.out.println("Hello World!!!");
    }
}

Plik XML:
Plik w którym zapisane są zależności między obiektami.

helloworld.xml
< beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
              
 <  bean id="helloworld" class="hello.HelloWorld" />


Uruchomienie:
Aby uruchomić przykład musimy podać ścieżkę do pliku XML, z którego będziemy korzystali:
Main.java
package hello;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
 public static void main(String[] args) {
  ApplicationContext context = new ClassPathXmlApplicationContext("helloBeans.xml");
  BeanFactory factory = context;
  HelloWorld bean = (HelloWorld) factory.getBean("helloworld");
  bean.hello();
  
 }
}

Cechy Springa:
Odwrócenie sterowania – kontener IoC (Inversion of Control) – technika, która pozwala przekazać na zewnątrz tworzenie i zarządzanie zależnościami obiektów. Opis zależności między klasami jest przeniesiony do oddzielnego pliku xml.

Zależności między Beanami:
Zależności między konkretnymi Beanami określa się w pliku XML. Są dwa sposoby ich określenia:
Za pomocą konstruktora:
 < bean id="PrimeServiceBean" class="kkk.PrimeService" />
 < bean id="ApplicationBean" class="kkk.Application">
  < constructor−arg>< ref bean=”PrimeServiceBean” />

Za pomocą setterów:
 < bean id="PrimeServiceBean" class="kkk.PrimeService" />
 < bean id="ApplicationBean" class="kkk.Application" >
  < property name="primeService" ref="PrimeServiceBean" />
 

Wykorzystanie zależności zapisanych w beanie. Program sprawdza czy podana liczba jest liczbą pierwszą.


Main.java
package kkk;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
 public static void main(String[] args) {
  ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  BeanFactory factory = context;
  Application test = (Application) factory.getBean("ApplicationBean");
  test.run();
  
 }
}
PrimeService.java
package kkk;

// odpowiedzialna za sprawdzenie czy dana liczba jest liczbą pierwszą
// powinny zostać wstrzyknięte do instancji Application z użyciem kontenera Spring 

public class PrimeService {
    public boolean sprawdzCzyPierwsza(int liczba) {
 double r = Math.sqrt(liczba);
 int i = 2;
 while (i <= r) {
     if ((liczba % i) == 0)
  return false;
     i++;
 }
 return true;
    }

}
Application.java
package kkk;

import java.util.Scanner;


// odpowiedzialna za wczytywanie wejścia i wypisywanie odpowiedzi

public class Application {
    private PrimeService primeService;

    public void setPrimeService(PrimeService primeService) {
 this.primeService = primeService;
    }

    public void run() {
 int liczba = wczytajDane();
 boolean czyPierwsza = primeService.sprawdzCzyPierwsza(liczba);
 wypiszWynik(czyPierwsza);
    }

    public static int wczytajDane() {
 Scanner s = new Scanner(System.in);
 System.out.print("Podaj liczbe: ");
 int w = s.nextInt();
 return w;
    }

    public static void wypiszWynik(boolean czyPierwsza) {
 if (czyPierwsza) {
     System.out.println("Wpisałeś liczbę pierwszą");
 } else {
     System.out.println("To nie jest liczba pierwsza");
 }
    }

}
bean.xml
< beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">

 < bean id="PrimeServiceBean" class="kkk.PrimeService" />
 < bean id="ApplicationBean" class="kkk.Application">
  
 

CRUD – podstawowe operacje na bazach danych

CRUD.java
package kkk;

public interface CRUD {
 public void create(Osoba osoba);
 public Osoba read(int id);
 public void update(Osoba osoba);
 public void delete(int id);
}

Manager.java
package kkk;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Manager implements CRUD {

 @Override
 public void create(Osoba c) {
  String query = "INSERT INTO OSOBA VALUES(" 
+ c.getId() + ", '" + c.getImie() + "','" + c.getNazwisko() + "');";
  try {
   polaczenieUpdate(query);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

 @Override
 public Osoba read(int id) {
  Osoba osoba = new Osoba();
  Statement statement;
  ResultSet rs;
  try {
   Class.forName("org.h2.Driver");
   Connection conn = DriverManager.getConnection("jdbc:h2:~/baza_ksiazki",
 "sa", "");
   statement = conn.createStatement();
   String query = "SELECT * FROM OSOBA where id = " + id;
   rs = statement.executeQuery(query);
   while (rs.next()) {
    osoba = new Osoba(rs.getInt("id"), 
rs.getString("IMIE"), rs.getString("nazwisko"));
   }
   conn.close();
   System.out.println(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return osoba;
 }

 @Override
 public void update(Osoba c) {
  String query = "UPDATE Osoba SET imie='" 
+ c.getImie() + "',nazwisko='" + c.getNazwisko() + "' WHERE ID=" + c.getId()
    + ";";
  try {
   polaczenieUpdate(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 @Override
 public void delete(int id) {
  String query = "DELETE from Osoba  WHERE ID=" + id + ";";
  try {
   polaczenieUpdate(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public void polaczenieUpdate(String query) {
  Statement statement;
  try {
   Class.forName("org.h2.Driver");
   Connection conn = DriverManager.getConnection("jdbc:h2:~/baza_ksiazki",
 "sa", "");
   statement = conn.createStatement();
   statement.executeUpdate(query);
   conn.close();
   System.out.println(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public void tworzenieBazy() {
  String konstruktorTabeliOsoba = "DROP TABLE IF EXISTS OSOBA; CREATE 
TABLE OSOBA(ID INT PRIMARY KEY, IMIE VARCHAR(255), NAZWISKO VARCHAR(255));";
  try {
   polaczenieUpdate(konstruktorTabeliOsoba);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

}

Main.java
package kkk;

public class Main {

 public static void main(String[] args) {
  Manager manager = new Manager();
  manager.tworzenieBazy();

  Osoba os1 = new Osoba(1, "adam", "piep");
  Osoba os2 = new Osoba(2, "tom", "kiep");

  manager.create(os1);
  manager.create(os2);

  Osoba wczytanaOsoba = manager.read(2);
  System.out.println("--- " + wczytanaOsoba.getImie() + " " 
+ wczytanaOsoba.getNazwisko() + " ---");

  Osoba os3 = new Osoba(2, "kamil", "rosol");
  manager.update(os3);

  wczytanaOsoba = manager.read(2);
  System.out.println("--- " + wczytanaOsoba.getImie() + " " 
+ wczytanaOsoba.getNazwisko() + " ---");

  manager.delete(2);
  wczytanaOsoba = manager.read(2);
  System.out.println("--- " + wczytanaOsoba.getImie() + " " 
+ wczytanaOsoba.getNazwisko() + " ---");
 }

}

Osoba.java
package kkk;

public class Osoba {
 private int  id;
 private String imie;
 private String nazwisko;

 public Osoba() {
 };

 public Osoba(int id, String imie, String nazwisko) {
  this.id = id;
  this.imie = imie;
  this.nazwisko = nazwisko;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getImie() {
  return imie;
 }

 public void setImie(String imie) {
  this.imie = imie;
 }

 public String getNazwisko() {
  return nazwisko;
 }

 public void setNazwisko(String nazwisko) {
  this.nazwisko = nazwisko;
 }

}

wtorek, 22 listopada 2011

Programowanie aspektowe – aspekty statyczne

W części pierwszej opisane zostały aspekty dynamiczne, czyli dodatki do istniejących klas i metod. Tym razem opiszę aspekty statyczne. Aspekty te pozwalają dodać nowe metody i pola do istniejących klas.
Aaa:
package kkk;

public class Aaa {

    public static void main(String[] args) {

 Obiekt samochodzik = new Obiekt((float) 99.99);
 System.out.println("cena - " + samochodzik.getCena());

 System.out.println("po podatku - " + samochodzik.dodajPodatek(99));
 System.out.println("po uldze - " + dodajUlge(99));

    }

    public static float dodajUlge(float cena) {
 return cena - cena * ulga / 100;
    }
}
AddMethod:
package kkk;

public aspect AddMethod {
    public static float podatek = 23;
    public static int Aaa.ulga = 15;

    public float Obiekt.dodajPodatek(float cena) {
 return cena + cena * podatek / 100;
    }
}
Obiekt:
package kkk;

public class Obiekt {
    private float cena;

    public Obiekt(float cena) {
 this.setCena(cena);
    }

    public float getCena() {
 return cena;
    }

    public void setCena(float cena) {
 this.cena = cena;
    }
}
Wynik:
cena - 99.99
po podatku - 121.770004
po uldze - 84.15

Jak widać w przykładzie aspekt dodaje jedną metodę do klasy Obiekt i jedno pole do klasy Aaa.
Na tych metodach i polach można operować tak samo jak na tych napisanych wprost.

czwartek, 10 listopada 2011

Czytywanie z i zapis do pliku

Dwie podstawowe operacje wykorzystywane przy pracy z plikami tekstowymi.

Wczytywanie pojedynczej linii z pliku:
public static void odczyt() {
 Scanner odczyt = null;
 try {
     odczyt = new Scanner(new File("C:/pliktekstowy.txt"));
 } catch (FileNotFoundException e) {
     e.printStackTrace();
 }
 String zdanie = odczyt.nextLine();
 System.out.println(zdanie);
    }
Zapis do pliku:
public static void zapis() {
 PrintWriter zapis = null;
 try {
     zapis = new PrintWriter("C:/pliktekstowy2.txt");
 } catch (FileNotFoundException e) {
     e.printStackTrace();
 }
 zapis.println("Hello World");
 zapis.close();
    }

środa, 2 listopada 2011

Programowanie aspektowe - AspectJ

Paradygmat programowania, który wspomaga separację programu na części jak najbardziej ze sobą niezwiązane. Pozwala zredukować ilość pisanego kodu, jednocześnie dzieląc program na logiczne moduły. Zmienia układ modułów widoczny dla programisty, po skompilowaniu do bytecodu jest całkowicie normalnym programem.
Styl programowania aspektowego stosowany jest do np. wydzielenia z kodu programu metod logowania. Zamiast w każdej klasie, czy metodzie pisać linijkę kodu zawierającą zapis do dziennika (log), można to wydzielić do aspektu, czyli innej klasy, która będzie wyszukiwała odpowiednią metodę i sama doda tą linijkę.

Główne zastosowania:
  • Zarządzanie transakcjami
  • Kontrola dostępu
  • Zarządzanie współbieżnym wykonaniem
  • Audyt/Monitorowanie
  • Wstrzykiwanie zależności
  • Uproszczenie wzorców projektowych
  • Narzędzia do generowania kodu infrastruktury

Instalacja:
W Eclipsie -> Help -> Install New Software… -> wpisujemy strone: http://download.eclipse.org/tools/ajdt/37/update -> wybieramy AspectJ Development Tools -> instalujemy

HelloWorld:
Aby utworzyć nowy projekt w AspectJ wybieramy:
File -> New -> Other… ->AspectJ -> Aspect Project
Możemy tworzyć zwykłe projekty Javy, do tego mogąc dodać aspekt.
public class Main {

    public static void main(String[] args) {
 HelloWorld.say("wiadomosc");
 HelloWorld.sayToPerson("wiad", "name");
    }
}
public class HelloWorld {
    public static void say(String message) {
 System.out.println(message);
    }

    public static void sayToPerson(String message, String name) {
 System.out.println(name + "," + message);
    }
}
Klasa AspectJ: PPM na projekcie -> New -> Other… -> AspectJ -> Aspect
public aspect MannersAspect {
    pointcut callSayMessage() : call( public static void HelloWorld.say*( . . ) ) ;

    before() : callSayMessage ( ) {
 System.out.println("Good day ! ");
    }

    after() : callSayMessage() {
 System.out.println("Thank you ! ");
    }
}
Uruchomienie: PPM na klasę Main -> Run as -> AspectJ/Java Application
Otrzymany wynik:
Good day !
wiadomosc
Thank you !
Good day !
name,wiad
Thank you !

Powyższy przykład pokazuje jak bez ingerencji w metody można dodać przed ich wykonaniem i po ich zakończeniu komunikat.
Teraz dodam kolejny aspekt obliczający czas wykonania wszystkich metod publicznych:
public aspect TimeAspect {
    pointcut publicTime() : execution(public * *.*(..)) && !execution(* Main.*(..));

    Object around() : publicTime() {
 long time = System.nanoTime();
 Object ret = proceed();
 System.out.println(System.nanoTime() - time);
 return ret;
    }
}
Wynik programu:
Good day !
wiadomosc
65698
Thank you !
Good day !
name,wiad
98034
Thank you !

Jak wygląda aspekt?
Aspekt jest traktowany jak zwykła klasa, zamiast class użyty jest aspect.
Ciało aspektu składa się z:
  • pointcut,
  • advice,

pointcut (definicja przecięcia)
Określa kontekst, dla którego ma działać aspekt, tzn. specyfikuje dla jakich metod (np. publicznych), o jakich nazwach (albo np. początkach nazw (HelloWorld.say*)-gwiazdka oznacza, że może być tu dowolny tekst), czy dla metod z jakimi parametrami aspekt ma być stosowany.

Specyfikator pointcut nazwa() : typ sygnatura
  • Specyfikator – tak jak w zwykłych metodach public, private…
  • pointcut – słowo kluczowe,
  • nazwa() – nazwa naszego przecięcia – może zawierać parametry, które są przekazywane w przechwytywanych metodach,
  • typ: call albo execution. Zazwyczaj dają taki sam efekt,
  1. call – aspekt wplatany jest w każde miejsce wywołania metody
  2. execution – aspekt wplatany jest w ciało przechwyconej metody, bardziej preferowana
  • Sygnatura – określa jakie metody aspekt ma przechwytywać, określa kolejno :
  1. adnotacje (opcjonalne)
  2. modyfikatory (opcjonalne)
  3. zwracaną wartość (wymagane)
  4. pakiet (opcjonalnie)
  5. klasę (wymagane)
  6. nazwę metody (wymagane)
  7. parametry (wymagane)

Przykład:
Zastosowane wszystkie parametry:
pointcut p1() : execution (@Special public void p2.App.m1(String));
Zastosowane tylko wymagane parametry:
pointcut p1() : execution (void App.m1(String));

Wieloznaczniki:
Zamiast wpisywania wszystkich parametrów można użyć wieloznaczników typu: * .. +
  • * oznacza wiele znaków (ale bez kropki),
  • .. oznacza wiele znaków (również kropki),
  • + rozszerza określenie typu o dowolny podtyp,

execution (void ppp.kkk.*(*)); - wszystkie metody w klasie “kkk” paczki „ppp”
execution (* ppp.*.*()); - wszystkie metody bez parametrów w paczce „ppp”,
execution (* ppp..*.*(..)); - oznacza paczkę „ppp” i wszystkie podrzędne pakiety metoda bez lub z dowolną ilością parametrów,

advice (rada):
miejsce(parametry) : nazwaPointcuta(parametry){
ciało metody
}
miejsce - określa w którym miejscu ma być wykonany kod aspektu:
  • before(): rada zostanie wykonana przed przechwyconym punktem złączenia,
  • around(): rada zostanie wykonana zamiast punktu złączania, chyba że metoda proceed() nakazuje inaczej,
  • after(): rada zostanie wykonana po przechwyconym punkcie złączenia, niezależnie od wyniku wykonania tego punktu;,
  • after() returning: rada zostanie wykonana po przechwyconym punkcie złączenia wyłącznie wtedy, gdy punkt ten wykonał się nie zgłaszając wyjątku;,
  • after() throwing: rada zostanie wykonana po przechwyconym punkcie złączenia wyłącznie wtedy, gdy punkt ten wykonał się zgłaszając wyjątek,

Przykład aspektu z parametrami:
public aspect ValidAspect {
    pointcut valid(int a) :
 call( public static int HelloWorld.sprawdz(int) ) && args(a) ;

    before(int a) : valid (a) {
 System.out.println("Good day ! " + a);
 if (a == 9) {
     System.out.println("----- znaleziono 9 -----");
 }
    }

    after(int a) : valid(a) {
 System.out.println("Thank you ! ");
    }
}
Część druga - aspekty statyczne.

niedziela, 30 października 2011

Maven - Eclipse

Maven jest narzędziem do budowy oprogramowania.
Cechy Mavena:
  • standaryzuje rozmieszczenie katalogów w systemie, nazewnictwo bibliotek i archiwów,
  • umożliwia podział projektu na moduły, z których każdy ma własną konfigurację,
  • wszystkie dane związane z budową aplikacji i  potrzebnymi wtyczkami umieszczone są w pliku konfiguracyjnym POM (Project Object Model).,
  • proces budowania oparty jest na wtyczkach,
  • istnieje możliwość dziedziczenia i system zależności pozwalający ograniczyć powtarzanie kodu,
  • pozwala generować raporty,

Instalacja:
w Eclipsie wybieramy Help->Install New Software... Dodajemy stronę: http://m2eclipse.sonatype.org/sites/m2e  -> zaznaczamy wszystko ->instalujemy.

Pierwszy projekt:
File->New->Other...->Maven->Maven Project
Wybieramy archetyp, czyli rodzaj budowanej aplikacji (w tym przypadku do budowy prostego programu wystarczy zaznaczony maven-archetype-quickstart)

Uzupełniamy podstawowe informacje o projekcie:
  • GroupID - id organizacji tworzącej projekt np. com.mycompany.app,
  • ArtifactId - nazwa projektu,
  • modelVersion - wersja modelu POM,
  • Package – nazwa automatycznie utworzonej paczki z domyślną klasą,
Te i inne dane wpisane przy tworzeniu można później zmienić w pliku POM.xml.

Po utworzeniu projektu w pliku POM.xml mamy jeszcze pozycje:
  • packaging - rodzaj wynikowego archiwum jar,war,...
  • url - adres strony projektu
  • properties - project.build.sourceEncoding - zastosowane kodowanie
Struktura katalogów:
Dodanie biblioteki:
Aby dodać bibliotekę używaną w projekcie wystarczy dopisać ją do POM, a Maven sam już ją ściągnie i zamontuje. Aby to zrobić należy wpisać w sekcji <dependencies> </dependencies> nową zależność:

Dodanie biblioteki JUnit:
<dependency>
<groupId>junit</groupId>   <!--nazwa archiwum-->
<artifactId>junit</artifactId> <!--nazwa archiwum-->
<version>3.8.1</version>   <!--wersja archiwum-->
<scope>test</scope>   <!--zasięg widoczności artefaktu-->
</dependency>

Zakres widoczności <scope> dzielimy na:
  • test  - obecna tylko przy uruchomieniu testów, nie włączana do wynikowego archiwum,
  • compile - włączana do archiwum,
  • provided - udostępniona przez środowisko uruchomieniowe, nie włączana do archiwum,
  • system - udostępniania przez system,
  • import - dołącza artefakt typu POM,

Moduły:
Dzięki Maven można tworzyć projekty złożone z modułów, czyli innych projektów, projekty podrzędne dziedziczą z nadrzędnego.
POM projektu głównego:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>pl.kodujemy</groupId>
<artifactId>ProjektGlowny</artifactId>
<packaging>pom</packaging>   <!-- projekt nadrzędny trzeba zmienić na pom-->
<version>1.0-SNAPSHOT</version>
<name>kodujemy</name>
<url>http://maven.apache.org</url>
<modules>  <!-- litsta modułów projektu -->
<module>widok</module>
<module>model</module>
<module>kontroler</module>
</modules>
...
</project>

POM podrzędny:
<project>
<parent>   <!-- nazwa rodzica -->
<groupId>pl.kodujemy</groupId>
<artifactId>ProjektGlowny</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>pl.kodujemyy</groupId>
<artifactId>widok</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>widok</name>
<url>http://maven.apache.org</url>
...
</project>

Aby stworzyć moduł do projektu:
New->Other...->Maven->Maven Module
Wybieramy Parent Project - czyli projekt pod który chcemy się podpiąć, pamiętając, aby wcześniej zmienić wartość jego <packaging> na pom.

Funkcje:
Z poziomu menu kontekstowego PPM->Run As mamy do wyboru kilka funkcji Mavena do wyboru:
  • assembly,
  • build,
  • clean,
  • generate sources,
  • install – skopiowanie utworzonego artefaktu do lokalnego repozytorium,
  • package – utworzenie wynikowego artefaktu, np.: archiwum jar lub war,
  • test – wykonanie testów jednostkowych,

Raporty:
Maven umożliwia wygenerowanie raportów np:
  • maven-javadoc-plugin – tworzy dokumentacje javadoc,
  • maven-checkstyle-plugin – raport stylu kodu: obecność komentarzy, użycie zmiennych, importów...
  • maven-pmd-plugin – wykrywa fragmenty pisane metodą „kopiuj/wklej”, pomijane bloki kodu...
  • findbugs-maven-plugin – wykrywa typowe błędy statyczne,
  • maven-surefire-report-plugin – raport wykonania testów,

Sekcja raportów:
<project>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
<version>3.0-beta-2</version>
<configuration>
<reportPlugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.7</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jxr-plugin</artifactId>
<version>2.1</version>
<configuration>
<aggregate>true</aggregate>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-report-plugin</artifactId>
<version>2.6</version>
</plugin>
</reportPlugins>
</configuration>
</plugin>
</plugins>
</build>
</project>

sobota, 29 października 2011

Java – konsola

Wczytywanie pojedynczych znaków z konsoli:
package kkk;

import java.io.*;
class BRReadLines{
    public static void main(String args[]) throws IOException {
 char c;
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 System.out.println("Wpisz znaki, 'q' to quit.");
 do {
     c = (char) br.read();
     System.out.println(c);
 } while (c != 'q');
    }
}
Wczytywanie łańcuchów znaków z konsoli:
package kkk;

import java.io.*;
class Main {
    public static void main(String args[]) throws IOException {
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 String str;
 System.out.println("Enter lines of text.");
 System.out.println("Enter 'stop' to quit.");
 do {
     str = br.readLine();
     System.out.println(str);
 } while (!str.equals("stop"));
    }
}
Znalezione na http://math.hosted.pl/math_2/programowanie_obiektowe/wyklad10.pdf
import java.util.Scanner;

public class Czytanie {
    public static void main(String args[]) {
 Scanner s = new Scanner(System.in);
 System.out.print("Imię i nazwisko: ");
 String i = s.next();
 String n = s.next(); // wczytywanie słów
 System.out.println(i+" "+n);
 System.out.println("Pseudo:");
 String r = s.next(); 
 System.out.println(r);
 System.out.print("Wiek: ");
 int w = s.nextInt(); // wczytwanie liczby całkowitej
 System.out.print("Zarobki: ");
 double z = s.nextDouble(); // rzeczywistej
 System.out.print("Opis: ");
 String o = s.nextLine(); // wiersza
    }
}
Znalezione na: http://student.pwsz.elblag.pl/~jopi/?co=obiektowe&id=021&p=1

wtorek, 18 października 2011

Logi - Log4j

Chronologiczny zapis informacji z działania systemu. Dane zapisywane w pliku, bazie danych, czy wyświetlane na konsoli z informacjami o przebiegu działania programu, sytuacjach gdzie występują błędy, albo jakiekolwiek inne ważne wg nas informacje. Może się przydać gdy w działającym już programie wystąpi błąd, a odtworzenie sytuacji kiedy on wystąpił jest trudne. Logi mogą być zastępowane przez nowsze co jakiś czas.

Przykład:
Klasa w której wywołujemy zapis logów:
package logi;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

public class Log4jTest {
// inicjalizacja logera
static final Logger logger = Logger.getLogger(Log4jTest.class); 
public static void main(String[] args) {

// plik konfiguracyjny
 PropertyConfigurator.configure("log4j.properties"); 

// wywołanie logów
 logger.trace("Info - TRACE");   
 logger.debug("Info - DEBUG");
 logger.info("Info - INFO");
 logger.warn("Info - WARN");
 logger.error("Info - ERROR");
 logger.fatal("Info - FATAL");
    }
}
Plik konfiguracyjny "log4j.properties":
#Ustalamy gdzie i jakie komunikaty beda wywolywane CA-konsola 
log4j.rootLogger=DEBUG, CA 

#Ustawienia dla konsoli
log4j.appender.CA=org.apache.log4j.ConsoleAppender
log4j.appender.CA.layout=org.apache.log4j.PatternLayout
#Typ komunikatu
log4j.appender.CA.layout.ConversionPattern=%-4r [%t] %-5p  %x - %m%n
Wyniki wypisany na konsoli:
1    [main] DEBUG   - Info - DEBUG
2    [main] INFO    - Info - INFO
2    [main] WARN    - Info - WARN
2    [main] ERROR   - Info - ERROR
2    [main] FATAL   - Info - FATAL 
Zapisanie loga do pliku.
Zmieniamy plik konfiguracyjny „log4j.properties
#Ustalamy gdzie i jakie komunikaty beda wywolywane CA-konsola 
log4j.rootLogger=DEBUG, CA, FA

#Ustawienia dla konsoli
log4j.appender.CA=org.apache.log4j.ConsoleAppender
log4j.appender.CA.layout=org.apache.log4j.PatternLayout
log4j.appender.CA.layout.ConversionPattern=%-4r [%t] %-5p  %x - %m%n

#Ustawienie dla pliku z logami
log4j.appender.FA=org.apache.log4j.FileAppender
log4j.appender.FA.File=plikzlogami.log
log4j.appender.FA.layout=org.apache.log4j.PatternLayout
log4j.appender.FA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

#Ustawiamy poziom od ktorego komunikaty maja pojawiac sie w pliku
log4j.appender.FA.Threshold = WARN
Wyniki jakie otrzymamy w pliku. Plik „plikzlogami.log” stworzyliśmy w katalogu z projektem
1    [main] WARN  logi.Log4jTest  - Info - WARN
1    [main] ERROR logi.Log4jTest  - Info - ERROR
2    [main] FATAL logi.Log4jTest  - Info - FATAL
Hierarchia komunikatów loggera od najmniej ważnego:
  • TRACE,
  • DEBUG,
  • INFO,
  • WARN,
  • ERROR,
  • FATAL

Wyjaśnienie konwencji zapisu:
''%d %5p %c{2}:%L - %m%n''
  • %d – czas wystąpienia zdarzenia
  • %p – poziom zdarzenia, (5 - liczba znakow dla pola)
  • %c – nazwa loggera zdarzenia (liczba hierarchii od końca {x})
  • %L – numer linii w pliku źrodłowym
  • %m – opis zdarzenia
  • %n – sparator linii zależy od platformy (\n lub \r\n)

sobota, 15 października 2011

Testowanie programu – JUnit

Testy jednostkowe to testy pojedynczych, najmniejszych metod w programie. Testowanie polega na porównaniu wyników jakie zwróci metoda (nie chodzi tylko o return, ale o wszystko na co ma wpływ, czyli np. czy dobrze zapisze wartość do bazy, czy usunie obiekt z listy) z wynikami oczekiwanymi zawartymi w teście. Przed rozpoczęciem testu można przygotować jego środowisko, czyli warunki w jakich metoda ma pracować (stworzeni obiektów, połączeń z bazą z których może korzystać).
Klasy testowe JUnit to zwykłe klasy, w których za pomocą specjalnych adnotacji określa się testy.

Podstawowe adnotacje: 
  • @BeforeClass – metoda wykonywana raz przed wszystkimi testami,
  • @Before – metoda wykonywana przed każdym testem,
  • @Test – oznaczenie testu,
  • @After – metoda wykonywana po każdym teście,
  • @AfterClass –metoda wykonywana raz po wszystkich testach,
  • @Ignore – wyłączenie testu,


Podstawowe metody używane w testach:
  • fail(wiadomość); – informuje, że metoda jest niepoprawna, zwraca komunikat „wiadomość”
  • assertTrue(warunek); - test poprawny gdy warunek = true,
  • assertTrue(wiadomość, warunek); - jeżeli warunek = true test jest poprawny, inaczej zwróci błąd i komunikat „ wiadomość”
  • assertEquals(wiadomość, spodziewane, aktualne); - porównuje wartość spodziewaną z wartością aktualną, porównuje kolejne wartości w listach, przy będzie wyświetli dodatkowo wiadomość,
  • assertEquals(wiadomość, spodziewane, aktualne, tolerancja); - porównuje wartości float i double i jeżeli róznica miedzy nimi nie jest większa niż tolerancja test jest pozytywny,
  • assertNull(wartość); – jeżeli wartość = null test jest pozytywny,
  • assertNotNull(„wiadomość”,wartość); – jeżeli wartość != null test jest pozytywny, jeżeli wartość = null wyświetli wiadomość,
  • assertSame(wiadomość, oczekiwana, aktualna); – sprawdza czy obiekt oczekiwany i aktualny jest takiego samego typu (czyli np. String int), jeżeli nie wyświetli wiadomość
  • assertNotSame(wiadomość, oczekiwana, aktualna); – sprawdza czy obiekt oczekiwany i aktualny jest różnego typu (czyli np. String int), jeżeli nie wyświetli wiadomość


Cechy testów:
  • Automatyzacja – uruchamianie testów musi być łatwe,
  • Kompletność – należy testować wszystko co może zawieść,
  • Powtarzalność – wielokrotne wykonanie testu daje te same wyniki,
  • Niezależność – od środowiska i innych testów,


Nazewnictwo:
  • KlasaPierwszaTest - Klasa w której testujemy klasę o nazwie „KlasaPierwsza”,
  • testMetodaPierwsza – metoda, która testuje metodę o nazwie „metodapierwsza”


Przykład:
Dla interfejsu:
public interface UserService {
class IllegalUsernameException extends RuntimeException {}
void addUser(User user) throws IllegalUsernameException;
User getUser(String username) throws IllegalUsernameException;
} 
Klasa wygenerowana automatycznie w Eclipse (ppm na nazwę klasy w menagerze -> New -> JUnit Test Case):
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class UserServiceTest {
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }
    @Before
    public void setUp() throws Exception {
    }
    @After
    public void tearDown() throws Exception {
    }
    @Test
    public void testAddUser() {
                        fail("Not yet implemented");
    }
    @Test
    public void testGetUser() {
                        fail("Not yet implemented");
    }
}
Klasa testowa:
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import org.junit.Before;
import org.junit.Test;
public class UserServiceTest {
    @Before
    public void setUp() throws Exception {
                        ArrayList<User> listUsers = Main.getListUsers();
                        listUsers = new ArrayList<User>();
                        Main.setListUsers(listUsers);
    }
    @Test
    public void testAddUser() {  
                        UserServiceImpl impl = new UserServiceImpl();
                        User u1 = new User();
                        impl.addUser(u1);
                        ArrayList<User> listUsers = Main.getListUsers();
                        assertNotNull( listUsers.get(0));
    }
    @Test
    public void testGetUser() {
                        UserServiceImpl impl = new UserServiceImpl();
                        User u1 = new User();
                        String imie = "kkk";
                        u1.setName(imie);
                        impl.addUser(u1);
                        User u2 = impl.getUser(imie);
                        ArrayList<User> listUsers = Main.getListUsers();
                        assertTrue( listUsers.get(0)==u2);
    }
}

czwartek, 6 października 2011

Skróty klawiszowe w Eclipse

Skróty klawiszowe zdecydowanie ułatwiają prace przy kodzie. Oto moje propozycje do codziennego stosowania:
Ctrl+Spacja – czyli auto-uzupełnianie tekstu. Chyba najważniejszy skrót w historii :) Bardzo ułatwia pisanie. Nie trzeba martwić się o literówki. Wystarczy wpisać początek interesującej nas formułki i po naciśnięciu tej kombinacji wyświetlona zostanie lista propozycji dokończenia tekstu. Dodatkowo pozwala szybko wpisywać całe często używane komendy np.:
syso + Ctrl+spacja   > System.out.println()

Inne ciekawe skróty:
Ctrl+/ - zakomentowanie zaznaczonych linii za pomocą "//"
Ctrl+Shift+F – formatuje kod według zapisanych wcześniej reguł
Ctrl+D - usunięcie całej linii w której znajduje się kursor (bez konieczności jej zaznaczenia)
Ctrl+Shift+O - porządkowanie importów
Ctrl+F6, Ctrl+E - wyświetla okno dzięki któremu możemy przeskoczyć no innego otwartego edytora. 

Poniżej przedstawiam listę wszystkich skrótów klawiszowych w Eclipse znalezioną na:

Aby zmienić, bądź ustawić własne skróty klawiszowe należy wybrać:
Windows › Preferences › General › Keys, wybrać Command, który chcemy ustawić i w polu Binding wpisać skrót.
Dla przykładu ustawiłem skrót do automatycznego generowania Getterów i Setterów dla istniejących pól jako Alt+Shift+S.


piątek, 23 września 2011

Eclips + Javadoc

Eclipse ułatwia korzystanie z javadoc-u. Aby wygenerować szkielet komentarza, należy:
  • Wpisać ciąg znaków: „*/**”,
  • Umieścić kursor w linijce z nagłówkiem klasy/ metody/ zmiennej, którą chcemy skomentować. Z menu kontekstowego wybrać Source->Add javadoc comment, lub nacisnąć Shift+Alt+J.

Np. dla metod zostanie wygenerowany komentarz zawierający odpowiednie wpisy:
  •  @param,
  •  @returns,
  •  @throws.

Szkielet komentarzu można modyfikować w preferencjach Eclipse'a: menu Window->Preferences->Java->Code Style->Code Templates.

Aby wygenerować dokumentacje należy wybrać: menu Project -> Generate Javadoc. Można tam określić dla jakich pakietów, czy klas chcemy wygenerować dokumentacje, albo jakie tagi uwzględnić.

środa, 21 września 2011

Dobre praktyki kodowania

Dobry kod jest:
  • czytelny,
  • prosty,
  • wydajny,
  • minimalny,
  • łatwy do zmiany,
  • posiada testy,

Pisanie kodu:
Najważniejsza jest czytelność kodu. Pisany kod powinien być zrozumiały dla innych, nie tylko do piszącego.
Nie powtarzaj się, bez sensu jest pisać kod wykonujący tą samą funkcjonalność w kilku miejscach.
Pliki nie powinny być większe niż 500 wierszy, a wiersz nie powinien być dłuższy niż 120 znaków. Zapewni to większą czytelność kodu, bez potrzeby długiego przewijania pliku.
Używaj wcięć w kodzie: przy warunkach, zagnieżdżeniach czy pętlach.

Nazwy:
Nazwy metod powinny być czasownikami,
Nazwy zmiennych, klas i obiektów powinny być rzeczownikami,
Nazwy klas – zaczynane od dużej litery (np. Student),
Stałe  - złożone tylko z dużych liter (np. MAX_VALUE),
Metody i zmienne zaczynają się małą literą, a nowe słowo z dużej bez podkreślników, myślników, innych odstępów w nazwie (np. returnOsoba),
Nazwy powinny mieć znaczenie,
Nazwy mogą być długie, nie używać niezrozumiałych skrótów,
Nazwy nie powinny być podobne do siebie,
Nazwy powinny odnosić się do rozwiązywanego problemu,
Nazwy powinny być możliwe do wymówienia,
Nie używać jednoliterowych zmiennych chyba ze jako licznik pętli (i,j,k)
Unikać słów kluczowych np. manager, procesor, info,
Używać set, get, is.

Metody:
Metody powinny być krótkie (max 20 wierszy),
Jak najmniej kodu w pętlach i warunkach (najlepiej jeden wiersz),
Metody nie powinny mieć wielu argumentów (najlepiej 0, max 3),
Metoda powinna wykonywać tylko jedno zadanie i nie mieć efektów ubocznych,
Metoda nie powinna robić czegoś co nie wynika jasno z jej nazwy,
Metody muszą być zrozumiałe,
Długą obsługę wyjątku lepiej przenieść do nowej metody,
Metody w klasie powinny być ułożone hierarchicznie. Bezpośrednio pod metodą wszystkie metody w niej wykorzystywane,
Metoda powinna korzystać tylko z metod udostępnionych przez:
  • macierzysty obiekt,
  • obiekty podane w argumentach,
  • obiekty które sama stworzyła,

Komentarze:
Najlepszą formą komentarza jest sam kod. Lepiej gdy komentarzy jest jak najmniej, a jeżeli już wystąpił powinien być zwięzły. Komentarze mają tendencję do utraty aktualności, w miarę starzenia się kodu. Lepiej zmienić kod, tak aby był czytelniejszy niż komentować kod nieczytelny. Nie używać graficznych podziałów kodu np. /////////////////// filtr /////////
Nie zakomentowywać kodu – później nie wiadomo co on robił do czego służył i czy można go usunąć.

Zły komentarz to komentarz:
  • opisujący oczywistość,
  • nieaktualny,
  • kłamliwy,
  • który nic nie wnosi,

Gdzie można komentować:
  • copyright u góry pliku,
  • cel wykonania wydawałoby się bezsensownych akcji,
  • wytłumaczenie użytych bibliotek,
  • komentarze TODO – rzeczy do zrobienia w przyszłości (najlepiej żeby było ich jak najmniej i żeby szybko go usunąć).

wtorek, 20 września 2011

Podstawowe operacje. Cz. 1. „Zmienne i pętle”

Zmienne
Zanim przejdziemy do omówienia podstawowych operacji musimy omówić zmienne. Zmienne są to liczby, znaki, napisy itd., które się zmieniają w trakcie wykonywania programu. Proste. Aby zadeklarować, czyli utworzyć taką zmienną musimy podać jej typ (czyli właśnie czy to będzie liczba, czy np. napis) oraz jej nazwę, którą będziemy się posługiwać.
  int calkowita; // liczba całkowita bez podanej wartości
  calkowita = 8; // deklaracja naszej liczby
  char znak = 'p'; // znak
  String napis = "xxxxx"; // napis
                 
Powyżej widać przykładową deklaracje trzech zmiennych. Aby wypisać taką zmienną na konsoli posłużymy się znaną już komendą:
                        System.out.println("liczba: " + calkowita + " a teraz string: " + napis);
Zmienna pomiędzy  plusami zostanie wstawiona w tekst. Klasa po zmianach wygląda teraz tak:
public class PierwszaKlasa {
  public static void main(String[] args) {
    int calkowita; // liczba całkowita bez podanej wartości
    calkowita = 8; // deklaracja naszej liczby
    char znak = 'p'; // znak
    String napis = "xxxxx"; // napis
    System.out.println("liczba: " + calkowita + " a teraz string: " + napis);
  }
}
A wynikiem jest:
liczba: 8 a teraz string: xxxxx

Pętla „while”
Pętla „while” czyli „dopóki” będzie się wykonywała dopóki warunek w niej zawarty jest prawdziwy. Ogólnie wygląda to tak:
while(warunek){
ciało pętli
}
Podam prosty przykład:

while(calkowita > 0){
   System.out.println("while: " + calkowita + " a teraz string: " + napis);
   calkowita = calkowita - 1;
}
Zwróci wynik:
while: 8 a teraz string: xxxxx
while: 7 a teraz string: xxxxx
while: 6 a teraz string: xxxxx
while: 5 a teraz string: xxxxx
while: 4 a teraz string: xxxxx
while: 3 a teraz string: xxxxx
while: 2 a teraz string: xxxxx
while: 1 a teraz string: xxxxx

Pętla „for”
Pętla, która będzie się wykonywała dla (for) jakiegoś warunku. Pętla jest bardzo podobna do „while”, tylko dodatkowo można przy jej tworzeniu zadeklarować wartość i automatycznie dokonywać jej zmiany. Podstawowa pętla „for” ma wygląd:
for(wartość początkowa; warunek; operacja){
ciało pętli
}
Przykład:
for(int liczba = 0; liczba < 10; liczba=liczba+1){
    System.out.println("for: " + liczba + " a teraz string: " + napis);
}
Wynik operacji:
for: 0 a teraz string: xxxxx
for: 1 a teraz string: xxxxx
for: 2 a teraz string: xxxxx
for: 3 a teraz string: xxxxx
for: 4 a teraz string: xxxxx
for: 5 a teraz string: xxxxx
for: 6 a teraz string: xxxxx
for: 7 a teraz string: xxxxx
for: 8 a teraz string: xxxxx
for: 9 a teraz string: xxxxx
Po wszystkich zmianach nasza klasa wygląda tak:
public class PierwszaKlasa {
 public static void main(String[] args) {

  int calkowita; // liczba całkowita bez podanej wartości
  calkowita = 8; // deklaracja naszej liczby
  char znak = 'p'; // znak
  String napis = "xxxxx"; // napis

  System.out.println("liczba: " + calkowita + " a teraz string: " + napis);

  
  while(calkowita > 0){
   System.out.println("while: " + calkowita + " a teraz string: " + napis);
   calkowita = calkowita - 1;
  }
  
  
  for(int liczba = 0; liczba < 10; liczba=liczba+1){
   System.out.println("for: " + liczba + " a teraz string: " + napis);
  }
  
 }
}

Programowanie dla zielonych Cz. 3 „Hello World”

Uruchomienie.
W tej części uruchomimy nasz pierwszy projekt. Z pobranego ostatnio programu wybieramy ikonkę eclipse.exe. Zostaniemy poproszeni o wybranie lokalizacji workspace tzn. miejsca gdzie będą przechowywane nasze aplikacje. Wybór jest dowolny, jak komu wygodnie. Po dokonaniu wyboru zostanie otwarty Eclipse. 

Pierwszy projekt.
Z menu na górze po lewej wybieramy: File -> New -> Project... -> Java Project. Otwarte zostanie okno, w którym wpisujemy nazwę projektu (Project name) np. HelloWorld i klikamy Finish. Właśnie stworzyliśmy pierwszy projekt, który jeszcze nic nie robi. W menadżerze po lewej została dodana nowa ikonka z nazwą naszego projektu. Po jej rozwinięciu widzimy pusty jeszcze folder src, gdzie będą składowane nasze zasoby, oraz plik z bibliotekami. Na razie wystarczą te, które zostały załadowane automatycznie.

Obiektowość.
Na czym polega programowanie obiektowe? W świecie obiektowym wyróżniamy dwie zasadnicze części: klasy i obiekty. Jak pisałem wcześniej obiektem jest wszystko. Człowiek patrząc na samochód bierze go, jako całość, jako jeden obiekt, który może wykonywać różne funkcje i składa się z różnych części, które też są obiektami: koła, silnik itd. Klasa natomiast jest to opis obiektu, jakby jego specyfikacja techniczna, w której jest opisane, z czego co się składa i co może robić. Aby stworzyć obiekt potrzebujemy klasy, żeby go opisać.

Pierwsza klasa.
Aby dodać klasę do naszego projektu klikamy prawym przyciskiem myszy na ikonę projektu w menadżerze, wybieramy New -> Class. W miejscu Name wpisujemy nazwę klasy np. PierwszaKlasa, poniżej zaznaczamy „public static void main(String[] args) „, dzięki czemu zostanie wygenerowana automatycznie pierwsza metoda i klikamy Finish. Metoda, która się pojawiła, czyli „main” jest to punkt startowy programu i wystarczy żeby była tylko jedna w całym projekcie.

Hello World
Stworzyliśmy pierwszy projekt, mamy w nim stworzona pierwszą klasę, czas sprawić, aby coś się działo. Tradycyjnie, jak to jest w każdej książce wypiszemy napis Hello World. W tym celu wystarczy dodać jedną linijkę kodu: „System.out.println("Hello World");” O co dokładnie w tej linijce chodzi nie ma sensu wspominać, ważne jest to, że wszystko, co znajduje się między apostrofami zostanie wypisane i tylko tyle trzeba zapamiętać, bo z tej składni korzysta się baaardzo często. Nasza klasa po dodaniu owej linii wygląda następująco:
public class PierwszaKlasa {
       public static void main(String[] args) {
              System.out.println("Hello World");
       }
}
Odpalamy.
Aby uruchomić program klikamy prawym przyciskiem myszy na ikonkę projektu w menadżerze -> Run As -> Java Application
W konsoli na dole zostanie wyświetlony napis.

niedziela, 18 września 2011

Klasa abstrakcyjna a Interfejs

Klasa abstrakcyjna:
Klasa z której nie można utworzyć obiektu. Można po niej dziedziczyć. Może posiadać metody z ciałem lub bez ciała. Używana jest do ogólnej reprezentacji podobnych obiektów.

Interfejs:
Jest to lista metod. W interfejsie metody nie mają ciał, jedynie nazwę, wymagane parametry i typ wartości zwracanej. Interfejsów używa się aby wymóc na klasie go implementującej aby miała napisane wszystkie metody  z tego interfejsu.

Różnice:
Klasa może dziedziczyć  z tylko jednej klasy abstrakcyjnej ale implementować  wiele interfejsów. Wszystkie metody z interfejsu musza się pojawić w klasie go implementującej a podczas dziedziczenia z klasy abstrakcyjnej nic nie musimy, za to już część metod dostajemy w spadku.

Programowanie dla zielonych Cz. 2 „Instalacja”

Od czego zacząć?
„Instalacja” Javy – pobieramy najnowszy JDK, czyli Java SE Development Kit ze strony http://java.sun.com/javase/downloads/widget/jdk6.jsp. Instalujemy paczkę.

Dodajemy zmienne środowiskowe.
W Windows 7: Panel sterowania\System i zabezpieczenia\System -> Zaawansowane ustawienia systemu -> Zmienne środowiskowe
W zmiennych systemowych, pole JAVA_HOME wartość np. C:\Program Files\Java\jdk1.6.0_26 – w zależności gdzie zainstalujemy paczke

IDE
Żeby coś zaprogramować musimy posiadać zintegrowane środowisko programistyczne, czyli tak zwane IDE. W naszym przypadku będzie to Eclipse – czyli obecnie chyba najpopularniejsze IDE. Program można pobrać z http://www.eclipse.org/downloads/. Bez instalowania, wystarczy ściągnąć i już można uruchamiać.

Programowanie dla zielonych Cz. 1 „Co i jak”

Po co uczyć się programowania?
Aby tworzyć. Każdy w dzieciństwie chciał mieć moc tworzenia dowolnych rzeczy z niczego. Teraz żyjemy w takich czasach że możemy to robić. Nie chodzi tu o prace zarobkową, ale o to by móc coś samemu zrobić co ma ręce i nogi. Chociaż często krzywe i owłosione to zrobione przez nas. Dodatkowo sam fakt że coś potrafię jest miły.

Jaki język programowania wybrać?
Na początek proponuje „C”. Język programowania C jest prostym do nauki strukturalnym językiem, który pojawił się już w roku 1972, więc baaaardzo dawno. Ogólnie rzecz ujmując fundamenty świata stoją na C. Da się w nim zrobić prawie wszystko, został rozwinięty do C++ aby zyskać obiektowość. Jest prosty w obsłudze i idealny do nauki.

Dlaczego zatem Java?
Java jest młodsza od C, powstała w 1995 roku i jest jednym z podstawowych języków na świecie, a do tego jest zorientowany obiektowo. Co to oznacza i czym się to różni od strukturalnego C? Otóż w językach strukturalnych lista zadań wykonywana jest po kolei: 1-2-3-4-5….. W obiektówce jest troszkę ciekawiej.  „Wszystko jest obiektem” – ja jestem obiektem, dom jest obiektem, liczba osiem jest obiektem i możemy na siebie oddziaływać. Niby skomplikowane, ale takie nie jest. To jest zdecydowanie bardziej ludzkie niż strukturalność. Zresztą wszystko wyjdzie w praniu.

Czy łatwo jest nauczyć się programować w Javie?
Nawet bardzo łatwo :) Cała ta tajemna sztuka składa się z:
 2 pętli: „for” i „while”,
 warunku „if”,
 instrukcji wyboru „switch”,
struktur grupujących dane: tablic i list
obiektowości świata,
matematyki.
Oczywiście to nie jest wszystko, ale jeżeli już się to opanuje to reszta nie ma znaczenia.

Jak długo trzeba się uczyć żeby programować?
Całe życie oczywiście :), ale żeby sprawdzić czy to nam się podoba wystarczą podstawy czyli dzień może dwa.

Słowa kluczowe

Static – zmienne i metody określone modyfikatorem „static” istnieją zawsze nawet jeżeli nie została utworzona żadna instancja klasy w których jest zadeklarowana. Taka zmienna jest tylko jedna, tzn. jeżeli zmienimy ją w jednym obiekcie zostanie zmieniona jej wartość we wszystkich obiektach tej klasy.
Odwołanie się do zmiennej statycznej wymaga użycia kropki ( NazwaKlasy.NazwaZmiennej)

Final – zmienna zdefiniowana jako „final”, która raz dostała wartość nie może być już zmieniona. Parametry metody z final nie mogą być zmienione. Metoda finalna nie może być nadpisana w sub-klasie.

Synchronized – metoda oznaczona jako „Synchronized” może być wywołana tylko przez jeden wątek w danym czasie.

Kolorowanie składni kodu źródłowego na blogu.

   Aby uzyskać ładne kolory we wstawianych listingach kodów źródłowych i za bardzo się nie namęczyć z własnoręczną edycją napisów korzystam z
  http://google-code-prettify.googlecode.com
Usługa ta automatycznie rozpoznaje jaki język programowania został wybrany i odpowiednio go formatuje.
   Instalacja takiego cudka na stronie jest banalna.
W szablonie strony (w przypadku bloggera Projekt->Edytuj kod HTML) wstawiamy między tagami <head> i </head>
<script src='http://google-code-prettify.googlecode.com/ svn/trunk/src/prettify.js' type='text/javascript'/>
<link href='http://google-code-prettify.googlecode.com/ svn/trunk/src/prettify.css' rel='stylesheet' type='text/css'/>
Natomiast w tagu <body > dodajemy onload='prettyPrint()'
Część mojego szablonu po tych operacjach wygląda następująco:

...
<script src='http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.js' type='text/javascript'/>
<link href='http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.css' rel='stylesheet' type='text/css'/>
</head> 
<body expr:class='&quot;loading&quot; + data:blog.mobileClass' onload='prettyPrint()'>

...

Teraz wystarczy we wpisywanych notkach użyć:
<code class="prettyprint"> …… </code>
Albo aby kod był w ramce:
<pre class="prettyprint"> …… </pre>
W miejsce kropek wstawiając kod źródłowy.

Oczywiście istnieje dużo możliwości konfiguracyjnych naszego formatowania ale na początek wystarczy to.


Plik README projektu znajduje się tutaj