! Help Java
! Help Java
doc
2) Am voie să pun o singură clasă publică. Ea va avea numele fişierului, deci salvez sub
numele Test.java
3) Instalez JDK
4) Ca să găsească calea către compilator:
a. O găsesc în Program file\Java
b. O adaug intr-un fişier bat
i. set path=%path%;C:\Program Files\Java\jdk1.8.0_45\bin
c. Sau
i. Computer
ii. Proprietăţi
iii. Advanced system setings
iv. Environment variables
v. Path. Este activă după reponirea command prompt.
5) javac Test.java
6) java Test
Tutoriale> http://docs.oracle.com/javase/tutorial/
JAVA J2EETutorial.pdf
Interfaţa este mai mult ca o clasă abstract care are numai metode abstracte. Pentru că în Java
nu este permisă moştenirea multiplă. Interfeţele permit realizarea de legături.
class NumeClasa implements Interfata1, Interfata2, ...
interface NumeInterfata extends Interfata1, Interfata2, ...
class FirstApp {
public static void main( String args[]) {
System.out.println("Hello world");
}
}
Vizualizarea appletului
appletviewer exemplu.html
Unicode
\u0030 - \u0039 : cifre ISO-Latin 0 - 9
\u0660 - \u0669 : cifre arabic-indic 0 - 9
\u4e00 - \u9fff : litere din alfabetul Han (Chinez, Japonez, Coreean)
Identificatorii
Sunt secvente nelimitate de litere si cifre Unicode, epand cu o litera. Identificatorii nu au
voie sa fie identici cu cuvintele rezervate.
Variabilele pot avea ca tip fie un tip primitiv de data, fie o referinta la un obiect.
final double PI = 3.14;
int valoare = 100;
long numarElemente = 12345678L;
Obs: Spre deosebire de C++ nu este permisa ascunderea unei variabile :
int x=12;
{
int x=96; //ilegal
}
Atentie: In Java nu exista goto. Se pot a defini etichete de forma nume_eticheta:, folosite
în expresii de genul: break nume_eticheata sau continue nume_eticheta
Exemplu:
i=0;
eticheta:
while (i<10) {
System.out.println("i="+i);
j=0;
while (j<10) {
j++;
if (j==5) continue eticheta;
if (j==7) break eticheta;
System.out.println("j="+j);
}
i++;
}
class Exemplu {
double x;
protected static int n;
public String s = "abcd";
private Point p = new Point(10, 10);
final static long MAX = 100000L;
}
This = referinţă la obiectul current. Sunt în clasa AAA şi mă refer la variabila x. În loc de
AAA.x pot scrie this.x
Super = referinţă la obiectul părinte
class B extends A {
B() {
this(0);
}
B(int x) {
super(x); System.out.println(x);
}
void metoda() {
super.metoda();
System.out.println(x);
}
[modificatori] TipReturnat numeMetoda ( [argumente] )
[throws TipExceptie1, TipExceptie2, ...]
{
// Corpul metodei
}
O metoda abstracta este o metoda care nu are implementare si trebuie obligatoriu sa faca
parte dintr-o clasa abstracta.
native
In cazul îın care avem o librarie importantă de funcţii scrise în alt limbaj de programare,
cum ar fi C, C++ si limbajul de asamblare, acestea pot fi refolosite din programele
Java. Tehnologia care permite acest lucru se numeşste JNI (Java Native Interface)¸ si
permite asocierea dintre metode Java declarate cu native¸ si metode native scrise în
limbajele de programare menţtionate.
synchronized
Este folosit în cazul în care se lucrează cu mai multe fire de execuţie iar metoda respectivă
gestionează resurse comune. Are ca efect construirea unui monitor care nu permite
executarea metodei, la un moment dat, decât unui singur fir de execuţie.
Metodele care nu returnează nimic au tipul void. Obligatoriu se scrie el.
Dacă o metodă trebuie să returneze o valoare acest lucru se realizează prin intermediul
instrucţiunii return, care trebuie să apară în toate situaţiile de terminare a funcţiei.
double radical(double x) {
if (x >= 0)
return Math.sqrt(x);
else {
System.out.println("Argument negativ !");
// Eroare la compilare
// Lipseste return pe aceasta ramura
}
}
Pentru a afla starea obiectului transmiterea prin valoare nu este bună. Se foloseşte o clasă:
// Varianta corecta class Param {
public int x, y, raza;
}
class Cerc {
private int x, y, raza;
public void aflaParametri(Param param) {
param.x = x; param.y = y; param.raza = raza;
}
}
Altă metodă:
Se află valorile cu funcţia şi se setează cu this.
class Cerc {
private int x, y, raza; public int getX() { return x;
}
public void setX(int x) {
this.x = x;
}
...
}
Nu există variabile globale. Se folosesc variabile de clasă (nu de instanţă, care ar trebui tot
timpul realocate).
funcţia sqrt care extrage radicalul unui număr şi care se găseşte în clasa Math. Dacă
nu ar fi fost funcţie de clasă, apelul ei ar fi trebuit făcut astfel (incorect, de altfel):
// Incorect !
Math obj = new Math();
double rad = obj.sqrt(121);
ceea ce ar fi fost extrem de neplăcut... Fiind însă metodă statică ea poate fi apelată prin:
Math.sqrt(121) .
LASĂ ÎMBRICATĂ:
class ClasaDeAcoperire{
class ClasaImbricata1 {
// Clasa membru
}
void metoda() {
class ClasaImbricata2 {
// Clasa locala metodei
}
}
Clase şi metode abstracte. Am Graphiscs. O serie de operaţii sunt comune: schimbarea culorii,
poziţia, etc. Altele sunt specfice, cum este desenarea figurii, care variază de la desen la desen:
cerc, pătrat. Declar desenarea ca abstract şi pun toate metodele neabstracte şi abstracte într-o cl
absteactă. Ea este superclasă pe baza căreia construiesc clasele cerc, pătrat, unde defines modul
de desenare.
try {
FileReader = ne FileReader("in.txt
FileWriter = ne FileWriter("out.tx
out w t");
w h i l e ( ( c = i innt . rc e; a d ( ) ) ! = -1)
out.write(c);
in.close();
out.close();
} catch(IOException e) {
System.err.println("Eroare la operatiile cu fisiere!");
e.printStackTrace();
}
}
}
import java.io.*;
120 CAPITOLUL 4. INTRĂRI SI IEŞIRI
import java.util.*;
public class ListareDirector {
System.out.println(
"Ca le absolut a: " + f.getAbsolutePath() +
"\n Poate citi: " + f.canRead() +
"\n Poate scrie: " + f.canWrite() +
"\n Parinte: " + f.getParent() +"\n Cale: " + f.getPath() +
"\n Lungime: " + f.length() +
"\n Data ultimei modificari: " +
n e w D a t e ( f . l a s t M o d i f i e d () ) ) ;
System.out.println("--------------");
}
try {
File director = new File(nume);
File[] continut = director.listFiles();
} catch(Exception e) {
e.printStackTrace();
}
}
}
145
• java.awt - interfaţa grafică cu utilizatorul
• java.lang.reflect - introspecţie
Proiecte:
Numele fişierului .java este numele clasei.
Poate exista numai o clasă public pe pachet
Clasele dintr-un pachet sunt în directoare cu numele pachetelor
In urma compilării fişierelor sursă vor fi generate unităţi de compilare pentru fiecare clasă
şi interfaţă din fişierele sursă. După cum ştim acestea au extensia
.class şi numele scurt al clasei sau interfeţei respective.
Spre deosebire de organizarea surselor, un fişier .class trebuie să se
gaseasca într-o ierarhie de directoare care să reflecte numele pachetului din care face parte
clasa respectivă.
Implicit, în urma compilării fişierele sursă şi unităţile de compilare se
găsesc în acelaşi director, însă ele pot fi apoi organizate separat. Este recomandat însă ca
această separare să fie făcută automat la compilare.
Revenind la exemplul de mai sus, vom avea următoarea organizare:
/matematica
/clase
/geometrie
/plan Poligon.class Cerc.class
/spatiu
Poliedru.class
Sfera.class
/algebra
Grup.class
/analiza
Functie.class
Matematica.class
Opţiunea -d specifică directorul rădăcină al ierarhiei de clase. In lipsa lui, fiecare unitate de
compilare va fi plasată în acelaşi director cu fişierul său sursă.
Deoarece compilăm clasa principală a plicaţiei, vor fi compilate în cascadă
toate clasele referite de aceasta, dar numai acestea. In cazul în care dorim să
compilăm explicit toate fişierele java dintr-un anumit director, de exemplu
surse/geometrie/plan, putem folosi expresia:
/matematica
/surse
/clase compile.bat
(javac -sourcepath surse surse/Matematica.java -d clase)
run.bat
(java -classpath clase Matematica)
Serializare = transformare obiect în şir octeţi nu salvează doar imaginea unui obiect ci şi
toate referinţele la alte obiecte pe care acesta le conţine.
<HTML>
<APPLET
CODE=BarChart.class
WIDTH=300
HEIGHT=250>
<PARAM NAME="columns" VALUE="4">
<PARAM NAME="c1" VALUE="110">
<PARAM NAME="c2" VALUE="150">
<PARAM NAME="c3" VALUE="100">
<PARAM NAME="c4" VALUE="170">
<PARAM NAME="label1" VALUE=“2000">
<PARAM NAME="label2" VALUE=" 2001">
<PARAM NAME="label3" VALUE=" 2002">
<PARAM NAME="label4" VALUE=" 2003">
</APPLET>
</HTML>
Pain Laborator5_CreareaUneiAnimatii.doc
import java.awt.*;
import java.applet.*;
}
public void run(){ // metoda run()
while(true){ // bucla infinita
repaint(); // reapelare paint(). Obligatoriu, altfel nu se misca
x=x+10; // pas de avans
if(x>(Xm-100)){ // testare pozitie
x=0; // fata de capatul cursei
i=(i+1)%3; // rotatie mesaje
}
try{ // testare situatie de exceptie
Thread.sleep(100); // pauza intre doua afisari. Cere
obligatoriu try catch
}catch(InterruptedException e){ // tratare exceptie
}
}
}
public void paint(Graphics g){ // metoda paint()
get_size(); // preluare dimensiuni applet
this.setBackground(Color.black); // setare culoare fond
this.setForeground(Color.yellow); // setare culoare scris
g.setColor(Color.orange);
Font f=new Font("Timesn",Font.BOLD,lit); // definire caractere
g.setFont(f); // setare scris
g.drawString("Move",x,y-5); // scriere mesaje protected
ecran
Font f1=new Font("Arial", Font.BOLD, 9);
g.setColor(Color.orange);
g.fillRect(x, y, 70, 70);
g.setColor(Color.white);
g.setFont(f1);
g.drawString("TM", x+58, y+64);
}
}
Pain laboratorul 1
Apelul metodelor statice si nestatice
class ExpSwitch {
static void numara(int i) {
switch (i) {
case 1 : IO.write("unu ");
case 2 : IO.write("doi ");
case 3 : IO.writeln("trei");
}
}
va produce la ieşire:
trei
doi trei
unu doi trei
Obs: metodele clasei apelate direct în main trebuie sa fie statice (cu modificatorul static).
Altfel trebuia creat un obiect de tip ExpSwitch pentru a putea apela metoda numara a
acestui obiect, aşa cum se arată în partea de program comentată
class DreptunghiMain{
public static void main(String arg[]){
//cream un dreptunghi
Dreptunghi d;
double a;
d=new Dreptunghi(3,5);
System.out.print("Dreptunghi initial: ");
d.afisare();
a=d.arie();
System.out.println("arie="+a);
if (d.maiMare(d2))
System.out.println("Noul dreptunghi e mai mare");
else
System.out.println("Dreptunghiul initial e mai mare");
}
}
try {
// Instructiuni care pot genera exceptii
}
catch (
TipExceptie1 variabila) {
// Tratarea exceptiilor de tipul 1
}
catch (TipExceptie2 variabila) {
// Tratarea exceptiilor de tipul 2
}
...
finally {
// Cod care se executa indiferent
// daca apar sau nu exceptii
}
package copierefisier;
import java.io.*;
public class CopiereFisier {
public static void main(String[] args) {
try {
FileReader in = new FileReader ("aaa.txt ");
FileWriter out = new FileWriter ("aab.txt ");
int c;
while ((c = in. read ()) != -1)
out.write (c);
in.close ();
out.close ();
} catch ( IOException e) {
System.err.println (" Eroare la operatiile cu fisiere !");
e.printStackTrace ();
}
}
}
Fir decexecuţie = ca un process, dar datele sunt commune cu celelalte fire de execuţie.
The syntax of the <APPLET> tag is shown below; the order of the parameters does
not matter:
<APPLET
[ALIGN = alignment]
[ALT = alternate-text]
CODE = applet-filename or OBJECT = serialized-applet
[CODEBASE = applet-directory-url]
[ARCHIVE = filename.zip/filename.jar]
HEIGHT = applet-pixel-height
[HSPACE = horizontal-pixel-margin]
[MAYSCRIPT = true/false]
[NAME = applet-name]
[VSPACE = vertical-pixel-margin]
WIDTH = applet-pixel-width
>
<PARAM NAME=parameter1 VALUE=value1>
<PARAM NAME=parameter2 VALUE=value2>
<PARAM NAME=parameter3 VALUE=value3>
...
[alternate-html]
</APPLET>
D
Image Loading
In this appendix:
• How Images are
Loaded
• A Brief Tour of
sun.awt.image
D.1 How Images are Loaded
You have seen how easy it is to display an image on screen and have probably
guessed that there’s more going on behind the scenes. The getImage() and draw-
Image() methods trigger a series of events that result in the image being available
for display on the ImageObserver. The image is fetched asynchronously in another
thread. The entire process* goes as follows:
1. The call to getImage() triggers Toolkit to call createImage() for the image’s
InputStreamImageSource (which is a URLImageSource in this case; it would be
a FileImageSource if we were loading the image from a local file).
2. The Toolkit registers the image as being “desired.” Desired just means that
something will eventually want the image loaded. The system then waits until
an ImageObserver registers its interest in the image.
3. The drawImage() method (use of MediaTracker or prepareImage()) registers
an ImageObserver as interested.
4. Registering an ImageObserver kicks the image’s ImageRepresentation into
action; this is the start of the loading process, although image data isn’t actually
transferred until step 9. ImageRepresentation implements the ImageConsumer
inter face.
5. The start of production registers the image source (ImageProducer URLImage-
Source) with the ImageFetcher and also registers the ImageRepresentation as
an ImageConsumer for the image.
* This summary covers Sun’s implementation ( JDK). Implementations that don’t derive from the JDK
may behave completely differently.
1017
1018 APPENDIX D: IMAGE LOADING
6. The ImageFetcher creates a thread to get the image from its source.
7. The ImageFetcher reads data and passes it along to the InputStreamImage-
Source, which is a URLImageSource.
8. The URLImageSource determines that JPEGImageDecoder is the proper
ImageDecoder for converting the input stream into an Image. (Other ImageDecoders
are used for other image types, like GIF.)
9. The ImageProducer starts reading the image data from the source; it calls the
ImageConsumer (i.e., the ImageRepresentation) as it processes the image. The
most important method in the ImageConsumer inter face is setPixels(), which
delivers pixel data to the consumer for rendering onscreen.
10. As the ImageConsumer (i.e., the ImageRepresentation) gets additional information,
it notifies the ImageObserver via imageUpdate() calls.
11. When the image is fully acquired across the network, the thread started by the
ImageFetcher stops.
As you see, there are a lot of unfamiliar moving pieces. Many of them are from the
java.awt.image package and are discussed in Chapter 12, Image Processing. Others
are from the sun.awt.image package; they are hidden in that you don’t need to
know anything about them to do image processing in Java. However, if you’re curious,
we’ll briefly summarize these classes in the next section.
D.2 A Brief Tour of sun.awt.image
The classes in sun.awt.image do the behind-the-scenes work for rendering an
image from a file or across the network. This information is purely for the curious;
you should never have to work with these classes yourself.
Image
The Image class in this package represents a concrete Image instance. It contains
the basis for the Image class that is actually used on the run-time platform,
which exists in the package for the specific environment. For instance,
the sun.awt.win32 package includes the W32Image ( Java 1.0), the
sun.awt.windows package includes WImage ( Java 1.1), while the
sun.awt.motif package includes the X11Image, and the sun.awt.macos package
includes the MacImage.
ImageRepresentation
The ImageRepresentation is the ImageConsumer that watches the creation of
the image and notifies the ImageObserver when it is time to update the display.
It plays an important part in the overall control of the Image production
process.
Image sources
A Java image can come from three different sources: memory (through createImage()),
local disk, or the network (through getImage()).
• OffScreenImageSource implements ImageProducer for a single framed
image in memory. When an Image created from an OffScreenImageSource
is drawn with drawImage(), the ImageObserver parameter can be null
since all the image information is already in memory and there is no need
for periodic updating as more is retrieved from disk. You can get the
graphics context of OffScreenImageSource images and use the context to
draw on the image area. This is how double buffering works.
• InputStreamImageSource implements ImageProducer for an image that
comes from disk or across the network. When an Image created from an
InputStreamImageSource is drawn with drawImage(), the ImageObserver
parameter should be the component being drawn on (usually this) since
the image information will be loaded periodically with the help of the
ImageObserver inter face). This class determines how to decode the image
type and initializes the ImageDecoder to one of GifImageDecoder, JPEGImageDecoder,
or XbmImageDecoder, although that can be overridden by a
subclass. It can use a ContentHandler to work with unknown image types.
• FileImageSource is a subclass of InputStreamImageSource for images that
come from the filesystem. It uses the filename to determine the type of
image to decode and checks the security manager to ensure that access is
allowed.
• URLImageSource is a subclass of InputStreamImageSource for images that
are specified by a URL.
• ByteArrayImageSource ( Java 1.1 only) is a subclass of InputStreamImage-
Source for images that are created by calling Toolkit.createImage(
byte[]).
Image decoders
An ImageDecoder is utilized to convert the image source to an image object. If
there is no decoder for an image type, it can be read in with the help of a
ContentHandler
or your own class that implements ImageProducer, like the
PPMImageDecoder shown in Chapter 12.
• GifImageDecoder reads in an image file in the GIF format.
• JPEGImageDecoder reads in an image file in the JPEG format.
D.2 A BRIEF TOUR OF SUN.AWT.IMAGE 1019
1020 APPENDIX D: IMAGE LOADING
• XbmImageDecoder reads in an image file in the XBM format. Although
XBM support is not required by the language specification, support is provided
with Netscape Navigator, Internet Explorer, HotJava, and the Java
Developer’s Kit from Sun.
ImageFetcher
The ImageFetcher class fetches the actual image from its source. This class creates
a separate daemon thread to fetch each image. The thread is run at a
higher priority than the default but not at the maximum priority.
Math.random()
Cristian_Frasinaru-Curs_practic_de_Java
System.exit(-1); //termina aplicatia
System.out.println("Salut " + nume + " " + prenume);
double numar = Double.parseDouble(args[0]);
Metodele de tipul parseTipNumeric pot produce except¸ii (erori) de
tipul
NumberFormatException
[public][abstract][final]class NumeClasa
[extends NumeSuperclasa]
[implements Interfata1 [, Interfata2 ... ]]
{
// Corpul clasei
}
• abstract
Declar˘a o clas˘a abstract˘a (¸sablon). O clas˘a abstract˘a nu poate fi
instant¸iat˘a, fiind folosit˘a doar pentru a crea un model comun pentru o
serie de subclase. (vezi ”Clase ¸si metode abstracte”)
abstract
Permite declararea metodelor abstracte. O metod˘a abstract˘a este o
metod˘a care nu are implementare ¸si trebuie obligatoriu s˘a fac˘a parte
dintr-o clas˘a abstract˘a. (vezi ”Clase ¸si metode abstracte”)
• native
In cazul ˆın care avem o libr˘arie important˘a de funct¸ii scrise ˆın alt
limbaj
de programare, cum ar fi C, C++ ¸si limbajul de asamblare, acestea
pot fi refolosite din programele Java. Tehnologia care permite acest
lucru se nume¸ste JNI (Java Native Interface) ¸si permite asocierea dintre
metode Java declarate cu native ¸si metode native scrise ˆın limbajele
de programare ment¸ionate.
Polimorfism =
se refera la:
• supraıncarcare (overloading) : ın cadrul unei clase pot exista metode
cu acela¸si nume cu condit¸ia ca signaturile lor s˘a fie diferite (lista de
argumente primite s˘a difere fie prin num˘arul argumentelor, fie prin
tipul lor) astfel ˆıncˆat la apelul funct¸iei cu acel nume s˘a se poat˘a
stabili
ˆın mod unic care dintre ele se execut˘a.
• supradefinire (overriding): o subclasa poate rescrie o metoda a clasei
parinte prin implementarea unei metode cu acelasi nume si aceeasi
signatur˘a ca ale superclasei.
Cu p variabilă de clasă putem număra câte obiecte au fost create din acea clasă:
class Exemplu {
static long nrInstante = 0;
Exemplu() {
// Constructorul este apelat la fiecare instantiere
nrInstante ++;
}
}
} catch (FileNotFoundException e) {
//Tratam un tip de exceptie
System.err.println("Fisierul nu a fost
gasit !");
System.err.println("Exceptie: " + e.ge
tMessage());
System.exit(1);
} catch (IOException e) {
//Tratam alt tip de exceptie
System.out.println("Eroare la citirea
din fisier!");
e.printStackTrace();
} finally {
if (f != null) {
// Inchidem fisierul
System.out.println("\nInchidem fisie
rul.");
try {
f.close();
} catch (IOException e) {
System.err.println("Fisierul nu poa
te fi inchis!");
e.printStackTrace();
}
}
}
}
Excepţii
Fluxuri
import java.io.*;
Reader InputStream
int read() int read()
int read(char buf[]) int read(byte buf[])
... ...
Reader InputStream
void write(int c) void write(int c)
void write(char buf[]) void write(byte buf[])
void write(String str) -
... ...
Cred că este Writter şi OutputStream
• Fi¸sier
FileReader, FileWriter
FileInputStream, FileOutputStream
Numite ¸si fluxuri fi¸sier, acestea sunt folosite pentru citirea
datelor dintr-un fi¸sier, respectiv scrierea datelor ˆıntr-un fi¸sier ¸si vor fi
analizate
ˆıntr-o sec¸tiune separata˘ (vezi ”Fluxuri pentru lucrul cu fi¸siere”).
• Memorie
CharArrayReader, CharArrayWriter
ByteArrayInputStream, ByteArrayOutputStream
Aceste fluxuri folosesc pentru scrierea/citirea informa¸tiilor ˆın/din
mem- orie ¸si sunt create pe un vector existent deja. Cu alte cuvinte,
permit tratarea vectorilor ca sursa˘/destina¸tie pentru crearea unor
fluxuri de intrare/ie¸sire.
StringReader, StringWriter
Permit tratarea ¸sirurilor de caractere aflate ˆın memorie ca
sursa˘/destina¸tie pentru crearea de fluxuri.
• Pipe
PipedReader, PipedWriter
PipedInputStream, PipedOutputStream
Implementeaza componentele de intrare/ie¸sire ale unei conducte de
˘
date (pipe). Pipe-urile sunt folosite pentru a canaliza ie¸sirea unui pro-
gram sau fir de execu¸tie ca˘tre intrarea altui program sau fir de
execu¸tie.
Flux de procesare
//crearea unui flux de intrare printr-un buffer
BufferedReader in = new BufferedReader(
new FileReader("fisier.txt"));
//echivalent cu
FileReader fr = new FileReader("fisier.txt");
BufferedReader in = new BufferedReader(fr);
import java.io
.*;
Copiere fişier
public class Copiere {
public static void main(String[] args) {
try {
FileReader = new FileReader("in.tx
ii
F nleWriter = new F ti"l)e
;Writer("out.t
out xt");
int c;
w h i l e ( ( c = i n . r e a d ( ) ) ! = -1)
out.write(c);
in.close();
out.close();
} catch(IOException e) {
System.err.println("Eroare la operatiile cu fi
siere!");
e.printStackTrace();
}
}
}
Citire-scriere cu buffer.- Se scrie când este umplut. Implicit are 512 octeţi.
BufferedOutputStream out = new BufferedOutputStream(
new FileOutputStream("out.dat"), 1024)
//1024 este dimensiunea bufferului
BufferedReader(Reader in)
BufferedReader(Reader in, int dim_buffer)
BufferedWriter(Writer out)
out.flush();
//bufferul este golit, datele se scriu in fisier
Am pus PATH
C:\Program Files\Java\jdk1.8.0_102\bin;%JAVA_HOME%\bin;C:\ProgramData\Oracle\Java\javapath;
%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT
%\System32\WindowsPowerShell\v1.0\;C:\Program Files\7-Zip
Parent = se foloseşte când se invocă constructorul părintelui sau o metodă a părintelui care are
acelaşi nume în fiu.
Method overloading = aceeaşi funcţie ccu număr sau tip de parametri diferiţi
Method Overriding = clasa child suprascrie metoda clasei părinte
Înaintea redefinirii se pune @override
@Override
public int compareTo(Student s) {
if (avg > s.avg )…
In this example, we are creating two classes Bike and Splendar. Splendar class extends Bike
class and overrides its run() method. We are calling the run method by the reference variable of
Parent class. Since it refers to the subclass object and subclass method overrides the Parent class
method, subclass method is invoked at runtime.
Since method invocation is determined by the JVM not compiler, it is known as runtime
polymorphism.
class Bike{
void run(){System.out.println("running");}
}
class Splender extends Bike{
void run(){System.out.println("running safely with 60km");}
s1 = new Triangle()
There are 2 classes one is parent class (Demo1) second is its subclass (Demo).
1. If Method run1 does not have parameters then the output of method will be same.
There is no use of Upcasting.
2. class Demo1{
3.
4. void run1(){
5. System.out.println("hello");
6. }
7. }
8.
9. class Demo extends Demo1 {
10.
11. void run1(){
12. System.out.println("hello1");
13. }
14.
15. public static void main(String args[]){
16.
17. Demo d = new Demo();
18. d.run1();
19.
20. Demo1 d1 = new Demo();
21. d1.run1();
22.
23. }
}
output: hello1
2. If we uses Parameterised overloading then the use of upcasting can be seen
clearly. There is the sense for Upcasting.
3. class Demo1{
4.
5. void run1(int a){
6.
7. System.out.println(a);
8. }
9. }
10.
11. class Demo extends Demo1 {
12.
13. void run1(String b){
14.
15. System.out.println(b);
16. }
17.
18. public static void main(String args[]){
19.
20. Demo d = new Demo();
21. d.run1("b");
22.
23. Demo1 d1 = new Demo();
24. d1.run1(2);
25.
26. }
}
În acest exemplu s-a executat metoda din părinte sau din fiu funcţie de tipul
parametrului.
Up-casting is casting to a supertype, while downcasting is casting to a subtype. Supercasting is
always allowed, but subcasting involves a type check and can throw a ClassCastException
Math.PI