28 lut 2010

Zasady overriding

  1. Lista argumentów musi dokładnie pasować. ( ?)
  2. Taki sam zwracany typ lub subtyp!
  3. Modyfikator dostępu nie może być bardziej restrykcyjny!
  4. Modyfikator dostępu może być mniej restrykcyjny.
  5. jeżeli klasy base i subclass są w tym samym pakiecie to można override metody nie oznaczone private lub final.
  6. Jeżeli klasy base i subclass są w różnych pakietach to można override metody nie oznaczone final i oznaczone public lub protected!
  7. Metoda nadpisująca może rzucać unchecked(runtime) wyjątkiem,jakimkolwiek.
  8. metoda nadpisująca nie może rzucać wyjątkiem(checked) zupełnie nowym lub bardziej ogólnym od metody nadpisywanej!
  9. metoda nadpisująca może rzucać wyjątkami mniej ogólnymi lub liczbebnością mniej
  10. metoda nadpisująca nie musi throw jakiekokolwiek wyjątku!
  11. Nie możeż nadpisywać metod finalnych.
  12. Nie możesz nadpiywać metod static!
  13. Jeżeli metoda nie może nie być dziedziczona to nie może być nadpisywana (np private method in base class)



public class Base {

public void publicMethodInBase(){}
public void methodWithException() throws Exception{}
public void methodWithManyExceptions()throws IOException,NotSerializableException{}

public int intReturnMethod(){return 1;}
public void intArgMethod(int x){};


}


public class Subclass extends Base{

/*Bardziej restrykcyjny mod dostępu !*/
//!protected void publicMethodInBase(){}

@Override /*Ob bo wężwzy exception*/
public void methodWithException() throws IOException{}

/*Jest wiecej wyjątków ale węższe od Exception*/
public void methodWithException() throws IOException,NotSerializableException{}

public void methodWithException() {} //ok, bo mniej wyjątków

/*Zonk bo szerszy exception!!*/
//!public void methodWithManyExceptions()throws Exception{}

//!public long intReturnMethod(){return 1;} //zonk bo inny return!

/*To nie overriding lecz overloading!*/
public void intArgMethod(long x){};
}

27 lut 2010

Polimoryzm


public class Base {

public static String _static="base_static";
public String _inst="base_inst";

public String publicMethod(){
return "base_public_method";
}
private String privateMethod(){
return "base_public_method";
}
}

public class Subclass extends Base{

public static String _static="subclass_static";
public String _inst="subclass_inst";

public String publicMethod(){
return "subclasss_public_method";
}
}

@Test
public void testprzyslaniania(){

Base base = new Base();
prn(base._inst); //base_inst
prn(base._static);//base_static
prn(base.publicMethod());//base_public_method

Subclass sub = new Subclass();
prn(sub._inst);//subclass_inst
prn(sub._static);//subclass_static
prn(sub.publicMethod());//subclasss_public_method

Base base_ref= sub;
prn(base_ref._inst);//base_inst
prn(base_ref._static);//base_static
prn(base_ref.publicMethod());//subclasss_public_method

Base base_base_cast=(Base)sub;
prn(base_base_cast._inst);//base_inst
prn(base_base_cast._static);//base_static
prn(base_base_cast.publicMethod());//subclasss_public_method

/**
* Wnioski:
* + dynamicznie (po typie obiektu) są tlko metody
* + zmienne static / inst = są wybierane po typie referencji!
*/
}

Extend - przykłady

Poniższe jest ok



interface Driver{}
interface Drivere extends Driver{}
abstract class AbsClass implements Driver{}
class FirstConcreteclass extends AbsClass implements Driver{}
abstract class SecoundABstratClass extends FirstConcreteclass{}


Java nie sprawdza ,ze podwórnie klasa FirstConcreteclass implementuje Driver
i klasa bastrakcyjna może rozszerzać nie abstrakcyjną,

Enum


public enum ERozmiar {

DUZY(100), SREDNI(10),
MALY(1) {

@Override
public String getStringReprezent() {
return "IAmMaly!!";
}
};

/**
* Wymagany jest konstruktor z intem
* nie może być public!!!
* wejdzie gdy Erozmiar roaz= Erozmia.DUZY
*/
ERozmiar(int wybrany) {
this.wybrany = wybrany;
}
private int wybrany;

public int getWybrany() {
return wybrany;
}

public String getStringReprezent() {
return "otherThanMALY";
}
}


public class ConcreteClass {

/**
* maly,sredni,wielki są pub;ic staic final!!!!!
*/
enum Rozmiary{ maly, SREDNI, WIELKI}


@Test
public void extendEnumTest(){
ERozmiar rozDuzy =ERozmiar.DUZY;
prn(rozDuzy.getStringReprezent());

ERozmiar rozMaly =ERozmiar.MALY;
prn(rozMaly.getStringReprezent());

//results:
//otherThanMALY
//IAmMaly!!
}


  1. Niem oże być deklarowany lokalnie! ( w metodzie)
  2. Wewnątrz klasy i owszem.!!!!!!!
  3. Moga być deklarowane w osobnym pliku!
  4. Dekalracja enuma poza klasą nie może być protected lub private!
  5. Dekalracja enuma poza klasą może być default lub public!
  6. Na końcu nie musi być średnika :D
  7. Enum może mieć metody , zmienne swoje , konctruktor z intem!!
  8. Jeżeli wydrukujemy to bedzie domyślenie drukowana anzwa enum np MALY
  9. Kązdy enum ma static funkcje values , która zwraca tablicę elemtów enuma w kolejności.
  10. Nie możesz wywołać konstruktora enuma bezpośrednio!!!
  11. Element elumu może nadpisywać metody w tym enumie!!

Zmienne final

  1. Raz zainicjalozowane nie mogą być zmieniane
  2. Jeśli chodzi o ptymitywy to chodzi o vartość
  3. Jeśli chodzi o Obiekt to nie wolno zmieniać referencji, zaś samo obiekt może być modyfikowany!.
  4. Nie ma final obiektów, tylko final referencje!
  5. Co do final klas- nie mogą być subklasowane
  6. Co do final metod - nie mogą być overriden!

public class ConcreteClass {

final int x;

public ConcreteClass() {
x=10;
//x=12; 2 raz nie wolno
}

@Test
public void finalTest() {

// x=12; tylko w KONSTRUKTORZE!
final int x_inside_method;
x_inside_method=9;
// x_inside_method++; nie wolno!! be be
}

Deklarowanie tablic


@Test
public void testTablicy(){
//all correct
int[] x;
int y[];
String[][] strinTab;
String [] stringTable[];
}

  1. Przy deklaracji nie używamy rozmiarów ( np int[5] tablica).

Zmienne lokalne

  1. Nazywane takrze automatyczne,
  2. Zmienne nie tylko są inicjalozowane ale także deklarowane wew. metody
  3. Są niszczone kiedy wyjdziemy z metody!
  4. Są na stosie
  5. Jeżeli zmienną bedzie obiekt to i tak bedzie on na stercie!
  6. Nie ma czegoś takiego jak obiekt lokalny , jest to tylko lokalna referencja do obiktu na stercie.
  7. trzebą ją zasinicjalozować!!!! ( przed użyciem)
  8. Może mieć taką samą nazwę jak zmienna instancji ( także static).

Porównanie modyfikatorów


  1. Zmienne lokalne : final
  2. Zmienne ( nie lokalne) : final, public, protected, private ,static, transient volatile
  3. Metody: final, public, protected, private ,static, abstract, synchronized, strictpf, native
  4. Klasa: hm... public, default, strictfp, abstract...( dodać)

Zmienne instancji

  1. Można wykorzystać 4 aces modifiers
  2. Może być final
  3. Może być transient
  4. Nie może być: synchronized,abstract, native, strictfp,
  5. Nie może być static, bo wtedy staje sie zmienną klasy

char- przytowanie


public void absMethod() {
char c =65000; // dodatnie 0-65535
short s = 6500;

c=s; //zonk : possible lost , chodzi o ujemne!
s=c; //jak wyżej

byte b=0;

s=b; //ok
c=b; //possible lost a presicion bo ujemne!!

}

Kwestia ustraty znaku!, Char ma tylko dodatnie!

Spis ważnych

  1. Dostępność memberów -SCJP book , page 39
  2. Gdy metoda w base throw Exception - SCJHP book,page 108
  3. hashcode a equals , SCJP book, page 554

Podstawy cz.2


  1. Do protected nie odnosimy się przez .
  2. Dla klas w innych pakietach do protected członków można dostać się tylko
    przez dziedziczenie
  3. Do protected member dostaniemy się z klasy z tego samoego pakietu!!!
  4. Zmienne lokalne są bez modyfikatorów dostępu
  5. W zmiennych lokalnych można uzywać final
  6. Protected= package + subclass throught inheritance
  7. Klasa nie bastrakcyjna z choć 1 metodą abstract jest illegal!!
  8. Klasa abstrakcyjna nie musi mieć abstrakcyjnych metod!.
  9. Pierwsza nie abstrakcyjna klasa musi implementować wszystkie metody abstrakcyjne z superclass.
  10. static + abstract method are illegal!
  11. Oznaczenie synchronized stodujemy tylko do metod i bloków kodu!
  12. Native tylko dla metod! ( deklaracja jak metody anstrakcyjne)
  13. strictfp tylko dla klas i metod ( nie dla zmiennych!!!! )
  14. Varargs: void method(int... x) {}
  15. Varargs musi być ostatnim marametrem!
  16. Varargs=> 0 lub wiele
  17. Jeżeli przed konstruktorem damy void to jest traktowany jako metoda.
  18. Konstruktor nie może być ani final ani static ani abstract!
  19. Ile zajmuje boolean to zależy od sprzętu!.
  20. Char i short zajmują 16 bitów.
  21. Klasy abstrakcyjne mogą implemntować interfejsy!
  22. Metod ,które są w interfejsie nie trzeba zapisywać w klasie abstrakcuyjnej, dopiero w pierwszej klasie konkretnej!!!
  23. volatile tylko do zmiennych!
  24. Jeżeli klasa nie jest public to nazwa nie musi pasować do nazwy pliku!!!
  25. Metoda private nie może być overriden!!
  26. throws jest dozwolone po sygnaturze metody abstrakcyjnej!!
  27. może być synchronized łączone z final i modyfikatorami dostępu.
  28. Klasa abstrakcyjna może rozszerzać klasę konkretną!!





25 lut 2010

Protected access


public class Parent {
protected int i=14;
}

public class Child extends Parent {

@Test
public void testProtectedAcess(){
prn(i); // z superClass => OK działa

Parent parent = new Parent();

//zadziałała jak 2 klasy sa w tym samym pakiecie!
prn(parent.i);


}
}



  • Trzeba się bacznie przypatrzeć!!

TODO

  1. Przysłanianie metod, które są prywatne w klasie bazowej
  2. Kiedy obiekty są dostępne dla GC! {scope ,wyjście z metod, różne!!!}

Interfejs

  1. W pliku java może być kilka interfejsów!
  2. Interfejs bez moted może być!
  3. metody interfejsu nie mposiadają ciała!
  4. Każda  metoda interfejsu musi być implementowana w klasie implementującej!
  5. uwaga! Klasa abstrakcyjna może posiadać abstrakcjyjne jak i nie abstrakcyjne metody! 
  6. Metoda int ok(); jest widziana jako public abstract ok()
  7.  Interfejs może zawierać zmienne ,które są public, static final ( consts) !!
  8. Nie może posiadać metod statycznych!
  9. Nie może być oznaczony  jako final, strictfp lub native!!
  10. Interfejs może extend  tylko  jedną lub kilka interfejsów!!
  11. Interfejs nie może immplement czegoś!!
  12. Każda metoda w interfejsie jest public i abstract!




//private interface Bouncable {} nie może być private
//protected interface Bouncable {} // nie wolno
abstract interface Bouncable2{};
//public abstract interface dsd{} nie ładzia
public interface Bouncable{

//test zmiennych
int ok=1; //widziana jako public static final !!!!!!!!!!!!!!!
//!int ok2; //musi być zainicjalozowana ( bo stała!!)

//!protected int ok=2; nie wolno

final int ok2=9; //ok
static int ok3=12; //ok
public int ok4=99; //ok

public abstract int ok(); //działa
int ok2(); //UWAGA!! i tak jest widziana jako public abstract!!

//!int ok3(){}; metody interfejsu nie mposiadają ciała!

//test static
//! static int metodaStatyczna(); nie może być STATIC!!

//test final
//!final void doSth(); niedozwolone
//!private void doSth(); niedozwolone

}

Pytania

  1. Czy klasa abstrakcyjna może imlementować interfejs?
  2. Klasa dziedzicząca z klasy abstrakcyjnej musi dziedziczyć wszytkie metody abstrakcyjne?
  3. Czy się to skompiluje? final abstract class{}
  4. Czy klasa abstrakcyjna musi mieć jakąkolwiek motedę lub zmienną ?

Klasa abstrakcyjna


abstract class Car{

private double price;//ok
private final int x=5;//ok

private static int $=9; //ok

private static final int _=9; //ok

/*variable cannot be abstract*/
//public abstract int i;

/* klasa abstrakcyjna nie ma ciała!*/
// public abstract int getInt(){};

public abstract int getInt(); //ok

/*niedozwolona kombinacja*/
//!private abstract int getIntPriv(); //ok

protected abstract int getIntPriv(); //ok
abstract int getInt2(); //ok


public int normalMethodWithBody(){ //ok

byte b=9; //ok
b=b++; //ok szok!!
return b; //autmoatyczna promocja typów na szerszy :D
}

}



  • Jeżeli klasa posiada choć 1 metodę abstract to cała klasa musi być abstract!
    >


  • Klasa dziedzicząca z klasy abstrakcyjnej musi dziedziczyć wszytkie metody abstrakcyjne!



Inkrementacja byte


byte x=7;
b++; //ok
b=b++;//ok
b=(b+10); // promocja b+10 na inta , trzeba cast
b=(byte)(b+10); // ok


Co się stanie po b++ ?

23 lut 2010

Deklaracja klasy -plik


  1. Tylko jedna publiczna klasa w pliku!
  2. komentarz może pojawić się na pozątku lub końcu każdej linii.
  3. Nazwa klasy publicznej musi być identyczna z nazwą pliku!
  4. Jeśli klasa jest częścią package to linia z package musi być pierwszą nie komentarzową linią!
  5. Linie z import muszą być pomiedzy package a deklaracją klay!
  6. import i package odnosi sie do całego pliku i może być tylko 1.
  7. Plik może zwierać więcej niepublicznych klas!
  8. Plik bez publicznej klasy nie musi pasować nazwą do czegokolwiek!

JavaBeans


  1. Pola prywatne
  2. metody get i set są public
  3. public void setCosik(int x)
  4. public int getCosik();
  5. Dla boolean : getBool() albo isBool().
  6. Event: public void addMyListener(MyListener m) //takei same nazwy!
  7. Przedrostek add i remove tylko w połączeniu z Listener!!!
  8. nie ma delete!!!

Nazwy identyfikatorów

  1. Identyfikator musi zaczynać się od: $,_ , lub litery.
  2. identyfikator nie może zaczynać się od cyfry!
  3. Kolejne znaki mogą być: cyfrą,literą,$,_.
  4. Nie ma limitów na długość ident.
  5. Nie możesz używać słów kluczowych javy.
  6. foo i Foo to dwa różne identyfikatory!!


  7. Wszystko tyczy się także nazw metod i klas




@Test
public void testIdentyfikatorow() {
//GOOD
int _=5;
int $=5;
int a=8;
int $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$=2;
int _____________________________________=3;
int _1234=4;

//BAD!!

//!int a:=9;
//!int e#=9;
//!int .f=9;
//!int 7g;
//!int enum=5 //bo keyword

}

public void ___(){ } //correct
public void $(){} //correct
public void _$_(){} //corect

private class ${}; //correct
private class ________{}//correct

22 lut 2010

Reszta z dzielenia


@Test
public void testModulo() {

//znak wyniki jest równy znakowi liczby przed %!!
assertEquals(-5 % -2, -1);
assertEquals(-5 % 2, -1);
assertEquals( 5 % -2, 1);
assertEquals( 5 % 2, 1);

assertEquals(-9 % -5, -4);
assertEquals(-9 % 5, -4);
assertEquals( 9 % -5, 4);
assertEquals( 9 % 5, 4);

//pass all
}

Przesunięcia bitowe


@Test
public void PrzesTest(){


assertEquals(23>>33, 23>>1); //pass
assertEquals(23<<33, 23<<1); //pass
assertEquals(23>>>33, 23>>>1); //pass
//ujemne
assertEquals(-23>>33, -23>>1); //pass

assertEquals(-4<<1, -8); //pass

assertEquals(1>>1, 0); //pass
}

Dzielenie przez zero


@Test
public void DivByZero(){

//int i=3/0;
//prn(i); //runtime-error

float f=1.0f/0;
prn(f); //print Infinity

double d=1.0/0;
prn(d); //print Infinity

//ciekawostka 1.0 jest doublem!!

int licznik=1;
int mianownik=0;

// int wynik=licznik/mianownik; //runtime-error

//MOD
int wynik=licznik%1;
prn(wynik); //wynik =0

//!int wynik=licznik%0; runtime error!
prn(wynik); //wynik =0

float ff= 5%0.3f;
prn(ff); //0.199999

float fff= 5%0.0f;
prn(fff); //NaN

float fy=1.0f/0.0f;
prn(fy); //Infinity
}

20 lut 2010

Tablica



//pomocnicza funkcja
private void testObjectTab(Object[] obTab){
for(Object ob: obTab)
prn(ob);
}


@Test
public void Tab3Init(){
int[]test = new int[5];
for(int x:test)
prn(x);
//wynik: 0,0,0,0,0
}
// @Test
public void InitTab2Test(){

testObjectTab(new Object[]{
new Integer(1),
new Float(1.1f),
new Double(1.1)}
);
//wynik: 1 , 1.1 ,1.1
}

// @Test
public void multiTab(){
int[][] mTab ={
{1,2,3},
{4,5,6}
};

for(int[] row:mTab)
for(int cell:row)
prn(cell);
//wynik: 1,2,3,4,5,6
assertEquals(mTab.length, 2); //pass!!!!!!!!!!!
}

// @Test
public void InitTest() {
int tab[];
int[] tab2;

int tab3[] = {1, 2};
int tab4[] = {1, 2, 3, 4, 5,}; //patrz przecinek! =>Ok



int tab4copy[] = tab4;

for (int x : tab4copy) {
x++; //nie zmienia nic w tablicy!
}
for (int x = 0; x < tab4copy.length; x++) {
tab4copy[x]++;
}
//sprawdzamy czy zmieniło się w 2 tablicach ( tab4copy i tab4)
for (int x : tab4) {
prn(x); //2,3,4,5,6
}
assertEquals(tab4, tab4copy); //pass


//test inicjalizacji
//!int tab5[3]; nie wolno bebe
int tab5[] = new int[0];
prn(tab5.length); //0



int tab6[] = new int[(char) 1];
int tab7[] = new int[(byte) 1];
//! int tab7[] = new int[(long)1]; zonk max może być Z
int tab9[] = new int[(int) 1.1];
int tab10[] = new int[(char) 1];

//pozyższe się udaje bo promowanie do inta

//ciekawostka
//! float f=1.1; bo 1.1 to double!


//tablioce obiektów
String[] s = {"ok", "", new String("ok")}; //ok
// String tabS[]={"ok",tabS[0]}; //variable might be not inicjalized!
Integer[] intTab = {1, 1, 3, new Integer(1)};

//int a Integer

//!int[] tabInt= new Integer[3]; zonk
//!Integer[] tabInteger= tab4; zonk


}

19 lut 2010

inicjalizacja


@Test
public void testInicjalizacji(){
Init it = new Init();

}

public class Init {

static String ss1;
String sm1;
String sm2;

static {
ss1=new String("'=ok");
prn("Klauzula static");
}
{
sm1=new String("ok");
sm2=new String ("ok");
prn("Klauzula instancyjna{}");
}

public Init() {
prn("Konstruktor");
}
}


Wynik:

Klauzula static
Klauzula instancyjna{}
Konstruktor

Przeciążanie metod


@Test
public void testPrzeciazanieMetod(){

f(5); //int
f(3/2); //int

short s=12;
f(s); //short
f(s-1); //int
f(1-1.0f); //float
f(s-1.0f); //float

byte b=10;
f(b/2); //int
f(b*b); //int
}

public void f(float x){ prn("float");}
public void f(byte x){ prn("byte"); }
public void f(short x){prn("short");}
public void f(int x){prn("int");}

Działania arytmetyczne


@Test
public void testDzialan(){

int x=-3%2;
assertEquals(-1,x ); //pass
x=-3/2;
assertEquals(-1, x); //pass

float y=1.1f;
y++;
assertTrue(y==2.1f); //pass

int i=1;
float f=i; //automatyczna promocja

f=3/2;
prn(f); //1.0
assertTrue(f==1); //pass

x=-1<<1; //przesunięcie ze znakiem
assertTrue(x==-2); //pass

x=4>>>1; //przesuniecie w lewo bez zbaku
assertEquals(x,2); //pass


}

Try,catch,finally


@Test
public void testTry(){

//!try{ } //musi być catch or finally
//! catch(Exception e){ } //musi być try
//!finally{} musi być try przed

try{ }finally{} //ok
try{}catch(Exception e){} //ok
}

18 lut 2010

ArrayList []


import java.util.ArrayList;

public class Test {
public static void main(String[] args) {
ArrayList array = new ArrayList();
array[0]="Hello world";
System.out.println(array[0]);
}
}


Nie ma operatora [] w listach!!

Static


// A.java
public class A {
private final int a = 10;
public static String b = "ClassA";
protected long c;
}

// B.java
public class B extends A {
public static String b = "ClassB";
private int d = 1;

public static void test() {
...
}
}




Z metod statycznych ma się tylko dostęp do zmiennych statycznych!

Pytanie: Do jakich zmiennych mam dostęp w B.test() ??

Cast


@Test
public void testCastowania(){

float _45f=45.0f;
char $='\u0000';
//!$=$*$; //promowane do int!!
$=(char)($*$); //poprawnie
//! $=-$; także int

//_45f=_45f/3;
//assertTrue(_45f==15); //pass

//porównanie inta z floatem

int _45i=45;

assertTrue(_45f==_45i);//pass
assertTrue(_45i==_45f);//pass

//inne promowania
long _45l=_45i; //autmoatyczne promowanie

// możliwa utrata informacji ->
//błąd kompilacji
//!_45i=_45l;

_45i=(int)_45l; //poprawnie!

float a12=(float)1/3;
prn(a12); //0.33333
int jestemIntem=(int)a12;
prn(jestemIntem); //0
//a12=1.1; //daje daoubla
a12=1.6f; //ok
jestemIntem=(int)a12;
prn(jestemIntem); //1 (zaokragla w dół)

}

Skracanie łańcucha logicznego


/**
* Pomocnicza
* @param test
* @return
*/
private boolean test(boolean test){
prn(test);
return test;
}

@Test
public void testLancuchaLogicznego(){

if(test(true) || test(true)){ } //true
if(test(true) && test(true)){ } //true true
if(test(false) || test(true)){ } //false true
if(test(false) && test(true)){ } //FFALSE
prn("ZŁOŻONE:");

if((test(false))||((test(false))&&(test(true)))){}
//false false

}

Inkrementacja dekrementacja


@Test
public void testKrementacji(){

/* Test 1*/
int i=5;
int j=i++;
int k=i++ + i;

assertEquals(5, j);//pass
assertEquals(13, k);//pass

/*Test2*/
i=5;
j=i--;
k=i++;
int l=i++ + --i;
assertEquals(5, j);//pass
assertEquals(4, k);//pass
assertEquals(10, l);//pass

/*Test3*/
i=5;
j=--i +i++ + i++;
assertTrue(13==j); //pass
assertTrue(6==i); //pass
}

Test print


//System.out.println(...)
@Test
public void testPrinta(){

float x=10/3; //x=3.0
float y= (float)10/3; //y=3.3333333
float z= 10/(float)3; //y=3.3333333

prn(1+2+2+"ok"); //5ok
prn("ok" + new String("nie")); //oknie
prn("OK"+(3-1));//ok2
//!prn("ok"+9-6); //nie da się
}

Referencje-test


@Test
public void testReferencji(){

String a=null;
String b=null;
b=a;
a=new String("ok");
// assertEquals(a, b); //b=null!
b=a;
assertEquals(a, b);//a równe b
assertTrue(a.equals(b)); //pass
assertTrue(a==b);//pass
}

17 lut 2010

Test println zmiennych


public class Main {
//typ nazwa wart domyślna
static boolean _boolean; //boolean
static char _char; //'\u0000'
static byte _byte; //(byte)0
static short _short; //(short)0
static int _int; //0
static long _long; //0L
static float _float; //0.0f
static double _double; //0.0d

public static void main(String[] args) {
System.out.println(_boolean); //false
System.out.println(_char); //jakiś kwadracik
System.out.println(_byte); //0
System.out.println(_short); //0
System.out.println(_int); //0
System.out.println(_long); //0
System.out.println(_float); //0.0
System.out.println(_double); //0.0
}
}

Zasięg zmiennych


/*
*Nie wolno używać static ,public,private,protcted
*wewnątrz metod
*
* Nie wolno napisywać zminnych ( w pod zasięgach)
*/
public static void testScope(){
// static int x; -błąd bo static
//private int x; - błąd bo public

int x;
{
int x; //błąd nie można napisywać
int y;
}
y=4; //błąd odwołąnie poza zasięgiem
}

Podstawy

  1. Obiekty są przechowywane na stercie.
  2. Typy prymitywne przechowywane są na stosie.
  3. Tablica obiektów inicjalozowana jest wartościami null.
  4. Tablica typów prymiywnych jest zerowana.
  5. Wartości domyślne nadawane są tylko dla składowych klas!
  6. Wartość domyślna dla zmiennej prymitywnej wew. metody nie jest nadawana! -> błąd kompilacji
  7. Public, static, private , protected nie można używać dla zmiennych wew. metody!
  8. Można przysłonić w metodzie pole klasy ale trzeba wtedy nadać wartość!
  9. Dla obiektów == i != porównuje referencje!
  10. Nie nadpisany equal() porównuje domyślnie referencje!
  11. Switch(x) => x musi być selektorem całkowitym!
  12. Każde działanie na byte,char lub short jest promowane do inta.
  13. Boolean nie możę być rzutowany na coś innego i coś innego nie może być rzutowane na booleana.
  14. Traktowanie liczb jako zmiennych logicznych jest niedozwolone!
  15. Nazwa zmiennej nie może być liczbą, może zaczynać się od litery,$ lub _.
  16. Z metod statycznych ma się tylko dostęp do zmiennych statycznych!
  17. Możemy skompilować bez błądów pusty plik javy! javac Test.java
  18. int x='x'; jest poprawne zaś char c=-1; jest niepoprawne
  19. Inicjalizacja zmiennych klasy następuje przed wywołaniem konstruktora!
  20. Klasa może być public lub bez ,protectedi private jest tylko dla zmiennych!
  21. Nie można mieszać final,absctact,strictfp ze sobą!
  22. strictfp - tylko do klass i metod , nie do zmiennych!
  23. Jeżeli klasa posiada choć 1 metodę abstract to cała klasa musi być abstract!
  24. Metoda oznaczona jako private nie może być przysłoniona (overriding) , or nadpisana :D
  25. Konstruktor nie może być synchronized!!!!