- Klasy inner nie mogą mieć czegokolwiek static!
- MyOuter mo = new MyOuter(); // gotta get an instance!
MyOuter.MyInner inner = mo.new MyInner(); - Instancja poza Outer class przez instancje.new Inner()
- IInstancja z klasy Outer Inner() normalnnie
- Nie mozna tworzyc Inner w statycznych metodach outer!!
- this w metodach Inner class odności sie do obiektu Inner !
- Outer.this odnosi sie wiadomo ( z poziomu metod Inner)
- Modyfikatory przy class Inner{} => public,protected,private ,final,abstract,static,strictfp //jak normalny member klasy Outer!!
- Local method class może być instance tylko w tej metodzie!
- Local method class może dobrać sie do Outer private members!
- Local method class nie może dostać sie do zmiennych w tej metodzie(nie fianl)!
- Local method class może dostać sie do zmiennych fonal w tej metodzie!!
- Local method class może być zonaczona jako final!! ( tak jak zmienna lokalna ,zasady)
- Local method class w metodzie statycznej ma tylko dostęp do zmiennych statycznych!! i nie ma dostępy do zmiennych outerClass!!
- Pamiętaj średniku po definicji klasy anonymous!!
- Klasa anonymous raczej overriding method niż dodaje ( problem z widzeniem nowej innej metody)
- interface cannot be in method :(
- Anonymous class moze implements tylko 1 interfejs!!
14 lis 2010
Inner class
13 lis 2010
Generics
- List oznacza każdą listę czegokolwiek
- List foo = new ArrayList();// bad!
- 1) List list = new ArrayList
(); //OK
2) List aList = new ArrayList();//OK
3) List foo = new ArrayList(); //BAD
4) List cList = new ArrayList();//BAD
5) List bList = new ArrayList(); //OK
6) List dList = new ArrayList(); //BAD
12 sie 2010
equal i hashCode
1. int hashcode() - jaki bukiet ?
2. boolean equals(Object ob)
3. sprawdzaj na początku instanceof!
4. nie używaj transient zmiennych w hashCode()
2. boolean equals(Object ob)
3. sprawdzaj na początku instanceof!
4. nie używaj transient zmiennych w hashCode()
@Test
public void test1() {
NotEqualOverriding a = new NotEqualOverriding();
NotEqualOverriding b = new NotEqualOverriding();
a.equals(b); //wersja 1 z return false;
a.equals((Object)b); //wersja 2
}
class NotEqualOverriding{
/*Tylko overloading*/
boolean equals(NotEqualOverriding er){
return false;
}
/** -> zonk to jest overloading! */
// @Override
public boolean equals(Object obj) {
// dodaj na poczatku test is-A!!
System.out.println(" nadpisny equal");
return super.equals(obj);
}
@Override
public int hashCode() {
int hash = 7;
return hash;
}
}
16 lip 2010
Try, catch throwing Exception
@Test
public void testThrowing(){
try{ }catch(NumberFormatException ex){ }finally{ }
}
@Test
public void testThrowing2() throws Exception{
try{
throw new Exception(); //=> musi byc throws
}catch(NumberFormatException ex){
throw new Exception();
//int x =9; // unreachable exception!!!!!!!!
}finally{
/**
* Wypisze naewt jak jest w Main;
*/
System.out.println("finally"); //wypisze
}
}
14 lip 2010
Porównanie integerów
@Test
public void testone(){
//test1
Integer piec1= 5;
Integer piec2= 5;
assertTrue(piec1==piec2); //pass
//test2
Integer integer1 = new Integer(10);
Integer integer2 = new Integer(10);
assertFalse(integer1==integer2); //pass
//test3
Integer piec1001= 1000;
Integer piec1002= 1000;
assertTrue(piec1==piec2); //pass
}
13 lip 2010
11 lip 2010
8 lip 2010
Autoboxing
//LEGAL
long l = 1000;
double d = 1000;
//NOT LEGAL
Long l1 = 1000; // error
Double d1 = 1000; // error
i
private static void wrap_byte(Byte b) {}
private static void wrap_short(Short s) {}
private static void wrap_char(Character c) {}
private static void wrap_int(Integer i) {}
private static void wrap_long(Long l) {}
private static void wrap_float(Float f) {}
private static void wrap_double(Double d) {}
private static void print() {
wrap_byte(10); // error
wrap_short(10); // error
wrap_char(10); // error
wrap_int(10);
wrap_long(10); // error
wrap_float(10); // error
wrap_double(10); // error
}
13 mar 2010
String haczyk
String s1 = "abc";
String s2 = "abc";
if(s1 == s2)
System.out.println(1); //true!!!!!
//zaś
String test2 = "abcd";
String test = new String("abcd");
/*to 2 różne referencje !!!!!!!*/
12 mar 2010
Static int
static int x = getValue();
static int y = 5;
static int z = getValue();
static int getValue() {
return y;
}
@Test
public void staticTest() {
prn("x=" + x);//x=0
prn("z=" + z);//z=5
}
- Z tego wychodzi ,że inicjalozowane jest z góry na dół!
Unreachable statement
@Test
public void unreachableTest() throws Exception {
int x = 7;
try {
x += x *= x;
prn(x);
} finally {
throw new Exception("sonk");
}
x=8;
}
- Poieważ x=8 nigdy nie zostanie wykonany!
Haczyki
enum INDEX{JEDEN,DWA,TRZY};
public void hello() {
int x[][] = new int[2][];
int x[0]={1,2}; //zonk :( compile error
int x[]={1,2,3};
int y= x[INDEX.DWA]; //zonk compile error!!!
}
- int a[]={1,2,}; //ok
- int a[]; a={1,2,3} //Compile error
Switch,case
@Test
public void swicz() {
//jako argument: byte, short, char, int i enum!
// NIE long ;(
//błąd nr 1
// wartość CASE jest większa niż typu !!!!
byte b = 10;
// switch(b){ case 150: break; }
//błąd nr 2
//zmienna jako CASEnie znana w czasie kompilacji
final int x = 7;
//sytuacja błędówa :D
final int y;
y = 7;
switch (y) {
case x: {
}
//! case y:{} // constant expr required!!!!!
}
//błąd nr 3 => powtarzajace się wartości case
// uwaga na obliecznia wartości case przez consty!
}
@Test
public void testDefaultInSwitch() {
/**
* WNOSIKI:
* 1) Jeśli istnieje case o wartości x to nei bedzie default
* 2) Jeśli nie istnieje case ... to bedzie default
* BEZ wezględu na miejsce!!!
*/
int x = 6;
switch (x) {
default: {
prn("Default");
break;
}
case 6: {
prn("6");
break;
}
}
/*WYNIK 6*/
/////////switch 2
x=5;
switch (x) {
default: {
prn("Default");
}
case 6: {
prn("6");
break;
}
}
/*WYNIK: Default 6*/
}
If &&,||,|,&
@Test
public void test1() {
//kwestia && i & w if
if(True("1") &&True("2") & True("3")){} // 1 2 3
if(False("1") &&True("2") & True("3")){} // 1 !!!!!!!!
if(True("1") &&False("2") & True("3")){} // 1 2 3
if(True("1") &&False("2") && True("3")){} // 1 2
if(False("1") & True("3")){} // 1 3
//kwestia || i |
if(True("1") || False("2")){}//1
if(True("1") | False("2")){}//1 2
if(False("1") ||False("2") && False("3")){} // 1 2
if(False("1") ||False("2") | False("3")){} // 1 2 2
}
public boolean True(String msg ){
System.out.println(msg);
return true;
}
public boolean False(String msg ){
System.out.println(msg);
return false;
}
9 mar 2010
Overriding i overloading
Following code fragment is given (Java 5): 1: class Human {Which of the following methods would compile if inserted at line 8 | | ||||||||||||||||||||
| |||||||||||||||||||||
Try catch finally
A try block can be followed either by a catch block or a finally block, or both.
A catch block must always be associated with a try block.
A finally block can never stand on its own (that is, without being associated with try block).
Haczyki v2
if(20%4){} //zonk bo wynikiem jest int!!
String s = null; /* Nie bedzie NullPointerException!!!!!!!!!*/
String result = s != null && s.equals("test") ? "yes" : "no";
- Kwestia || i | w jednym ifie + kwsestia && i & w jednym ifie
- Jeśli casy w switchu się powtórzą to! => compilation error!!!!!!!!!
8 mar 2010
Println
System.out.println(1+2+"sd");//3sd
System.out.println("_"+12+3); //_123
System.out.println("_"+(1+2+3)); //_6
6 mar 2010
== i Wrappery
- == zwraca true jesli prymitywy są równe i wrapper={Boolean,Byte, Integer<-127;128>}
- Jeśli wrapper nie należy do powyższego to == porównuje referencje!
//uwaga na != i equals na wrapperach
//!= referencje
//equals -> prymitywy!
Integer i=1000;
Integer j=1000;
if(i!=j)
prn( "rózne obiekty"); //wyświetli
assertEquals(i, j); //pass bo 100==100
Integer i2=100;
Integer j2=100;
if(i2!=j2)
prn( "rózne obiekty"); // NIE wyświetli
assertEquals(i, j); //pass bo 100==100
Wrappers
//ok
Boolean b=true;
Boolean b2 = new Boolean("True");
Boolean b22 = new Boolean("trUe");
assertEquals(b22, b2); //pass
assertTrue(b22==true); //pass
Boolean b3= new Boolean(null);
assertTrue(b3==false); //pass
Boolean b4= new Boolean("Yes");
assertTrue(b4==false); //pass
if(b4){/*Do sth:D*/} //ok
//Integer
Integer x=Integer.valueOf("1011", 2);
prn(x); //11
//Float
float f= Float.valueOf("3.14f");
prn(f); //3.14
Inicjalizacja tablic
Jak mamy tablicę intów to nie możemy do niej przypisać tablucy charów!!!
zaś jeśli chodzi o tablice referencji to można przypisać tablicę subtypu do base typu!!
// assertEquals(x, y); //fail ok2 ok
//al ok!!
int[][][] xx= new int[9][5][];
int [][][] xxx= new int[9][][];
int[][][][] xxxx= new int[9][][][];
xxxx[3]=new int[2][][]; //ok
//! xxxx[3]=new int[2][][][]; //nie ok
//uwaga nr 2
//int y=-4;
// x[y]=2; //runtime!! exception
//uwaga nr 1
int[] u2 = new int[5];
// u2[29]=4; // runtime exception!!!!v
//init
int zm=9;
int zmTab[] = {zm,zm,9}; //ok
//size test
int[] tab1={1,};
int[] tab2={1};
assertEquals(tab1.length, tab2.length);//pass
//! int x[] = new int[3]{1,2,3}; bez rozmiaru!!!
Inicjalizacja tablic
// assertEquals(x, y); //fail ok2 ok
//al ok!!
int[][][] xx= new int[9][5][];
int [][][] xxx= new int[9][][];
int[][][][] xxxx= new int[9][][][];
xxxx[3]=new int[2][][]; //ok
//! xxxx[3]=new int[2][][][]; //nie ok
//uwaga nr 2
//int y=-4;
// x[y]=2; //runtime!! exception
//uwaga nr 1
int[] u2 = new int[5];
// u2[29]=4; // runtime exception!!!!v
//init
int zm=9;
int zmTab[] = {zm,zm,9}; //ok
//size test
int[] tab1={1,};
int[] tab2={1};
assertEquals(tab1.length, tab2.length);//pass
//! int x[] = new int[3]{1,2,3}; bez rozmiaru!!!
String, kopia referencji
// @Test
public void test1(){
String m="male";
String d=m.toUpperCase();
//! assertEquals(d, m); //fail
//test 2
String x="ok";
String y=x;
assertEquals(x, y);//pass
x+="2";
assertEquals(x, y);//fail ok2 ok
x=x+"2";
// assertEquals(x, y); //fail ok2 ok
}
@Test
public void test2(){
String x= "Out";
reassignStr(x);
assertEquals(x, "In"); // fail Out In
//Wniosek:
//Metoda bierze KOPIE referencji!
//nie ma wpływwu na referencje x!!
}
private void reassignStr(String ref){
ref= "In";
}
Promocja typów - rozszerzająca
• byte to short, int, long, float, or double
• short to int, long, float, or double
• char to int, long, float, or double
• int to long, float, or double
• long to float or double
• float to double
1 mar 2010
Haczyki
Metoda o identycznej nazwie jak konstruktor ( np z void)- Return char gdy metoda zwraca inta -> ok dozwolone
- Zwracanie null kiedy powinniśmy zwracać prymitywa.
- Do tablicy prowadzi referencja.
- Jeżeli stworzyłeś konstruktor z argumentami to już nie ma tego domyślnego bez argumentów
- Czy klasa abstrakcyjna ma konstruktor? -> Tak!
- Czy interfejs ma konstrutor? -Nie!
- Domyślny konstruktor ma taki sam access mod jak klasa!
- W konstruktorze nei może być jednocześnie this(..) i super(..)
- Metody static nie sa overriden lecz tylko po typie referencji!!
- instanceof tylko dla rferencji i klasy z tego samego drzewa dziedziczenia !
- long is illegal in switch statement!
- null isntance of [jakakolwiek kalsa] => false !! ( także pośrednio)
- [Dog object] instance of Cat => compilation error!
- argument byte not passing to method(Long)
- int x => wybierze Object x niż Integer... (var-arg)
- List nie możesz dodać Dog or Cat !!
- List poprawne!!
- List oznacza każdy rodzaj Listy!!!
//haczyki
String[] czyDozwolonyNull(){ return null; } //ok
int[] czyDozwolonyNullDlaPrymiTywa(){ return null; } //ok
}
abstract class CzykonstruktorMa {
public CzykonstruktorMa() {
}
}
class Konkret{
int dupeczka;
public Konkret() { }
/*To jest metoda a nie konstruktor!!!*/
public void Konkret(){}
public Konkret(int dupeczka) {
Konkret(); //metoda e nie konstruktor
this.dupeczka = dupeczka;
}
}
class Base{
int x; int y;
public Base(int x, int y) {
this.x = x; this.y = y;
}
}
//!class Extended extends Base{ } zonk bo
//nie ma domyślnego konstruktora
/*Teraz jest ok*/
class Extended extends Base{
public Extended(int x, int y) {
super(x, y);
}
}
Poliporfizm
Tylko metody sąwywoływane dynamicznie ( po typie obiektu na który wskazuje referencja)- Zmienne static i nonstatic nie są dynamicznie wybierane, wybieran są ząś po typie referencji!!
- Overloading nie po typie referencji!!
- Przy oveloading można dowolnie zmieniać modyfikator dostępu jak i zwracaną wartość.
instanceof
@Test
public void testInstanceOf() {
//assertTrue(null instanceof Object); false
//assertTrue(null instanceof String); false
//!!assertTrue(int instanceof Object); compilation Error
//@assertTrue(String instanceof Object); błąd kompilacji
//primitives
int x = 6;
//assertTrue(x instanceof Object); zonk :)
/**
* Wnioske:
* referencja instanceof Klasa
*/
int[] tab ={1,2,3};
assertTrue(tab instanceof Object); //ok
}
Pisane tylko małymi literami- Zasada: po lewej stronie referencja
- Zasada: po proawej stronie Klasa Name
28 lut 2010
Zasady overriding
- Lista argumentów musi dokładnie pasować. ( ?)
- Taki sam zwracany typ lub subtyp!
- Modyfikator dostępu nie może być bardziej restrykcyjny!
- Modyfikator dostępu może być mniej restrykcyjny.
- jeżeli klasy base i subclass są w tym samym pakiecie to można override metody nie oznaczone private lub final.
- Jeżeli klasy base i subclass są w różnych pakietach to można override metody nie oznaczone final i oznaczone public lub protected!
- Metoda nadpisująca może rzucać unchecked(runtime) wyjątkiem,jakimkolwiek.
- metoda nadpisująca nie może rzucać wyjątkiem(checked) zupełnie nowym lub bardziej ogólnym od metody nadpisywanej!
- metoda nadpisująca może rzucać wyjątkami mniej ogólnymi lub liczbebnością mniej
- metoda nadpisująca nie musi throw jakiekokolwiek wyjątku!
- Nie możeż nadpisywać metod finalnych.
- Nie możesz nadpiywać metod static!
- 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!!
}
- Niem oże być deklarowany lokalnie! ( w metodzie)
- Wewnątrz klasy i owszem.!!!!!!!
- Moga być deklarowane w osobnym pliku!
- Dekalracja enuma poza klasą nie może być protected lub private!
- Dekalracja enuma poza klasą może być default lub public!
- Na końcu nie musi być średnika :D
- Enum może mieć metody , zmienne swoje , konctruktor z intem!!
- Jeżeli wydrukujemy to bedzie domyślenie drukowana anzwa enum np MALY
- Kązdy enum ma static funkcje values , która zwraca tablicę elemtów enuma w kolejności.
- Nie możesz wywołać konstruktora enuma bezpośrednio!!!
- Element elumu może nadpisywać metody w tym enumie!!
Zmienne final
- Raz zainicjalozowane nie mogą być zmieniane
- Jeśli chodzi o ptymitywy to chodzi o vartość
- Jeśli chodzi o Obiekt to nie wolno zmieniać referencji, zaś samo obiekt może być modyfikowany!.
- Nie ma final obiektów, tylko final referencje!
- Co do final klas- nie mogą być subklasowane
- 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[];
}
- Przy deklaracji nie używamy rozmiarów ( np int[5] tablica).
Zmienne lokalne
- Nazywane takrze automatyczne,
- Zmienne nie tylko są inicjalozowane ale także deklarowane wew. metody
- Są niszczone kiedy wyjdziemy z metody!
- Są na stosie
- Jeżeli zmienną bedzie obiekt to i tak bedzie on na stercie!
- Nie ma czegoś takiego jak obiekt lokalny , jest to tylko lokalna referencja do obiktu na stercie.
- trzebą ją zasinicjalozować!!!! ( przed użyciem)
- Może mieć taką samą nazwę jak zmienna instancji ( także static).
Porównanie modyfikatorów
- Zmienne lokalne : final
- Zmienne ( nie lokalne) : final, public, protected, private ,static, transient volatile
- Metody: final, public, protected, private ,static, abstract, synchronized, strictpf, native
- Klasa: hm... public, default, strictfp, abstract...( dodać)
Zmienne instancji
- Można wykorzystać 4 aces modifiers
- Może być final
- Może być transient
- Nie może być: synchronized,abstract, native, strictfp,
- 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
- Dostępność memberów -SCJP book , page 39
- Gdy metoda w base throw Exception - SCJHP book,page 108
- hashcode a equals , SCJP book, page 554
Podstawy cz.2
- Do protected nie odnosimy się przez .
- Dla klas w innych pakietach do protected członków można dostać się tylko
przez dziedziczenie - Do protected member dostaniemy się z klasy z tego samoego pakietu!!!
- Zmienne lokalne są bez modyfikatorów dostępu
- W zmiennych lokalnych można uzywać final
- Protected= package + subclass throught inheritance
- Klasa nie bastrakcyjna z choć 1 metodą abstract jest illegal!!
- Klasa abstrakcyjna nie musi mieć abstrakcyjnych metod!.
- Pierwsza nie abstrakcyjna klasa musi implementować wszystkie metody abstrakcyjne z superclass.
- static + abstract method are illegal!
- Oznaczenie synchronized stodujemy tylko do metod i bloków kodu!
- Native tylko dla metod! ( deklaracja jak metody anstrakcyjne)
- strictfp tylko dla klas i metod ( nie dla zmiennych!!!! )
- Varargs: void method(int... x) {}
- Varargs musi być ostatnim marametrem!
- Varargs=> 0 lub wiele
- Jeżeli przed konstruktorem damy void to jest traktowany jako metoda.
- Konstruktor nie może być ani final ani static ani abstract!
- Ile zajmuje boolean to zależy od sprzętu!.
- Char i short zajmują 16 bitów.
- Klasy abstrakcyjne mogą implemntować interfejsy!
- Metod ,które są w interfejsie nie trzeba zapisywać w klasie abstrakcuyjnej, dopiero w pierwszej klasie konkretnej!!!
- volatile tylko do zmiennych!
- Jeżeli klasa nie jest public to nazwa nie musi pasować do nazwy pliku!!!
- Metoda private nie może być overriden!!
- throws jest dozwolone po sygnaturze metody abstrakcyjnej!!
- może być synchronized łączone z final i modyfikatorami dostępu.
- 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
- Przysłanianie metod, które są prywatne w klasie bazowej
- Kiedy obiekty są dostępne dla GC! {scope ,wyjście z metod, różne!!!}
Interfejs
- W pliku java może być kilka interfejsów!
- Interfejs bez moted może być!
- metody interfejsu nie mposiadają ciała!
- Każda metoda interfejsu musi być implementowana w klasie implementującej!
- uwaga! Klasa abstrakcyjna może posiadać abstrakcjyjne jak i nie abstrakcyjne metody!
- Metoda int ok(); jest widziana jako public abstract ok()
- Interfejs może zawierać zmienne ,które są public, static final ( consts) !!
- Nie może posiadać metod statycznych!
- Nie może być oznaczony jako final, strictfp lub native!!
- Interfejs może extend tylko jedną lub kilka interfejsów!!
- Interfejs nie może immplement czegoś!!
- 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
- Czy klasa abstrakcyjna może imlementować interfejs?
- Klasa dziedzicząca z klasy abstrakcyjnej musi dziedziczyć wszytkie metody abstrakcyjne?
- Czy się to skompiluje? final abstract class{}
- 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
Tylko jedna publiczna klasa w pliku!- komentarz może pojawić się na pozątku lub końcu każdej linii.
- Nazwa klasy publicznej musi być identyczna z nazwą pliku!
- Jeśli klasa jest częścią package to linia z package musi być pierwszą nie komentarzową linią!
- Linie z import muszą być pomiedzy package a deklaracją klay!
- import i package odnosi sie do całego pliku i może być tylko 1.
- Plik może zwierać więcej niepublicznych klas!
- Plik bez publicznej klasy nie musi pasować nazwą do czegokolwiek!
JavaBeans
- Pola prywatne
- metody get i set są public
- public void setCosik(int x)
- public int getCosik();
- Dla boolean : getBool() albo isBool().
- Event: public void addMyListener(MyListener m) //takei same nazwy!
- Przedrostek add i remove tylko w połączeniu z Listener!!!
- nie ma delete!!!
Nazwy identyfikatorów
- Identyfikator musi zaczynać się od: $,_ , lub litery.
- identyfikator nie może zaczynać się od cyfry!
- Kolejne znaki mogą być: cyfrą,literą,$,_.
- Nie ma limitów na długość ident.
- Nie możesz używać słów kluczowych javy.
- foo i Foo to dwa różne identyfikatory!!
- 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) {
ArrayListarray = 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
- Obiekty są przechowywane na stercie.
- Typy prymitywne przechowywane są na stosie.
- Tablica obiektów inicjalozowana jest wartościami null.
- Tablica typów prymiywnych jest zerowana.
- Wartości domyślne nadawane są tylko dla składowych klas!
- Wartość domyślna dla zmiennej prymitywnej wew. metody nie jest nadawana! -> błąd kompilacji
- Public, static, private , protected nie można używać dla zmiennych wew. metody!
- Można przysłonić w metodzie pole klasy ale trzeba wtedy nadać wartość!
- Dla obiektów == i != porównuje referencje!
- Nie nadpisany equal() porównuje domyślnie referencje!
- Switch(x) => x musi być selektorem całkowitym!
- Każde działanie na byte,char lub short jest promowane do inta.
- Boolean nie możę być rzutowany na coś innego i coś innego nie może być rzutowane na booleana.
- Traktowanie liczb jako zmiennych logicznych jest niedozwolone!
- Nazwa zmiennej nie może być liczbą, może zaczynać się od litery,$ lub _.
- Z metod statycznych ma się tylko dostęp do zmiennych statycznych!
- Możemy skompilować bez błądów pusty plik javy! javac Test.java
- int x='x'; jest poprawne zaś char c=-1; jest niepoprawne
- Inicjalizacja zmiennych klasy następuje przed wywołaniem konstruktora!
- Klasa może być public lub bez ,protectedi private jest tylko dla zmiennych!
- Nie można mieszać final,absctact,strictfp ze sobą!
- strictfp - tylko do klass i metod , nie do zmiennych!
- Jeżeli klasa posiada choć 1 metodę abstract to cała klasa musi być abstract!
- Metoda oznaczona jako private nie może być przysłoniona (overriding) , or nadpisana :D
- Konstruktor nie może być synchronized!!!!
Subskrybuj:
Posty (Atom)