Java Book
This document was uploaded by user and they confirmed that they have the permission to share it. If you are author or own the copyright of this book, please report to us by using this DMCA report form. Report DMCA
Overview
Download & View Java Book as PDF for free.
More details
- Words: 40,791
- Pages: 329
Java Programming 1
Version July 2000 Second Impression
The Team Production / Series Supervision Jambu Krishnamurthy Vice President – Product Development The Head Sridhar Subramaniam Head – Training Solutions Technical Writers Thiru Murugan .H Uma .S Ajay Balaji Review Jambu Krishnamurthy Sridhar Subramaniam Production/Design Vijay. V Editor Nurjehan Dhanani
Copyright 1999, Comp-U-Learn Inc. All Rights Reserved
No Part of this Book may be reproduced in any form by any means, stored in a retrieval system, or transmitted by any mode, electronic, mechanical, photocopying, recording, or otherwise, without written permission from the publisher. Exceptions are made to the program listings, which can be typed, stored in a Computer System and executed. No patent liability is assumed with respect to the use of the information contained herein. Although every precaution has been taken in the preparation of this book, the publisher assumes no responsibility for errors or omissions. Neither is any liability assumed for damages resulting from the use of the information contained herein.
All Trade Marks Acknowledged
The Book at a Glance , %HIRUH:H%HJLQ L ,, +RZWRXVHWKLV%RRN LL ,,, 2EMHFWLYHVRIWKLV%RRN LLL ,9 &RQYHQWLRQVXVHGLQWKLV%RRN LLL -DYD²$Q,QWURGXFWLRQ )XQGDPHQWDOVRI-DYD 223VLQ-DYD ,QWHUIDFHV 3DFNDJHV 6WUHDPV )LOHV+DQGOLQJ ([FHSWLRQ+DQGOLQJDQG0XOWLWKUHDGLQJ -DYD$SSOHWV $EVWUDFW:LQGRZLQJ7RRONLW +DQGOLQJ$:7(YHQWV 0RUHDERXW$:7 -DYD'DWD%DVH&RQQHFWLYLW\ 1HWZRUNLQJLQ-DYD ,*ORVVDU\ ,,$SSHQGL[HV ,,,,QGH[
Table of Contents ,%HIRUH:H%HJLQ L ,,+RZWRXVHWKLV%RRN LL ,,,2EMHFWLYHVRIWKLV%RRN LLL ,9&RQYHQWLRQVXVHGLQWKLV%RRN LLL -DYD²$Q,QWURGXFWLRQ
,QWURGXFWLRQWR-DYD +LVWRU\RI-DYD )HDWXUHVLQ-DYD -DYDDQGWKH,QWHUQHW -DYD$Q223/DQJXDJH &YV-DYD -DYD7RROV $SSOLFDWLRQ3URJUDPPLQJ &UHDWLQJDQ$SSOLFDWLRQ $SSOHW3URJUDPPLQJ &UHDWLQJDQ$SSOHW 2YHUYLHZRI-DYD
)XQGDPHQWDOVRI-DYD²
'DWDW\SHV 9DULDEOHVLQ-DYD /LWHUDOV.H\ZRUGV ,GHQWLILHUV 2SHUDWRUVLQ-DYD ([SUHVVLRQ(YDOXDWLRQ 2SHUDWRU3UHFHGHQFH 6FRSHRI9DULDEOHV &RPPHQWLQJLQ-DYD
7DEOHRI&RQWHQWV &RQWG
'HFLVLRQ0DNLQJ )RUORRS :KLOH 'R«:KLOH/RRS 6ZLWFK %UHDN6WDWHPHQWV $UUD\VLQ-DYD 6WULQJVLQ-DYD
2236LQ-DYD²
7UDGLWLRQDO3URJUDPPLQJ0RGHO 2EMHFW2ULHQWHG3URJUDPPLQJ$SSURDFK )HDWXUHVRI2EMHFW2ULHQWHG3URJUDPPLQJ %DVLF&RQFHSWVRI223V &UHDWLQJ&ODVVHVDQG2EMHFWVLQ-DYD &RQVWUXFWRUV *DUEDJH&ROOHFWLRQ )LQDOL]H0HWKRG ,QKHULWDQFH 3RO\PRUSKLVP 5HFXUVLRQ $GYDQWDJHVRI223VLQ-DYD
,QWHUIDFHV 3DFNDJHV
,QWURGXFWLRQWR,QWHUIDFHV :KDWLVDQLQWHUIDFH" ,QWULFDFLHVLQDQ,QWHUIDFH ,QWHUIDFH5HIHUHQFHV ([WHQGLQJWKH,QWHUIDFH
7DEOHRI&RQWHQWV &RQWG
7KH&ORQHDEOH,QWHUIDFH ,QQHU&ODVVHV 3DFNDJHV 1HHGIRU3DFNDJHV &/$663$7+9DULDEOH $FFHVV3URWHFWLRQ 2YHUYLHZRI-DYD%XLOWLQ3DFNDJHV
6WUHDPV )LOH+DQGOLQJ²
-DYD6WUHDP&ODVV 3ULQW6WUHDP 6\VWHP3URSHUWLHV ,QSXWDQG2XWSXW6WUHDPV )LOHVDQG'LUHFWRULHV )LOH,QSXWDQG2XWSXW6WUHDPV 'DWD,QSXWDQG2XWSXW6WUHDPV )LOWHUHG6WUHDPV %XIIHUHG6WUHDPV 3XVKEDFN,QSXW6WUHDP 5DQGRP$FFHVV)LOH 5HDGHUDQG:ULWHU&ODVVHV
([FHSWLRQ+DQGOLQJDQG0XOWLWKUHDGLQJ
([FHSWLRQ+DQGOLQJ²$Q,QVLJKW $GYDQWDJHVRI([FHSWLRQ+DQGOLQJ 8QFDXJKW([FHSWLRQV 0XOWLSOH&DWFK&ODXVHV
7DEOHRI&RQWHQWV &RQWG
,PSOLFLWDQG([SOLFLW([FHSWLRQV -DYDODQJ7KURZDEOH )LQDOO\&ODXVH &UHDWLQJ2ZQ([FHSWLRQ6XEFODVVHV 0XOWL7KUHDGLQJ 7KUHDG6WDWHV 7KUHDG3ULRULW\ 'DHPRQ7KUHDGV
-DYD$SSOHWV
,QWURGXFWLRQWR$SSOHW $SSOHWYV$SSOLFDWLRQ $SSOHW$UFKLWHFWXUH 'HYHORSLQJDQ$SSOHW $SSOHWLQ+70/ %DVLF0HWKRGVLQ$SSOHW 3DUDPHWHUSDVVLQJWR$SSOHWV *UDSKLFVFODVV )RQW&ODVV &RORU&ODVV ,PDJHV $QLPDWLRQXVLQJ,PDJHV
$EVWUDFW:LQGRZLQJ7RRONLW $:7 $Q$:72YHUYLHZ $:7$UFKLWHFWXUH %DVLF8,&RPSRQHQWV
7DEOHRI&RQWHQWV &RQWG
%XWWRQV &KHFN%R[HV 5DGLR%XWWRQV &KRLFHV 7H[W)LHOGV 7H[W$UHDV /LVWV 6FUROOEDUVDQG6OLGHUV &DQYDVHV
+DQGOLQJ$:7(YHQWV
,QWURGXFWLRQWR(YHQWV $SSOHW(YHQWV %XWWRQ(YHQWV +DQGOLQJ0XOWLSOH(YHQWV ,WHP(YHQWV 0RXVH(YHQW+DQGOLQJ 'RXEOHFOLFNV 0RXVH0RYHPHQWV 0RXVH'UDJDQG0RXVH0RYH(YHQWV 0RXVH(QWHUDQG0RXVH([LW(YHQWV .H\ERDUG(YHQWV 'HIDXOW.H\V
0RUH$ERXW$:7 /D\RXW0DQDJHUV )ORZ/D\RXW
7DEOHRI&RQWHQWV &RQWG %RUGHU/D\RXW &DUG/D\RXW *ULG/D\RXWV *ULG%DJ/D\RXW ,QVHWV 3DQHOV )UDPHV 0HQXV 0HQX$FWLRQV 'LDORJ%R[ -DYD'DWD%DVH&RQQHFWLYLW\ ,QWURGXFWLRQWR-'%& 0LFURVRIW V2'%& 7LHULQJ -'%&$UFKLWHFWXUH -'%&'ULYHUV 'ULYHU3URSHUW\,QIR&ODVV &RQQHFWLRQ&ODVV 'DWDEDVH0HWD'DWD,QWHUIDFH 3UHSDUHG6WDWHPHQW &DOODEOH6WDWHPHQW ([HFXWLQJ64/XVLQJ-'%& 7UDQVDFWLRQ3URFHVVLQJ
7DEOHRI&RQWHQWV &RQWG 1HWZRUNLQJLQ-DYD 1HWZRUNLQJLQ-DYD 'DWDJUDPV :KDWLVD'DWDJUDP" 'DWDJUDP3DFNHW 'DWDJUDP6RFNHW 'XSOLFDWLRQRI6RFNHW &UHDWLQJ/LQNV,QVLGH$SSOHWV 2SHQLQJ:HE&RQQHFWLRQV 7KH85/&RQQHFWLRQ&ODVV 6RFNHWV 2WKHU$SSOHW+LQWV &RPPXQLFDWLQJ%HWZHHQ$SSOHWV , *ORVVDU\ ,,$SSHQGL[HV L$SSHQGL[ LL$SSHQGL[ LLL$SSHQGL[ ,,,,QGH[
Before We Begin 6RPHERG\ VDLG WKDW RQH·V JRDO LV WR HYROYH DQG ILQG JUHDWHU KHLJKWV
i
How to use this Book 7KLV ERRN LV ZULWWHQ LQ D OXFLG VW\OH LQ DQ DWWHPSW WR SURYLGH FODULW\ RQ FRPSOH[WHFKQLFDOWRSLFV6LQFHWKHUHDGHUVDUHQHZWRWKHVXEMHFWWKHXQGHU PHQWLRQHGGHWDLOVZLOOPDNHWKHPXVHWKHERRNLQWKHPRVWHIILFLHQWPDQQHU $OVR LW ZLOO HQDEOH WKH UHDGHUV WR NQRZ DERXW WKH RUJDQL]DWLRQ DQG WKH SDWWHUQDGRSWHGLQWKLVERRN 7KH%RRNDWD*ODQFHJLYHV\RXDQRYHUYLHZRIWKHYDULRXVWRSLFVFRYHUHGLQ WKH %RRN 7KHVH DUH WKH VHVVLRQV ZKLFK ZLOO EH FRYHUHG LQ $GYDQFHG 7HFKQRORJLHV HPHUJLQJ DW WKH -DYD IURQW ,W DOVR SURMHFWV DQ RXWORRN RI WKH PRGXOHFRYHUDJHDQGLWVFRQWHQWVZKLFKZLOOVSDQIRUVHVVLRQV 7KH7DEOHRI&RQWHQWVHQDEOHV\RXWRNQRZDERXWWKHYDULRXVWRSLFVXQGHU HDFK 6HVVLRQ 7KH WRSLFV JLYHQ XQGHU 6HVVLRQ WLWOH UHIOHFW WKH 3RLQW SURJUDP7KHVXEMHFWLPSDUWHGLQWKHFODVVURRPVHVVLRQZLOOEHDFFRUGLQJWR WKHVH JLYHQ KHDGLQJV ,W EDVLFDOO\ KHOSV WR SUHSDUH IRU HYHU\ FODVV URRP VHVVLRQE\OHWWLQJ\RXNQRZDERXWWKHVHVVLRQFRYHUDJH$JDLQWKHVHSRLQWV ZLOODOVREHFRYHUHGLQWKHEHJLQQLQJRIHYHU\VHVVLRQXQGHUWKHWLWOH´,QWKLV 6HVVLRQµ (DFK VHVVLRQ EHJLQV ZLWK DQ REMHFWLYH 7KHVH REMHFWLYHV DUH OLVWHG RQ WKH VHVVLRQFRYHUSDJH7KLVZLOOIDFLOLWDWH\RXWR NQRZ WKH \DUGVWLFNV E\ ZKLFK \RXFDQHYDOXDWH\RXUNQRZOHGJHDFTXDLQWDQFHLQHDFKVHVVLRQ)ROORZLQJWKH FRXUVHZDUH GXULQJ FODVVURRP VHVVLRQ ZLOO HQDEOH \RX WR KDYH D EHWWHU XQGHUVWDQGLQJ RI WKH VXEMHFW ([DPSOHV DUH FLWHG WR JLYH PRUH FODULW\ DQG KHOS\RXWRKDYHDQLGHDDERXWWKHLPSOHPHQWDWLRQRIWKHFRQFHSWGHILQHG,W LVVXJJHVWHGWKDW\RXWU\WRZRUNWKHH[DPSOHVJLYHQLQ\RXUODEVHVVLRQVE\ \RXUVHOILQRUGHUWRKDYHDFOHDUXQGHUVWDQGLQJRIWKHFRQFHSW$WWKHHQGRI HYHU\VHVVLRQVHOISUDFWLFHH[HUFLVHVDUHSURYLGHG
Objectives of this Book 7KLVERRNLVLQWHQGHGWRJLYHSUHOLPLQDU\DQGLQWHUPHGLDWHH[SRVXUHRQ-DYD /DQJXDJH $W WKH HQG RI WKLV PRGXOH \RX VKRXOG EH DEOH WR ZULWH D -DYD $SSOLFDWLRQ RU -DYD $SSOHWV FRPIRUWDEO\ FRPSLOH LW DQG H[HFXWH LW
Conventions Used in this Book ♦ Each session is divided into 12 topics. It is called the Twelve Point Program (12pp). In every session, these points are distinctly shown in an underlined bigger font. ♦ Subheadings appear in bold without underlining. ♦ Note is shown inside a box. It is information which is necessary to understand the subject discussed but does not come as a part of the text flow. ♦ Summary is at the end of each session, shown in a special table, italicized. ♦ Each session ends with a ‘Going Over It Again’. This helps the student in recapitulating the session contents. ♦ Figure numbers and descriptions are given below each picture, diagram or screen for proper navigation.
iii
Session 1
Java-An Introduction
On Completion of this Session We will be able to understand...
) ) )
Basic concepts in Java
) ) )
About Java Application
Java as an OOP language Tools in Java About Java Applet Features of Java
In This Session...
Introduction to Java
History of Java
Features in Java
Java and Internet
Java-An OOP Language
C++ vs Java
Java Tools
Application Programming
Creating an Application
Applet Programming
Creating an Applet
Overview of Java
JAVA-An Introduction
Introduction to Java -DYD LV DQ REMHFW RULHQWHG PXOWLWKUHDGHG SURJUDPPLQJ ODQJXDJH GHYHORSHG E\ 6XQ 0LFURV\VWHPV-DYDLVQRWRQO\DQREMHFWRULHQWHGSURJUDPPLQJODQJXDJHEXWDOVRDFRQFXUUHQW SURJUDPPLQJODQJXDJH:HFDQFUHDWHFODVVHVREMHFWVDQGXVHLQKHULWDQFHWKDWUHIOHFWWKHW\SLFDO REMHFWRULHQWHG IHDWXUHV :H FDQ DOVR FUHDWH DQG PDQLSXODWH WKUHDGV 7KHVH SRZHUV WRJHWKHU PDNH -DYD TXLWH SRZHUIXO 0DQ\ RI -DYD·V FKDUDFWHULVWLFV FRPHV IURP RWKHU ODQJXDJHV ,W KDV ERUURZHGFRQVWUXFWVIURPPDQ\RIWRGD\·VPRGHUQREMHFWRULHQWHGODQJXDJHV,QDGGLWLRQ-DYD LVDSODWIRUPLQGHSHQGHQWRUPDFKLQHLQGHSHQGHQWODQJXDJH)URPWKHSURFHHGLQJSDUDJUDSKV ZHFDQHDVLO\XQGHUVWDQGZK\-DYDLVSODWIRUPLQGHSHQGHQW $WUDGLWLRQDOODQJXDJHDOORZVXVWRZULWHSURJUDPVWKDWQHHGVWREHFRPSLOHGXVLQJDFRPSLOHU $FRPSLOHUFRPSLOHVRXUSURJUDPLQWRVRPHWKLQJFDOOHGWKHPDFKLQHODQJXDJHZKLFKYDULHVIRU GLIIHUHQWPDFKLQHVGHSHQGLQJXSRQWKHLULQWHUQDOFRQILJXUDWLRQ$IWHUFRPSLODWLRQZHKDYHWR H[HFXWH WKLV FRPSLOHG SURJUDP RQ RXU PDFKLQH 6LQFH GLIIHUHQW FRPSXWHUV KDYH GLIIHUHQW PDFKLQH ODQJXDJHV D SURJUDP FRPSLOHG IRU RQH PDFKLQH FDQQRW EH H[HFXWHG RQ DQRWKHU PDFKLQH)RUSXWWLQJDSURJUDPRQDZHESDJHWKHEURZVHUVKRXOGFRPSLOHWKHSURJUDPHDFK WLPH DQG WKHQ UXQ 0RUHRYHU WKH ULVN LQYROYHG LV RI YLUXVHV JHWWLQJ WUDQVIHUUHG IURP VXFK D SURJUDPGXULQJWKHFRPSLODWLRQSURFHVV ,Q-DYDWKHVLWXDWLRQLVFRPSOHWHO\GLIIHUHQW7KHFRPSLOHUKDVDVSHFLDOW\LQWKDWLWJHQHUDWHVWKH VDPH PDFKLQH FRGH IRU HDFK DQG HYHU\ PDFKLQH W\SH LQ WKH ZRUOG WR EH SUHFLVH 7KH -DYD FRPSLOHU DVVXPHV D WKHRUHWLFDOO\ GHILQHG PDFKLQH FDOOHG -DYD 9LUWXDO 0DFKLQH DQG FRPSLOHV FRGHIRULW6XFKFRPSLOHGFRGHLVNQRZQDVE\WHFRGH7KLVE\WHFRGHLVPDFKLQHLQGHSHQGHQW VRWKDWZHFDQUXQWKLVH[HFXWDEOHFRGHLQDQ\W\SHRIPDFKLQHDFURVVWKH,QWHUQHW7KLVUHVXOWV LQ-DYDEHLQJUHIHUUHGWRDVD0DFKLQHLQGHSHQGHQWRUSODWIRUPLQGHSHQGHQWODQJXDJH
History of Java 7KH -DYD ODQJXDJH ZDV GHYHORSHG E\ 6XQ 0LFURV\VWHPV LQ 6XQ EHJDQ D SURMHFW IRU VRIWZDUHWRUXQ79 9&5VHWVLQWHUDFWLYH79DQG9&5,Q DJURXSRI6XQHQJLQHHUV OHG E\ 3DWULFN 1DXJKWRQ DQG 6XQ IHOORZ -DPHV *RVOLQJ ZDQWHG WR GHVLJQ D VPDOO ODQJXDJH ZKLFKFRXOGEHXVHGIRULQWHUDFWLYHFRQVXPHUGHYLFHV,Q6HSWHPEHU WKHEDVLFV\VWHPZDV GUDIWHG7KHLQWHUDFWLYHFRQVXPHUGHYLFHZDVFDOOHG6WDU6HYHQDQGZDVSDUWRIDODUJHUSURMHFW FDOOHG*UHHQ3URMHFW-DYD·VRULJLQDOQDPHZDV2DNQDPHGDIWHUWKHWUHHRXWVLGH-DPHV*RVOLQJ RIILFH+RZHYHUVLQFHWKHUHZDVDOUHDG\DODQJXDJHQDPHG2DNH[LVWLQJ6XQQDPHGLW-DYD-DYD LVQRWDQDFURQ\P,WLVDWUDGHPDUNRI6XQ0LFURV\VWHPV 7KH*UHHQ3URMHFWVSHQWDOORI DQGKDOIRI ORRNLQJIRUSHRSOHWREX\LWVWHFKQRORJ\ 1HYHUWKHOHVVQRERG\ZDVUHDG\WREX\LW$WWKLVWLPHWKH:RUOG:LGH:HE ::: DSDUWRI WKH ,QWHUQHW ZDV JURZLQJ ELJJHU 7KH NH\ WR WKH :HE LV WKH EURZVHU WKDW WUDQVODWHV K\SHUWH[W
Comp-U-Learn
3
Java Programming I
SDJHWRVFUHHQ7KHUHIRUH6XQUHOHDVHGWKHQHZ-DYDFDSDEOH+RW-DYDDEURZVHUZULWWHQLQ-DYD DV D YHKLFOH IRU GRZQORDGLQJ DQG UXQQLQJ WKH DSSOHWV )LQDOO\ WKH -DYD ODQJXDJH ZDV RIILFLDOO\ UHOHDVHGLQPLG 6XQ UHOHDVHG WKH ILUVW YHUVLRQ RI -DYD LQ HDUO\ ,W ZDV IROORZHG E\ -DYD D FRXSOH RI PRQWKVODWHU+RZHYHULQWKLVYHUVLRQDOVR6XQPLVVHGVRPHWKLQJWRVDWLVI\WKH,7SHRSOH6RLQ 0D\ 6XQUHOHDVHG-DYDYHUVLRQZLWKDVHHPLQJO\HQGOHVVVWUHDPRILPSURYHPHQWVDQG QHZ OLEUDULHV ZKLFK EHFDPH D PRVW LPSRUWDQW DVSHFW LQ -DYD ,Q 6XQ 0LFURV\VWHPV UHOHDVHGWKHODWHVWYHUVLRQDV-DYDZKLFKUHSODFHVWKHHDUO\WR\OLNH*8,DQGJUDSKLFVWRRONLWV ZLWKVRSKLVWLFDWHGDQGVFDODEOHYHUVLRQVWKDWFRPHDORWFORVHUWRWKHSURPLVHRI´:ULWHRQFH 5XQDQ\ZKHUHµWKDQWKHLUSUHGHFHVVRUV
Features in Java 7KLVVHFWLRQEULHIO\GLVFXVVHVWKHW\SLFDOIHDWXUHVRI-DYDZKLFKKDVKHOSHGLWEHFRPHDUHOHJDWH LWWRWKHSRVLWLRQRIEHLQJDGLVWLQJXLVKHGSURJUDPPLQJODQJXDJHRIWRGD\·VWHFKQRORJ\ Java is an easy programming language
-DYD LV WKH RQH RI WKH HDVLHVW SURJUDPPLQJ ODQJXDJHV LQ WKH ZRUOG QRZ 1R SURJUDPPLQJ ODQJXDJHDVSRZHUIXODV-DYDLVDQ\HDVLHU6LQFH-DYDLVREMHFWRULHQWHGSURJUDPPLQJLQ-DYDLV YHU\VLPSOH,WKDVDOOWKHPRGHUQIHDWXUHVWKDWZHZDQWLQDSURJUDPPLQJODQJXDJH,WZLOOPDNH DVPRRWKUHSODFHPHQWRI&DQG&LQGXHFRXUVHRIWLPHEXWWKDWLVQRWWKHRQO\WKLQJ,Q DGGLWLRQZHFDQXVHWKH-DYDSUHGHILQHGOLEUDULHVDQGSDFNDJHVLQRXUSURJUDP$OVRLQ-DYD WKHUHDUHQRUHVWULFWLRQVUHODWHGWRV\QWD[DQGSURJUDPPLQJFRQVWUXFWVFRPSDUHGWRDQ\RWKHU SURJUDPPLQJODQJXDJHV Java is portable and architecturally neutral
:ULWHRQFHDQGUXQDQ\ZKHUHLVWKHVORJDQIRU-DYD$OUHDG\ZHKDYHVHHQWKHFRQFHSWRIE\WH FRGH%HFDXVHRIWKLVE\WHFRGH-DYDLVFDOOHGDSODWIRUPLQGHSHQGHQWSURJUDPPLQJODQJXDJH DUFKLWHFWXUDOO\ QHXWUDO D VLQJOH SURJUDP FDQ UXQ RQ DQ\ W\SH RI PDFKLQH 7KLV PDNHV WKH FRQFHSW RI SRUWLQJ IURP RQH SODWIRUP WR DQRWKHU UHGXQGDQW 7KH VDPH YHUVLRQ RI WKH DSSOLFDWLRQ UXQV RQ DOO SODWIRUPV 6XFK SODWIRUP LQGHSHQGHQW ODQJXDJH LV QRW RQO\ XVHIXO IRU QHWZRUNVEXWDOVRIRUVLQJOHV\VWHPVRIWZDUHGLVWULEXWLRQ Java is a Distributed language
,Q D GLVWULEXWHG V\VWHP REMHFWV FDQ EH RQ D ORFDO RU D UHPRWH V\VWHP -DYD DSSOHWV DQG DSSOLFDWLRQVFDQRSHQDQGDFFHVVREMHFWVDFURVVWKHQHWDVHDVLO\DVWKH\FDQDFFHVVDILOHIURPD ORFDOILOHV\VWHP7KHH[WHQVLYHOLEUDU\RIURXWLQHVEXLOWLQWRWKHODQJXDJHDOORZV-DYDDSSOLFDWLRQ DQGDSSOHWWRHDVLO\ZRUNZLWK7&3,3SURWRFROVOLNH+773DQG)737KHEHDXW\RI-DYDEHLQJ
4
Comp-U-Learn
JAVA-An Introduction
DGLVWULEXWHGV\VWHPLVWKDWPDQ\GHVLJQHUVDWGLIIHUHQWUHPRWHORFDWLRQVFDQFROODERUDWHRQD VLQJOHSURMHFWEHFDXVHWKHE\WHFRGHLVLQWHUSUHWHGLQZHESDJHVDORQJZLWK-DYDDSSOHWV7KRXJK WKLVPDNHVWKHZHESDJHVWDNHDORQJHUWLPHWRORDG Java provides security
-DYD SURJUDPV DUH UHODWLYHO\ VDIH EHFDXVH WKH\ GR QRW KDYH SHUPLVVLRQ WR DFFHVV DOO RI RXU FRPSXWHU·V PHPRU\ DQG GLVF VSDFH -DYD KDV D EXLOWLQ PHFKDQLVP WR VDIHJXDUG RXU PDFKLQH IURPYLUXVHV6R-DYDLVLQWHQGHGWREHXVHGLQQHWZRUNHGGLVWULEXWHGHQYLURQPHQWV Java is Robust
-DYD EDVHG DSSOLFDWLRQV RU DSSOHWV DUH ZHOO EHKDYHG DQG ZLOO QRW OHW D V\VWHP FUDVK 7KH\ DOVR EHKDYHXQLIRUPO\DFURVVGLIIHUHQWSODWIRUPV7KLVIHDWXUHLVDOVRYHU\XVHIXO7KH-DYDFRPSLOHU GHWHFWV PDQ\ SUREOHPV GXULQJ FRPSLODWLRQ WLPH LWVHOI ZKLFK LQ RWKHU ODQJXDJHV ZRXOG EH VKRZQXSRQO\DWUXQWLPH$OVR-DYDGRHVQRWVXSSRUWSRLQWHUDULWKPHWLF6RDQ\RQHFDQZULWH D-DYDSURJUDPZLWKRXWKDYLQJWRZRUU\DERXWWKHPHPRU\OHDNDJHRUPHPRU\FRUUXSWLRQWKDW LVXVXDOO\DIHDWXUHRIEDGSRLQWHUPDQDJHPHQW ([FHSWLRQ FRQGLWLRQV LQ WUDGLWLRQDO HQYLURQPHQWV RIWHQ DULVH LQ VLWXDWLRQV VXFK DV GLYLVLRQ E\ ]HUR RU ILOH QRW IRXQG DQG PXVW EH PDQDJHG ZLWK FOXPV\ DQG KDUG WR UHDG FRQVWUXFWV -DYD KHOSV LQ WKLV DUHD E\ SURYLGLQJ REMHFW RULHQWHG H[FHSWLRQ KDQGOLQJ ,Q D ZHOOZULWWHQ -DYD SURJUDPDOOUXQWLPHHUURUVFDQDQGVKRXOGEHPDQDJHGE\RXUSURJUDP Java is a Multithreaded Language
-DYD ZDV GHVLJQHG WR PHHW WKH UHDOZRUOG UHTXLUHPHQW RI FUHDWLQJ LQWHUDFWLYH QHWZRUNHG SURJUDPV 7R DFFRPSOLVK WKLV -DYD VXSSRUWV PXOWLWKUHDGHG SURJUDPPLQJ ZKLFK DOORZV XV WR ZULWH SURJUDPV WKDW GR PDQ\ WKLQJV DW RQFH 7KH -DYD UXQ WLPH FRPHV ZLWK DQ HOHJDQW \HW VRSKLVWLFDWHG VROXWLRQ IRU PXOWLSURFHVV V\QFKURQL]DWLRQ WKDW PDNHV LW SRVVLEOH WR FRQVWUXFW VPRRWKO\ UXQQLQJ LQWHUDFWLYH V\VWHPV -DYD LV DQ HDV\ WR DSSURDFK PXOWLWKUHDGLQJ ODQJXDJH ,W DOORZVXVWRWKLQNDERXWWKHVSHFLILFEHKDYLRURIRXUSURJUDPQRWWKHPXOWLWDVNLQJVXEV\VWHP DVDZKROH Java is dynamic
-DYD LV D PRUH G\QDPLF ODQJXDJH WKDQ WKH RWKHU ODQJXDJHV ,W ZDV GHVLJQHG WR DGDSW WR DQ HYROYLQJ HQYLURQPHQW -DYD SURJUDPV FDUU\ ZLWK WKHP VXEVWDQWLDO DPRXQWV RI UXQ WLPH LQIRUPDWLRQWKDWDUHXVHGWRYHULI\WKHREMHFWDWUXQWLPH7KLVPDNHVLWSRVVLEOHWRG\QDPLFDOO\ OLQNFRGHLQDVDIHDQGH[SHGLHQWPDQQHU
Comp-U-Learn
5
Java Programming I
Java and the Internet %\XVLQJ-DYDXVHUVZLOOGRZQORDG-DYDE\WHFRGHIURPWKH,QWHUQHWDQGUXQWKHPRQWKHLURZQ PDFKLQHV-DYDSURJUDPVWKDWZRUNRQZHESDJHVDUHFDOOHGDSSOHWV7RXVHWKLVDSSOHWZHQHHG D-DYDHQDEOHGEURZVHUZKLFKLQWHUSUHWVWKHE\WHFRGHIRUXV6LQFH6XQOLFHQVHVWKH-DYDVRXUFH FRGHLWLQVLVWVWKDWWKHUHEHQRFKDQJHVLQWKHODQJXDJHDQGEDVLFOLEUDU\VWUXFWXUHV'XHWRWKLV ZHDUHVXUHWKDWDQDSSOHWUXQVRQDQ\EURZVHUWKDWLVDGYHUWLVHGDV-DYDHQDEOHG 7KH ,QWHUQHW KHOSHG FDWDSXOW -DYD WR WKH IRUHIURQW RI SURJUDPPLQJ 7KH UHDVRQ LV WKDW -DYD H[SDQGVWKHXQLYHUVHRIREMHFWVWKDWFDQPRYHDERXWIUHHO\LQF\EHUVSDFH,QDQHWZRUNWKHUH DUH WZR YHU\ EURDG FDWHJRULHV RI REMHFWV WKDW DUH WUDQVPLWWHG EHWZHHQ WKH VHUYHU DQG RXU SHUVRQDOFRPSXWHUQDPHO\SDVVLYHDQGDFWLYHSURJUDPV :KHQZHUHDGRXUHPDLOZHDUHYLHZLQJWKHSDVVLYHGDWD(YHQZKHQZHGRZQORDGDSURJUDP WKHFRGHIRUWKHSURJUDPLVVWLOORQO\SDVVLYHXQWLOZHH[HFXWHLW+RZHYHULQWKHVHFRQGW\SHRI REMHFWWKDWFDQEHWUDQVPLWWHGWRRXUFRPSXWHUDVDG\QDPLFVHOIH[HFXWLQJSURJUDPLWLVFDOOHG DVDQDFWLYHSURJUDP $SSOHWVFDQEHXVHGWRDGGEXWWRQVDQGLQSXWILHOGVWRZHESDJH+RZHYHUGRZQORDGLQJWKRVH DSSOHWVRYHUDGLDOXSOLQHLVVORZDQGZHFDQGRPXFKWKHVDPHZLWK'\QDPLF+70/+70/ IRUPV DQG D VFULSWLQJ ODQJXDJH VXFK DV -DYD6FULSW ,Q HDUO\ GD\V DSSOHWV ZHUH XVHG IRU DQLPDWLRQV OLNH VSLQQLQJ JOREHV FDUWRRQV +RZHYHU DQLPDWHG *,) FDQ GR PXFK RI WKLV DQG '\QDPLF+70/FRPELQHGZLWKVFULSWLQJFDQGRHYHQPRUHRIZKDW-DYDDSSOHWVZHUHXVHGIRU
Java- An OOP Language 7KHREMHFWRULHQWHGFRQFHSWKDVSURYHQLWVZRUWKLQWKHODVWWKLUW\\HDUV,WLVRQHRIWKHPRVW SRSXODUWHFKQRORJLHV0DQ\RIXVPLJKWKDYHKHDUGWKLVZRUGPD\EHSHUKDSVZLWKRXWNQRZLQJ ZKDWLWPHDQV:KDWHYHULWPD\EH223LVRQHRIWKHVLPSOHVWDQGSODLQWKLQJVZHFDQFRPH DFURVV LQ RXU SURJUDPPLQJ FDUHHU 223 ODQJXDJH SURYLGHV VLPSOH FRQVWUXFWV WR HQDEOH XV WR H[SUHVVRXUQDWXUDOLGHDVHIILFLHQWO\7KLVDOORZVXVWRWDONDERXWYDULRXVREMHFWV 6LQFH-DYDLVDQREMHFWRULHQWHGSURJUDPPLQJODQJXDJHZHFDQXVHPRVWRIWKHREMHFWRULHQWHG FRQFHSWV LQ RXU -DYD SURJUDPPLQJ -DYD IRFXVHV RQ GHILQLQJ GDWD DQG IXQFWLRQV WKDW PD\ EH DSSOLHGWRWKRVHREMHFWV7KLVIDFLOLWDWHVSURJUDPGHYHORSPHQWXVLQJQDWXUDOSDUDGLJPV,Q-DYD ZHFDQFRQVWUXFWDSURJUDPXVLQJWKHIROORZLQJREMHFWRULHQWHGFRQFHSWV ♦ ♦ ♦ ♦
6
Encapsulation Inheritance Polymorphism Interfaces
Comp-U-Learn
JAVA-An Introduction
$OWKRXJK -DYD VXSSRUWV WKH REMHFWRULHQWDWLRQ LW GRHV QRW VXSSRUW PXOWLSOH LQKHULWDQFH ,W VXSSRUWVVLQJOHLQKHULWDQFHZKHUHRQHFODVVFDQLQKHULWIURPRQO\RQHRWKHUFODVV2QWKHRWKHU KDQG-DYDVXSSRUWVDEVWUDFWFODVVHV LQWHUIDFHVXVLQJZKLFKSURJUDPPHUVFDQVLPXODWHPXOWLSOH LQKHULWDQFH7KHDEVWUDFWEDVHFODVVIRUDOO-DYDFODVVHVLVDFODVVFDOOHGREMHFW
C++ vs. Java $OWKRXJK-DYDLVREMHFWRULHQWHGWKHUHDUHVRPHGLIIHUHQFHVEHWZHHQ-DYDDQG&DQREMHFW RULHQWHG SURJUDPPLQJ ODQJXDJH LWVHOI $SDUW IURP WKH REMHFWRULHQWHG FRQFHSWV -DYD GLIIHUV IURP&LQYDULRXVZD\V7KHIROORZLQJOLVWVWKHGLIIHUHQFHV ♦ Java omits header files, pre-processor, goto statement and multi dimensional arrays. ♦ Like C, C++, Java does not support the pointer arithmetic. In addition, Java omits the important elements, union and structures. ♦ Java does not support the multiple inheritance. Through interfaces, we can simulate multiple inheritance. ♦ Java does not support stand-alone functions. All Java functions including the main function should be declared within the class. ♦ Although Java supports polymorphism, it does not support the operator overloading. ♦ In Java, the main function should take one parameter, which is a string type variable. The String class object itself determines the number of arguments. ♦ Java has an auto garbage collection mechanism. Therefore, we do not need to worry about freeing memory. ♦ In Java we can comment the lines by using the “/**” and “*/”. It can be used by the javadoc tool, which will be discussed later. ♦ The boolean data types, unlike in C++, are not an interpretation of the integers 0 and 1. Therefore in Java, Java boolean cannot be typecast into integers. They can have values either true or false.
Java Tools -DYDLVDFRPSOHWHSURJUDPPLQJHQYLURQPHQWDQGFRPHVZLWKLWVRZQVHWRI WRROV(DFK-DYD WRROKDVDVLJQLILFDQWIHDWXUH7KHIROORZLQJDUHWKH-DYDWRROVXVHGIRU-DYDSURJUDPPLQJ JDK
6WDQGVIRU-DYD'HYHORSHUV.LWDYDLODEOHIRULWVVXSSRUWHGSODWIRUPVRQZKLFKZHKDYHWRZULWH RXU-DYDSURJUDP,WLQFOXGHVIROORZLQJWRROVIRUIXUWKHUIDFLOLWLHV
Comp-U-Learn
7
Java Programming I Javac
6WDQGVIRU-DYDFRPSLOHUE\ZKLFKZHFRPSLOHRXU-DYDDSSOLFDWLRQDVZHOODVWKHDSSOHW$IWHU FRPSLOLQJ RXU -DYD SURJUDP D FODVV ILOH ZLOO DXWRPDWLFDOO\ EH FUHDWHG LQ WKH VDPH GLUHFWRU\ ZKLFKFRQWDLQVWKHE\WHFRGHRIWKHSURJUDP7KHV\QWD[WRFRPSLOHWKHSURJUDPLV javac
< type our Java file here with the .Java extension.>
E.g.: C:/jdk1.2/bin/javac example.java
Java
7KLV LV WKH -DYD LQWHUSUHWHU 8VLQJ WKLV ZH ZLOO EH DEOH WR UXQ RXU DSSOLFDWLRQ SURJUDP LQ WKH FRPPDQG OLQH 7KLV VKRXOG EH GRQH DIWHU FRPSLOLQJ WKH -DYD ILOH %HFDXVH ZKHQ ZH UXQ RXU -DYDILOHWKH-DYDLQWHUSUHWHUZLOOORRNIRUWKHFODVVILOHRIWKDWSDUWLFXODUSURJUDPWRH[HFXWHWKH RXWSXW7KHV\QWD[WRUXQRXUDSSOLFDWLRQSURJUDPLV Java
< Java file without the .Java extension.>
Example 1.1 C:/jdk1.2/bin/java example
Appletviewer
:HFDQUXQRXUDSSOHWSURJUDPXVLQJWKLVVWDQGDORQHEURZVHUDQGJHWRXURXWSXWLQDZLQGRZ :HFDQDOVRXVHDQ\RWKHUEURZVHUOLNH,QWHUQHW([SORUHU7KHV\QWD[DWFRPPDQGOLQHLV Appletviewer < HTML file.html extension.>
$QDSSOHWLVW\SLFDOO\YLHZHGOLNHWKLV Example 1.2 C:/jdk1.2/bin/appletviewer example.html
javadoc
7KLV WRRO UHFRJQL]HV WKH WKLUG FRPPHQW GHOLPLWHU ´
µ DQG XVHV LW WR DXWRPDWLFDOO\ JHQHUDWH GRFXPHQWDWLRQ 7KLV WRRO XVHV WKHVH W\SH RI FRPPHQWV -DYDGRF XQGHUVWDQGV D QXPEHU RI SDUDPHWHUVWKDWZHFDQHPEHGLQWKHVHFRPPHQWV7KHMDYDGRFRQO\ZRUNVRQSXEOLFFODVVHV 8
Comp-U-Learn
JAVA-An Introduction Jdb
7KLV WRRO LV FDOOHG -DYD GHEXJJHU ZKLFK LV XVHG WR GHEXJ RXU SURJUDP ,I ZH KDYH DQ\ FRPSLODWLRQHUURUVZHFDQHDVLO\ILQGRXWWKHHUURUORFDWLRQE\XVLQJWKH-DYDGHEXJJHUWRRO $OVRWKH-DYDHQYLURQPHQWKDVVRPHRWKHUWRROVOLNHMDYDSURIZKLFKLVWRJHQHUDWHSURILOHIRU RXUSURJUDPMDYDKZKLFKLVXVHGWRJHQHUDWH WKH KHDGHUILOHVIRULQWHJUDWLQJ&LQWR RXU-DYD FRGH
Application Programming -DYDDSSOLFDWLRQVDUHVLPLODUWRRWKHUSURJUDPPLQJODQJXDJHV,Q-DYDWKHUHDUHWZRSDUWVLQWKH SURJUDPPLQJHQYLURQPHQWDSSOLFDWLRQDQGDSSOHW,QDQDSSOLFDWLRQZHFDQZULWHRXUSURJUDP DQG LW UXQV VWDQG DORQH RQ WKH -DYD 9LUWXDO 0DFKLQH 7KDW PHDQV WKDW ZH FDQ UXQ RXU -DYD DSSOLFDWLRQSURJUDPLQRXUVWDQGDORQHPDFKLQH7KHMDYDFFRPSLOHULVXVHGWRFRPSLOHWKH-DYD DSSOLFDWLRQ7KH-DYDLQWHUSUHWHULVXVHGWRUXQWKH-DYDDSSOLFDWLRQLQWKHFRPPDQGOLQH 7KH DSSOLFDWLRQ LV ORDGHG IURP WKH ORFDO ILOH V\VWHP EHFDXVH LW LV DVVXPHG WKDW XVHUV ORDG DSSOLFDWLRQ IURP WKH ORFDO ILOH V\VWHP 7KHUH DUH IHZHU ILOHV DQG QHWZRUN VHFXULW\ UHVWULFWLRQV LPSRVHG $QLPSRUWDQWDGYDQWDJHIRUODUJHDSSOLFDWLRQVLVWKDWWKHPHPRU\VSDFHFDQEHFRQWUROOHG)URP WKH -90 ZH FDQ FRQWURO LQLWLDO OLPLWV IRU WKH VWDFN DQG KHDS ,I RXU DSSOLFDWLRQ XVHV D ODUJH DPRXQWRIPHPRU\ZHZLOOKDYHFRPSOHWHFRQWURORIWKHVHVHWWLQJV :LQGRZV DSSOLFDWLRQV DUH VLPLODU WR UXQQLQJ DQ DSSOHW IURP ZLWKLQ D ZHE EURZVHU 7KH PDLQ GLIIHUHQFH LV WKDW WKHUH DUH IHZHU ILOH DQG QHWZRUN VHFXULW\ UHVWULFWLRQV 6WDQGDORQH ZLQGRZ DSSOLFDWLRQVPXVWDOVRSURYLGHWKHLURZQFRQQHFWLRQWRUHVRXUFHVVXFKDVSLFWXUHVDQGVRXQG 7KH\GLIIHUIURPDSSOHWVLQWKDWWKH\GRQRWUXQIURP:HEEURZVHUV
Creating an Application ,Q-DYDFUHDWLQJDQDSSOLFDWLRQSURJUDPFRQVLVWVRIWKHIROORZLQJVWHSV ♦ Create a Java Source file with .Java extension. ♦ Compile this source file by using javac compiler. ♦ Run this application by using Java interpreter. 7KH IROORZLQJ H[DPSOH LOOXVWUDWHV WKH SUHOLPLQDU\ WKLQJV DERXW FUHDWLRQ RI DQ DSSOLFDWLRQ SURJUDP
Comp-U-Learn
9
Java Programming I
Example 1.3 class first_program public static void main(String args[]) { System.out.println(“Welcome to Comp-U-Learn!”); } }
$-DYDDSSOLFDWLRQVKRXOGFRQWDLQWKHIROORZLQJVWHSV &ODVV GHILQLWLRQ 7KH ILUVW OLQH VKRXOG FRQWDLQ WKH NH\ZRUG FODVV DQG WKH FODVV QDPH ILUVWBSURJUDPLVWKHVRXUFHILOHQDPH 0DLQPHWKRG ,QWKHVHFRQGOLQHZHVKRXOGGHILQHWKHPDLQPHWKRG,QWKLVOLQHZHDOVRVSHFLI\ WKHDFFHVVPRGHUHWXUQW\SHDQGWKHPDLQNH\ZRUGZLWKWKHVLQJOHSDUDPHWHU,QDGGLWLRQZH FDQ KDYH DQ\ QXPEHU RI FODVV PHWKRGV DQG YDULDEOHV ZLWKLQ D FODVV GHILQLWLRQ ,Q WKH DERYH SURJUDP ♦ 3XEOLFLQGLFDWHVWKDWWKHPDLQPHWKRGFDQEHFDOOHGE\DQ\REMHFW ♦ 6WDWLFLQGLFDWHVWKDWWKHPDLQPHWKRGLVLQWKHFODVVGHILQLWLRQ,Q-DYDDSSOLFDWLRQ WKH PDLQPHWKRGVKRXOGEHLQVLGHWKHFODVVGHILQLWLRQ ♦ 9RLGGHQRWHVWKDWWKHPDLQPHWKRGKDVQRUHWXUQW\SH ♦ 7KHPDLQPHWKRGWDNHVDVLQJOHDUJXPHQWDVDQDUUD\RIVWULQJV7KHVHVWULQJVZKHQ JLYHQ DV DUJXPHQWV WR WKH SURJUDP DW FRPPDQG OLQH DUH FDOOHG FRPPDQG OLQH DUJXPHQWV
Note In Java the source file name should be same as the class name. When we run our program, the interpreter will look for the .class file of that source file name 1RZW\SHLQWKHDERYHSURJUDPLQ1RWHSDG'26HGLWRU DQGVDYHLWDVILUVWBSURJUDPMDYDLQ -DYD·VELQGLUHFWRU\IROORZWKHVWHSVJLYHQEHORZLQWKHFRPPDQGOLQHWRJHWWKHRXWSXW 1. Compile the program using javac ( javac first_program.java) 2. Press Enter and wait until the compilation is over without any errors. 3. Then run the program using the interpreter ( java first_program) 1RZZHFDQJHWWKHRXWSXWLQWKHFRPPDQGOLQHDVIROORZV
10
Comp-U-Learn
JAVA-An Introduction
Fig 1.1
Applet Programming $QDSSOHWLVDG\QDPLFDQGLQWHUDFWLYHSURJUDPWKDWFDQUXQLQVLGHDZHESDJHGLVSOD\HGE\D -DYDHQDEOHGEURZVHUVXFKDV+RW-DYDRU1HWVFDSH-DYDDSSOHWVKDYHUHVWULFWLRQVWRHQVXUH VHFXULW\WRSUHYHQWWKHPIURPEHLQJDIIHFWHGE\YLUXVHV $SSOHWV DUH D FRPPRQ ZD\ RI ZULWLQJ LQWHUDFWLYH XVHU LQWHUIDFH -DYD DSSOLFDWLRQV ,QWHJUDWLQJ ZHE EDVHG VRXQG DQG JUDSKLFV LQWR DSSOLFDWLRQV LV VLPSOLILHG E\ XVLQJ PHWKRGV LQ WKH DSSOHW FODVV$SSOHWVDUHHVVHQWLDOO\SURJUDPVWKDWUXQIURPZLWKLQDZHEEURZVHU7KH\DSSHDUDVSDUW RI +70/ GRFXPHQWV LQ WKH VDPH ZD\ WKDW SLFWXUHV DUH UHSUHVHQWHG $SSOHWV RQO\ UXQ IURP ZLWKLQ-DYDHQDEOHGEURZVHUVVXFKDV1HWVFDSH+RW-DYDDQGWKH,QWHUQHW([SORUHU
Creating an Applet ,QWKLVVHFWLRQZHDUHJRLQJWROHDUQDERXWWKHFUHDWLRQRIDVLPSOHDSSOHWSURJUDP7KHGHWDLOV UHJDUGLQJDSSOHWVZLOOEHGLVFXVVHGLQWKHVXFFHHGLQJVHVVLRQV7KHFUHDWLRQRIDQDSSOHWFRQVLVWV RIWKHIROORZLQJIRXUVWHSV ♦ ♦ ♦ ♦
Importing the necessary built-in Java packages Defining applet subclasses Applet implementation Passing this Java applet’s .class file into HTML file.
&RQVLGHU WKH IROORZLQJ DSSOHW H[DPSOH VD\ ILUVWBDSSOHWMDYD ,W ZLOO JLYH WKH GHWDLOV WR FUHDWHDQDSSOHW Comp-U-Learn
11
Java Programming I
Example 1.4 import java.awt.*; import java.applet.*; public class first_applet extends Applet { public void paint(Graphics g) { g.drawString("Welcome to Comp-U-Learn!",50,20); } }
,QWKHDERYHSURJUDPWKHILUVWWZROLQHVDUHXVHGWRLPSRUWVRPHSDFNDJHVDQGFODVVHVZKLFK DUH EHLQJ XVHG ZLWKLQ WKH DSSOHW /LNH DSSOLFDWLRQV KHUH WR ZH KDYH WR VSHFLI\ WKH FODVV GHFODUDWLRQ DW WKH EHJLQQLQJ 7KH H[WHQGV NH\ZRUG LV XVHG KHUH WR H[WHQG VRPH SUHGHILQHG FODVVHVWRRXUSURJUDP 7KHQZHKDYHWRLPSOHPHQWWKHDSSOHWE\PHDQVRIWKHDSSOHWPHWKRGV,QWKLVSURJUDPWKH SDLQWPHWKRGRIDSSOHWLVXVHGWRSULQWVRPHWH[WLQWKHZLQGRZ)LQDOO\ZHKDYHWRSDVVWKLV VRXUFHILOH ILUVWBDSSOHWFODVV LQWRDQ+70/ILOH)RUWKDWZHKDYHWRFUHDWHDQ+70/ILOH VD\ ILUVWBDSSOHWKWPO ZKLFKVKRXOGFRQWDLQWKHIROORZLQJFRGH
1RZFRPSLOHWKLVILUVWBDSSOHWMDYDILOHRQWKHFRPPDQGOLQHXVLQJMDYDF7KHQUXQWKLV ILUVWBDSSOHWKWPOILOHXVLQJDSSOHWYLHZHU 7KH IROORZLQJ ILJXUH VKRZV WKH RXWSXW RI WKH DERYH DSSOHWSURJUDP
Fig 1.2
12
Comp-U-Learn
JAVA-An Introduction
$IWHU FRPSLOLQJ WKH -DYD ILOH ZH JHW WKH RXWSXW IRU WKH DERYH SURJUDP E\ EURZVLQJ WKH ILUVWBDSSOHWKWPOILOHLQWKH,QWHUQHWH[SORUHU
Fig 1.3
Overview of Java 6RIDUZHKDYHGLVFXVVHGDERXW-DYDLWVIHDWXUHVDQGLWVVLPSOHSURJUDPPLQJHQYLURQPHQW7KLV VHFWLRQLVDTXLFNRYHUYLHZRI-DYD -DYDDVRIWRGD\LVSRSXODUGXHLWV,QWHUQHWIDFLOLWLHVEURZVLQJHWFEXWLWKDVPRUHSRWHQWLDOWR EHFRPHDVHULRXVSURJUDPPLQJODQJXDJHLQIXWXUH7RGD\PDQ\SHRSOHIDLOWRYLVXDOL]HWKLVEXW ZHFDQEHFRQILGHQWWKDWLWZLOOSURYHWREHVR,QIDFWWKLVLVWKHPDMRUUHDVRQZK\-DYDDWWUDFWV PDQ\ SHRSOH ,W KDV DOO WKH JRRG SRLQWV RI D ZHOOWKRXJKW RXW ODQJXDJH OLNH 3DVFDO WKDW LV D VWUXFWXUDO ODQJXDJH ,WV V\QWD[ ORRNV VLPLODU WR & EXW LW KDV YHU\ FDUHIXOO\ DYRLGHG DOO WKH SUREOHPDWLFFRQVWUXFWVRI&OLNHSRLQWHUVVWUXFWXUHVDQGXQLRQV ,QDGGLWLRQWKHPDMRUPLVWDNHPDGHLQWKH&GHVLJQWRSDWFKXS&ZLWKWKH223IDFLOLWLHV KDVEHHQDYRLGHGLQ-DYD,Q&DQ\&SURJUDPFDQEHDFFHSWHGDVD&SURJUDP WKXV HYHQWXDOO\DOOWKHDGYDQWDJHVRI223JRWNLOOHG-DYDGRHVQRWDOORZWKLVDQGIRUFHVWKHVRIWZDUH SURJUDPPHUWRGHYHORSFRGHLQDV\VWHPDWLFVWUXFWXUHGWRSGRZQDQG223PDQQHU )RUDOOWKHVHUHDVRQV-DYDZRXOGEHWKHODQJXDJHRIIXWXUH$IWHU\HDUVPRVWSUREDEO\SHRSOH ZLOO VD\ WKDW ´ LW DOVR KDV DOO WKH IDFLOLW\µ +HUH LW UHPLQGV XV RI VRPHWKLQJ VLPLODU WKDW KDG KDSSHQHGZLWK&DURXQG 7KDWWLPHHYHU\ERG\UHJDUGHGLWWREHWKH ´6\VWHPVSURJUDPPLQJµODQJXDJHDQGPDQ\H[SHUWVDOVRIDLOHGWRVHHLWVRWKHUSRWHQWLDOVDVD JHQHUDOSURJUDPPLQJODQJXDJH$IWHU\HDUVLQ HYHU\RQHXQGHUVWRRGLWDVDGHYHORSPHQW ODQJXDJH DQG DGGHG D OLQH VD\LQJ ´LW LV EHWWHU VXLWHG WR GR ORZOHYHO V\VWHPRULHQWHG SURJUDPPLQJµ 7KXV -DYD ZLOO EHFRPH D SRZHUIXO JHQHUDO SXUSRVH SURJUDPPLQJ ODQJXDJH LQ WKHQH[WFHQWXU\ Comp-U-Learn
13
Java Programming I
Summary In this session, we learnt about the Java language and how Java is an objectoriented language. Now we can appreciate the relationship between the Java and the Internet. In this session we also learnt how Java differs from the other programming languages. After this Java preliminary, we learnt about Java tools and its uses. We also learnt to write a simple Java application program and create a simple applet.
Going Over It Again I. Fill in the Blanks
-DYDLVRIILFLDOO\UHOHDVHGLQBBBBBBBBBBBBB ,Q D QHWZRUN WKHUH DUH WZR YHU\ EURDG FDWHJRULHV RI REMHFWV WKH\ DUH BBBBBBBBB DQG BBBBBBBBBBBB 7KURXJKBBBBBBBBBBBZHFDQVLPXODWHPXOWLSOHLQKHULWDQFH ,Q-DYDWKHVRXUFHILOHQDPHVKRXOGEHVDPHDVWKHBBBBBBBQDPH $IWHUFRPSLOLQJRXU-DYDSURJUDPDBBBBBBBILOHZLOOEHDXWRPDWLFDOO\FUHDWHGLQWKHVDPH GLUHFWRU\E\BBBBBBBFRPSLOHU
II. State True or False
-DYDLVDVWUXFWXUDODQGREMHFWRULHQWHGODQJXDJH -DYDVXSSRUWVDOOWKHSRO\PRUSKLVPFRQFHSWV :HFDQUXQ$SSOHWVE\WKHVWDQGDORQHLQWHUSUHWHU ,QDSSOHWVWKHUHLVQRQHHGIRUPDLQPHWKRG :HFDQXVHWKHMDYDFWRROIRUGHEXJJLQJRXUSURJUDP
14
Comp-U-Learn
JAVA-An Introduction III. One line Answers
:KDWDUHWKHWZRSURJUDPPLQJW\SHVRIIHUHGE\-DYD" :KDWLV-90" /LVWRXWWKH-90WRROV +RZGRZHLPSOHPHQWPXOWLSOHLQKHULWDQFHLQ-DYD" :KDWLVDQDSSOHW" IV. Match the following
$SSOHW
DPXOWLSOHLQKHULWDQFH
-DYDGRF
EE\WHFRGH
LQWHUIDFHV
FEURZVHU
+773)73
GGRFXPHQWDWLRQ
-DYDF
H,QWHUQHWSURWRFROV
Comp-U-Learn
15
Session 2
Fundamentals of Java
On Completion of this Session We will be able to understand...
) Java Syntax & Identifiers ) Java variables and its scope ) About commenting in Java ) Java programming constructs ) Arrays & Strings in Java
In This Session...
Data types & Variables in Java
Literals, Keywords & Identifiers
Operators in Java
Expression Evaluations & Operator Precedence
Scope of Variables
Commenting in Java
Decision Making
For Loop
While & Do… While Loop
Switch & Break Statements
Arrays in Java
Strings in Java
Fundamentals of Java
Data types & Variables in Java ,Q WKLV VHFWLRQ ZH ZLOO EH GLVFXVVLQJ DERXW WKH GDWD W\SHV DQG YDULDEOHV XVHG LQ -DYD ,Q -DYD WKHUHDUHWZRW\SHVRIGDWDNLQGV7KH\DUH ♦ Primitive data types ♦ Reference data types 7KHSULPLWLYHGDWDW\SHVFRQWDLQDVLQJOHYDOXH,QWHJHUIORDWFKDUDFWHUDQGERROHDQGDWDW\SHV FRPHXQGHUWKLVW\SH7KHUHIHUHQFHW\SHVDUHFDOOHGVXFKEHFDXVHWKHYDOXHRIUHIHUHQFHYDULDEOH LVDUHIHUHQFHWRDQDFWXDOYDOXHUHSUHVHQWHGE\DQRWKHUYDULDEOH)RUH[DPSOHDUUD\VFODVVHVDQG LQWHUIDFHV IDOO XQGHU WKLV FDWHJRU\ ,Q DGGLWLRQ ZKHQ D FODVV LV FUHDWHG LQ HVVHQFH D QHZ GDWD W\SHLVFUHDWHG:H·OOVHHWKHVHGDWDW\SHVLQGHWDLO 7KHIROORZLQJWDEOHOLVWVWKHPRVWRISULPLWLYHGDWDW\SHVWKHLUVL]HDQGUDQJH Type Byte Short Int Long Float Double Char Boolean
Size 1 2 4 8
Range -128 to 127 -32,768 to 32, 767 -2,147,483,648 to 2,147,483,647 -9,223,372,036,854,775,808 To 9,223,372,036,854,775,807 approx. ±3.40282347E+38F approx. ±1.79769313486231570E+308 true or false
4 8 2 -
Variables in Java
,Q -DYD ZH KDYH WR GHFODUH WKH W\SH RI YDULDEOH ZH DUH JRLQJ WR XVH 7KH YDULDEOH GHFODUDWLRQ DOZD\VFRQWDLQVWZRSDUWV2QHLVGDWDW\SHDQGDQRWKHULVYDULDEOHQDPH7KHIROORZLQJV\QWD[ VKRXOGEHXVHGWRGHFODUHDYDULDEOH
(e.g.: int
no;)
,Q-DYDZKLOHGHFODULQJDYDULDEOHZHKDYHVRPHUHVWULFWLRQV ♦ A variable name must be a legal identifier of a series of Unicode characters. ♦ A variable name should not be the same as any keywords or literals. Comp-U-Learn
19
Java Programming I
♦ They must not have the same name as another variable. ♦ Java is case sensitive. So int Myint, myInt, MyInt, and myint are different variables. Variable initialization
/RFDO YDULDEOHV ZKLFK DUH YDULDEOHV GHFODUHG LQ PHWKRGV PXVW EH LQLWLDOL]HG EHIRUH WKH\ DUH XVHG,IQRWDFRPSLOHWLPHHUURUZLOORFFXU$YDOXHDVVLJQHGWRWKHYDULDEOHPXVWPDWFKWKH YDULDEOHW\SH E.g.:
int
number = 0;
Using Variables
7KHIROORZLQJH[DPSOHLOOXVWUDWHVWKHXVHRIYDULDEOHVLQ-DYD Example 2.1 class var_usage { public static void main(String args[]) { int a=10; double b=4.5; char c='n'; System.out.println(" This is the Usage of System.out.println(" The value of a is: " System.out.println(" The value of b is: " System.out.println(" The value of c is: " } }
Variables"); +a); +b); +c);
,QWKLVH[DPSOHWKH 6\VWHPRXWSULQWOQ VWDWHPHQW LV XVHG WR SULQW VRPH WH[W RQ WKH VFUHHQ ,Q DGGLWLRQKHUHZHDUHSULQWLQJWKHLQLWLDOL]HGYDULDEOHVVRZHKDYHWRXVH´µRSHUDWRUDORQJZLWK WKHYDULDEOHQDPH$IWHUUXQQLQJWKHDERYHSURJUDPZHJHWWKHRXWSXWDVIROORZV This is the Usage of Variables The value of a is: 10 The value of b is: 4.5 The value of c is: n
Note For printing text on consecutive lines, System.out.println statement is used. If we use the System.out.print statement, the text will be printed in the same line. 20
Comp-U-Learn
Fundamentals of Java
Literals, Keywords & Identifiers ,Q -DYD WKHUH DUH VRPH OLWHUDOV DQG UHVHUYHG ZRUGV $ OLWHUDO UHSUHVHQWV WKH YDOXH RI D FHUWDLQ W\SHZKHUHWKHW\SHGHVFULEHVKRZWKDWYDOXHEHKDYHV7KHUHDUHGLIIHUHQW W\SHVRIOLWHUDOYL] QXPHULFFKDUDFWHUERROHDQDQGVWULQJ Number
,QWKLVW\SHZHFDQKDYHOLWHUDOVOLNHLQWORQJRFWDOKH[DGHFLPDOHWFDQXPEHUEHJLQQLQJZLWK LVFDOOHGRFWDOQXPEHU$OHDGLQJ[QXPEHULVFDOOHGKH[DGHFLPDOQXPEHU8VLQJWKHOHWWHU(RU HIROORZHGE\WKHH[SRQHQWFDQXVHWKHH[SRQHQWVZLWKIORDWLQJSRLQWOLWHUDOV Boolean
7KHUHDUHRQO\WZRW\SHVRIERROHDQOLWHUDOV7KH\DUHWUXHDQGIDOVH Character
$VLQJOHFKDUDFWHUHQFORVHGZLWKLQVLQJOHTXRWHVH[SUHVVHVWKHFKDUDFWHUOLWHUDOV7KHVHDUHVWRUHG DV8QLFRGHFKDUDFWHUV Escape Sequences
7KHVH DUH DOVR D IRUP RI FKDUDFWHU OLWHUDO EXW DUH QRW SULQWHG RQ WKH VFUHHQ7KH\ FRXOG EH FRPELQHGZLWKDQ\RWKHUOLWHUDO7KHIROORZLQJWDEOHVKRZVHVFDSHVHTXHQFHVXVHGLQ-DYD Literals \n \t \b \r \f \\ \” \ddd \xdd \udddd
Usage To insert a new line (line feed) For tab control To give backspace For carriage return To give form feed For backslash to print a “ symbol For octal For Hexadecimal For Unicode character
Key words
.H\ZRUGVDUHDOVRFDOOHGUHVHUYHGZRUGV+HUHLVDFRPSOHWHOLVWRIWKHNH\ZRUGVLQ-DYDIRU RXUIXUWKHUUHIHUHQFH$OORIWKHPDUHQRWFXUUHQWO\LQXVH VRPHRIWKHPDUHUHVHUYHGIRUIXWXUH HQKDQFHPHQWV Comp-U-Learn
21
Java Programming I
DEVWUDFWERROHDQEUHDNE\WH FDVHFDVWFDWFKFKDUFODVVFRQVWFRQWLQXH GHIDXOWGRGRXEOHHOVHH[WHQGVILQDOILQDOO\IORDWIXWXUH JHQHULFLILPSOHPHQWVLPSRUWLQQHULQVWDQFHRILQWLQWHUIDFH ORQJQDWLYHQHZQXOORSHUDWRURXWHU SDFNDJHSXEOLFSURWHFWHGDQGSULYDWH UHVWUXQUHWXUQVKRUWVWDWLFVXSHUVZLWFKV\QFKURQL]HG WKLVWKURZWUDQVLHQWWU\YDUYRLGYRODWLOHZKLOH Identifiers
7KHLGHQWLILHUVDUHWKHV\PEROVXVHGLQD-DYDSURJUDP,GHQWLILHUVFDQQRWVWDUWZLWKDQXPEHU DOWKRXJKQXPEHUVDUHDOORZHGLQVLGHLGHQWLILHUV7KHV\PEROVWKDWFDQEHXVHGDVLGHQWLILHUVLQ -DYDDUH #A ?^`>@aa_ !" ´DQGHWF.
Operators in Java ,Q -DYD RSHUDWRUV FRPH LQ VHYHUDO W\SHV 7KH\ FDQ EH XVHG ZLWK YDULDEOHV WR LQGLFDWH PDWKHPDWLFDOUHODWLRQVKLSEHWZHHQWZRRUPRUHLWHPVWRFUHDWHORJLFDOVWUXFWXUHVRUWRSHUIRUP FRPSXWDWLRQV 7KH RSHUDWRUV VXSSRUWHG E\ -DYD DUH $ULWKPHWLF $VVLJQPHQW /RJLFDO DQG &RPSDULVRQ $ULWKPHWLFRSHUDWRUV $OOEDVLFDULWKPHWLFRSHUDWRUVVXFKDV DQGXQDU\RSHUDWRUVFRPHVXQGHUWKLVW\SH 7KHIROORZLQJWDEOHOLVWVWKH$ULWKPHWLFRSHUDWRUV Description Multiplication Division Addition Subtraction Modulus Increment Decrement Bit-wise complement
22
Operators * / + % ++ -~
Function Multiply the given two numbers Divide two numbers Add two numbers Subtract two numbers Determine the remainder in a division operation Increase the value of a specified variable by one Decrease the value of a specified variable by one Change the bit values of a specified variable, Converting all ones to zeros and vice versa
Comp-U-Learn
Fundamentals of Java
7KHIROORZLQJH[DPSOHVKRZVWKHXVDJHRIWKHDULWKPHWLFRSHUDWRUVLQ-DYD Example 2.2 class arithmetic { public static void main(String { int a=20; int b=10; double c=4.5; System.out.println(" The Usage System.out.println(" The value System.out.println(" The value System.out.println(" The value System.out.println(" The value System.out.println(" The value a++; b--; System.out.println(" System.out.println(" System.out.println(" System.out.println(" } }
Now, Now, Now, Now,
the the the the
args[])
of of of of of of
Arithmetic operators"); (a+b) is: " +(a+b)); (a-b) is: " +(a-b)); (a*b) is: " +(a*b)); (b+c) is: " +(b+c)); (a*c) is: " +(a*c));
second value of a is: " +a); second value of b is: " +b); final value of a is: " +(--a)); final value of b is: " +(++b));
$IWHUVDYLQJWKLVILOHDVDULWKPHWLFMDYDUXQWKHSURJUDP:HJHWWKHIROORZLQJRXWSXW 7KH8VDJHRI$ULWKPHWLFRSHUDWRUVDUHVKRZQEHORZ The value of (a+b) is: 30 The value of (a-b) is: 10 The value of (a*b) is: 200 The value of (b+c) is: 14.5 The value of (a*c) is: 90.0 Now, the second value of a is: 21 Now, the second value of b is: 9 Now, the final value of a is: 20 Now, the final value of b is: 10 Assignment operators
,Q-DYDWKHDVVLJQPHQWRSHUDWRUDSSOLHVWKHYDOXHRIWKHH[SUHVVLRQIURPWKHULJKWVLGHWRWKH YDULDEOHLQWKHOHIWVLGH:HFDQDOVRXVHWKHVH$VVLJQPHQWRSHUDWRUVLQWKHVKRUWFXWIRUPV)RU H[DPSOHWKHIROORZLQJWZRH[SUHVVLRQVZLOOJLYHWKHVDPHUHVXOW Comp-U-Learn
23
Java Programming I int int
xy = xy + 10 xy += 10
//using normal assignment // using shortcut assignment
7KHIROORZLQJWDEOHOLVWVWKHDVVLJQPHQWRSHUDWRUVDQGIXQFWLRQV Description Assign Addition Subtraction Multiplication Division Bitwise right Bitwise left Bitwise and Bitwise xor Bitwise or
Operator = += -= *= /= >>= <<= &= ^= |=
Function Assign right operand to left operand Add right from left & assign the value Subtract right from left & assign the value Multiply two values & assign it to left operand Divide two values & assign it to left operand Perform bitwise right shift Perform bitwise left shift Perform bitwise and operation Perform bitwise xor operation Perform bitwise or operation
Logical operators
/RJLFDORSHUDWRUVDUHXVHGWRHYDOXDWHDQH[SUHVVLRQWRFKHFNZKHWKHUWKHH[SUHVVLRQLVWUXHRU IDOVH6RWKHVHORJLFDORSHUDWRUVSHUIRUPWKHHYDOXDWLRQDQGUHWXUQWKHYDOXHDVD%RROHDQW\SH Description And Or
Operator && ||
Not
!
Function returns true if both operands are true returns true if any one of operands are true. returns reverse Boolean value of the expression
Comparison operators
7KHVHDUHXVHGWRFRPSDUHWKHRSHUDQGV$%RROHDQYDOXHLVUHWXUQHGZKHQXVLQJYDULDEOHVRU OLWHUDOV ZLWK WKH FRPSDULVRQ RSHUDWRUV &RQGLWLRQDO RSHUDWLRQ LV DOVR D VSHFLDO W\SH RI FRPSDULVRQ WKDW LV RQO\ ZLWK WKH DVVLJQPHQW RSHUDWRUV 7KH WDEOH JLYHQ EHORZ OLVWV WKH FRPSDULVRQRSHUDWRUV Description Less than Greater than Equal to 24
Operator < > ==
Function return true when result is less than return true when result is greater than the compared return true when result is equal Comp-U-Learn
Fundamentals of Java
Description Less than or equal to Greater than or equal to Not equal to Conditional
Operator <= >=
Function return true when result is less than or equal return true when result is greater than or equal
!= ?:
return true when result is not equal return first value of expression when result is true.
:H FDQ XVH WKHVH ORJLFDO ELWZLVH DQG FRPSDULVRQ RSHUDWRUV LQ WKH FRQGLWLRQDO VWDWHPHQWV ([DPSOHVLQWKHFRPLQJVHFWLRQVZLOOJLYHWKHXVDJHRIWKHVHRSHUDWRUV
Expression Evaluation & Operator Precedence $QH[SUHVVLRQLVDFROOHFWLRQRIYDULDEOHVDQGRSHUDWRUVWKDWVSHFLI\DFRPSXWDWLRQ([SUHVVLRQV DUHXVHGWRSHUIRUPRSHUDWLRQVRQWKHGDWDLQDSURJUDP7KHH[SUHVVLRQVDUHQRWVWDWHPHQWV )RUH[DPSOHFRQVLGHUWKHH[SUHVVLRQ int a= 20 * 3 + 7
,QWKHDERYHH[SUHVVLRQLQWHJHUDZLOOJHWDYDOXHRI:K\FDQ·WLWJHW"7KLVLVEHFDXVHWKH RSHUDWRUVKDYHSUHFHGHQFHLQWKLVH[SUHVVLRQ-DYDZLOOWUHDWWKHDERYHH[SUHVVLRQDV ,IZHZDQWWKHYDOXHZHKDYHWRJLYHWKHH[SUHVVLRQDV int a= 20 * (3 + 7)
7KH RSHUDWRUV DQG ² ZLOO KDYH VDPH SUHFHGHQFH $QG KDYH HTXDO SUHFHGHQFH &RPSDULQJ WKHVH WZR JURXSLQJV RI SUHFHGHQFH WKH RSHUDWRUV DQG HQMR\ KLJKHU SUHFHGHQFHWKDQWKHRSHUDWRUVDQG
Scope of Variables ,QWKLVVHFWLRQZHZLOOOHDUQDERXWWKHVFRSHRIYDULDEOHVZLWKLQDSURJUDP$YDULDEOH·VVFRSHLV WKHEORFNRIFRGHZLWKLQZKLFKWKHYDULDEOHLVDFFHVVLEOH$OVRWKHVFRSHRIDYDULDEOHGHWHUPLQHV ZKHQWKHYDULDEOHLVFUHDWHGDQGGHVWUR\HG:HFDQHVWDEOLVKWKHVFRSHRIDSDUWLFXODUYDULDEOHDW WKHWLPHRIGHFODUDWLRQ7KHIROORZLQJDUHWKHPDLQW\SHRIVFRSHRIDYDULDEOH ♦ Local variable ♦ Member variable 7KH ORFDO YDULDEOHV DUH GHFODUHG ZLWKLQ D PHWKRG RU EORFN RI FRGH LQ D PHWKRG &RQVLGHU WKH H[DPSOH:HFDQVHHWKHYDULDEOHVDEDQGF7KH\DUHGHFODUHGZLWKLQWKHPDLQPHWKRG6R Comp-U-Learn
25
Java Programming I
ZH FDQ XVH WKHVH YDULDEOHV ZLWKLQ WKH PDLQ PHWKRG RQO\ ,Q JHQHUDO D ORFDO YDULDEOH FDQ EH DFFHVVHGIURPLWVGHFODUDWLRQSDUWWRWKHHQGRIWKHFRGHEORFNLQZKLFKLWZDVGHFODUHG $ PHPEHU YDULDEOH LV D PHPEHU RI D FODVV RU DQ REMHFW DQG LV GHFODUHG ZLWKLQ D FODVV %XW LW VKRXOGQRWEHZLWKLQDQ\RIWKHFODVVPHWKRGV,IZHGHFODUHDYDULDEOHLQVLGHDPHWKRGZHFDQ DFFHVV WKDW YDULDEOH ZLWKLQ WKDW PHWKRG RQO\ :KLFK PHDQV LW ZLOO EH FRQVLGHUHG DV D ORFDO YDULDEOHRIWKDWPHWKRG7KHVWDWLFPHWKRGRIDFODVVFDQDFFHVVRQO\VWDWLFYDULDEOHVWKH\FDQ·W DFFHVVWKHYDULDEOHVZKLFKDUHGHFODUHGRWKHUZLVH
Commenting in Java ,Q -DYD SURJUDPV ZH FDQ FRPPHQW OLQHV E\ XVLQJ VLQJOH RU PXOWLSOH OLQH FRPPHQWLQJ V\QWD[ 8VLQJWKHIROORZLQJSURJUDPZHFDQXQGHUVWDQGWKHFRPPHQWLQJV\QWD[ Example 2.3: class comment { public static void main(String args[]) { int a=20; int b=10; // The following lines give us an idea about operators System.out.println(" The Usage of Arithmetic operators"); System.out.println(" The value of (a+b) is: " +(a+b)); System.out.println(" The value of (a-b) is: " +(a-b)); // Now a, b are going to be changed a++; b--; /* In the next two lines we are going to use the changed value of a, b and c */ System.out.println(" Now, the second value of a is: " +a); System.out.println(" Now,the second value of b is: " +b); } }
5XQWKHDERYHSURJUDPDQGVHHWKHRXWSXW2QO\SULQWVWDWHPHQWVJLYHQLQWKHSURJUDPZLOOEH SULQWHGLQWKHRXWSXW$Q\WKLQJWKDWDSSHDUVDIWHU´µXQWLOWKHHQGRIWKDWVLQJOHOLQHLVFDOOHG DVLQJOHOLQHFRPPHQWDQGLVLJQRUHGE\WKHMDYDFFRPSLOHU ,QDGGLWLRQDQ\WKLQJWKDWDSSHDUVDIWHU XSWR LVFDOOHGDVPXOWLSOHOLQHFRPPHQWLQJ:H FDQJLYHDQ\QXPEHURIOLQHVLQEHWZHHQWKH DQG 7KH-DYDFRPSLOHUZLOOLJQRUHDOOWKHVH OLQHV,QWKHDERYHH[DPSOHZHFDQVHHWZRW\SHVRIFRPPHQWLQJ
26
Comp-U-Learn
Fundamentals of Java
&RPPHQWVDUHDGGHGIRUWKHUHDGHUWRXQGHUVWDQGWKHSURJUDPEHWWHU WKH\DUHRIQRXVHWRWKH PDFKLQH7KHFRPSLOHULJQRUHVWKHVHFRPPHQWV:HFDQDOVRIROORZWKLVVW\OHLQRXUSURJUDPV WRPDNHRXU SURJUDP DQXQGHUVWDQGDEOHRQH:KHQZHZULWHDUHODWLYHO\ ELJJHU SURJUDP DQG UHDG LW DIWHU VL[ PRQWKV FRPPHQWV ZLOO SURYLGH D ORW RI LQIRUPDWLRQ WKDW ZRXOG RWKHUZLVH EH GLIILFXOWWRJXHVVIURPWKHSURJUDPDORQH
Decision Making /LNH DOO RWKHU SURJUDPPLQJ ODQJXDJHV -DYD KDV LWV RZQ SURJUDPPLQJ FRQVWUXFWV ,Q WKH IROORZLQJ VHFWLRQV ZH FDQ VHH YDULRXV -DYD SURJUDPPLQJ FRQVWUXFWV 7KHVH SURJUDPPLQJ FRQVWUXFWV LQFOXGHV WKH FRQGLWLRQDO VWDWHPHQWV FRQWURO VWDWHPHQWV DQG YDULRXV ORRSV %HIRUH JRLQJWRWKHVHWKLQJVZHKDYHWRXQGHUVWDQGWKHFRQFHSWRIGHFLVLRQPDNLQJ &RPSXWHUVDUHXVHIXOQRWRQO\EHFDXVHWKH\KDYHWKHDELOLW\WRVWRUHDQGPDQLSXODWHQXPEHUV EXW DOVR EHFDXVH WKH\ KDYH WKH DELOLW\ WR SLFN XS WKH ULJKW DOWHUQDWLYH E\ PHDQV RI GHFLVLRQ PDNLQJ(YHU\SURJUDPPLQJODQJXDJHRIIHUVDIDFLOLW\WRZULWHGRZQDOWHUQDWLYHVWREHIROORZHG ,Q -DYD WKHUH LV QR H[FHSWLRQ WR WKDW -DYD SURYLGHV WKH WZR SURJUDPPLQJ FRQVWUXFWV LI DQG VZLWFKVWDWHPHQWV 8VLQJ WKH ORJLFDO RSHUDWRUV DQG FRPSDULVRQ RSHUDWRUV ZH FDQ FUHDWH D FRQVWUXFW IRU GHFLVLRQ PDNLQJ0RVWRIWKHVHGHFLVLRQPDNLQJLVGRQHGHSHQGLQJXSRQWKHUHWXUQYDOXHWKDWLVHLWKHU WUXHRUIDOVH :KHQ LVXVHGWKHULJKWGHFLVLRQZLOOEHFDUULHGRXWGHSHQGLQJRQWKHIROORZLQJUHWXUQW\SH LIERWKVWDWHPHQWVDUHWUXH True && true = true True && false = false False && true = false False && false = false :KHQ__ $1' RSHUDWRULVXVHGLQRXUFRQGLWLRQDOVWDWHPHQWVWKHULJKWGHFLVLRQZLOOEHGRQH LIDQ\RQHWKHVWDWHPHQWVLVWUXH7KHGHVFULSWLRQIROORZV True || true = true True || false = true False || true = true False || false = false
Comp-U-Learn
27
Java Programming I
$OVRZHFDQXVHWKHVHFRQGLWLRQVMRLQWO\OLNH WUXH IDOVH __WUXH 7KHUHWXUQW\SHRIWKH DERYHFRQGLWLRQZLOOEHWUXH7KHRWKHURSHUDWRUZLOOZRUNDVIROORZV (true) = ! true = false !(false) = ! false = true if… and If.. else statements
7KLV LV D FRQGLWLRQDO VWDWHPHQW WKDW H[HFXWHV WKH ILUVW VHW RI VWDWHPHQWV LI WKH FRQGLWLRQ LV WUXH DQGWKHVWDWHPHQWIROORZLQJHOVHLIWKHFRQGLWLRQLVIDOVH7KHVHLIHOVHFDQEHQHVWHGDWDQ\OHYHO 7KHV\QWD[LV if (condition) { statements } else { statements }
7KHIROORZLQJH[DPSOHZLOOJLYHWKHXVDJHRIWKHLIDQGLI«HOVHVWDWHPHQWV Example 2.4 class sample { public static void main(String args[]) { int mark1=73; int mark2=60; { if ((mark1>=75) && (mark2>=75)) { System.out.println("Grade A"); } else if (((mark1>=50) && (mark2>=50)) && ((mark1<=74) && (mark2<=74))) { System.out.println("Grade B"); } else { System.out.println("Grade C"); } } } }
28
Comp-U-Learn
Fundamentals of Java
7KHRXWSXWRIWKHDERYHSURJUDPZLOOEH*UDGH%%HFDXVHWKHJLYHQPDUNDQGPDUNEHORQJV WRWKHVHFRQGFRQGLWLRQ
For loop ,QDIRUORRSZHKDYHWRSDVVWKUHHSDUDPHWHUVVHSDUDWHGE\VHPLFRORQVIROORZHGE\WKHVHWRI VWDWHPHQWVWREHH[HFXWHGGXULQJWKHORRSRSHUDWLRQ The syntax is for (initialization; condition; increment ) { Statements }
♦ In the initialization part, we have to initialize the variable, which can be a new one declared as any of the datatypes. ♦ In second part, we have to give an expression as a condition. The return value of this expression may be true or false. Depending upon the return value, the loop statements will be executed. ♦ Last part is used to increase/decrease the counter variable. It is also optional and can be updated programmatically within the loop statements. ♦ The loop will be terminated when the condition becomes false. The following example illustrates the use of for loop. Example 2.5 class loop_example { public static void main(String args[]) { for (int i=1; i<=5;i++) { System.out.println("This is No: " +i +" execution!"); } System.out.println("Loop terminated!"); } }
7KHRXWSXWZLOOEH This is No: This is No:
1 execution! 2 execution!
Comp-U-Learn
29
Java Programming I This is No: 3 execution! This is No: 4 execution! This is No: 5 execution! For Loop terminated!
While & Do… While Loop :KLOHORRSH[HFXWHVWKHVWDWHPHQWVXQWLODQH[SUHVVLRQLVWUXH:KHQWKHFRQGLWLRQLVQRORQJHU WUXHH[HFXWLRQFRQWLQXHVIURPWKHILUVWVWDWHPHQWDIWHUWKHZKLOHVWDWHPHQWV 7KHV\QWD[LV while (condition)
{ statements } ,QDGRZKLOHORRSWKHH[SUHVVLRQLVHYDOXDWHGRQO\DIWHUDOOWKHVWDWHPHQWVDUHH[HFXWHGDWOHDVW RQFH7KHV\QWD[LV do { statements } while(condition);
7KHIROORZLQJH[DPSOHLOOXVWUDWHVWKHXVDJHRIZKLOHORRS:H·OOJHWWKHRXWSXWVLPLODUWRWKH SUHYLRXVRQH Example 2.6 class loop1 { public static void main(String args[]) { int i=1; // Initialization while(i<=5) // Condition { System.out.println("This is No: " +i +" execution!"); i++; // Incrementation } System.out.println("While Loop terminated!"); } }
30
Comp-U-Learn
Fundamentals of Java
Switch & Break Statements 7KRXJKZHFDQXVH,I«HOVHVWDWHPHQWVWRGHDOZLWKPXOWLSOHFRQGLWLRQVZHFDQXVHWKHVZLWFK VWDWHPHQWVEHFDXVHWKH\DUHPRUHHIILFLHQWVLPSOHHDV\DQGUHDGDEOH7KLVRSHUDWRUDOORZVXVWR JURXS WRJHWKHU WKH FRQGLWLRQ DQG DVVRFLDWHG DFWLRQ WR SHUIRUP :KHQ WKH EUHDN NH\ZRUG LV HQFRXQWHUHGWKHUHVWRIWKHFRQGLWLRQVRIWKHVZLWFKDUHQRWHYDOXDWHG7KHV\QWD[IRUWKHVZLWFK VWDWHPHQWLV switch (variable) { case(value1): statements break; case(value2): statements break; default: statements break; }
Break
7KLV EUHDN NH\ZRUG WHUPLQDWHV WKH FXUUHQW IRU ZKLOH DQG VZLWFK SDVVHV WKH FRQWURO WR WKH ILUVW VWDWHPHQWDIWHUWKHORRS7KHPDLQXVHRIEUHDNLVWREUHDNWKHORRSDQGFRQWLQXHWKHH[HFXWLRQ RIWKHUHPDLQLQJVWDWHPHQWVDIWHUWKHORRS 7KHV\QWD[LV While(condition) { statements break; /* After executing the above the loop will be terminated.*/ }
statements
Continue
,QFRQWLQXHWKHFRQWUROSDVVHVWRWKHFRQGLWLRQLQDZKLOHORRSDQGWRWKHXSGDWHH[SUHVVLRQLQD IRUORRS
Note The important difference between the break and continue is that the loop is not terminated in continue. 7KHIROORZLQJH[DPSOHEULHIO\LOOXVWUDWHVWKHVZLWFKVWDWHPHQWZLWKXVLQJEUHDNNH\ZRUG,WDOVR JLYHVWKHRXWSXWDV´7KXUVGD\µ Comp-U-Learn
31
Java Programming I
Example 2.7 class var_usage { public static void main(String args[]) { int i=5; switch(i) { case 1: System.out.println("Sunday!"); break; case 2: System.out.println("Monday!"); break; case 3: System.out.println("Tuesday!"); break; case 4: System.out.println("Wednesday!"); break; case 5: System.out.println("Thursday!"); break; case 6: System.out.println("Friday!"); break; case 7: System.out.println("Saturday!"); break; default: System.out.println("Holiday!"); break; } } }
Arrays in Java $QDUUD\LQ-DYDLVDQHIIHFWLYHPHDQVRIVWRULQJDFROOHFWLRQRUVHULHVRUDJURXSRIYDULDEOHVDQG UHIHUULQJWRWKHPE\DFRPPRQQDPH7KHQXPEHURIYDOXHVWKDWFDQEHVWRUHGLQDQDUUD\LV FDOOHGDUUD\VL]H(DFKYDULDEOHLVFDOOHGDVDUUD\HOHPHQWRULWHP7KHUHDUHWKUHHVWHSVWRFUHDWH DQDUUD\ GHFODUDWLRQPHPRU\DOORFDWLRQDQGLQLWLDOL]DWLRQ Array declaration
/LNHDYDULDEOHZHKDYHWRGHFODUHDQDUUD\XVLQJWKHIROORZLQJV\QWD[7KHDUUD\PD\EHRIDQ\ GDWDW\SH
32
Comp-U-Learn
Fundamentals of Java <array type> <array name>
Example: int [] array1; double [] array2;
Memory allocation
$IWHU GHFODULQJ DQ DUUD\ ZH KDYH WR DOORFDWH WKH PHPRU\ IRU WKDW DUUD\ 2QO\ WKHQ DUH ZH DFWXDOO\FUHDWLQJDQDUUD\7KHQHZNH\ZRUGLVXVHGIRUWKLV7KHV\QWD[LV <array name> = new <array type with no of items> e.g.:array1 = new int[4]; array2 = new double[7];
Array initialization
$IWHUWKHGHFODUDWLRQDQGWKHPHPRU\DOORFDWLRQZHFDQLQLWLDOL]HWKHDUUD\HOHPHQWVLQGLYLGXDOO\ RUWRWDOO\:HFDQLQLWLDOL]HDQDUUD\XVLQJWKHLQGH[YDOXHZKLFKVWDUWVIURPWRODVWEXWEHIRUH WKHDUUD\HOHPHQW7RDFFHVVDSDUWLFXODUDUUD\HOHPHQWZHKDYHWRXVHWKHFRUUHVSRQGLQJLQGH[ YDOXH7KHV\QWD[LV array1[0]=1; array1[1]=2; and so on upto n-1 th element.
$OVRZHFDQGRDOOWKUHHRSHUDWLRQVDWWKHVDPHWLPHDVSHUWKHIROORZLQJH[DPSOHFRGH
int[]
array1 = new int[4]; double array2[] = new double[7];
Multidimensional Array
-DYDGRHVQRWVXSSRUWPXOWLGLPHQVLRQDODUUD\+RZHYHUDQDUUD\RIDUUD\VFDQEHFUHDWHG7KLV FDQEHGRQHZLWKDQLQGLYLGXDODUUD\LQLWLDOL]DWLRQ)RUH[DPSOHDWZRGLPHQVLRQDODUUD\FDQEH FUHDWHGDV VD\$UUD\ Array1[0][0]=20; Array1[0][1]=34; Array1[1][0]=23; Array1[1][1]=45;
DQGVRRQ
Comp-U-Learn
33
Java Programming I
Strings in Java 6WULQJV DUH VHTXHQFHV RI FKDUDFWHUV ,Q -DYD 6WULQJV DUH LQVWDQFHV RI WKH FODVV 6WULQJ :KHQ D VWULQJ OLWHUDO LV XVHG LQ WKH SURJUDP -DYD DXWRPDWLFDOO\ FUHDWHV DQ REMHFW RI WKH 6WULQJ FODVV 6WULQJVDUHXQXVXDOLQWKLVDVSHFW 7KHUHDUHYDULRXVPHWKRGVDYDLODEOHLQ6WULQJFODVV)UHTXHQWO\XVHGRQHVDUHHTXDOVOHQJWKDQG VXEVWULQJ7KHHTXDOVFRPSDUHVD6WULQJREMHFWZLWKWKHJLYHQREMHFWDQGUHWXUQVWUXHLIWKH\DUH HTXDO7KHQH[WRQHLVXVHGWRUHWXUQWKH6WULQJOHQJWK7KHVXEVWULQJLVXVHGIRUH[WUDFWLRQ 7KHIROORZLQJ H[DPSOH LOOXVWUDWHV DOO WKH GHWDLOV UHJDUGLQJ DQ DUUD\ EDVLFV DQG DERXW WKH 6WULQJ FODVV Example 2.8 class exarray { public static void main(String args[]) { int array1[] = {10,20,30}; // integer type array declaration and initialization // The following are the String type array declaration and initialization String array2[] = {"First","Second","Third"}; String sample=”Hai! Students!”; for (int i=0; i<=2; i++) { System.out.println("The " +array2[i] +" element is: " +array1[i]); } System.out.println("The Extracted String is: " +(sample.substring(0,4))); } }
7KHRXWSXWZLOOEHDVIROORZV The First element is: 10 The Second element is: 20 The Third element is: 30 The Extracted String is: Hi!
34
Comp-U-Learn
Fundamentals of Java
Summary In this session we have learnt various Java data types, literals, reserved words and identifiers. Now we have a brief idea about operators and expression evaluation using operator precedence. We also tried our hands on decision making using if.. else statement, switch statement and various loops such as for/while. At the end of this session, we learnt all the concepts regarding arrays and strings in Java. We have a full-fledged knowledge about Java fundamentals and Java programming constructs.
Going Over It Again I. Fill in the Blanks
BBBBBBBBBBBVWDWHPHQWLVXVHGWRSULQWVRPHWH[WRQWKHVFUHHQ 7KHERROHDQOLWHUDOVDUHBBBBBBBBBBBDQGBBBBBBBBBBBB ,QIRUORRSBBBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBDUHWKHSDUDPHWHUV 7KHVXEVWULQJPHWKRGLVXVHGIRUVWULQJBBBBBBBBBBB ,QGHFLVLRQPDNLQJWKHULJKWGHFLVLRQZLOOEHWDNHQGHSHQGLQJRQWKHBBBBBBBBW\SH
II. State True or False
$YDULDEOHFDQKDYHWKHVDPHQDPHDVWKDWRIDQ\UHVHUYHGZRUG ([SUHVVLRQHYDOXDWLRQGHSHQGVRQWKHRSHUDWRUSUHFHGHQFH ,Q-DYDPXOWLSOHOLQHFRPPHQWFDQEHGRQHE\ DQG :KHQWKHEUHDNNH\ZRUGLVHQFRXQWHUHGWKHUHVWRIWKHFRQGLWLRQVRIWKHVZLWFKZLOOQRWEH H[HFXWHG $UUD\VDUHSULPLWLYHGDWDW\SHV -DYDVXSSRUWVPXOWLGLPHQVLRQDODUUD\V
Comp-U-Learn
35
Java Programming I III. One line Answers
:KDWDUHWKHWZRGDWDW\SHVDYDLODEOH" :KDWLVDOLWHUDOLQ-DYD" ([SODLQORFDOYDULDEOHV :KDWLVWKHXVHRI RSHUDWRU" /LVWRXWWKHPHWKRGVDYDLODEOHLQ6WULQJFODVV IV. Define the Following
3ULPLWLYHGDWDW\SH 5HIHUHQFHGDWDW\SHV ,GHQWLILHUV $UUD\V 0HPEHUYDULDEOH
36
Comp-U-Learn
Session 3
OOPs In Java
On Completion of this Session We will be able to understand...
) Traditional Programming Model ) Object Oriented Programming Approach ) Basic concepts of OOPs and its features ) Java Programming using OOPs ) Understanding various modifiers in Java ) Super and Sub classes ) Constructors and overloaded constructors ) Garbage collection in
In This Session...
Traditional Programming Model
Object Oriented Programming Approach
Features of Object Oriented Programming
Basic concepts of OOPS
Creating Classes and Objects in Java
Constructors
Garbage Collection
Finalize Method
Inheritance
Polymorphism
Recursion
Advantages of OOPs in Java
OOPs In Java
Traditional Programming Model %HIRUHDSSO\LQJWKHSURJUDPPLQJFRQVWUXFWVLQ-DYDZKLFKZHKDYHVHHQLQWKHODVWVHVVLRQZH QHHG WR NQRZ DERXW WKH FRQFHSWV RI 2EMHFW 2ULHQWHG 3URJUDPPLQJ ,Q WKLV VHFWLRQ DQG WKH VXFFHHGLQJRQHVZHDUHJRLQJWROHDUQDERXW223DQGLWVKLVWRU\,QODWHUVHVVLRQVZH·OODSSO\ WKHVH223FRQFHSWVLQ-DYD ,Q HDUOLHU GD\V WUDGLWLRQDO SURJUDPPLQJ XVLQJ KLJK OHYHO ODQJXDJHV VXFK DV &2%2/ )2575$1DQG&ZHUHFRPPRQO\NQRZQDVSURFHGXUHRULHQWHGSURJUDPPLQJ7KLVPHWKRGRI SURJUDPPLQJWKRXJKVWUXFWXUHGZDVQRWPHHWLQJPRVWRIWKHUHTXLUHPHQWVRISURJUDPPHUV,Q WKLV DSSURDFK WKH LPSHWXV LV JLYHQ RQO\ WR WKH VHTXHQFH RI WKLQJV WR EH GRQH ZKLFK LV DFFRPSOLVKHG WKURXJK D QXPEHU RI IXQFWLRQV ,W DOVR DLPV WR SURYLGH D WRS GRZQ PRGXODU DSSURDFKLQSURJUDPPLQJPHWKRGRORJ\$W\SLFDOVWUXFWXUHRIDSURFHGXUHRULHQWHGSURJUDPLV VKRZQEHORZ
Main Program
Function 1
Function 2
Function 3
Function 4
Fig 3.1
7KHIROORZLQJDUHWKHFRQVWUDLQWVWKDWZHUHHQFRXQWHUHGLQWKHSURFHGXUDODSSURDFK ♦ Greater emphasis is laid on the process of the application (Sequences involved to do the task). This means that more stress is enforced on the function or methods and not on the data.
Comp-U-Learn
39
Java Programming I
♦ The procedural approach does not model real world problems very well because the functions are action oriented. They don’t really correspond to the elements of the problem. ♦ Modules are tightly inter-woven, inter dependent and difficult to separate. As a result of this inter-dependency between modules, modification of one program could affect all other programs that depend on it. This led to the complexity of code especially for huge programs. ♦ Most often, applications with almost similar features have to be re-written and recompiled resulting in higher software maintenance costs as the applications lack portability to run in multiple servers and in heterogeneous environments. ♦ Most functions use global data resulting in the data moving around the system openly throughout all modules. When functions transform data from one form to another, the true state and nature of the data is not available throughout all the modules. 7KHPDMRUPRWLYDWLQJIDFWRULQWKHLQYHQWLRQRI2EMHFW2ULHQWHGDSSURDFKLVWRVDOYDJHVRPHRI WKHIODZVHQFRXQWHUHGLQWKHSURFHGXUDODSSURDFK223ODQJXDJHVVXFKDV&6PDOOWDON-DYD HWFRYHUFRPHWKHVHGUDZEDFNV7KH\DUHPRGHOHGDIWHUUHDOZRUOGFKDUDFWHULVWLFVDQGKHQFHDUH VLPSOHDQGHDV\WRXQGHUVWDQG
Object Oriented Programming Approach 223WUHDWVGDWDDVDFULWLFDOHOHPHQWLQWKHSURFHVVRISURJUDPGHYHORSPHQWDQGGRHVQRWDOORZ LWWRIORZIUHHO\DURXQGWKHV\VWHP,WWLHVGDWDPRUHFORVHO\WRWKHIXQFWLRQVWKDWRSHUDWHRQLW DQG SURWHFWV LW IURP DFFLGHQWDO PRGLILFDWLRQV IURP RXWVLGH IXQFWLRQV 223 DOORZV XV WR GHFRPSRVH D SUREOHP LQWR D QXPEHU RI HQWLWLHV FDOOHG REMHFWV DQG WKHQ EXLOGV GDWD DQG IXQFWLRQV DURXQG WKHVH HQWLWLHV 7KH RUJDQL]DWLRQ RI GDWD DQG IXQFWLRQV LQ REMHFW RULHQWHG SURJUDPVLVVKRZQEHORZ
40
Comp-U-Learn
OOPs In Java
Object A
Object B
Data
Data
Function
Function
Functio
Data
Object C
Fig. 3.2
Features of Object Oriented Programming 1. 2. 3. 4. 5. 6. 7. 8.
Emphasis is more on data rather than procedure. Programs are divided into what are known as objects. Data structures are designed so that they characterize objects. Functions that operate on data of an object are tied together in the data structure. Data is hidden and cannot be accessed by external functions. Objects may communicate with each other through functions. New data and functions can be easily added whenever necessary. Follows bottom-up approach in program design.
Note
2EMHFW RULHQWHG SURJUDPPLQJ LV DQ DSSURDFK WKDW SURYLGHV D ZD\ RI PRGXODUL]LQJSURJUDPVE\FUHDWLQJSDUWLWLRQHGPHPRU\DUHDIRUERWKGDWDDQG IXQFWLRQVWKDWFDQEHXVHGDVWHPSODWHVIRUFUHDWLQJFRSLHVRIVXFKPRGXOHVRQ GHPDQG
Comp-U-Learn
41
Java Programming I
+HUHZH FRQVLGHU DQ REMHFW WR DFFHVV DQG RSHUDWH RQ D SDUWLWLRQHG DUHD RI FRPSXWHU PHPRU\ WKDWVWRUHVGDWDDQGDVHWRIRSHUDWLRQVWKDWFDQDFFHVVWKDWGDWD6LQFHPHPRU\SDUWLWLRQV DUH LQGHSHQGHQWWKHREMHFWVFDQEHXVHGLQDYDULHW\RIGLIIHUHQWSURJUDPVZLWKRXWPRGLILFDWLRQV
Basic Concepts of OOPS $Q\223ODQJXDJHVKRXOGVXSSRUWWKHIROORZLQJIHDWXUHV-DYDVXSSRUWVWKHVH223VFRQFHSWV H[FHSWIHZRILWVLQWHUQDOSURSHUWLHV ♦ Classes ♦ Objects ♦ Data Abstraction ♦ Data Encapsulation ♦ Inheritance ♦ Polymorphism Classes
$ FODVV LV D WHPSODWH WKDW GHILQHV WKH YDULDEOHV DQG WKH PHWKRGV FRPPRQ WR DOO REMHFWV RI D FHUWDLQNLQG)RUH[DPSOHOHWXVFRQVLGHUGLIIHUHQWNLQGVRIRUQDPHQWVVXFKDVULQJVEDQJOHV EUDFHOHWVFKDLQVVWXGVHWF$OORIWKHPKDYHDJHQHUDOEHKDYLRUDQGVWDWH$OOWKHVHMHZHOVFDQ EHSXWXSLQWRDEURDGHUFDWHJRU\FDOOHGMHZHOVRURUQDPHQWV+HQFHLQWKLVFDVHZHFDOO-HZHOV RURUQDPHQWVDVDFODVV
Note A class is a user-defined datatype that encompasses the entire set of data and code of an object. Objects
2EMHFWV FDQ EH UHDO RU LPDJLQDU\ 7KH\ DUH WKH LQVWDQFHV RI FODVVHV 2EMHFWV DUH WKH EDVLF UXQ WLPHHQWLWLHVLQDQREMHFWRULHQWHGV\VWHP7KH\PD\EHDSHUVRQDSODFHDEDQNDFFRXQWDWDEOH RI GDWD RU DQ\ LWHP WKDW WKH SURJUDP PXVW KDQGOH ,Q VRIWZDUH WHUPV DQ REMHFW LV D VRIWZDUH EXQGOH RI YDULDEOHV DQG UHODWHG PHWKRGV 3UREOHPV LQ SURJUDPPLQJ DUH DQDO\]HG LQ WHUPV RI REMHFWV DQG WKH QDWXUH RI FRPPXQLFDWLRQ EHWZHHQ WKHP 3URJUDP REMHFWV VKRXOG EH FKRVHQ VXFKWKDWWKH\PDWFKFORVHO\ZLWKWKHUHDOZRUOGREMHFWV
42
Comp-U-Learn
OOPs In Java
Note Each object contains data and code to manipulate the data. Objects can interact without having to know details of each other’s data or code. Examples of objects are 5HDOREMHFWV²0DUXWKL9DQRXUFODVVURRPEDOOHWF ,PDJLQDU\²5HFRUG2UJDQL]DWLRQHWF &RPSOH[²'DWDEDVHVSUHDGVKHHWVSDFNDJHVHWF 2QFH D FODVV LV GHILQHG ZH FDQ FUHDWH DQ\ QXPEHU RI REMHFWV EHORQJLQJ WR WKDW FODVV (DFK REMHFW LV DVVRFLDWHG ZLWK WKH GDWD RI W\SH FODVV ZLWK ZKLFK WKH\ DUH FUHDWHG )RU H[DPSOH PDQJRDSSOHDQGRUDQJHDUHPHPEHUVRIWKHFODVVIUXLW&ODVVHVDUHXVHUGHILQHGGDWDW\SHVDQG EHKDYHOLNHWKHEXLOWLQW\SHVRIDSURJUDPPLQJODQJXDJH7KHV\QWD[XVHGWRFUHDWHDQREMHFWLV QRGLIIHUHQWWKDQWKHV\QWD[XVHGWRFUHDWHDQLQWHJHUREMHFWLQ&,IIUXLWKDVEHHQGHILQHGDVD FODVVWKHQWKHVWDWHPHQW )UXLWPDQJR ZLOO FUHDWH DQ REMHFW PDQJR EHORQJLQJ WR WKH FODVV IUXLW 7KLV FRXOG EH H[SODLQHG IXUWKHU E\ FRPSDULQJZLWK int k;
+HUHNLVDQREMHFWRILQWHJHUGDWDW\SHDQGKDVDOOWKHSURSHUWLHVSHUWDLQLQJWRDQLQWHJHU Data Abstraction
$EVWUDFWLRQUHIHUVWRWKHDFWRIUHSUHVHQWLQJHVVHQWLDOIHDWXUHVZLWKRXWLQFOXGLQJWKHEDFNJURXQG GHWDLOV RU H[SODQDWLRQV &ODVVHV XVH WKH FRQFHSW RI DEVWUDFWLRQ DQG DUH GHILQHG DV D OLVW RI DEVWUDFWDWWULEXWHVVXFKDVVL]HZHLJKWFRVWDQGIXQFWLRQVWRRSHUDWHRQWKHVHDWWULEXWHV7KH\ HQFDSVXODWHDOOWKHHVVHQWLDOSURSHUWLHVRIWKHREMHFWVWKDWDUHWREHFUHDWHG6LQFHWKHFODVVHVXVH WKHFRQFHSWRIGDWDDEVWUDFWLRQWKH\DUHNQRZQDV$EVWUDFW'DWD7\SHV $'7 )RUH[DPSOH LIZHWDNHPDQJRDVDQREMHFWWKHQWKHSURSHUWLHVVXFKDVFRORUWDVWHYDULHW\FRVWVL]HHWFDUH QRW H[SOLFLWO\ TXRWHG RQ WKH IDFH RI PHUHO\ VD\LQJ LW DV D )UXLW 7KHVH SURSHUWLHV DUH WRWDOO\ HQFDSVXODWHGLQ)UXLW+HQFHZHFDOOLWRQO\DV)UXLWDQGWKHLQKHUHQWSURSHUWLHVRIWKHIUXLWDUH WRWDOO\KLGGHQLQVLGHE\PDNLQJWKHWHUP)UXLWDEVWUDFW 7KHUHDUHWZRNLQGVRI$EVWUDFWLRQ ♦ Data Abstraction ♦ Functional abstraction Comp-U-Learn
43
Java Programming I
,IZHWDNHDFDUDVDQH[DPSOHIRUDFODVVWKHQ Data Abstraction
(QJLQHQXPEHUVSHHGHWF Functional Abstraction
6WDUW6WRSHWF Data Encapsulation
7KH ZUDSSLQJ XS RI GDWD DQG IXQFWLRQV LQWR D VLQJOH XQLW FDOOHG FODVV LV NQRZQ DV HQFDSVXODWLRQ 'DWD HQFDSVXODWLRQ LV WKH PRVW VWULNLQJ IHDWXUH RI D FODVV 7KH GDWD LV QRW DFFHVVLEOH WR WKH RXWVLGH ZRUOG DQG RQO\ WKRVH IXQFWLRQV ZKLFK DUH ZUDSSHG LQ WKH FODVV FDQ DFFHVVLW7KHVHIXQFWLRQVSURYLGHWKHLQWHUIDFHEHWZHHQWKHREMHFW·VGDWDDQGWKHSURJUDP7KLV LQVXODWLRQ RI WKH GDWD IURP GLUHFW DFFHVV E\ WKH SURJUDP LV FDOOHG GDWD KLGLQJ (QFDSVXODWLRQ HPERGLHVLQIRUPDWLRQKLGLQJ
Creating Classes and Objects in Java ,Q-DYDZHFDQFUHDWHDQREMHFWE\FUHDWLQJDQLQVWDQFHRIDFODVV)RUH[DPSOH Date today=new Date(); Rectangle rect=new Rectangle();
+HUH'DWHLVDEXLOWLQFODVVDYDLODEOHLQWKHMDYDXWLOSDFNDJH WRGD\LVDYDULDEOHRIW\SH'DWH DQGLVLQLWLDOL]HGXVLQJWKHQHZRSHUDWRU1RWHWKDWWKHQHZRSHUDWRULQVWDQWLDWHGWKH'DWHFODVV E\FUHDWLQJDQHZREMHFWIRU'DWHDQGWKHQLQLWLDOL]HVLW ,WLVQRWHVVHQWLDOWKDWHYHU\WLPHDQREMHFWFUHDWLRQVKRXOGKDYHVLPXOWDQHRXVLQLWLDOL]DWLRQDOVR ,WLVSRVVLEOHWRKDYHRQO\REMHFWFUHDWLRQDORQH Example 3:1 Date
today;
7KHJHQHUDOV\QWD[LV Classname Objectname;
/HWXVWDNHDQRWKHUH[DPSOH 796HWV6RQ\3KLOLSV 44
Comp-U-Learn
OOPs In Java
+HUHZHKDYHFUHDWHGWZRREMHFWVRIWKHFODVV796HWV7KH\FDQEHLQLWLDOL]HGRUWKH\FDQEHVHW WRQXOO +RZWR,QLWLDOL]H" Sony=new TVSets; Philips=Sony;
2EMHFWV FDQ HLWKHU EH LQLWLDOL]HG WKURXJK WKH QHZ RSHUDWRU RU LW FDQ DOVR EH LQLWLDOL]HG XVLQJ DQRWKHU LQVWDQFH 7KH QHZ RSHUDWRU LV XVHG IRU DOORFDWLQJ PHPRU\ WR WKH REMHFW ,Q WKLV FDVH ERWK 6RQ\ DQG 3KLOLSV UHIHU WR WKH VDPH REMHFW 1RZ DVVXPLQJ WKH PHWKRGV 3OD\ 0XWH &RQWUDVWDUHLQWKH796HWVFODVVWKH\FDQEHLQYRNHGDV Sony.Play(); Philips.Contrast();
+RZWR,QLWLDOL]HWR1XOO Sony=null;
Note Local object variables are not automatically initialized to null. We must initialize them, either by calling new or by setting them to null. Creating a Class in Java
$ FODVV LV D EOXHSULQW RU SURWRW\SH WKDW FDQ EH XVHG WR FUHDWH PDQ\ REMHFWV 7KH FODVV FRQVWUXFWLRQKDVWZRSKDVHV ♦ Class Declaration ♦ Class Body Class Declaration
$ FODVV GHFODUDWLRQ PXVW FRQWDLQ WKH FODVV NH\ZRUG DQG WKH QDPH RI WKH FODVV WKDW LV WR EH GHILQHG class ClassName { ........... .......... ........... }
Comp-U-Learn
45
Java Programming I
$W\SLFDOFODVVGHFODUDWLRQZLOOEHOLNHWKLV >PRGLILHUV@FODVV&ODVV1DPH>H[WHQGVVXSHU&ODVV1DPH@>LPSOHPHQWV,QWHUIDFH1DPHV@ { ............................ ....................... };
7KH LWHPV EHWZHHQ > DQG @ DUH RSWLRQDO &ODVV QDPHV PXVW EH D OHJDO -DYD LGHQWLILHU DQG E\ FRQYHQWLRQ EHJLQ ZLWK D FDSLWDO OHWWHU :H ZLOO VHH HDFK RQH RI WKHP LQ GHWDLO 2I WKH DERYH PHQWLRQHG FODVV GHFODUDWLRQ IRUPDW RQO\ WKH FODVV NH\ZRUG DQG WKH FODVV QDPH DUH YHU\ LPSRUWDQW DQG PRVW UHTXLUHG 7KH RWKHU LWHPV DUH RSWLRQDO ,I ZH GRQ·W PDNH DQ H[SOLFLW GHFODUDWLRQIRUWKHRSWLRQDOLWHPVWKH-DYDFRPSLOHUDVVXPHVFHUWDLQGHIDXOWVDQRQILQDOQRQ SXEOLFQRQDEVWUDFWVXEFODVVHVRI2EMHFWWKDWLPSOHPHQWVQRLQWHUIDFHV
Class Modifiers
$PRGLILHULVRWKHUZLVHFDOOHGDQDFFHVVVSHFLILHU7KH\GHILQHWKHVFRSHRIWKHFODVVDQGDOVRWKH XVDJHRIWKH REMHFWV RIWKDWSDUWLFXODUFODVV $ FODVV FDQ KDYH DQ\ RI WKUHH PRGLILHUV ² SXEOLF DEVWUDFWRUILQDO 7KHSXEOLFPRGLILHUGHFODUHVWKDWWKHFODVVFDQEHXVHGE\REMHFWVRXWVLGHWKHFXUUHQWSDFNDJH %\GHIDXOWDFODVVFDQRQO\EHXVHGE\RWKHUFODVVHVLQWKHVDPHSDFNDJHLQZKLFKLWLVGHFODUHG
Note Package is a collection of classes grouped together. Packages are convenient for organizing our work and separating our code libraries provided with others. 7KHDEVWUDFWPRGLILHUGHFODUHVWKDWWKHFODVVLVDQDEVWUDFWFODVV$QDEVWUDFWFODVVLVXVHGZKHQ ZHQHHGDPRUHJHQHULFFODVVDQGSUREDEO\PRUHDEVWUDFW$EVWUDFWFODVVHVDUHQRWLQVWDQWLDWHG 7KDWLVLIDFODVVLVGHFODUHGDVDEVWUDFWQRREMHFWVRIWKDWFODVVFDQEHFUHDWHG:HZLOOKDYHWR H[WHQGWKDWFODVVLQRUGHUWRFUHDWHDQLQVWDQFHRIWKHFODVV$EVWUDFWFODVVHVFDQKDYHFRQFUHWH GDWDIXQFWLRQVDQGDOVRPD\FRQWDLQVRPHDEVWUDFWPHWKRGVDOVR$QDEVWUDFWFODVVPXVWKDYH DWOHDVWRQHDEVWUDFWPHWKRG &ODVVHVWKDWFDQQRWEHSDUHQWFODVVHVDUHFDOOHGILQDOFODVVDQGZHXVHWKHILQDOPRGLILHULQWKH GHILQLWLRQRIWKHFODVVWRLQGLFDWHWKLV)LQDONH\ZRUGLVXVHGWRSUHYHQWLQKHULWDQFH&ODVVHVDUH PDGHILQDOIRUWKHSXUSRVHRIHIILFLHQF\DQGIRUVHFXULW\UHDVRQV
46
Comp-U-Learn
OOPs In Java
Super Class and Sub Classes
6XSHUFODVVHVDQG6XEFODVVHVDUHWKHPHDQVWKURXJKZKLFKLQKHULWDQFHLVLPSOHPHQWHGLQ-DYD 7KHSDUHQWRUWKHEDVHFODVVLVFDOOHGD6XSHUFODVV7KHGHULYHGFODVVLVFDOOHGD6XEFODVV-DYD XVHV WKH H[WHQGV NH\ZRUG LQ RUGHU WR LPSOHPHQW LQKHULWDQFH ,QKHULWDQFH LQ -DYD LV SXEOLF LQ QDWXUH Example 3.2 class Employee { ........ .......... } class Manager extends Employee { ............ ............. }
+HUHWKHFODVV0DQDJHULVDGHULYHGFODVVDQGFODVV(PSOR\HHLVDEDVHFODVV Object Class – The universal Super Class
7KHREMHFWFODVVLVWKHXOWLPDWHDQFHVWRUYHU\FODVVLQ-DYDH[WHQGV2EMHFW+RZHYHUWKHUHLV QRQHHGWRVD\ class Employee extends Object
6LQFHWKHXOWLPDWHSDUHQWFODVV2EMHFWLVWDNHQIRUJUDQWHGLIQRSDUHQWLVH[SOLFLWO\PHQWLRQHG 2EMHFWFODVVLVORFDWHGLQWKHSDFNDJHMDYDODQJ(YHU\FODVVLQ-DYDH[WHQGVIURP2EMHFW6RPH PHWKRGVLQWKH2EMHFWFODVVDUHDVIROORZV public Boolean equals(Object obj)
7KLV PHWKRG WHVWV ZKHWKHU RU QRW RQH REMHFW LV HTXDO WR DQRWKHU 7KH HTXDOV PHWKRG DV LW LV LPSOHPHQWHG LQ WKH 2EMHFW SDUHQW FODVV GHWHUPLQHV ZKHWKHU RU QRW WZR REMHFWV SRLQW WR WKH VDPHDUHDRIPHPRU\ $QRWKHU LPSRUWDQW PHWKRG LQ 2EMHFW LV WKH WR6WULQJ PHWKRG WKDW UHWXUQV D VWULQJ WKDW UHSUHVHQWV WKH YDOXH RI WKLV REMHFW 7KH WR6WULQJ PHWKRG LV XQLTXH IRU DQ LPSRUWDQW UHDVRQ ZKHQHYHU DQ REMHFW LV FRQFDWHQDWHG ZLWK D VWULQJ XVLQJ WKH ´µ RSHUDWRU WKH -DYD FRPSLOHU
Comp-U-Learn
47
Java Programming I
DXWRPDWLFDOO\LQYRNHVWKHWR6WULQJPHWKRGWRREWDLQDVWULQJUHSUHVHQWDWLRQRIWKHREMHFW)RU H[DPSOH Date today=new today(1998,12,26); String last=“ Today date is “ + today; //automatically invokes today.toString public Object clone()
7KLV LV XVHG WR FORQH WKH REMHFW E\ DOORFDWLQJ PHPRU\ DQG FRS\LQJ WKH FXUUHQW REMHFW LQWR LW &ORQLQJLVQRWKLQJEXWPDNLQJDELWE\ELWFRS\,WLVVLPSO\DQRWKHUREMHFWZLWKWKHVDPHEDVH W\SHVDQGILHOGV The class called Class
-DYD PDLQWDLQV D 5XQ 7LPH 7\SH ,GHQWLILFDWLRQ ZKLFK NHHSV WUDFN RI WKH FODVV WR ZKLFK HDFK REMHFW EHORQJV 7KLV HQVXUHV WKDW WKH FXUUHQW PHWKRGV DUH VHOHFWHG DW UXQWLPH 7KH FODVV WKDW KROGVWKLVLQIRUPDWLRQLVFDOOHG&ODVV7KHJHW&ODVV PHWKRGRI2EMHFWUHWXUQVDQLQVWDQFHRI WKLVFODVV Class Body
7KHFODVVERG\FRPSRQHQWRIDFODVVLPSOHPHQWDWLRQFDQLWVHOIFRQWDLQWZRGLIIHUHQWVHFWLRQV 9DULDEOHGHFODUDWLRQV 0HWKRGV class ClassName { Membervariable Declarations Method Declarations }
Member Variable Declarations
$PHPEHUYDULDEOHGHFODUDWLRQORRNVOLNHWKLV >DFFHVVVSHFLILHU@>VWDWLF@>ILQDO@>WUDQVLHQW@>YRODWLOH@GDWDW\SHYDULDEOH1DPH $PHPEHUYDULDEOHGHFODUDWLRQGHILQHVWKHIROORZLQJDVSHFWVRIDYDULDEOH $FFHVVVSHFLILHUGHILQHVZKLFKRWKHUFODVVHVKDYHDFFHVVWRWKHYDULDEOH7KHIROORZLQJLVWKHOLVW RIPRGLILHUVWKDWFDQEHXVHGZLWKWKHPHWKRGVDQGPHPEHUYDULDEOHGHFODUDWLRQVLQ-DYD
48
Comp-U-Learn
OOPs In Java
Public
7KHNH\ZRUGSXEOLFPHDQVWKDWDQ\FODVVLQDQ\SDFNDJHFDQ DFFHVVWKHYDULDEOHVRUPHWKRGV 0HWKRGVGHFODUHGDVSXEOLFDUHDFFHVVLEOHWRDOO Example 3:3 public void shape() { }
Protected
$Q\FODVVLQWKHVDPHSDFNDJHDVWKHFODVVLQZKLFKLWLVGHFODUHGFDQDFFHVVSURWHFWHGYDULDEOHV RUPHWKRGV)RUH[DPSOHLQSDFNDJH3DFN class A { protected int min; }
+HUHPLQFDQEHXVHGE\DQ\FODVVLQWKHSDFNDJH3DFNLUUHVSHFWLYHRIZKHWKHUWKH\KDYHEHHQ GHULYHGRUQRW$OVRZKHQWKHUHDUHDQ\RWKHUFODVVHVWKDWKDYHEHHQGHULYHGIURPFODVV$WKH\ FDQPDNHXVHRIWKHSURWHFWHGGDWD´LQWPLQµHYHQWKRXJKWKHVXEFODVVHVPD\UHVLGHLQRWKHU SDFNDJHV QRWLQ3DFN Private
3ULYDWH YDULDEOHV RU PHWKRGV FDQ RQO\ EH DFFHVVHG ZLWKLQ WKH FRQILQHV RI WKH GHFODULQJ FODVV 2QO\ WKH PHPEHUV DQG PHWKRGV RI WKDW SDUWLFXODU FODVV FDQ DFFHVV WKH SULYDWH GDWD 1R RWKHU PHWKRGVFODVVHVDQGQRWHYHQVXEFODVVHVZKHWKHULQVLGHRURXWVLGHWKHSDFNDJHFDQKDYHDFFHVV WRWKHSULYDWHGDWD class Hour { private int hr, min, sec; private void input(); }
+HUHWKHPHWKRGLQSXWFDQPDNHXVHRIWKHSULYDWHGDWDKUPLQDQGVHF Static
:KHQZHZDQWDPHWKRGWREHDFODVVPHWKRGXVHWKHVWDWLFNH\ZRUGLQWKHPHWKRGGHFODUDWLRQ 6WDWLFILHOGVGRQRWFKDQJHIURPRQHLQVWDQFHRIDFODVVWRDQRWKHU6WDWLFPHWKRGVEHORQJWRD
Comp-U-Learn
49
Java Programming I
FODVVDQGGRQRWRSHUDWHRQDQ\LQVWDQFHRIDFODVV6WDWLFPHWKRGVFDQRQO\DFFHVVVWDWLFILHOGV 6WDWLFLQLWLDOL]DWLRQRFFXUVZKHQWKHFODVVLVILUVWORDGHG6WDWLFPHWKRGVFDQQRWEHRYHUORDGHG 6WDWLFPHWKRGVEHORQJWRDFODVVDQGGRQRWRSHUDWHRQDQ\LQVWDQFHRIWKHFODVV Example 3.4 class Myclass { static private int i; static public int output() { return i; } static public void input(int j) { i=j; } }
Note Overloading refers to the existence of more than one function with the same name but with different function signature. The parameters passed to a method is called its signature. Final
9DULDEOHV RU PHWKRGV GHFODUHG DV ILQDO FDQQRW EH RYHUORDGHG RU FKDQJHG &ODVV YDULDEOHV DUH RIWHQ XVHG ZLWK WKH NH\ZRUG ILQDO WR GHILQH FRQVWDQWV 7KLV RIIHUV EHWWHU PHPRU\ HIILFLHQF\ WKDQ ILQDO LQVWDQFH YDULDEOHV EHFDXVH FRQVWDQWV FDQQRW FKDQJH $ ILQDO PHWKRG KDV DQ LPSOHPHQWDWLRQ WKDW ZLOO QRW EH FKDQJHG DQ\ZKHUH LQ WKH PRGXOH DQG LV FULWLFDO WR WKH FRQVLVWHQWVWDWHRIWKHREMHFW)LQDOPHWKRGVFDQQRWEHRYHUULGGHQLQWKHVXEFODVVHV Transient
7UDQVLHQW YDULDEOHV DUH QRW SDUW RI WKH REMHFWV SHUVLVWHQW VWDWH ,W PDUNV WKH GDWD QRW WR EH SHUVLVWHQW 0HPEHU YDULDEOHV WKDW DUH SDUW RI WKH SHUVLVWHQW VWDWH RI DQ REMHFW PXVW EH VDYHG ZKHQWKHREMHFWLVDUFKLYHG:HXVHWKHWUDQVLHQWNH\ZRUGWRLQGLFDWHWKDWWKHSDUWLFXODUYDULDEOH LVQRWSDUWRIWKHSHUVLVWHQWVWDWHRIWKHREMHFW class Some { transient int hai; }
50
Comp-U-Learn
OOPs In Java
Volatile
7KLVPHDQVWKDWWKHYDULDEOHLVPRGLILHGLQYDULDEO\E\GLIIHUHQWPHWKRGVZLWKRXWDQ\FRUUHODWLRQ ,WLVQRWXVHGFRPPRQO\7KHIROORZLQJYDULDEOHGHFODUDWLRQLVDQH[DPSOHRIKRZWRGHFODUH WKDWDYDULDEOHFDQEHPRGLILHGDV\QFKURQRXVO\ Example 3.5 class Anything { volatile int r; }
Implementing Methods in Java
$PHWKRGLPSOHPHQWDWLRQFRQWDLQVWZRSDUWV ♦ Method declaration ♦ Method body Method Declaration
$PHWKRGGHFODUDWLRQSURYLGHVDORWRILQIRUPDWLRQDERXWWKHPHWKRGWRWKHFRPSLOHUWKHUXQ WLPHV\VWHPDQGWRRWKHUFODVVHVDQGREMHFWV7KLVFRQWDLQVWKHQDPHRIWKHPHWKRGWKHUHWXUQ W\SHRIWKHPHWKRGWKHW\SHRIDUJXPHQWVUHTXLUHGE\WKHPHWKRGDQGWKHPRGLILHUVIRUWKDW PHWKRG Method body
7KLV FRQWDLQV WKH FRGH VHJPHQW WR EH H[HFXWHG E\ WKH PHWKRG ,Q FDVH WKH SDUWLFXODU PHWKRG UHWXUQVDQ\YDOXHWKHQWKHERG\ZLOOFRQWDLQWKHUHWXUQNH\ZRUG Example 3.6 class some { public int dummy(int a) { int b=a+5; return b; } }
7KHUHWXUQYDOXHYRLGVLJQLILHVWKDWWKHPHWKRGZLOOQRWUHWXUQDQ\YDOXH,QWKHDERYHH[DPSOH WKH PHWKRG GXPP\ DFFHSWV DQ LQWHJHU YDULDEOH DV DQ DUJXPHQW -DYD VXSSRUWV PHWKRG RYHUORDGLQJ 7KH PHWKRG WKDW KDV D VDPH QDPH DV WKDW RI WKH FODVV LV FDOOHG WKH FRQVWUXFWRU 0HWKRGVFDQDOVREHRYHUULGGHQ Comp-U-Learn
51
Java Programming I
7KLVPHDQVWKDWWKHPHWKRGVLQWKHVXSHUFODVVHVFDQEHZULWWHQLQWKHVXEFODVVHVZLWKUHOHYDQW FKDQJHVWRPHHWWKHQHHGVRIWKHVXEFODVV%XWLQWKLVFDVHWKHRYHUULGLQJPHWKRGPXVWKDYH WKHVDPHQDPHUHWXUQW\SHDQGSDUDPHWHUOLVWLVWKHPHWKRGLWRYHUULGHV,Q-DYDDUJXPHQWVDUH SDVVHG E\ YDOXH RQO\ WR WKH PHWKRGV 3DVVLQJ YDULDEOHV E\ YDOXHV DVVXUHV WKDW WKH PHWKRGV XQLQWHQWLRQDOO\FDQQRWPRGLI\DYDULDEOH·VYDOXHWKDWLVRXWVLGHLWVVFRSH
Note When a method returns a value, the datatype of the value returned by the return statement must match the datatype that the method is actually returning. There cannot be a mismatch in the declaration and in the actual return statement. $VLPSOHH[DPSOHKHUHWRVKRZKRZWRFDOODPHWKRGLQ-DYD class ex2 { public static void main(String args[]) { System.out.println(" We are in the main function "); System.out.println(); System.out.println("Call to the method sample "); sample(); System.out.println(); System.out.println("Back to main function "); } static void sample() { int a= 10; a= a* 10; System.out.println("Now we are in the sample method "); System.out.println(a); } }
2XWSXW2IWKHSURJUDP We are in the main function Call to the method sample Now we are in the sample method 100 Back to main function
Note A method is a collection of statements that performs a series of operations. In languages like C, they are called functions.
52
Comp-U-Learn
OOPs In Java
Constructors &RQVWUXFWRUVDUHVSHFLDOPHWKRGVSURYLGHGLQHDFK-DYDFODVVWKDWDUHUHVSRQVLEOHIRULQLWLDOL]LQJ QHZREMHFWVRIWKDWW\SH7KHQHZRSHUDWRUFUHDWHVWKHREMHFWDQGWKHFRQVWUXFWRULQLWLDOL]HVLW$ FODVV PD\ SURYLGH PXOWLSOH FRQVWUXFWRUV WR SHUIRUP GLIIHUHQW NLQGV RI LQLWLDOL]DWLRQ RQ QHZ REMHFWV$FRQVWUXFWRUWKDWWDNHVQRDUJXPHQWVLVFDOOHGDGHIDXOWFRQVWUXFWRU7KLVLVLQYRNHG DXWRPDWLFDOO\ZKHQWKHREMHFWLVLQLWLDOL]HG Example 3.7 Date today=new Date(); TVSets Philips=new TVSets(); TVSets Sony=new Sony();
:KHQ WKH FRQVWUXFWRU WDNHV DUJXPHQWV LW LV FDOOHG DQ RYHUORDGHG FRQVWUXFWRU 7KH FRPSLOHU PDNHV WKH GHFLVLRQ UHJDUGLQJ LQYRFDWLRQ RI WKH DSSURSULDWH FRQVWUXFWRU GHSHQGLQJ XSRQ WKH W\SHDQGWKHQXPEHURIDUJXPHQWVSDVVHGWRLW7KLVFRQFHSWLVFDOOHGRYHUORDGLQJ
Note Overloading refers to the concept where there are more than one function with the same name but with different parameters. These parameters may differ in number, sequence and data type of the arguments. Calls to the functions are bound according to the nature of the arguments passed. Examples 3.8 Date today = new Date(1998,10,28); TVSets Sony = new Sony(14,Portable); Rectangle rect = new Rectangle(10,10,200,200);
+HUH WRGD\ REMHFW LV LQLWLDOL]HG ZLWK DUJXPHQWV \HDU PRQWK DQG GD\ 7KH FRQVWUXFWRU ZLWK WKUHHDUJXPHQWVDYDLODEOHLQ'DWHFODVVLVLQYRNHG$QHZUHFWDQJOHUHFWRIVL]H ZLOOEHFUHDWHGDQGLQLWLDOL]HG Referring an Object variable
/HWXVVD\WKDWZHZDQWWRPRYHWKHUHFWDQJOHWRDQHZORFDWLRQ&KDQJLQJ WKHUHFWDQJOHWRD QHZORFDWLRQFRXOGEHGRQHE\WKHIROORZLQJPHWKRGV ♦ Manipulate the object’s variables directly rect.x=80; rect.y=100;
Comp-U-Learn
53
Java Programming I
ZKHUH[\DUHWKHQHZORFDWLRQVRIWKHUHFWDQJOH *HQHUDOV\QWD[ ObjectReference.Variable
♦ Call the move method which is available in the Rectangle class rect.move(80,100);
7KLVVWDWHPHQWZLOOPRYHWKHREMHFWUHFWWRDQHZORFDWLRQ0HWKRGFDOOVDUHGLUHFWHGDWD VSHFLILF REMHFW WKH REMHFW VSHFLILHG LQ WKH PHWKRG FDOO LV WKH REMHFW WKDW UHVSRQGV WR WKH LQVWUXFWLRQ 0HWKRG FDOOV DUH NQRZQ DV PHVVDJHV ,Q WKH H[DPSOH RQ 3RO\PRUSKLVP ZKLFK LV JRLQJWREHGHDOWODWHUZLOOH[SODLQWKHEDVLFFRQFHSWVRI&RQVWUXFWRUV
Garbage Collection 0DQ\REMHFWRULHQWHGODQJXDJHVUHTXLUHWKDWZHNHHSWUDFNRIDOOWKHREMHFWVZHFUHDWHDQGFDQ GHVWUR\ WKHP ZKHQ ZH QR ORQJHU QHHG WKHP :ULWLQJ FRGH WR PDQDJH PHPRU\ LQ WKLV ZD\ LV WHGLRXVDQGRIWHQHUURUSURQH-DYDWDNHVFDUHRIWKLVPHPRU\PDQDJHPHQWWHFKQLTXH7KH-DYD UXQWLPHHQYLURQPHQWGHOHWHVREMHFWVZKHQLWGHWHUPLQHVWKDWWKH\DUHQRORQJHUEHLQJXVHG7KLV SURFHVVLVNQRZQDVJDUEDJHFROOHFWLRQ$QREMHFWLVHOLJLEOHIRUJDUEDJHFROOHFWLRQZKHQWKHUH DUH QR PRUH UHIHUHQFHV WR WKDW REMHFW 5HIHUHQFHV WKDW DUH KHOG LQ D YDULDEOH DUH QDWXUDOO\ GURSSHGZKHQWKHYDULDEOHJRHVRXWRIVFRSH7KHJDUEDJHFROOHFWRUUXQVV\QFKURQRXVO\ZKHQ WKHV\VWHPUXQVRXWRIPHPRU\RULQUHVSRQVHWRDUHTXHVWIURPD-DYDSURJUDP-DYD3URJUDPV FDQDVNIRUWKHJDUEDJHFROOHFWRUWRUXQDWDQ\WLPHE\FDOOLQJ6\VWHPJF 7KHILQDOL]H PHWKRGZLOOEHFDOOHGEHIRUHWKHJDUEDJHFROOHFWRUVZHHSVDZD\WKHREMHFW&DOOWKH VWDWLFPHWKRG6\VWHPUXQ)LQDOL]HUV2Q([LW 758( WRJXDUDQWHHWKDWILQDOL]HUPHWKRGVDUHFDOOHG EHIRUH -DYD VKXWV GRZQ $VNLQJ WKH JDUEDJH FROOHFWLRQ WR UXQ GRHV QRW JXDUDQWHH WKDW RXU REMHFWVZLOOEHJDUEDJHFROOHFWHG
Finalize Method %HIRUHDQREMHFWLVJDUEDJHFROOHFWHGWKHUXQWLPHV\VWHPFDOOVLWVILQDOL]HPHWKRG,WLVLQWHQGHG WRUHOHDVHV\VWHPUHVRXUFHVVXFKDVRSHQILOHVRURSHQVRFNHWVEHIRUHJHWWLQJFROOHFWHG2XUFODVV FDQSURYLGHIRUILQDOL]DWLRQVLPSO\E\GHFODUDWLRQRIDPHWKRGFDOOHGILQDOL]HDQGLPSOHPHQWLQJ LW)RU([DPSOH protected void finalize() { … statements }
54
Comp-U-Learn
OOPs In Java
Inheritance ,Q UHDO OLIH ZH FDQ REVHUYH LQKHULWDQFH DOPRVW HYHU\ZKHUH $ FKLOG IRU H[DPSOH WDNHV RQ WKH FKDUDFWHULVWLFV RI WKH SDUHQWV ,QKHULWDQFH LV WKH PHFKDQLVP WKURXJK ZKLFK D FODVV FDQ EH GHILQHG LQ WHUPV RI DQ H[LVWLQJ FODVV ,QKHULWDQFH LV WKH SURFHVV E\ ZKLFK REMHFWV RI RQH FODVV DFTXLUH WKH SURSHUWLHV RI REMHFWV RI DQRWKHU FODVV ,W VXSSRUWV WKH FRQFHSW RI KLHUDUFKLFDO FODVVLILFDWLRQ7KHIROORZLQJH[DPSOHVKRZVWKHSURSHUW\LQKHULWDQFHRIREMHFWV
Vehicles Attributes: Have engine Carry people Carry luggage Used for transport
Four Wheelers
Two Wheelers
Attributes :
Attributes :
Cars
Jeep
Motor Bikes
Scooters
Attributes:
Attributes:
Attributes:
Attributes:
Fig 3.3 ,Q2236WKHFRQFHSWRILQKHULWDQFHSURYLGHVWKHLGHDRIUHXVDELOLW\7KLVPHDQVWKDWZHFDQ DGGDGGLWLRQDOIHDWXUHVWRDQH[LVWLQJFODVVZLWKRXWPRGLI\LQJLW7KLVLVSRVVLEOHE\GHULYLQJD QHZ FODVV IURP WKH H[LVWLQJ RQH 7KH QHZ FODVV ZLOO KDYH WKH FRPELQHG IHDWXUHV RI ERWK WKH FODVVHV)RUH[DPSOHKHUH9HKLFOHVLVDEURDGFDWHJRU\ZKLFKH[SODLQVWKHYDULRXVDWWULEXWHVRI DOOWKHYHKLFOHVFRPPRQO\7KLVFRXOGEHIXUWKHUGLYLGHGLQWRWZRVSHFLILFFDWHJRULHVOLNH7ZR Comp-U-Learn
55
Java Programming I
ZKHHOHUV DQG )RXU ZKHHOHUV %RWK WKHVH FODVVHV ZLOO KDYH WKH SURSHUWLHV RI WKH JHQHUDO FODVV ´9HKLFOHVµ$JDLQWZRZKHHOHUVFODVVFRXOGEHGHULYHGRUEURNHQLQWRFODVV´0RWRU%LNH´DQG FODVV´6FRRWHUV´ZKLFKKDYHWKHVSHFLILFDWWULEXWHVRIWKHVHWZRW\SHVRIYHKLFOHV7KXVWKURXJK LQKHULWDQFHZHDUHDEOHWRJHQHUDWHDQHZFODVVIURPDQH[LVWLQJRQH7KHSURSHUWLHVFRPPRQWR ERWK WKHVH FODVVHV DUH QRW UHZULWWHQ EXW DUH UHXVHG ,QKHULWDQFH HQDEOHV WKH UHILQHPHQW RU VSHFLDOL]DWLRQRIDQH[LVWLQJFODVV7KRXJKDFKLOGLQKHULWVWKHFKDUDFWHULVWLFVIURPLWVSDUHQWVLW DOVRKDVLWVRZQIHDWXUHV $ FODVV FDQ LQKHULW WKH DWWULEXWHV RI WZR RU PRUH FODVVHV 0XOWLSOH LQKHULWDQFH DOORZV XV WR FRPELQHWKHIHDWXUHVRIVHYHUDOH[LVWLQJFODVVHVDVDVWDUWLQJSRLQWIRUGHILQLQJQHZFODVVHV,WLV OLNHDFKLOGLQKHULWLQJWKHFRORURIWKHIDWKHUDQGWKHIDFHFXWRIWKHPRWKHU
Mammals
Birds
Platypus
Fig 3.4 ,QWKLVH[DPSOHLIPDPPDOVDQGELUGVDUHWZRFODVVHVWKHQSODW\SXVH[KLELWVWKHFKDUDFWHULVWLFV RIERWKWKHVHFODVVHV Note Java does not support multiple inheritance due to difficulty in maintaining and keeping track of the code. ,Q-DYDZHFDQLQKHULWDVXSHUFODVVE\WKH.H\ZRUGH[WHQGV7KHIROORZLQJH[DPSOHLOOXVWUDWHV LQKHULWDQFHLQ-DYD class base { public String name="Peter"; public int age=23; }
56
Comp-U-Learn
OOPs In Java class base1 extends base { private int acc_no=4566; public void disp() { System.out.println("The name is : " +name); System.out.println("The Age is : " +age); System.out.println("The account No. is : " +acc_no); } public static void main(String args[]) { base1 b = new base1(); b.disp(); } }
6DYHWKHILOHDVEDVHMDYD7KHRXWSXWLVDVIROORZV The name is : Peter The Age is : 23 The account No. is : 4566
Polymorphism 3RO\PRUSKLVPLV\HWDQRWKHULPSRUWDQW223FRQFHSW3RO\PHDQVPDQ\0RUSKPHDQVIRUPV 3RO\PRUSKLVPPHDQVWKHDELOLW\WRWDNHPRUHWKDQRQHIRUP)RUH[DPSOHLIZHWDNHPRYHDV DQRSHUDWLRQWKHQWKHPDQZDONVILVKVZLPVELUGVIO\DQGZRUPVFUDZO7KLVLVQRWKLQJEXWDQ RSHUDWLRQ H[KLELWLQJ GLIIHUHQW EHKDYLRU LQ GLIIHUHQW LQVWDQFHV 7KH EHKDYLRU GHSHQGV XSRQ WKH W\SHVRIGDWDXVHGLQWKHRSHUDWLRQ )RUH[DPSOHFRQVLGHUWKHRSHUDWLRQRIGUDZLQJ)RUGUDZLQJYDULRXVVKDSHVZHFDQXVHVDPH GUDZ PHWKRG E\ JLYLQJ WKH FRUUHVSRQGLQJ SDUDPHWHUV 7KLV LV FDOOHG 2YHUORDGLQJ %DVLFDOO\ 223 VXSSRUWV )XQFWLRQ RYHUORDGLQJ DQG 2SHUDWRU RYHUORDGLQJ %XW -DYD GRHV QRW VXSSRUW 2SHUDWRURYHUORDGLQJ 3RO\PRUSKLVPLVH[SODLQHGFOHDUO\LQWKHIROORZLQJGLDJUDP
Comp-U-Learn
57
Java Programming I Shape Draw()
Circle Object
Box Object
Triangle Object
Draw(Circle)
Draw(Box)
Draw(Triangle)
Fig 3.5 /HWXVORRNDWDFRPSOHWHH[DPSOHRIDFODVVLQ-DYD7KLVH[SODLQVWKHFRQFHSWRI&RQVWUXFWRUV DQG2YHUORDGLQJFRQFHSWRI3RO\PRUSKLVP Example 3.9 // Creation of a
Class called AddSub
class AddSub { int num1,num2; public AddSub() { num1=20; num2=10; System.out.println("Default constructor invoked "); } public AddSub(int x, int y) { num1=x; num2=y; System.out.println("Overloaded Constructor Invoked "); } public int AddNum() { int num3; num3=num1 + num2; return num3; } public int SubNum()
58
Comp-U-Learn
OOPs In Java { int num3; num3=num1-num2; return num3; } } public class ex3 { public static void main(String args[]) { AddSub a=new AddSub(); AddSub b=new AddSub(60,50); System.out.println(" The value of num1 of object a is "+ a.num1); System.out.println(" The value of num2 of object a is "+ a.num2); System.out.println(); System.out.println(" The result of addition of object a is "+a.AddNum()); System.out.println(); System.out.println(" The result of subtraction of object a is "+a.SubNum()); System.out.println(); System.out.println(" The value of num1 of object b is "+ b.num1); System.out.println(" The value of num2 of object b is "+ b.num2); System.out.println(); System.out.println(" The result of addition of object b is "+b.AddNum()); System.out.println(); System.out.println(" The result of subtraction of object b is "+b.SubNum()); } }
2XWSXWRIWKH3URJUDPLVVKRZQEHORZ Default constructor invoked Overloaded Constructor Invoked The value of num1 in object a is 20 The value of num2 in object a is 10 The The The The The The
result of addition of object a is result of subtraction of object a value of num1 in object b is 60 value of num2 in object b is 50 result of addition of object b is result of subtraction of object b
30 is 10
110 is 10
Comp-U-Learn
59
Java Programming I Keywords this & super
,QDPHWKRGWKHNH\ZRUGWKLVUHIHUVWRWKHREMHFWRQZKLFKWKHPHWKRGRSHUDWHV:KHQWKLVLV XVHGLQVLGHDFRQVWUXFWRUWKHQWKHFRQVWUXFWRUFDOOVDQRWKHUFRQVWUXFWRURIWKHVDPHFODVV7KLV LVDFDOOWRRQHRIWKHFXUUHQWREMHFWV$JDLQLWLVUHTXLUHGRQO\ZKHQWKHUHLVDQDPELJXLW\LQWKH PHWKRGQDPHDQGLVRIWHQXVHGWRPDNHWKHLQWHQWRIWKHFRGHFOHDUHU)RUH[DPSOH class Book { int NoPages; int Weight; Book(int NoPages, int Weight) { this.NoPages=NoPages; this.weight=Weight; } }
Super
7KHNH\ZRUGVXSHUDOZD\VUHIHUVWRWKHVXSHUFODVV Example 3.10 class Employee { int salary; Employee(int i) { this.salary=i; } } class Manager extends Employee { Manager(int l) { super(l); }
+HUHWKHVXSHULVXVHGWRFDOOWKHFRQVWUXFWRURIWKHEDVHFODVV,QVKRUWWKHVXSHUUHIHUVWKHEDVH FODVV,QFDVHRIRYHUULGLQJWKHEDVHFODVVPHWKRGVLQWKHVXEFODVVHVWKHVXEFODVVHVPD\FDOOWKH EDVHFODVVPHWKRGXVLQJ Super.BaseClassMethodName();
60
Comp-U-Learn
OOPs In Java
Recursion 5HFXUVLRQLVDJHQHUDOPHWKRGZKHUHE\DIXQFWLRQFDOOVLWVHOILQDUHSHDWHGIDVKLRQ7KLVFRXOG EH H[SODLQHG DV D UHFXUVLYH PHWKRG UHSHDWHGO\ FDOOLQJ LWVHOI XQWLO D VSHFLILF FULWHULRQ LV PHW :KHQ WKH FRQGLWLRQ EHFRPHV IDOVH WKH UHFXUVLRQ WHUPLQDWHV 7KHUH DUH DFWXDOO\ WZR W\SHV RI UHFXUVLRQSRVVLEOH 'LUHFW5HFXUVLRQ +HUHWKHVXESURJUDPVFDOOVRQO\LWVHOI ,QGLUHFW5HFXUVLRQ +HUHDVXESURJUDPFDOOVDQRWKHUVXESURJUDPZKLFKLQWXUQFDOOVWKHILUVW VXESURJUDP Example 3.11 Direct Recursion Static int recu(int x) { if (x=1) return x; else return x * recursion(x-1); } Indirect Recursion Static int even (int x) { if )x=0) return true; else return odd(x-1); } static int odd(int x) { if(x=0) return false; else return even(x-1); }
Accessor and Mutator Methods
0HWKRGV WKDW FKDQJH LQVWDQFH ILHOGV DUH FDOOHG PXWDWRU PHWKRGV DQG WKRVH WKDW ZLOO DFFHVV LQVWDQFH ILHOGV ZLWKRXW PRGLI\LQJ WKHP DUH FDOOHG DFFHVVRU PHWKRGV 7KH FRQYHQWLRQ XVHG LQ -DYDLVWRXVHWKHORZHUFDVHSUHIL[JHWIRUDFFHVVRUPHWKRGVDQGVHWIRUPXWDWRUPHWKRGV
Comp-U-Learn
61
Java Programming I
Example of Accessor methods are as follows : int getDate() int getMonth() int getYear()
Example of Mutator methods are as follows : void setDate(int) void setMonth(int) void setYear(int)
Message Communication
$QREMHFWRULHQWHGSURJUDPFRQVLVWVRIDVHWRIREMHFWVWKDWFRPPXQLFDWHZLWKHDFKRWKHU7KH SURFHVV RI SURJUDPPLQJ LQ DQ REMHFWRULHQWHG ODQJXDJH WKHUHIRUH LQYROYHV WKH IROORZLQJ EDVLF VWHSV &UHDWLQJFODVVHVWKDWGHILQHREMHFWVDQGWKHLUEHKDYLRU &UHDWLQJREMHFWVIURPFODVVGHILQLWLRQV (VWDEOLVKLQJFRPPXQLFDWLRQDPRQJREMHFWV $PHVVDJHIRUDQREMHFWLVDUHTXHVWIRUH[HFXWLRQRIDSURFHGXUHDQGWKHUHIRUHZLOOLQYRNHD IXQFWLRQ SURFHGXUH LQ WKH UHFHLYLQJ REMHFW WKDW JHQHUDWHV WKH GHVLUHG UHVXOW 0HVVDJH SDVVLQJ LQYROYHV VSHFLI\LQJ WKH QDPH RI WKH REMHFW WKH QDPH RI WKH IXQFWLRQ PHVVDJH DQG WKH LQIRUPDWLRQWREHVHQW
Note Message passing supports all possible interactions between objects. Objects that send and receive messages need not be in the same process or even in the same machine
Advantages of OOPS in Java 7KURXJKLQKHULWDQFHZHFDQHOLPLQDWHUHGXQGDQWFRGHDQGH[WHQGWKHXVHRIH[LVWLQJFODVVHV :HFDQPDNHXVHRIWKHH[LVWLQJPRGXOHVWREXLOGRWKHUSURJUDPVLIWKH\ZDQWWRFRPPXQLFDWH ZLWKRQHDQRWKHUUDWKHUWKDQGHYHORSLQJWKHPRGXOHIURPWKHVFUDWFK 7KH SULQFLSOH RI GDWD KLGLQJ KHOSV WKH SURJUDPPHU WR EXLOG VHFXUH SURJUDPV WKDW FDQQRW EH WDPSHUHGE\RWKHUSURJUDPVRUHYHQWKHRWKHUFRGHLQWKHVDPHSURJUDP 62
Comp-U-Learn
OOPs In Java
,WLVSRVVLEOHWRKDYHPXOWLSOHLQVWDQFHVRIDQREMHFWWRFRH[LVWZLWKRXWDQ\LQWHUIHUHQFH ,WLVHDV\WRSDUWLWLRQWKHZRUNLQDSURMHFWEDVHGRQSURMHFWV 2EMHFWRULHQWHGV\VWHPVFDQEHHDVLO\XSJUDGHGIURPVPDOOWRODUJHV\VWHPV 0HVVDJH SDVVLQJ WHFKQLTXHV IRU FRPPXQLFDWLRQ EHWZHHQ REMHFWV PDNHV WKH LQWHUIDFH GHVFULSWLRQVZLWKH[WHUQDOV\VWHPVPXFKVLPSOHU $OOFODVVHVDQGREMHFWVWKHUHRIFDQEHWUHDWHGDVVHSDUDWHPRGXOHV7KLVPDNHVGHVLJQLQJVLPSOHU ,QKHULWDQFHHQDEOHVXVLQUHXVDELOLW\RIDFRGH 7KHVRIWZDUHV\VWHPEDVHGRQ223LVFORVHWRUHDOZRUOGDQGKHQFHVLPSOHWRXQGHUVWDQG Summary In this session, we learnt basic concepts, advantages and features of OOP. We are able to apprise the traditional programming model with the Object oriented approach. The application of OOP in Java, the concept of super and sub classes tries to bring forth inheritance in Java. Also the usage of the various modifiers like public, private, abstract, final, static, volatile, transient will enable the programmer to achieve an absolute proficiency and have an concrete knowledge of OOP. The garbage collection in Java frees the programmer from worrying about the pains of memory leakage.
Going Over It Again I. Fill in the Blanks
$FODVVFRQWDLQVBBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBVSHFLILHUSUHYHQWVLQKHULWDQFHLQ-DYD BBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBBBBBBBBBBBDUHWKHWZRNLQGVRIDEVWUDFWLRQ 7KHBBBBBBBBLVXVHGWRLQLWLDOL]HDQGDOORFDWHPHPRU\WRWKHREMHFWV BBBBBBBBBBBBBBBBBLVWKHXQLYHUVDOVXSHUFODVVLQ-DYDIRUDOOREMHFWV 7KHWZRW\SHVRIUHFXUVLRQDUHBBBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBBBBBBBBBBBB
Comp-U-Learn
63
Java Programming I II. State True or False
7KHWUDGLWLRQDOPRGHOGRHVQRWVLPXODWHUHDOZRUOGSUREOHPV -DYDVXSSRUWVPXOWLSOHLQKHULWDQFH &RQVWUXFWRUVDUHLQYRNHGDWWKHHQGRIWKHFODVV 7KHPHWKRGWR6WULQJ LVDYDLODEOHLQWKH'DWHFODVV 3ULYDWHDFFHVVVSHFLILHGGDWDDQGPHWKRGVFDQEHDFFHVVHGDQ\ZKHUHLQWKHSDFNDJH III. One line Answers
'HILQHLQKHULWDQFH :KDWLVSRO\PRUSKLVP" 'HILQHUHFXUVLRQ %ULHIO\H[SODLQWKHXVDJHRIVXSHUPHWKRG ([SODLQSUHFLVHO\WKHQHHGIRUILQDOL]HPHWKRG %ULHIO\GHVFULEHWKHJDUEDJHFROOHFWRULQ-DYD :KDWLVIXQFWLRQRYHUORDGLQJ"
64
Comp-U-Learn
Session 4
Interfaces and Packages
On Completion of this Session We will be able to understand...
) Introduction to Interfaces ) Implementing the Interfaces ) Cloneable Interface ) About Inner classes ) Importance of packages ) Creating packages ) Access Protection ) Overview of Java Built in Packages
In This Session...
Introduction to Interfaces
What is an interface?
Intricacies in an Interface
Interface References
Extending the Interface
The Cloneable Interface
Inner Classes
Packages
Need for Packages
CLASSPATH Variable
Access Protection
Overview of Java Built-in Packages
Interfaces and Packages
Introduction to Interfaces ,QWKHHDUOLHUVHVVLRQVZHIRXQGWKDWZHFDQFUHDWHVXEFODVVHVLQ-DYDE\H[WHQGLQJDQDOUHDG\ GHILQHG FODVV ,Q -DYD PXOWLSOH LQKHULWDQFH LV QRW SRVVLEOH 8VLQJ WKH NH\ZRUG H[WHQGV LW LV SRVVLEOHWRLQKHULWWKHSURSHUWLHVRIMXVWDFODVVRQO\7KHUHPD\EHVRPHFLUFXPVWDQFHVZKLFK UHTXLUHWKHSURSHUWLHVRIWZRFODVVHVWREHLQKHULWHG /HW XV WDNH DQ H[DPSOH &RQVLGHU D FODVV FDOOHG FRRUGLQDWH ZKLFK WDONV DERXW [ DQG \ FRRUGLQDWHV RI SRLQWV DQG D FODVV FDOOHG SURSHUWLHV WKDW WDONV DERXW WKH IRUHJURXQG DQG EDFNJURXQGFRORUVXVHGWRGUDZVKDSHV1RZLIZHZDQWWRGHILQHVRPHJHRPHWULFILJXUHVD\ VTXDUHZHZRXOGQDWXUDOO\OLNHWRWDONDERXWLWVFRRUGLQDWHVDVZHOODVFRORUV6RLWLVUHTXLUHGWR LQKHULW IURP ERWK WKHVH FODVVHV $Q DOWHUQDWH ZD\ RI LPSOHPHQWLQJ WKH PHWKRG RI D GLIIHUHQW FODVVLVWKURXJKDQLQWHUIDFH7KLVVHVVLRQSURYLGHVDQRYHUYLHZRILQWHUIDFHV
What is an interface? $Q LQWHUIDFH LV YHU\ PXFK OLNH D FODVV ZLWK FRQVWDQW YDOXHV DQG PHWKRG GHFODUDWLRQV 7KH GLIIHUHQFHLVWKDWPHWKRGVLQDQLQWHUIDFHDUHRQO\GHFODUHGEXWQRWLPSOHPHQWHG$QLQWHUIDFHLV H[DFWO\ OLNH D FODVV EXW ZLWK WKH NH\ZRUG FODVV EHLQJ UHSODFHG E\ WKH NH\ZRUG LQWHUIDFH $Q LQWHUIDFH LV VLPLODU WR DQ DEVWUDFW FODVV ZLWK D UHVWULFWLRQ WKDW DOO PHWKRGV LQ DQ LQWHUIDFH DUH DEVWUDFW7KHIROORZLQJH[DPSOHH[SODLQVGHFODUDWLRQRIDQLQWHUIDFH interface ExampleInterface { void xx(); // abstract by default; no body void yy(); }
7KH DERYH H[DPSOH VXJJHVWV WKDW WKHUH DUH WZR SDUWV LQ DQ LQWHUIDFH WKH LQWHUIDFH GHFODUDWLRQ DQG WKH LQWHUIDFH ERG\ 7KH GHFODUDWLRQ SDUW FRQVLVWV RI QDPH RI WKH LQWHUIDFH DQG ZKHWKHU LW LQKHULWV IURP DQ\ RWKHU LQWHUIDFH 7KH LQWHUIDFH ERG\ FRQVLVWV RI WKH FRQVWDQW YDOXHV LQ WKH LQWHUIDFHDQGWKHGHFODUDWLRQRIWKHPHWKRGVRIWKHLQWHUIDFH1RZWRXVHWKHLQWHUIDFHDFODVV PXVWLPSOHPHQWWKHFRUUHVSRQGLQJDEVWUDFWIXQFWLRQV:HPD\GHILQHDFODVVFDOOHGVRPHDV public class some implements ExampleInterface { void xx(); // write the code here void yy(); // write the code here7 }
Comp-U-Learn
67
Java Programming I
+HUHWKHFODVVVRPHFDQLPSOHPHQWPRUHWKDQRQHLQWHUIDFHEXWLWFDQQRWH[WHQGPRUHWKDQRQH FODVV,Q-DYDDQLQWHUIDFHLVDUHIHUHQFHGDWDW\SHDQGDVVXFKFDQEHXVHGLQDOOSODFHVZKHUHD W\SHFDQEHXVHG:HZLOOVHHWKLVLQGHWDLOXQGHUWKHKHDGLQJ´8VLQJDQ,QWHUIDFHDVD7\SHµ
Intricacies in an Interface ,QWHUIDFHV DUH XVHG WR GHILQH D SURWRFRO RI EHKDYLRU WKDW FDQ EH LPSOHPHQWHG E\ DQ\ FODVV DQ\ZKHUH LQ WKH FODVV KLHUDUFK\ /HW XV WU\ WR GLIIHUHQWLDWH EHWZHHQ LQWHUIDFHV DQG DEVWUDFW FODVVHV$EVWUDFWFODVVHVDUHXVHGRQO\ZKHQWKH\DUHVXSHUFODVVHVDQGWKHVXEFODVVHVLPSOHPHQW WKHPHWKRGV
Note In the case of interfaces, the methods can be implemented even by classes, which are not inherited. 2IWHQLQWHUIDFHVDUHWKRXJKWRIDVDQDOWHUQDWLYHWRPXOWLSOHFODVVLQKHULWDQFH:KLOHLQWHUIDFHV PD\VROYHVRPHRIWKHVDPHSUREOHPVWKDWPXOWLSOHFODVVLQKHULWDQFHGRWKH\DUHTXLWHGLIIHUHQW ,QSDUWLFXODU ♦ We cannot inherit variables from an interface ♦ We cannot inherit method implementations from an interface. ♦ The interface hierarchy is independent of the class hierarchy- classes that implement the same interface may or may not be related through the class hierarchy. This is not true for multiple inheritance. 7KHVWUHQJWKRIWKHLQWHUIDFHOLHVLQWKHIDFWWKDWDQXQUHODWHGFODVVZKLFKGRHVQRWEHORQJWRWKH KLHUDUFK\ FDQ LPSOHPHQW WKH PHWKRGV RI DQ LQWHUIDFH 7KHUHIRUH LQKHULWDQFH GRHV QRW WDNH SODFHLQWKLVFRQFHSW+HUHLVDQH[DPSOHWKDWWHOOVPRUHDERXWDQLQWHUIDFH Example 4.1 interface one { public void xx(); } interface two extends { public void yy(); }
one
class cl1 implements one { public void xx() {
68
Comp-U-Learn
Interfaces and Packages System.out.println(“The function xx of class cl1 implements interface one“); } public void yy() { System.out.println(“Original yy in class but not in interface “); } } class cl2 implements two { public void xx() { System.out.println(“The function xx of class cl2 implements interface two “); } public void yy() { System.out.println(“The function yy of class cl2 implements interface two “); } }
$QLQWHUIDFHFDQH[WHQGDQRWKHULQWHUIDFH OLNHWZRH[WHQGVRQHDQGKDVWZRPHWKRGV[[DQG\\ EXW DQ LQWHUIDFH FDQQRW H[WHQG D FODVV DQG D FODVV FDQQRW H[WHQG DQ LQWHUIDFH D FODVV FDQ LPSOHPHQWDQLQWHUIDFH $FODVVFDQMXVWLPSOHPHQWDOOPHWKRGVRIDQLQWHUIDFH FOLPSOHPHQWV WZR RULWFDQKDYHLWVRZQPHWKRGVDOVRLQDGGLWLRQWRWKHPHWKRGVRIWKHLQWHUIDFH FOKDVLWV RZQPHWKRG\\ZKLFKLVQRWDPHWKRGRIWKHLQWHUIDFHRQH
Note All methods in an interface are always public, static, final and abstract; even if we do not use the word public, they are public in one and two above. But for their implementations within a class, omitting the word public creates problems. An interface can extend multiple interfaces. 7KHVWHSVLQYROYHGLQFUHDWLQJDQLQWHUIDFHDUH 'HFODUHWKHLQWHUIDFH $GGDEVWUDFWPHWKRGVWRWKHLQWHUIDFHERG\ 6DYHWKHILOHZLWKDMDYDH[WHQVLRQ &RPSLOHWKHLQWHUIDFHFUHDWHG 7KHVWHSVLQYROYHGLQLPSOHPHQWLQJDQLQWHUIDFHDUH 'HFODUHWKHFODVVDQGXVHWKHLPSOHPHQWNH\ZRUGIROORZHGE\WKHQDPHRIWKHLQWHUIDFH ,PSOHPHQWHYHU\DEVWUDFWPHWKRGWKDWKDVEHHQGHFODUHGZKLOHFUHDWLQJWKHLQWHUIDFH 6DYHWKHILOHZLWKDMDYDH[WHQVLRQ &RPSLOHWKHDSSOHWRUDSSOLFDWLRQFUHDWHG
Comp-U-Learn
69
Java Programming I
7KH IROORZLQJ DUH VRPH RI WKH JXLGHOLQHV WR EH IROORZHG ZKLOH FUHDWLQJ DQG LPSOHPHQWLQJ LQWHUIDFHV ♦ An interface can be declared as public, whereby it can be implemented even outside a package. ♦ An interface cannot be considered a substitute for multiple inheritance, which is not supported by Java. ♦ While declaring members in an interface, we may not use the private and protected access specifiers. ♦ Constants declared in an interface are implicitly public, static and final. ♦ All methods declared in an interface are implicitly public and abstract. ♦ A class can implement as many interfaces as required with each interface name being separated by a comma(,).
Note If the parent class already implements an interface, its subclasses do not need to explicitly use the implement keyword. $VDPSOHSURJUDPWRVKRZWKHZRUNLQJRIDQLQWHUIDFH Example 4.2 package Display; public interface DisplayInterface { public String GetDlsplayText(); //no implementation of this method } // This applet implements the method declared in the interface import java.awt.*; import java.applet.*; import java.lang.*; import Display.DisplayInterface; public class ex13 extends Applet implements DisplayInterface { public void paint(Graphics g) { String str=GetDisplayText(); g.drawString(str,80,100); } public String GetDisplayText() { return " Display Text "; } }
70
Comp-U-Learn
Interfaces and Packages
Note Member declarations in an interface disallow some of the use of declaration modifiers and discourage the use of others. We may not use transient, volatile or synchronized in a member declaration in an interface. Also, we may not use the private and protected specifiers when declaring members of an interface.
Interface References :HFDQGHFODUHYDULDEOHVDVREMHFWUHIHUHQFHVWKDWXVHDQLQWHUIDFHUDWKHUWKDQDFODVVW\SH$Q\ LQVWDQFHRIDFODVVWKDWLPSOHPHQWVWKHGHFODUHGLQWHUIDFHFDQEHVWRUHGLQVXFKDYDULDEOH:KHQ ZHFDOODPHWKRGWKURXJKRQHRIWKHVHUHIHUHQFHVWKHFRUUHFWYHUVLRQZLOOEHFDOOHGEDVHGRQWKH DFWXDOLQVWDQFHRIWKHLQWHUIDFHEHLQJUHIHUUHGWR7KLVLVRQHRIWKHNH\IHDWXUHVRILQWHUIDFHV 7KHPHWKRGWREHH[HFXWHGLVORRNHGXSG\QDPLFDOO\DWUXQWLPHDOORZLQJFODVVHVWREHFUHDWHG ODWHU WKDQ WKH FRGH ZKLFK FDOOV PHWKRGV RQ WKHP 7KH FDOOLQJ FRGH FDQ GLVSDWFK WKURXJK DQ LQWHUIDFHZLWKRXWKDYLQJWRNQRZDQ\WKLQJDERXWWKHFDOOHGFRGH Example 4.3 interface Iface { void callfn(int i); } class One implements Iface { public void callfn(int a) { System.out.println(“Calling the callfn with “ + a); } } class Two implements Iface { public void callfn(int a) { System.out.println(“Call from class two of method of callfn”); System.out.println(“a squared is “ + (a * a)); } } class ex12 { public static void main(String args[]) { Iface i=new One(); Two j=new Two(); i.callfn(100);
Comp-U-Learn
71
Java Programming I i=j; i.callfn(100); } }
Extending the Interface $QLQWHUIDFHFDQLQKHULWDQRWKHUE\XVHRIWKHNH\ZRUGH[WHQGV7KHV\QWD[LVWKHVDPHDVIRU LQKHULWLQJFODVVHV:KHQDFODVVLPSOHPHQWVDQLQWHUIDFHWKDWLQKHULWVDQRWKHULQWHUIDFHLWPXVW SURYLGHLPSOHPHQWDWLRQVIRUDOOPHWKRGVGHILQHGZLWKLQWKHLQWHUIDFHLQKHULWDQFHFKDLQ7KLVFDQ EHLOOXVWUDWHGWKURXJKDQH[DPSOH Example 4.4 interface A { void meth1(); void meth2(); } interface B extends A { void meth3(); } class cl1 implements B { public void meth1() { System.out.println(“implementing method 1 in Interface A”); } public void meth2() { System.out.println(“implementing method 2 in Interface A”); } public void meth3() { System.out.println(“implementing method 3 in Interface B”); } } class ex14 { public static void main(String args[]) { cl1 obj=new cl1(); obj.meth1(); obj.meth2(); obj.meth3(); } }
72
Comp-U-Learn
Interfaces and Packages
$VDQH[SHULPHQWZKHQZHWU\WRUHPRYHWKHLPSOHPHQWDWLRQIRUPHWKRGPHWK LQWKHFODVV FO LW ZLOO FDXVH D FRPSLODWLRQ HUURU EHFDXVH DQ\ FODVV WKDW LPSOHPHQWV DQ LQWHUIDFH PXVW LPSOHPHQWDOOPHWKRGVGHILQHGE\WKDWLQWHUIDFH
The Cloneable Interface :KHQ ZH PDNH D FRS\ RI WKH YDULDEOH WKH RULJLQDO DQG WKH FRS\ DUH UHIHUHQFHV WR WKH VDPH REMHFW7KLVPHDQVDFKDQJHWRHLWKHUYDULDEOHDOVRDIIHFWVWKHRWKHU Day Bday=new Day(1998,8,16); Day d=Bday; d.advance(100); //Oops will also change Bday
7KLVLVGHSLFWHGEHORZ
Bday
Day
D
Day 16 Month 8 Year 1998
Fig. 4.1 ,IZHZRXOGOLNH'WREHDQHZREMHFWWKDWEHJLQVLWVOLIHEHLQJLGHQWLFDOWR%GD\EXWZKRVHVWDWH FDQGLYHUJHRYHUWLPHWKHQZHXVHWKHFORQH PHWKRG Day Bday=new Bday(1998,8,16); Day d=(Day)Bday.clone(); // must cast because clone() returns an Object d.advance(100); //Bday will not be changed.
7KHFORQHPHWKRGLVDSURWHFWHGPHWKRGRI2EMHFWZKLFKPHDQVWKDWRXUFRGHFDQQRWVLPSO\ FDOO LW 7KH FORQH PHWKRG LV LPSOHPHQWHG WKURXJK WKH &ORQHDEOH LQWHUIDFH 7KH FORQH PHWKRG ZLOOPDNHDELWZLVHFRS\RIWKHFODVV·VREMHFWV
Comp-U-Learn
73
Java Programming I
Day
Bday
Day 16 Month 8 Year 1998
Day
D
Day 16 Month 8 Year 1998
Fig. 4.2
Inner Classes $QLQQHUFODVVLVDFODVVWKDWLVGHILQHGLQVLGHDQRWKHUFODVV7KHQHHGIRULQQHUFODVVHVFDQEH VWDWHGDVIROORZV ♦ An object of an inner class can access the implementation of the object that created it – including data that would otherwise be private. ♦ Inner classes can be hidden from other classes in the same package. ♦ Anonymous inner classes are handy when we want to define callbacks on the fly. ♦ Inner classes are very convenient when we are writing event-driven programs. Example 4.5 class LinkedList { ............ ............. ................... private: class Node
74
Comp-U-Learn
Interfaces and Packages { public Node *Next; int data; } class Iterator { public : void insert(int x); int erase(); } ................. }
+HUH WKH /LQNHG /LVW FODVV LV WKH RXWHU FODVV DQG WKH FODVVHV 1RGH DQG ,WHUWRU DUH WZR LQQHU FODVVHV 1RWH WKDW WKH H[DPSOH VKRZQ DERYH LV ZULWWHQ LQ & 7KLV LV MXVW WR VKRZ WKH VLPLODULWLHVDQGWKHGLIIHUHQFHEHWZHHQ-DYDDQG&
Note An object that comes from an inner class has an implicit reference to the outer class object that instantiated it. Through this pointer, it gains access to the total state of the outer object. A static inner class can be used whenever the inner class does not need to access an outer class.
Packages ,Q-DYDHYHU\WKLQJLVGHVFULEHGLQWHUPVRIFODVVHVDQGVRWKHQXPEHURIFODVVHVXVHGE\DVLQJOH SURJUDPLVYHU\ODUJH7KHUHIRUHLWEHFRPHVLQHYLWDEOHWRSURSHUO\RUJDQL]HWKHVHFODVVHVIURP WKH SRLQW RI WKHLU UHXVDELOLW\ LQ PXOWLSOH SURJUDPV -DYD SURYLGHV VXFK D IDFLOLW\ WKURXJK SDFNDJHV $ SDFNDJH LV D JURXS RI FODVVHV ,W FRXOG EH FRPSDUHG WR WKH OLEUDULHV RIIHUHG E\ SURJUDPPLQJ ODQJXDJHV OLNH & DQG & 7KH FODVVHV RIIHUHG E\ -DYD DUH RUJDQL]HG LQWR SDFNDJHVZKLFKPD\EHLPSRUWHGLQDQDSSOLFDWLRQZLWKWKHLPSRUWVWDWHPHQWDVLOOXVWUDWHGLQ WKHH[DPSOHEHORZ import java.awt.*; import java.applet.*; import java.awt.Button;
%\UXOHHYHU\FODVVLQ-DYDEHORQJVWRVRPHSDFNDJH,IZHGRQ·WPHQWLRQDERXWDSDFNDJHWKH FRPSLOHUDVVXPHVWKDWZHDUHSXWWLQJWKHFODVVHVLQWKHGHIDXOWSDFNDJH7KLVGHIDXOWSDFNDJHKDV QRQDPHLQ-DYD
Comp-U-Learn
75
Java Programming I
Need for Packages /HW XV VHH WKH QHHG IRU SDFNDJHV EHIRUH WU\LQJ WR GHILQH D SDFNDJH ,I WKH FRQFHSW RI LPSRUW VWDWHPHQWGRHVQRWH[LVWLQ-DYDZHDQGKDGWRIRUH[DPSOHFUHDWHD%XWWRQREMHFWZHZRXOG KDYHWRVD\ java.awt.Button MyButton=new java.awt.Button(“sample”);
7KLVLVDYHU\WHGLRXVZD\RIFUHDWLQJD%XWWRQZLWKWKHDGGLWLRQDORYHUORDGRIQHHGLQJWRNQRZ WKHIXOO\TXDOLILHGQDPHVZKHQUHIHUULQJWRDFODVVRI-DYD7KHVDPHWKLQJFRXOGEHDSSURDFKHG LQDVWUDLJKWIRUZDUGPDQQHU import java.awt.button; ............................................. ............................................. Button MyButton = new Button(“sample”);;
7RFUHDWHSDFNDJHVVLPSO\LQFOXGHDSDFNDJHFRPPDQGDVWKHILUVWVWDWHPHQWLQD-DYDVRXUFH ILOH $Q\ FODVV GHFODUHG ZLWKLQ WKDW ILOH ZLOO EHORQJ WR WKH VSHFLILHG SDFNDJH 7KH SDFNDJH VWDWHPHQWGHILQHVDQDPHVSDFHLQZKLFKFODVVHVDUHVWRUHG,IZHRPLWWKHSDFNDJHVWDWHPHQW WKHQWKHFODVVQDPHVDUHSXWLQWRDGHIDXOWSDFNDJHZKLFKKDVQRQDPH$WWKHEHJLQQLQJRIWKH FODVVGHFODUDWLRQDGGWKHIROORZLQJFRGH package Packagename;
Example package pkg;
+HUH SNJ LV WKH QDPH RI WKH SDFNDJH -DYD XVHV ILOH V\VWHP GLUHFWRULHV WR VWRUH SDFNDJHV )RU H[DPSOHWKHFODVVILOHVIRUDQ\FODVVHVWKDWDUHGHFODUHGWREHSDUWRIWKHSDFNDJHSNJPXVWEH VWRUHGLQDGLUHFWRU\FDOOHGSNJ0RUHWKDQRQHILOHFDQLQFOXGHWKHVDPHSDFNDJHVWDWHPHQW7KH SDFNDJHVWDWHPHQWVLPSO\VSHFLILHVWRZKLFKSDFNDJHVWKHFODVVHVGHILQHGLQDILOHEHORQJ Creation of a Package The following are the steps involved in the creation of a package
,GHQWLI\WKHKLHUDUFK\LQZKLFKZHZRXOGOLNHWRSODFHWKHFODVVILOHV &UHDWHDGLUHFWRU\ZKLFKKDVWKHVDPHQDPHDVWKDWRIWKHSDFNDJH ,QFOXGHSDFNDJHVWDWHPHQWDORQJWKHSDFNDJHQDPHDVWKHILUVWVWDWHPHQWLQWKHSURJUDP 'HFODUHWKHFODVVHVUHTXLUHGLQWKHSDFNDJH
76
Comp-U-Learn
Interfaces and Packages
6DYHWKHILOHQRZZLWKWKHQDPHRIWKHFODVVDORQJZLWKMDYDH[WHQVLRQ &RPSLOHWKHILOHXVLQJMDYDFWRFUHDWHWKHFODVVILOHLQWKHVDPHGLUHFWRU\ LHWKHGLUHFWRU\WKDW KDVWKHQDPHRIWKHSDFNDJH ([HFXWHWKHFODVVILOH
CLASSPATH Variable :KHQZHDUHZULWLQJVPDOOSURJUDPVLWGRHVQRWPDWWHULIWKHSDFNDJHQDPHLVQRWPHQWLRQHG %HFDXVHLWZLOOEHLQWKHGHIDXOWSDFNDJH-DYDFRPSLOHUDQGLQWHUSUHWHUVHDUFKHVWKHFODVVILOHVLQ WKH SDWK VSHFLILHG LQ &/$663$7+ YDULDEOH 7KH FXUUHQW ZRUNLQJ GLUHFWRU\ LV E\ GHIDXOW LQFOXGHG LQ WKLV YDULDEOH +HQFH LW LV SRVVLEOH WR FRPSLOH DQG H[HFXWH ILOHV IURP WKH H[LVWLQJ FXUUHQWGLUHFWRU\,QFDVHRIFUHDWLQJDSDFNDJHLWVKRXOGEHHQVXUHGWKDWWKHURRWGLUHFWRU\RI WKHSDFNDJHLVLQFOXGHGLQWKH&/$663$7+YDULDEOH7KLVLVEHFDXVHWKHVSHFLILFORFDWLRQWKDW WKH -DYD FRPSLOHU ZLOO FRQVLGHU DV WKH URRW RI DQ\ SDFNDJH KLHUDUFK\ LV FRQWUROOHG E\ &/$663$7+ 6LQFHFODVVHVFRXOGEHDQ\ZKHUHZHPXVWLQGLFDWHWRWKH-DYDLQWHUSUHWHUZKHUHLWFDQILQGWKH FODVVHVWKDWZHDUHWU\LQJWRUXQ7KLVLVGRQHWKURXJKWKH&/$663$7+HQYLURQPHQWYDULDEOH 7KH&/$663$7+YDULDEOHFRPSULVHVDOLVWRIGLUHFWRU\QDPHVWKDWFRQWDLQ-DYDFRPSLOHG-DYD FODVVHV 7KH DFWXDO FRQVWUXFW RI &/$663$7+ GHSHQGV RQ WKH V\VWHP ZH DUH UXQQLQJ 7KH FODVVHV LQFOXGHG ZLWK WKH -DYD GHYHORSPHQW HQYLURQPHQW DUH DXWRPDWLFDOO\ DYDLODEOH WR XV EHFDXVHWKHLQWHUSUHWHUDXWRPDWLFDOO\DSSHQGVWKHFRUUHFWGLUHFWRU\WRRXU&/$663$7+ZKHQLW VWDUWVXS Snapshot on Packages
♦ As default, every class belongs to some package in Java. ♦ A package statement before the class statement is necessary. ♦ Two or more packages can be grouped. This creates a hierarchy of packages. ♦ Package hierarchy is denoted by writing the dot (.) after every level; aaa.bbb.ccc means that the package ccc is in the bbb package which is in the aaa package. ♦ Java restriction is that we should keep the packages/classes into corresponding directories/files. ♦ It is possible to create a class called cla in ccc as well as in bbb or in ttt. There is no conflict; they actually have different full names to be qualified. ♦ A package can contain only one public class.
Comp-U-Learn
77
Java Programming I
Example 4.6 package mainpack; public class Class1 { public static void meth1() { System.out.println(“Hello Friends”); } }
&UHDWHDGLUHFWRU\FDOOHGPDLQSDFNXQGHUELQDQGVDYHWKLVILOHDV&ODVVMDYD package mainpack.child; public class Class2 { public static void meth2() { System.out.println(“Good Bye Friends”); } }
1RZFUHDWHDVXEGLUHFWRU\FDOOHGFKLOGXQGHUWKHGLUHFWRU\PDLQSDFN6DYHWKLVILOHDV&ODVVMDYD LQWKHVXEGLUHFWRU\FKLOG1RZXQGHUELQGLUHFWRU\RSHQDQHZILOHDQGZULWHWKHIROORZLQJFRGH import mainpack.*; import mainpack.child.*; class ex14 { public static void main(String args[]) { Class1.meth1(); Class2.meth2(); } }
6DYHWKLVILOHDVH[MDYDFRPSLOHXVLQJMDYDFDQGH[HFXWHWKHFODVVILOH
Note The star form may increase compilation time especially if we import several large packages. For this reason it is a good idea to explicitly name the classes that we want to use rather importing whole packages. $OORIWKHVWDQGDUG-DYDFODVVHVLQFOXGHGZLWK-DYDDUHVWRUHGLQDSDFNDJHFDOOHGMDYD7KHEDVLF ODQJXDJHIXQFWLRQVDUHVWRUHGLQDSDFNDJHLQVLGHRIWKHMDYDSDFNDJHFDOOHGMDYDODQJ1RUPDOO\ ZHKDYHWRLPSRUWHYHU\SDFNDJHRUFODVVWKDWZHZDQWWRXVHEXWVLQFH-DYDLVXVHOHVVZLWKRXW PXFKRIWKHIXQFWLRQDOLW\LQMDYDODQJWKHFRPSLOHUIRUDOOSURJUDPVLPSOLFLWO\LPSRUWVLW
78
Comp-U-Learn
Interfaces and Packages
Access Protection &ODVVHVDQGSDFNDJHVDUHERWKPHDQVRIHQFDSVXODWLQJDQGFRQWDLQLQJWKHQDPHVSDFHDQGVFRSH RI YDULDEOHV DQG PHWKRGV 3DFNDJHV DFW DV FRQWDLQHUV IRU FODVVHV DQG RWKHU VXERUGLQDWH SDFNDJHV &ODVVHV DFW DV FRQWDLQHUV IRU GDWD DQG FRGH 7KH FODVV LV -DYD·V VPDOOHVW XQLW RI DEVWUDFWLRQ %HFDXVH RI WKH LQWHUSOD\ EHWZHHQ FODVVHV DQG SDFNDJHV -DYD DGGUHVVHV IRXU FDWHJRULHVRIYLVLELOLW\IRUFODVVPHPEHUV ♦ ♦ ♦ ♦
Subclasses in the same package Non subclasses in the same package Sub classes in different packages Classes that are neither in the same package nor subclasses
7KHWKUHHDFFHVVVSHFLILHUVSULYDWHSXEOLFDQGSURWHFWHGSURYLGHDYDULHW\RIZD\VWRSURGXFH WKHPDQ\OHYHOVRIDFFHVVUHTXLUHGE\WKHVHFDWHJRULHV7KHIROORZLQJWDEOHVKRZVWKHXVDJHRI YDULRXVDFFHVVVSHFLILHUVDQGWKHLUVFRSHLQWKHSDFNDJHV Description Same class Same package Subclass Same package Non subclass Different package Sub class Different package Non Sub class
Private Yes No No
No modifier Yes Yes Yes
Protected Yes Yes Yes
Public Yes Yes Yes
No
No
Yes
Yes
No
No
Yes
Yes
$FODVVKDVRQO\WZRSRVVLEOHDFFHVVOHYHOV GHIDXOWDQGSXEOLF:KHQDFODVVLVGHFODUHGDVSXEOLF LWLVDFFHVVLEOHE\DQ\RWKHUFRGH,IDFODVVKDVGHIDXOWDFFHVVWKHQLWFDQRQO\EHDFFHVVHGE\ RWKHUFRGHZLWKLQLWVVDPHSDFNDJH Access Control Rules
$OOWKHFODVVHVDUHSXWLQWRWKHVHFDWHJRULHV This class (T). Subclasses of this class in the same package (SP) Non subclasses of this class in the same package (NP) Subclasses of this class in the other package (SO) Non subclasses of this class in other packages (NO) As the access attributes, Java provides these five alternatives
Comp-U-Learn
79
Java Programming I
1RQH QRWVSHFLI\LQJDQ\WKLQJ Private Public Private protected Protected 7KHUXOHVIRUXVLQJWKHVHDWWULEXWHVDUHDVIROORZV ,I ZH GRQ·W VSHFLI\ DQ\WKLQJ WKLV FODVV DQG WKH GDWDPHWKRGV GHILQHG LQVLGH LW DUH YLVLEOH DFFHVVLEOH WKURXJKRXWWKHSDFNDJHFRQWDLQLQJWKLVFODVV YLVLEOHDFFHVVLEOHWR76313 ,IZHGHFODUHVRPHWKLQJ WKLVFODVVRUWKHGDWDPHWKRGVGHILQHGLQVLGHLW DVSULYDWHLWLVYLVLEOH DFFHVVLEOH RQO\ LQ WKLV FODVV YLVLEOH WR 7 7KH ZRUG SULYDWH LV JHQHUDOO\ XVHG IRU KLGLQJ LQIRUPDWLRQIURPRWKHUFODVVHV ,IZHGHFODUHVRPHWKLQJDVSULYDWHSURWHFWHGLWLVYLVLEOH DFFHVVLEOH LQVLGHDOOWKHVXEFODVVHVLQ WKLVSDFNDJHDVZHOODVLQRWKHUSDFNDJHV YLVLEOHWR76362 ,I ZH GHFODUH VRPHWKLQJ DV SURWHFWHG LW LV YLVLEOH LQVLGH DOO FODVVHV RI WKLV SDFNDJH DQG DOVR LQVLGHWKHVXEFODVVHV RIRWKHUSDFNDJHV YLVLEOHWR 763136R ,WLVQRWYLVLEOHRQO\IRUWKH QRQVXEFODVVHVRIRWKHUSDFNDJHV QRWYLVLEOHWR12 ,IZHGHILQHVRPHWKLQJSXEOLFLWLVYLVLEOHHYHU\ZKHUH YLVLEOHWR763136212
Overview of Java Built-in Packages 7KH-'.$3,FRQVLVWVRISDFNDJHVDOORIZKLFKDUHLQWKH&RUH$3,2IWKH&RUH$3, SDFNDJHV DUH SDUW RI WKH -DYD )RXQGDWLRQ &ODVVHV -)& 7KH &RUH $3, JUHZ VLJQLILFDQWO\ IURP-'.WR2IWKH&RUH$3,SDFNDJHVWKDWZHUHDUHDGGHGLQ-'. DUHLQ WKH-)&6ZLQJDQG 1RQVZLQJ DUH-DYD,'/ &25%$DQG&RV1DPLQJ DUHVHFXULW\ DUH XWLOLW\ SDFNDJHV -$5 DQG 0,0( VXSSRUW LV -DYD %HDQV LV 50, DQG LV 2EMHFW 5HIHUHQFHV MDYDODQJUHI 7KHEXONRIWKHQHZ-'.SDFNDJHVDUH-)&DQG&25%$ &RUH$3,SDFNDJHVDUHOLVWHGKHUHXQGHU ♦ ♦ ♦ ♦ ♦ 80
Java.applet Java.awt Java.beans Java.io Java.lang Comp-U-Learn
Interfaces and Packages
♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦
Java.math Java.net Java.rmi Java.security Java.sql Java.text Java.util Com.sun.java.swing Com.sun.java.image.codec.jpeg Com.sun.java.accessibility Org.omg.CORBA
The java.applet
7KHMDYDDSSOHWSDFNDJHLVRQHRIWKHVPDOOHVWSDFNDJHVLQWKHFRUH$3,,WFRQVLVWVRIRQHFODVV DQGWKUHHLQWHUIDFHVWKDWSURYLGHWKHEDVLFIXQFWLRQDOLW\QHHGHGWRLPSOHPHQWDSSOHWV7KHDSSOHW FODVV SURYLGHV PHWKRGV WR GLVSOD\ LPDJHV SOD\ DXGLR ILOHV UHVSRQG WR HYHQWV DQG REWDLQ LQIRUPDWLRQ DERXW DQ DSSOHW·V H[HFXWLRQ HQYLURQPHQW 7KH $SSOHW&RQWH[W LQWHUIDFH GHILQHV PHWKRGV WKDW DOORZ DQ DSSOHW WR DFFHVV WKH FRQWH[W LQ ZKLFK LW LV EHLQJ UXQ 7KH $SSOHW6WXE LQWHUIDFHVXSSRUWVFRPPXQLFDWLRQEHWZHHQDQDSSOHWDQGLWVEURZVHUHQYLURQPHQWDQGLVXVHG WR GHYHORS FXVWRP DSSOHW YLHZHUV 7KH $XGLR&OLS LQWHUIDFH SURYLGHV PHWKRGV WKDW VXSSRUW SOD\LQJDXGLRFOLSV The java.awt
7KH MDYDDZW SDFNDJH LPSOHPHQWV WKH FRUH FODVVHV DQG LQWHUIDFHV RI WKH $EVWUDFW ZLQGRZ 7RRONLW,WLVDODUJHSDFNDJHFRQWDLQLQJFODVVHVDQGLQWHUIDFHV7KHVHFODVVHVDQGLQWHUIDFHV SURYLGHWKHVWDQGDUG$:7*8,FRQWUROVDVZHOODVGUDZLQJSULQWLQJDQGRWKHUFDSDELOLWLHV The Javabeans
7KLVSDFNDJHKDVEHHQDGGHGWRVXSSRUWWKHLPSOHPHQWDWLRQIRUDEHDQFRQWDLQHUWKDWSURYLGHV DQH[HFXWLRQFRQWH[WIRUEHDQVGXULQJGHVLJQDQGUXQWLPHH[HFXWLRQ7KLVSDFNDJHFRQWDLQV FODVVHVDQGHLJKWLQWHUIDFHVWKDWSURYLGHWKHEDVLF-DYD%HDQVIXQFWLRQDOLW\ The java.io
7KLV SURYLGHV D VHW RI LQSXW DQG RXWSXW VWUHDPV XVHG WR UHDG DQG ZULWH GDWD WR ILOHV RU RWKHU LQSXWDQGRXWSXWVRXUFHV Comp-U-Learn
81
Java Programming I
The java.lang
7KHMDYDODQJSDFNDJHSURYLGHV FODVVHVDQGWKUHHLQWHUIDFHVWKDWLPSOHPHQWIXQGDPHQWDO-DYD REMHFWV %HFDXVH RI LWV LPSRUWDQFH WKH MDYDODQJ SDFNDJH LV LQFOXGHG ZLWK DOO -DYD SODWIRUPV UDQJLQJIURP(PEHGGHG-DYDWRWKHIXOOEORZQ-'. The java.math
7KH -DYDPDWK SDFNDJH SURYLGHV WZR FODVVHV %LJ'HFLPDO DQG %LJ,QWHJHU WKDW SURYLGH WKH FDSDELOLW\ WR SHUIRUP DUELWUDU\ SUHFLVLRQ DULWKPHWLF ,W SURYLGHV D OLEUDU\ RI PDWK URXWLQHV DQG YDOXHVVXFKDV3, The java.net
7KHMDYDQHWSDFNDJHKDVFODVVHVDQGILYHLQWHUIDFHVIRU7&3,3QHWZRUNSURJUDPPLQJ The java.rmi
7KH 5HPRWH 0HWKRG ,QYRFDWLRQ SDFNDJHV SURYLGH WKH FDSDELOLW\ WR XVH GLVWULEXWHG REMHFWV ZLWKLQ-DYD7KLVLVDQHZDGGLWLRQWR-'.,WVXSSRUWVSHUVLVWHQWUHPRWHREMHFWUHIHUHQFHV DQGDXWRPDWLFREMHFWDFWLYDWLRQ The java.security
7KHILYHMDYDVHFXULW\SDFNDJHVVXSSRUWLPSOHPHQWDWLRQRI-'.FRQILJXUDEOHVHFXULW\SROLF\ DQG FU\SWRJHQLF VHFXULW\ PHFKDQLVPV ,W SURYLGHV VSHFLDO VSHFLILFDWLRQV IRU WKH NH\V XVHG LQ FRPPRQFU\SWRJUDSKLFDOJRULWKPV 7KLV SDFNDJH KDV FODVVHV DQG HLJKW LQWHUIDFHV WKDW IRUP WKHIRXQGDWLRQIRUWKH6HFXULW\$3, The Swing
6ZLQJ LV D MDYD H[WHQVLRQ WR WKH $:7 WKDW SURYLGHV PDQ\ QHZ *8, FRPSRQHQWV LPSURYHPHQWVWRH[LVWLQJFRPSRQHQWVDQGWKHFDSDELOLW\WRVHOHFWIURPDYDULHW\RI*8,ORRN DQG IHHOV VXFK DV 0HWDO :LQGRZV 0RWLI DQG 0DFLQWRVK ,W SURYLGHV FODVVHV WR LPSOHPHQW ERUGHUVDQGERUGHUVW\OHVWKHWDEOHFRPSRQHQWWH[WSURFHVVLQJFRPSRQHQWV The java.utility
7KLVFRQWDLQVDFROOHFWLRQRIXWLOLW\FODVVHV$PRQJWKHPDUHWKHVHYHUDOJHQHULFGDWDVWUXFWXUHV OLNH 'LFWLRQDU\ 6WDFN 9HFWRU DQG +DVKWDEOH ,W DOVR FRQWDLQV FODVVHV WR PDQLSXODWH FDOHQGDU GDWHV7KH-DYDXWLOSDFNDJHDOVRFRQWDLQVWKH2EVHUYHULQWHUIDFHDQG2EVHUYDEOHFODVVZKLFK DOORZREMHFWVWRQRWLI\RQHDQRWKHUZKHQWKH\FKDQJH 82
Comp-U-Learn
Interfaces and Packages
Summary Interfaces are declared like classes but using the keyword interface. Interface has two parts the interface declaration and the interface body. Any class outside the hierarchy can implement interfaces. Interfaces are mainly used to draw a similarity between unrelated classes. Interfaces are not a substitute for multiple inheritance. All the methods declared in the interface are abstract. Implementing the interface results in the implementation of the methods declared in the interface. A package is a group of classes similar to the libraries offered by most programming languages. Packages help simplify programming and remove the overhead of remembering fully qualified package names to refer a class. The keyword package identifies the package. The import statement is used to import classes of a package in other programs. Some of the standard Java packages are java.applet, java.lang, java.net, java.util, java.awt and java.io.
Going Over It Again I. Fill in the Blanks
$QLQWHUIDFHLVGHFODUHGXVLQJBBBBBBBBBNH\ZRUG $OOWKHPHWKRGVLQDQLQWHUIDFHDUHBBBBBBBB $SDFNDJHDOZD\VFRQWDLQBBBBBBBSXEOLFFODVV BBBBBBBSDFNDJHSURYLGHVDOLEUDU\RIPDWKURXWLQHV BBBBBBBBSDFNDJHSURYLGHVDVHWRILQSXWDQGRXWSXWVWUHDPVXVHGWRUHDGDQGZULWHGDWD WRILOHVRURWKHULQSXWDQGRXWSXWVRXUFHV II. State True or False
,QWHUIDFHLVDQDOWHUQDWLYHWRPXOWLSOHLQKHULWDQFH $FODVVFDQH[WHQGPRUHWKDQRQHFODVV 0HWKRGLPSOHPHQWDWLRQVDQGYDULDEOHVDUHLQKHULWHGIURPDQLQWHUIDFH $QLQWHUIDFHFDQQRWH[WHQGRWKHULQWHUIDFHV 3URWHFWHGGDWDFDQEHDFFHVVHGE\WKHQRQVXEFODVVHVRIRWKHUSDFNDJHV
Comp-U-Learn
83
Java Programming I
III. One line Answers
'HILQHLQWHUIDFH 'LIIHUHQWLDWHPXOWLSOHLQKHULWDQFHDQGLQWHUIDFH 'HILQHLQQHUFODVVHV :KDWLVWKHDGYDQWDJHRILPSOHPHQWLQJFORQH PHWKRG" :ULWHDVKRUWQRWHRQSDFNDJHV
84
Comp-U-Learn
Session 5
Streams and File Handling
On Completion of this Session We will be able to understand...
) Stream class and its functions ) System Properties ) Input Stream and its methods ) Output Streams and its methods ) Directory Structure ) File Input and Output Streams ) Buffered Streams & Filtered Streams
In This Session...
Java Stream Class
Print Stream
System Properties
Input and Output Streams
Files and Directories
File Input and Output Streams
Data Input and Output Streams
Filtered Streams
Buffered Streams
Pushback Input Streams
Random Access File
Reader and Writer Classes
Streams and File Handling
Java Stream Class 6WUHDP LQ -DYD LV D JHQHUDO DEVWUDFWLRQ RI WKH GDWD WUDQVIHU PHFKDQLVP 6HSDUDWH VWUHDPV DUH SURYLGHGIRULQSXWDQGRXWSXW$OOLQSXWRXWSXWRSHUDWLRQVLQ-DYDDUHGRQHXVLQJWKHEDVLFW\SH E\WH&KDUDFWHUVDUHGHDOWWKURXJKWKHLUVSHFLILFFRGHZKRVHYDOXHVDUHE\WHW\SH-DYDSURJUDPV DOO UHDG IURP DQG ZULWH WR VWUHDPV $ VWUHDP LV D IORZLQJ VHTXHQFH RI FKDUDFWHUV 7KH LQSXW VRXUFH FDQ EH IURP D NH\ERDUG D ILOH RU WKH QHWZRUN DQG WKH RXWSXW GHVWLQDWLRQ FDQ EH WKH VFUHHQRUDILOHRUWKHQHWZRUN7KHGDWHLVVHQWRUUHFHLYHGDVDVHTXHQFHRIE\WHV The Stream Classes
-DYDLPSOHPHQWVVWUHDPVZLWKLQDFODVVKLHUDUFK\GHILQHGLQWKHMDYDLRSDFNDJH$WWKHWRS RI WKHKLHUDUFK\DUHWZRDEVWUDFWFODVVHV ,QSXW6WUHDPDQG2XWSXW6WUHDP-DYDKDVVHYHUDOFRQFUHWH VXEFODVVHVRIHDFKWRKDQGOHWKHGLIIHUHQFHVEHWZHHQYDULRXVGHYLFHVVXFKDVGLVNILOHVQHWZRUN FRQQHFWLRQVDQGHYHQPHPRU\EXIIHUV
Print Stream 7KH3ULQW6WUHDPFODVVSURYLGHVDOORI WKHIRUPDWWLQJ FDSDELOLWLHVZH KDYH EHHQ XVLQJ IURP WKH 6\VWHP ILOH KDQGOH 6\VWHPRXW -DYD·V 3ULQW6WUHDP REMHFWV VXSSRUW WKH SULQW DQG SULQWOQ PHWKRGV IRU DOO W\SHV LQFOXGLQJ REMHFWV 7KH PHWKRGV RI WKLV FODVV DUH ZLGHO\ XVHG LQ -DYD DSSOLFDWLRQV 7KH WZR PHWKRGV WKDW DUH YHU\ IDPLOLDU WR XV DUH 6\VWHPRXWSULQWOQ DQG 6\VWHPRXWSULQW 7KH6\VWHPHUUPHWKRGLVXVHGWRSULQWHUURUPHVVDJHVDQG6\VWHPLQLVDQ ,QSXW6WUHDP Print, println and write methods
7KHSULQWDQGSULQWOQPHWKRGVDUHHVVHQWLDOO\WKHVDPH WKH\ERWKZULWHWKHLUVWULQJDUJXPHQWWR WKHVWUHDP7KHRQHGLIIHUHQFHEHWZHHQWKHWZRLVWKDWSULQWOQDGGVDQHZOLQHFKDUDFWHUWRWKH HQGRILWVRXWSXWZKHUHDVSULQWGRHVQ·W System.out.println(“welcome to Java streams “);
,VWKHVDPHDV System.out.print(“Welcome to Java steams \n”);
7KHZULWHPHWKRGLVOHVVIUHTXHQWO\XVHGWKDQSULQWRUSULQWOQFRPPDQGV:ULWHLVXVHGWRZULWH E\WHVWRWKHVWUHDP7KH\DUHXVHGWRZULWH1RQ$6&,,GDWD Comp-U-Learn
87
Java Programming I Java’s Stream Input Output Classes
Stream Class BufferedInputStream BufferedOutputStream ByteArrayInputStream ByteArrayOutputStream DataInputStream DataOutput Stream File File Descriptor FileInputStream FileOutputStream FilterInputStream FilterOutputStream InputStream LineNumberInputStream OutputStream PipedInputStream PipedOutputStream PrintStream PushbackInputStream RandomAccessFile SequenceInputStream
Stream Tokenizer String BufferInputStream
Definition Buffered input stream Buffered output stream Input stream that reads from a byte array Output stream that writes to a byte array An input stream that contains methods for reading Java standard data types An output stream that contains methods for writing Java standard data types Deals directly with files and the file system Deals with record pointers, file descriptions and file access mechanisms Input stream that reads from a file Output stream that writes to a file Implements Input Stream Implements Output Stream Abstract class that describes stream input Input stream that counts lines Abstract class that describes stream output Input pipe Output pipe Output stream that contains print() and println() Input stream that supports one-byte “unget” which returns a byte to the input stream Supports random access file I/O Input stream that is a combination of two or more input streams which will be read sequentially, one after the other Tokenizing input stream Input streams that read from a string
Built-in streams in Java
$OO-DYDSURJUDPVDXWRPDWLFDOO\LPSRUWWKHMDYDODQJSDFNDJH7KLVSDFNDJHGHILQHVDFODVVFDOOHG 6\VWHPZKLFKHQFDSVXODWHVVHYHUDODVSHFWVRIWKHUXQWLPHHQYLURQPHQW,WDOVRFRQWDLQVWKUHH SUHGHILQHGYDULDEOHVFDOOHGLQRXWDQGHUU7KHVHILHOGVDUHGHFODUHGDVSXEOLFDQGVWDWLFZLWKLQ 6\VWHP 7KLV PHDQV WKDW WKH\ FDQ EH XVHG E\ DQ\ RWKHU SDUW RI RXU SURJUDP DQG ZLWKRXW UHIHUHQFHWRDVSHFLILF6\VWHPREMHFW 88
Comp-U-Learn
Streams and File Handling
6\VWHPRXWUHIHUVWRWKHVWDQGDUGRXWSXWVWUHDP%\GHIDXOWWKLVUHIHUVWRWKHPRQLWRU6\VWHPLQ UHIHUVWRWKHVWDQGDUGLQSXWVWUHDPZKLFKLVE\GHIDXOWWKHNH\ERDUG6\VWHPHUUUHIHUVWRWKH VWDQGDUG HUURU VWUHDP ZKLFK LV DOVR WKH VFUHHQ E\ GHIDXOW +RZHYHU WKHVH VWUHDPV FDQ EH UHGLUHFWHGWRDQ\FRPSDWLEOH,2GHYLFH
System Properties 7KH6\VWHPFODVVPDLQWDLQVDVHWRISURSHUWLHVNH\YDOXHSDLUVWKDWGHILQHWUDLWVRUDWWULEXWHVRI WKH FXUUHQW ZRUNLQJ HQYLURQPHQW :KHQ WKH UXQWLPH V\VWHP ILUVW VWDUWV XS WKH V\VWHP SURSHUWLHV DUH LQLWLDOL]HG WR FRQWDLQ LQIRUPDWLRQ DERXW WKH UXQWLPH HQYLURQPHQW LQFOXGLQJ LQIRUPDWLRQ DERXW WKH FXUUHQW XVHU WKH FXUUHQW YHUVLRQ RI WKH -DYD UXQWLPH DQG HYHQ WKH FKDUDFWHU XVHG WR VHSDUDWH FRPSRQHQWV RI D ILOH QDPH 7KH 6\VWHP FODVV SURYLGHV VHYHUDO PHWKRGV WR UHDG DQG ZULWH V\VWHP SURSHUWLHV ,W LV SRVVLEOH WR FKDQJH WKH VHW RI V\VWHP SURSHUWLHVFRPSOHWHO\7KH6\VWHPFODVVFRQWDLQVWZRSURSHUWLHVJHW3URSHUW\DQGJHW3URSHUWLHV 7KH*HW3URSHUW\PHWKRGUHWXUQVDVWULQJFRQWDLQLQJWKHYDOXHRIWKHSURSHUW\3URYLGHGDVDQ DUJXPHQW)RUH[DPSOH System.getProperty(“home.name”);
,IWKHDUJXPHQWGRHVQRWKDYHDYDOXHRUWKHSURSHUW\GRHVQRWH[LVWWKHQ1XOO3RLQWHU([FHSWLRQ ZLOOEHUDLVHG7RDYRLGWKLVZHFDQXVHOLNH System.getProperty(“home.name”,”Nothing “);
7KLV PHWKRG ZLOO UHWXUQ WKH YDOXH ´1RWKLQJµ LI WKH DUJXPHQW KRPHQDPH GRHV QRW KDYH DQ\ YDOXH 7KH JHW3URSHUWLHV PHWKRG UHWXUQV D 3URSHUWLHV REMHFW WKDW FRQWDLQV D FRPSOHWH VHW RI V\VWHPSURSHUW\NH\YDOXHSDLUV 7KHVHW3URSHUWLHV PHWKRGLVXVHGWRPRGLI\WKHH[LVWLQJVHWRIV\VWHPSURSHUWLHV7KLVPHWKRG WDNHV D 3URSHUWLHV REMHFW WKDW KDV EHHQ LQLWLDOL]HG WR FRQWDLQ WKH NH\YDOXH SDLUV IRU WKH SURSHUWLHVWKDWKDVWREHVHW7KLVPHWKRGUHSODFHVWKHHQWLUHVHWRIV\VWHPSURSHUWLHVZLWKWKH QHZ VHW UHSUHVHQWHG E\ WKH 3URSHUWLHV REMHFW 7KH VHW3URSHUWLHV PHWKRG FKDQJHV WKH VHW RI V\VWHP SURSHUWLHV IRU WKH FXUUHQW UXQQLQJ DSSOLFDWLRQ 7KHVH FKDQJHV DUH QRW SHUVLVWHQW &KDQJLQJV\VWHPSURSHUWLHVZLWKLQDQDSSOLFDWLRQZLOOQRWDIIHFWIXWXUHLQYRFDWLRQVRIWKH-DYD LQWHUSUHWHU IRU WKLV RU DQ\ RWKHU DSSOLFDWLRQ 7KH UXQ WLPH V\VWHP UHLQLWLDOL]HV WKH V\VWHP SURSHUWLHV HDFK WLPH LWV VWDUWV XS $Q ([DPSOH WR VKRZ WKH JHW3URSHUWLHV DQG VHW3URSHUWLHV 0HWKRGVLVJLYHQEHORZ
Comp-U-Learn
89
Java Programming I
Example 5.1 import java.io.FileInputSteeam; import java.util,Properties; class PropertiesTest { public static void main(String args[]) { try { FileInputStream pfile=new FileInputStream(“MyProps.txt”); Properties p=new Properties(System.getProperties()); p.load(pfile); System.setProperties(p); System.getProperties().list(System.out); } catch(java.io.FileNotFoundException e) { System.err.println(“Cannot find the file MyProps.txt”); } catch(java.io.IOException e) { System.err.printlln(“Input Output Error “); } } }
+HUHWKHJHW3URSHUWLHV PHWKRGZLOOUHWXUQD3URSHUWLHVREMHFWZLWKWKHFXUUHQWVHWRIV\VWHP SURSHUWLHV LQLWLDOL]HG E\ WKH UXQWLPH V\VWHP DORQJ ZLWK WKH SURSHUWLHV DYDLODEOH LQ WKH ILOH ´0\3URSVW[Wµ2QFHGRQHWKHVHSURSHUWLHVDUHVHWXVLQJWKHVHW3URSHUW\PHWKRG
Note Finalization can be forced to occur by the method System.runFinalization and the garbage collector can be made to run at anytime using System.gc(). Method read()
7KHORZHVWOHYHOLQSXWPHWKRGLVUHDG ,WFRPHVLQVHYHUDOIRUPV(DFKWLPHUHDG LVFDOOHGLW UHDGVDVLQJOHE\WHIURPWKHLQSXWVWUHDPDQGUHWXUQVLWDVDQLQWHJHUYDOXH,WUHWXUQV²ZKHQ WKH HQG RI WKH VWUHDP LV HQFRXQWHUHG ,W FDQ WKURZ DQ ,2([FHSWLRQ ([FHSWLRQV UHIHU WR QRQ KDQGOHGHUURUVDQGDEQRUPDOLWLHVRFFXULQJGXULQJDSURJUDPH[HFXWLRQVXFKDVGLYLVLRQE\]HUR ILOH QRW IRXQG HWF ([FHSWLRQV DUH KDQGOHG LQ GHWDLO LQ WKH IROORZLQJ VHVVLRQ 7KH IROORZLQJ SURJUDPGHPRQVWUDWHVUHDG ,WUHDGVFKDUDFWHUVIURPWKHVWDQGDUGLQSXWXQWLOWKHXVHUW\SHVD ´Tµ
90
Comp-U-Learn
Streams and File Handling
Example 5.2 import java.io.*; class ex22 { public static void main(String args[]) throws IOException { char c; System.out.println("enter characters, q to quit. "); do{ c=(char)System.in.read(); System.out.println(c); }while(c!='q'); } }
7KHRXWSXWLVGLIIHUHQWEHFDXVH6\VWHPLQLVOLQHEXIIHUHGE\GHIDXOW 7KHRXWSXWRIWKHSURJUDPLV enter characters, q to quit. 123456q 1 2 3 4 5 6
Reading a String
-DYD SURYLGHV D EXLOW LQ PHWKRG FDOOHG UHDG/LQH ZKLFK DXWRPDWLFDOO\ UHDGV D VHTXHQFH RI FKDUDFWHUVIURPWKHLQSXWVWHDPDQGUHWXUQVWKHPLQ DQREMHFW RIW\SH6WULQJ 7KLVPHWKRG LV SDUW RI WKH 'DWD,QSXW6WUHDP FODVV ZKLFK SURYLGHV PHWKRGV IRU UHDGLQJ DOO RI -DYD·V VLPSOH W\SHVSOXVOLQHVRIWH[W7KHJHQHUDOIRUPRIUHDG/LQH LV Final String readLine() throws IOException
UHDG/LQH UHWXUQV D VWULQJ REMHFW %HIRUH XVLQJ UHDG/LQH ZH PXVW REWDLQ D 'DWD,QSXW6WUHDP REMHFWWKDWLVOLQNHGWRDQLQSXWVWUHDP7KHJHQHUDOIRUPLV DataInputStream(InputStream istream)
+HUHLVWUHDPLVWKHVWUHDPWKDWLVOLQNHGWRWKHLQVWDQFHRI'DWD,QSXW6WUHDPEHLQJFUHDWHG7R UHDG FRQVROH LQSXW ZH FDQ XVH 6\VWHPLQ IRU WKLV SDUDPHWHU $Q H[DPSOH WR GHPRQVWUDWH WKH DERYHFRQFHSWLVJLYHQEHORZ
Comp-U-Learn
91
Java Programming I
Example 5.3 import java.io.*; class ex23 { public static void main(String args[]) throws IOException { DataInputStream in=new DataInputStream(System.in); String str; System.out.println("Enter lines of text "); System.out.println("Enter 'End' to quit"); do{ str=in.readLine(); System.out.println(str); }while(!str.equals("End")); } }
7KHRXWSXWRIWKHSURJUDPZLOOEH Enter lines of text Enter ‘End’ to quit Ba ba Black Sheep Ba ba Black Sheep Have you any wool Have you any wool End End
$QRWKHUH[DPSOHWRVKRZWKHEHKDYLRURI,2VWUHDPVLVJLYHQEHORZ Example 5.4 import java.io.*; class ex24 { public static void main(String args[]) throws IOException { DataInputStream in=new DataInputStream(System.in); String str[]=new String[50]; System.out.println("Enter lines of text "); System.out.println("Enter 'End' to quit"); for(int i=0;i<50;i++) { str[i]=in.readLine(); if(str[i].equals("End")) break;
92
Comp-U-Learn
Streams and File Handling } System.out.println("The file is for(int i=0;i<50;i++) { if(str[i].equals("end")) break; System.out.println(str[i]); } } }
");
7KHRXWSXWRIWKHSURJUDP Enter lines of text Enter ‘End’ to quit Ba ba black sheep Have you any wool End The file is Ba ba black sheep Have you any wool End
Input and Output Streams Input Stream
7KH ,QSXW6WUHDP FODVV KDQGOHV DQ\ NLQG RI LQSXW $OO WKH PHWKRGV RI WKLV FODVV WKURZ DQ ,2([FHSWLRQ LI DQ\ HUURU RFFXUV 7KH VXPPDU\ RI WKH PHWKRGV DYDLODEOH LQ WKLV FODVV LV OLVWHG KHUHXQGHU read()
Returns an int representation of the next available byte. read(byte b[])
$WWHPSWV WR UHDG V E\WHV LQWR WKH DUUD\ E ZKHUH V LV WKH VL]H RI WKH DUUD\ E V EOHQJWK ,W UHWXUQVDQLQWWHOOLQJKRZPDQ\E\WHVDUHDFWXDOO\UHDG WKHDFWXDOE\WHVUHDGPD\EHOHVVWKDQWKH DUUD\VL]H read(byte b[],int off,int len)
$WWHPSWV WR UHDG XS WR FK E\WHV DQG VWRUHV WKHP LQ E IURP E>RII@ RQZDUGV ,W UHWXUQV DQ LQW WHOOLQJKRZPDQ\E\WHVDUHDFWXDOO\UHDG
Comp-U-Learn
93
Java Programming I skip(long n)
:LOOVNLSQQH[WE\WHVDQGZLOOUHWXUQWKHQXPEHURIDFWXDOE\WHVVNLSSHG available()
5HWXUQVWKHQXPEHURIE\WHVFXUUHQWO\DYDLODEOHIRUUHDGLQJ WKHVHDUHMXVWWKHUHPDLQLQJXQUHDG E\WHV close()
&ORVHVWKHFXUUHQW,QSXW6WUHDP)XUWKHUDWWHPSWWRUHDGWKURHVDQ,2([FHSWLRQ mark(int rr)
3ODFHVDPDUNDWWKHFXUUHQWSRVLWLRQ7KLVPDUNZLOOUHPDLQYDOLGXQWLOQH[WUUE\WHV DUHUHDG 8VLQJWKLVPDUNZHPD\FRPHEDFNWRWKLVSRVLWLRQDQGVWDUWDIUHVKUHDGLQJ reset()
5HWXUQVWKHLQSXWSRLQWHUWRWKHSUHYLRXVO\PDUNHGSRVLWLRQ mark supported()
5HWXUQVWUXHLIPDUN DQGUHVHW PHWKRGVDUHVXSSRUWHGRQWKLVVWUHDP Output Stream
/LNH ,QSXW6WUHDP -DYD GHILQHV 2XWSXW6WUHDP DV DQ DEVWUDFW FODVV WR GHDO ZLWK DOO NLQGV RI RXWSXWV $OO PHWKRGV RI WKLV FODVV UHWXUQ YRLG DQG WKURZ DQ ,2([FHSWLRQ LQ FDVH RI IDLOXUHV +HUHLVWKHOLVWRILWVPHWKRGV write(int b)
:ULWHVDVLQJOHE\WHWRDQRXWSXWVWUHDP DIWHUFRQYHUWLQJLWWRE\WHW\SH 6LQFHWKHW\SHRIELV LQW ZH FDQ FRQVWUXFW H[SUHVVLRQV RI DOUHDG\ GHILQHG LQW YDULDEOHV IRU SDVVLQJ DV WKH GXPP\ SDUDPHWHUE write(byte b[])
:LOOZULWHDFRPSOHWHDUUD\RIE\WHVRQWKHRXWSXWVWUHDP
94
Comp-U-Learn
Streams and File Handling write(byte b[]. Int off, int len)
:ULWHOHQE\WHVIURPWKHDUUD\EVWDUWLQJIURPE>RII@ flush()
)OXVKHVDQ\E\WHVWKDWKDYHEHHQZULWWHQWRWKHORJLFDO2XWSXW6WUHDPEXWKDYHQRWUHDFKHGWR WKHDFWXDOGHYLFH OLNHDILOHRQWKHGLVN close()
&ORVHVWKHVWUHDP)XUWKHUDWWHPSWWRZULWHZLOOJHQHUDWHDQHUURU
Files and Directories )LOHVDUHWKHSULPDU\VRXUFHDQGGHVWLQDWLRQIRUGDWDZLWKLQPRVWSURJUDPV)LOHLQSXWRXWSXW RSHUDWLRQLVFRPPRQLQDQ\ODQJXDJH-DYDGHYRWHVDZKROHUDQJHRIPHWKRGVIRXQGLQDFODVV FDOOHG)LOHLQWKHMDYDLRSDFNDJHWRGRWKHVHRSHUDWLRQV)LOHLVDVXEFODVVRI6WUHDPLQ-DYD7KLV LV WKH RQO\ VXEFODVV WKDW GHDOV ZLWK WKH ILOHV LQ WKH GLVN ILOH V\VWHP 8VDJH RI ILOHV KDV VHYHUH UHVWULFWLRQVLQDSSOHWVWRHQVXUHWKDWWKHGLVNRIWKHGHVWLQDWLRQ UXQWLPHHQYLURQPHQW LVQRW FRUUXSWHG E\ DQ\ FKDQFH %XW ILOHV DUH UHTXLUHG IRU DQ\ RWKHU DSSOLFDWLRQ SURJUDP WKDW GRHV VRPHWKLQJXVHIXOIRUWKHDYDLODEOHGDWDDQGSURGXFHVUHVXOWVRISHUPDQHQW QDWXUH-DYDWHDWVD GLUHFWRU\DOVRDVDILOHEXWFHUWDLQPHWKRGVIRUILOHVDQGGLUHFWRULHVDUHGLIIHUHQW$)LOHREMHFWLV XVHGWRREWDLQRUPDQLSXODWHWKHLQIRUPDWLRQDVVRFLDWHGZLWKDGLVNILOHVXFKDVWKHSHUPLVVLRQV WLPHDQGGDWHDQGGLUHFWRU\SDWKDQGWRQDYLJDWHVXEGLUHFWRU\KLHUDUFKLHV6LQFH)LOHGRHVQRW RSHUDWH RQ VWUHDPV LW LV QRW D VXEFODVV RI ,QSXW6WUHDP RU 2XWSXW6WUHDP 7KH IROORZLQJ FRQVWUXFWRUVDUHXVHGWRFUHDWH)LOHREMHFWV ♦ File(String dirpath) ♦ File(String dirpath, String filename) ♦ File(File dirObj, String filename) +HUHWKHGLUSDWKLVWKHSDWKQDPHRIWKHILOHILOHQDPHLVWKHQDPHRIWKHILOHDQGGLU2EMLVDILOH REMHFWWKDWVSHFLILHVDGLUHFWRU\ 7KHIROORZLQJH[DPSOHFUHDWHVWKUHHILOHV ILIDQGI7KHILUVW)LOHREMHFWLVFRQVWUXFWHGZLWKD GLUHFWRU\SDWKDVWKHRQO\DUJXPHQW7KHVHFRQGLQFOXGHVWZRDUJXPHQWV²WKHSDWKDQGWKHILOH QDPH7KHWKLUGLQFOXGHVWKHILOHSDWKDVVLJQHGWRIDQGDILOHQDPH IUHIHUVWRWKHVDPHILOHDV I 7KH QH[W LQFOXGHV WKH GLUHFWRU\ XQGHU ZKLFK WKH SDUWLFXODU ILOH ´DXWRH[HFEDWµ KDV WR EH FUHDWHG Comp-U-Learn
95
Java Programming I File File File File
f1=new f2=new f3=new f3=new
File(“/”); File(“/”, “autoexec.bat”); File(f1,”autoexec.bat”); File(“user”,”autoexec.bat”);
Note The Java convention is to use the UNIX and URL style forward slash for path separators. Methods of File Class
7KHIROORZLQJDUHVRPHRIWKHLPSRUWDQWPHWKRGVDYDLODEOHLQWKH)LOHFODVV getName()
7KLVPHWKRGLVXVHGWRREWDLQWKHQDPHRIWKHILOHVSHFLILHG getPath()/ getAbsolutePath()
7KHVH PHWKRGV KHOS WR JHW WKH SDWK RI WKH ILOH VSHFLILHG DQG WKH DEVROXWH SDWK RI WKH ILOH VSHFLILHGUHVSHFWLYHO\ exists()
7KLVPHWKRGLVXVHGWRFKHFNLIWKHQDPHGILOHH[LVWVLQWKDWGLUHFWRU\RUQRW isFile()/isDirectory()
7KHVHDUHXVHGWRFKHFNLIWKHQDPHGILOHLVDQRUGLQDU\ILOHRUDGLUHFWRU\UHVSHFWLYHO\ canRead()/canWrite()
7KHVH PHWKRGV DUH XVHG WR FKHFN LI WKH VSHFLILHG ILOH LV UHDGDEOHZULWDEOH UHVSHFWLYHO\ 7KHVH PHWKRGVUHWXUQD%RROHDQYDOXHGHSHQGLQJRQWKHLUUHDGDELOLW\ZULWDELOLW\ lastModified()
7KLVPHWKRGUHWXUQVWKHODVWPRGLILFDWLRQWLPHRIWKHILOH length()
7KLVPHWKRGLVXVHGWRNQRZWKHILOHVL]HLQE\WHV
96
Comp-U-Learn
Streams and File Handling delete()
7KLVPHWKRGLVXVHGWRGHOHWHWKHVSHFLILHGILOH renameTo()
7KLVPHWKRGLVXVHGWRUHQDPHDVSHFLILHGILOH,WWDNHVDILOHREMHFWWKDWEHFRPHVWKHGHVWLQDWLRQ ILOHRUWKHUHQDPHGILOHDVLWVSDUDPHWHU isFile()
7KLVUHWXUQVWUXHPRVWRIWKHWLPHEXWVRPHVSHFLDOILOHVVXFKDVGHYLFHGULYHUVDQGQDPHGSLSHV PD\QRWEHKDYHOLNHQRUPDOILOHVVRWKLVPHWKRGFDQEHXVHGWRPDNHVXUHWKDWWKHHQWLW\ZH DFFHVVLVDILOH isAbsolute()
7KLVPHWKRGUHWXUQVWUXHLIWKHILOHKDVDQDEVROXWHSDWKIDOVHLIUHODWLYH $QH[DPSOHWRVKRZWKHZRUNLQJRIYDULRXVPHWKRGV&UHDWHDVLPSOHWH[WILOHFDOOHGGXPP\W[W XQGHUF ?H[DPSOHWRUXQWKLVSURJUDP Example 5.5 import java.io.File; class ex25 { static void a(String s) { System.out.println(s); } public static void main(String args[]) { File f1=new File("c:/example/dummy.txt"); a("File Name : " + f1.getName()); a("Path : "+f1.getPath()); a("Absolute Path is :" + f1.getAbsolutePath()); a("Parent : " +f1.getParent()); a(f1.exists() ? "File exists " : "File does not exist "); a(f1.canWrite() ? "is writable " : " is not writable "); a(f1.canRead() ? "readable " : " is not readable"); a("is" +(f1.isDirectory() ? "" : "not" +" a directory")); a(f1.isFile() ? "is normal file" : "is not a normal file"); a(f1.isAbsolute() ? "is absolute " : "is not absolute "); a("file last modified : " + f1.lastModified()); a("file size : " + f1.length() + "Bytes "); } }
Comp-U-Learn
97
Java Programming I
7KHRXWSXWRIWKHSURJUDPLV File name : dummy.txt Path : c:\example\dummy.txt Absolute Path : c:\example\dummy.txt Parent : c:\example File exists is writable readable isnot a directory is normal file is absolute file last modified : 934007788000 file size : 217 Bytes
Directories
$ GLUHFWRU\ LV D )LOH WKDW FRQWDLQV D OLVW RI RWKHU ILOHV DQG GLUHFWRULHV :KHQ ZH FUHDWH D )LOH REMHFWDQGLWLVDGLUHFWRU\WKHLV'LUHFWRU\ PHWKRGZLOOUHWXUQWUXH,QWKLVFDVHZHFDQFDOOWKH OLVWPHWKRGRQWKDWREMHFWWRH[WUDFWWKHOLVWRIRWKHUILOHVDQGGLUHFWRULHVLQVLGH7KHOLVWRIILOHV LVUHWXUQHGLQDQDUUD\RI6WULQJREMHFWV7KHSURJUDPVKRZQKHUHZLOOGHPRQVWUDWHWKHXVDJHRI OLVWPHWKRGWRH[DPLQHWKHFRQWHQWVRIDGLUHFWRU\&DOOLQJWKHOLVWPHWKRGRQD)LOHREMHFWWKDW LVQRWDGLUHFWRU\ZLOOFDXVHUXQWLPH1XOO3RLQWHU([FHSWLRQ Example 5.6 import java.io.File; class ex26 { public static void main(String args[]) { int i; String dname="C:/jdk1.2"; File f1=new File(dname); if(f1.isDirectory()) { System.out.println("Directory contents of "+dname); String s[]=f1.list(); for(i=0;i<s.length;i++) { File f=new File(dname + "/" + s[i]); if (f.isDirectory()) System.out.println(s[i] + " is a Directory"); else System.out.println(s[i] + " is a file"); } } else
98
Comp-U-Learn
Streams and File Handling System.out.println(dname+ " is not a Directory"); } }
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex26 Directory contents of C:/jdk Uninst.isuis a file binis a Directory READMEis a file LICENSEis a file COPYRIGHTis a file README.htmlis a file jreis a Directory libis a Directory includeis a Directory include-oldis a Directory demois a Directory src.jaris a file
FilenameFilter
7KLVLVXVHGWROLPLWWKHQXPEHURIILOHVUHWXUQHGE\WKHOLVW PHWKRGWRLQFOXGHRQO\WKRVHILOHV ZKLFKPDWFKDFHUWDLQILOHQDPHSDWWHUQRUILOWHU7KHQOLVWPHWKRGLVXVHGDVIROORZV String[] list(FilenameFilter ffobject);
)LOHQDPHILOWHULVDQLQWHUIDFH DQGIIREMHFWLVDQREMHFWRIWKLVLQWHUIDFH7KLVLQWHUIDFH GHILQHV RQO\DVLQJOHPHWKRGFDOOHGDFFHSW ZKLFKLVFDOOHGRQFHIRUHDFKILOHLQDOLVW7KLVPHWKRGLV XVHGIRUH[WUDFWLQJILOHVZLWKDSDUWLFXODUH[WHQVLRQ7KHJHQHUDOV\QWD[IRUDFFHSW LV Boolean accept(File dir,String filename)
7KHDFFHSW PHWKRGUHWXUQVWUXHIRUILOHVLQWKHGLUHFWRU\E\GLUWKDWVKRXOGEHLQFOXGHGLQWKH OLVWWKDWLVWKRVHPDWFKWKHILOHQDPHDUJXPHQWDQGIDOVHIRUWKRVHWKDWVKRXOGEHH[FOXGHG$Q H[DPSOHWRVKRZWKHZRUNLQJRI)LOHQDPH)LOWHUIROORZV Example 5.7 import java.io.*; public class OnlyExt implements FilenameFilter { String ex; public OnlyExt(String ex) { this.ex="." +ex;
Comp-U-Learn
99
Java Programming I } public boolean accept(File dir,String fname) { return fname.endsWith(ex); } }
6DYHWKLVILOHZLWKWKHH[WHQVLRQ2QO\([WMDYDXQGHUELQ import java.io.*; class ex27 { public static void main(String args[]) { String dirname="C:/example"; File f1=new File(dirname); FilenameFilter ff=new OnlyExt("doc"); String s[]=f1.list(ff); for(int i=0; i<s.length;i++) System.out.println(s[i]); } }
7KHRXWSXWRIWKHSURJUDPH[MDYDLVDVIROORZV C:\jdk1.2\bin>javac ex27.java C:\jdk1.2\bin>java ex27 OOPs In Java.doc ~$ided tour-3 qns.doc ~$terfaces.doc ~$treams.doc Answers to guide tour-3.doc guided tour-3 qns.doc Interfaces.doc Streams.doc Cover Page.doc C:\jdk1.2\bin>
File Input and Output Streams FileInput Stream
)LOH VWUHDP FRQVLVWV RI WKH )LOH,QSXW6WUHDP DQG )LOH2XWSXW6WUHDP 7KH )LOH,QSXW6WUHDP FODVV FUHDWHVDQ,QSXW6WUHDPWKDWZHFDQXVHWRUHDGWKHFRQWHQWVRIDILOH7KLVFODVVUHDGVGDWDIURP WKHDFWXDOGLVNILOHV7KHWZRPRVWFRPPRQFRQVWUXFWRUVDUH 100
Comp-U-Learn
Streams and File Handling
FileInputStream(String filepath) FileInputStream(File fileobj) (LWKHUFDQWKURZXSD)LOHQRW)RXQG([FHSWLRQ+HUHILOHSDWKLVWKHIXOOQDPHRIDILOHDQGILOHREM LVD)LOHREMHFWWKDWGHVFULEHVWKHILOH 7KHIROORZLQJH[DPSOHFUHDWHVWZR)LOH,QSXW6WUHDPVWKDWXVHWKHVDPHGLVNILOHDQGHDFKRIWKH WZRFRQVWUXFWRUV FileInputStream f1=new FileInputStream(“c:/jdk1.2/bin/ex27.java”); File f=new File(“c:/jdk1.2/bin/ex27.java”); FileInputStream f1=new FileInputStream(f);
$OWKRXJKWKHILUVWFRQVWUXFWRULVSUREDEO\PRUHFRPPRQO\XVHGWKHVHFRQGDOORZVXVWRFORVHO\ H[DPLQH WKH ILOH XVLQJ WKH )LOH PHWKRGV EHIRUH ZH DWWDFK LW WR DQ LQSXW VWUHDP :KHQ D )LOH,QSXW6WUHDP LV FUHDWHG LW LV RSHQHG IRU UHDGLQJ )LOH,QSXW6WUHDP RYHUULGHV VL[ RI WKH PHWKRGVLQWKHDEVWUDFWFODVV,QSXW6WUHDP7KHPDUN DQGUHVHW PHWKRGVDUHQRWRYHUULGGHQ DQGDQ\DWWHPSWWRXVHWKHVHPHWKRGVRQD)LOH,QSXW6WUHDPZLOOJHQHUDWHDQ,2([FHSWLRQ FileOutput Stream
)LOH2XWSXW6WUHDP FUHDWHV DQ 2XWSXW6WUHDP WKDW ZH FDQ XVH WR ZULWH WR D ILOH ,WV WZR PRVW FRPPRQFRQVWUXFWRUVDUH FileOutputStream(String filePath) FileOutputStream(File fileObj) (LWKHUFDQWKURZDQ,2([FHSWLRQRUDVHFXULW\H[FHSWLRQ+HUHILOH3DWKLVWKHIXOOSDWKQDPHRI DILOHDQGILOH2EMLVD)LOHREMHFWWKDWGHVFULEHVWKHILOH&UHDWLRQRID)LOH2XWSXW6WUHDPLVQRW GHSHQGHQWRQWKHILOHDOUHDG\H[LVWLQJ)LOH2XWSXW6WUHDPZLOOFUHDWHWKHILOHEHIRUHRSHQLQJLWIRU RXWSXWZKHQZHFUHDWHWKHREMHFW,QFDVHZKHQZHWU\WRRSHQDUHDGRQO\ILOHDQ,2([FHSWLRQ ZLOO EH WKURZQ 7KH IROORZLQJ H[DPSOH LOOXVWUDWHV WKH XVDJH RI )LOH,QSXW6WUHDP DQG )LOH2XWSXW6WUHDP Example 5.8 import java.io.*; class ex28 { public static byte[] getInput() throws Exception { byte inp[]=new byte[150]; System.out.println("enter text"); System.out.println("only 150 bytes ");
Comp-U-Learn
101
Java Programming I System.out.println("Press enter after each line to get input into the program "); for(int i=0;i<150;i++) inp[i]=(byte)System.in.read(); return inp; } public static void main(String args[]) throws Exception { byte input[]=getInput(); OutputStream f=new FileOutputStream("c:/jdk1.2/bin/new.txt"); for(int i=0;i<150;i++) f.write(input[i]); f.close(); int size; InputStream fi=new FileInputStream("c:/jdk1.2/bin/new.txt"); size=fi.available(); for(int i=0;i<size;i++) System.out.print((char)fi.read()); f.close(); } }
2XWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex28 enter text only 10 bytes Press enter after each line to get input into the program Serialized Serialized C:\jdk1.2\bin>
Data Input and Output Streams 7KLVFODVVFRQWDLQVDVHWRIPHWKRGVWRDFFHSWYDULRXVW\SHVRIGDWD6RPHRIWKHPDUH Int readInt throws IOException Char readChar throws IOException $ VHW RI PHWKRGV H[LVWV LQ WKLV FODVV WR ZULWH WKH GDWD WR WKH RXWSXW VRXUFH 6RPH RI WKH PHWKRGVDUH void writeBytes(String s) void writeInt(int k) void writeChar(char c) $OO WKHVH PHWKRGV WKURZ ,2([FHSWLRQ $Q H[DPSOH WR VKRZ 'DWD,QSXW DQG 'DWD2XWSXW VWUHDPVLVJLYHQKHUHXQGHU 102
Comp-U-Learn
Streams and File Handling
Example 5.9 import java.io.*; class ex31 { public static void main(String args[]) throws IOException { BufferedReader d=new BufferedReader (new InputStreamReader(new FileInputStream("c:/example/dummy.txt"))); DataOutputStream o=new DataOutputStream (new FileOutputStream("c:/uma/dummy1.txt")); String l; while((l=d.readLine())!= null) { String a=l.toUpperCase(); System.out.println(a); o.writeBytes(a+ "\r\n"); } d.close(); o.close(); } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex31 DUMMY FILE CONTENTS THIS IS USED AS TEST FILE FOR ALL EXAMPLES ROSE IS A BEAUTIFUL FLOWER TIGER IS A MAJESTIC ANIMAL BE GOOD DO GOOD
ByteArrayInputStream
%\WH$UUD\,QSXW6WUHDP LV DQ LPSOHPHQWDWLRQ RI DQ LQSXW VWUHDP WKDW XVHV D E\WH DUUD\ DV WKH VRXUFH7KLVFODVVKDVWZRFRQVWUXFWRUVHDFKRIZKLFKUHTXLUHVDE\WHDUUD\WRSURYLGHWKHGDWD VRXUFH %\WH$UUD\,QSXW6WUHDP E\WHDUUD\>@ %\WH$UUD\,QSXW6WUHDP E\WHDUUD\>@LQWVWDUWLQWQXP%\WHV +HUHDUUD\LVWKHLQSXWVRXUFH7KHVHFRQGFRQVWUXFWRUFUHDWHVDQ,QSXW6WUHDPIURPDVXEVHWRI WKHE\WHDUUD\WKDWEHJLQVZLWKWKHFKDUDFWHUDWWKHLQGH[VSHFLILHGE\VWDUWDQGLVQXP%\WHVORQJ $ %\WH$UUD\,QSXW6WUHDP LPSOHPHQWV RQH DGGLWLRQDO PHWKRG WKDW LV QRW VXSSRUWHG E\ D )LOH,QSXW6WUHDP UHVHW 7KLV PHWKRG UHVHWV WKH VWUHDP SRLQWHU WR UHIHU WR WKH VWDUW RI WKH Comp-U-Learn
103
Java Programming I
VWUHDP ZKLFK LQ WKLV FDVH LV WKH VWDUW RI WKH E\WH DUUD\ SDVVHG WR WKH FRQVWUXFWRU %\WH$UUD\2XWSXW LV DQ LPSOHPHQWDWLRQ RI DQ RXWSXW VWUHDP WKDW XVHV D E\WH DUUD\ DV WKH GHVWLQDWLRQ%\WH$UUD\2XWSXW6WUHDPKDVWZRFRQVWUXFWRUV ByteArrayOutputStream() ByteArrayOutputStream(int numBytes) ,QWKHILUVWIRUPDEXIIHURIE\WHVLVFUHDWHG,QWKHVHFRQGDEXIIHULVFUHDWHGZLWKDVL]H HTXDOWRWKDWVSHFLILHGE\QXP%\WHV7KHEXIIHUVL]HZLOOEHLQFUHDVHGDXWRPDWLFDOO\LIQHHGHG 7KHIROORZLQJH[DPSOHDFFHSWVVSHFLILHGQXPEHURIFKDUDFWHUVDVLQSXWDQGFRQYHUWVWKHPLQWR XSSHUFDVHFKDUDFWHUV Example 5.10 import java.io.*; class ex29 { public static void main(String args[]) throws Exception { ByteArrayOutputStream f=new ByteArrayOutputStream(12); System.out.println("enter 10 chars and then press enter key"); System.out.println("these will be converted into uppercase characters "); while(f.size()!=10) { f.write(System.in.read()); } System.out.println("accepted characters into an array"); byte b[]=f.toByteArray(); System.out.println("displaying characters in the array"); for(int i=0;i
104
Comp-U-Learn
Streams and File Handling
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex29 enter 10 chars and then press enter key these will be converted into uppercase characters Acrobatics accepted characters into an array displaying characters in the array A c r o b a t i c s Converted to upper case characters ACROBATICS
StringBufferInputStream
6WULQJ%XIIHU,QSXW6WUHDPLVVLPLODUWR%\WH$UUD\,QSXW6WUHDPH[FHSWWKDWWKHLQWHUQDOEXIIHULVD 6WULQJ LQVWHDG RI D E\WH DUUD\ DQG WKHUH LV QR FRUUHVSRQGLQJ RXWSXW FODVV ,W KDV RQO\ RQH FRQVWUXFWRU StringBufferInputStream(String str)
,QWKLVFRQVWUXFWRUVWULVWKH6WULQJREMHFWXVHGDVWKHLQSXWVRXUFH
Filtered Streams )LOWHUHG VWUHDPV DUH VLPSO\ ZUDSSHUV DURXQG XQGHUO\LQJ LQSXW RU RXWSXW VWUHDPV WKDW WUDQVSDUHQWO\SURYLGHVRPHH[WHQGHGOHYHORIIXQFWLRQDOLW\7KHVHVWUHDPVDUHW\SLFDOO\DFFHVVHG E\PHWKRGVWKDW DUHH[SHFWLQJDJHQHULFVWUHDPZKLFKLVDVXSHUFODVVRIWKHILOWHUHGVWUHDPV 7\SLFDOH[WHQVLRQVDUHEXIIHULQJFKDUDFWHUWUDQVODWLRQDQGUDZGDWDWUDQVODWLRQ 7KHVH ILOWHUHG VWUHDPV KDYH WKH DGGLWLRQDO IXQFWLRQ RI SURYLGLQJ V\QFKURQL]DWLRQ $OO RI WKH FRQVWUXFWRUV DQG PHWKRGV SURYLGHG LQ WKHVH FODVVHV DUH LGHQWLFDO WR ,QSXW6WUHDP DQG 2XWSXW6WUHDPH[FHSWWKDWWKH\DUHV\QFKURQL]HG
Comp-U-Learn
105
Java Programming I
Buffered Streams %XIIHUHG VWUHDPV H[WHQG WKH ILOWHUHG VWUHDP FODVVHV E\ DWWDFKLQJ D PHPRU\ EXIIHU WR WKH ,2 VWUHDPV 7KLV EXIIHU DOORZV -DYD WR GR ,2 RSHUDWLRQV RQ PRUH WKDQ D E\WH DW D WLPH KHQFH LQFUHDVLQJSHUIRUPDQFH%HFDXVHWKHEXIIHULVDYDLODEOHVNLSSLQJPDUNLQJDQGUHVHWWLQJRIWKH VWUHDPEHFRPHVSRVVLEOH BufferedInputStream
%XIIHULQJ ,2 LV D YHU\ FRPPRQ SHUIRUPDQFH RSWLPL]DWLRQ -DYD·V %XIIHUHG,QSXW6WUHDP FODVV DOORZV XV WR ZUDS DQ\ ,QSXW6WUHDP LQWR D EXIIHUHG VWUHDP DQG DFKLHYH WKLV SHUIRUPDQFH LPSURYHPHQW %XIIHULQJ DQ LQSXW VWUHDP DOVR SURYLGHV WKH IRXQGDWLRQ UHTXLUHG WR VXSSRUW PRYLQJ EDFNZDUG LQ WKH VWUHDP RI WKH DYDLODEOH EXIIHU 7KLV FODVV DFFHSWV LQSXW E\ XVLQJ D EXIIHUHG DUUD\ RI E\WHV WKDW DFWV DV D FDFKH DQG LW XWLOL]HV WKH PDUN DQG UHVHW PHWKRG $ FKXQNRIE\WHVIURPWKHEXIIHUHGDUUD\FDQEHFKRVHQDQGUHDG BufferedOutputStream
$%XIIHUHG2XWSXW6WUHDPLVVLPLODUWRDQ\2XWSXW6WUHDPZLWKWKHH[FHSWLRQRIDQDGGHGIOXVK PHWKRGWKDWLVXVHGWRHQVXUHWKDWGDWDEXIIHUVDUHSK\VLFDOO\ZULWWHQWRWKHDFWXDORXWSXWVWUHDP 6LQFHWKHSRLQWRID%XIIHUHG2XWSXW6WUHDPLVWRLPSURYHSHUIRUPDQFHE\UHGXFLQJWKHQXPEHU RIWLPHVWKHV\VWHPDFWXDOO\ZULWHVWKHGDWDZHPD\QHHGWRFDOOIOXVK WRFDXVHDQ\GDWDWKDWLV LQ WKH EXIIHU WR EH ZULWWHQ 8QOLNH %XIIHUHG,QSXW6WUHDP EXIIHUHG RXWSXW GRHVQ·W SURYLGH DQ\ DGGLWLRQDOIXQFWLRQDOLW\%XIIHUVIRURXWSXWLQ-DYDDUHPHDQWWRLQFUHDVHWKHSHUIRUPDQFH
Pushback Input Stream 3XVKEDFN LV XVHG RQ DQ LQSXW VWUHDP WR DOORZ D FKDUDFWHU WR EH UHDG DQG WKHQ UHWXUQHG LH SXVKHGEDFN WRWKHVWUHDP7KH3XVKEDFN,QSXW6WUHDPFODVVLPSOHPHQWVWKLVLGHD,WSURYLGHVD PHFKDQLVPWRSHHNDWZKDWLVFRPLQJIURPDQLQSXWVWUHDPZLWKRXWGLVUXSWLQJLW+RZHYHUDQ\ DWWHPSWWRSXVKEDFNPRUHWKDQDVLQJOHFKDUDFWHUUHVXOWVLQDQ,2([FHSWLRQEHLQJWKURZQ$Q H[DPSOHWRVKRZWKH3XVKEDFN,QSXW6WUHDPDQGXQUHDG Example 5.11 import java.io.*; class ex30 { public static void main(String args[]) throws IOException { String s="if (a== 4) a=0 \n"; byte buf[]=new byte[s.length()]; s.getBytes(0,s.length(),buf,0); ByteArrayInputStream in=new ByteArrayInputStream(buf);
106
Comp-U-Learn
Streams and File Handling PushbackInputStream f=new PushbackInputStream(in); int c; while((c=f.read()) !=-1) { switch(c) { case '=': if((c=f.read())=='=') System.out.print(".eq."); else { System.out.print("<-"); f.unread(c); } break; default: System.out.print((char)c); break; } } } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex30 if (a.eq. 4) a<-0
Stream Tokenizer
7KLVFODVVKHOSVLQLGHQWLI\LQJWKHSDWWHUQVLQWKHLQSXWVWUHDP,WLVUHVSRQVLEOHIRUEUHDNLQJXS WKH ,QSXW6WUHDP LQWR WRNHQV ZKLFK DUH GHOLPLWHG E\ D VHW RI FKDUDFWHUV 7KH EHVW XVH RI WKLV FODVVLVWRLGHQWLI\WKHQXPEHURIZRUGVRUOLQHVZLWKLQDILOH
Random Access File 5DQGRP$FFHVV)LOH HQFDSVXODWHV D UDQGRP DFFHVV ILOH ,W LV QRW GHULYHG IURP ,QSXW6WUHDP RU 2XWSXW6WUHDP,QVWHDGLWLPSOHPHQWVWKHLQWHUIDFH'DWD,QSXWDQG'DWD2XWSXWZKLFKGHILQHV WKHEDVLF,2PHWKRGV,WDOVRVXSSRUWVSRVLWLRQLQJUHTXHVWVLHZHFDQSRVLWLRQWKHILOHSRLQWHU ZLWKLQWKHILOH,WKDVWKHIROORZLQJFRQVWUXFWRUV RandomAccessFile(File fObj, string acc) RandomAccessFile(String fname, String acc)
,Q WKH ILUVW IRUP I2EM VSHFLILHV WKH QDPH RI WKH ILOH WR RSHQ DV D )LOH REMHFW ,Q WKH VHFRQG PHWKRGWKHQDPHRIWKHILOHLVSDVVHGDVIQDPH,QERWKWKHFDVHVDFFGHWHUPLQHVZKDWW\SHRI Comp-U-Learn
107
Java Programming I
ILOH DFFHVV LV SHUPLWWHG ,I LW LV ¶U· WKHQ WKH ILOH KDV UHDG DFFHVV DQG LI LW LV ¶UZ· WKHQ WKH ILOH LV RSHQHG LQ UHDGZULWH PRGH 7KH PHWKRG VHHN LV XVHG WR VHW WKH FXUUHQW SRVLWLRQ RI WKH ILOH SRLQWHUZLWKLQWKHILOH void seek(long newPos)
+HUHQHZSRVVSHFLILHVWKHQHZSRVLWLRQLQE\WHVRUWKHILOHSRLQWHUIURPWKHEHJLQQLQJRUHQG RIWKHILOH$IWHUDFDOOWRWKHVHHNPHWKRGWKHQH[WUHDGRUZULWHRSHUDWLRQVZLOORFFXUDWWKH QHZILOHSRVLWLRQ
Reader and Writer Classes 7KH GLIIHUHQFH EHWZHHQ 5HDGHUV DQG ,QSXW6WUHDPV LV WKDW ZKLOH UHDGHUV DUH DEOH WR UHDG FKDUDFWHUVLQSXWVWUHDPVUHDGE\WHV7KLVLQFUHDVHVWKHSRZHURIWKH-DYD,26WUHDPFODVVHVE\ EHLQJ DEOH WR UHDG DQ\ FKDUDFWHUV DQG WKXV HQDEOLQJ LQWHUQDWLRQDOL]DWLRQ ,Q VLPSOH WHUPV LW LV SRVVLEOH WR ZULWH -DYD SURJUDPV LQ ODQJXDJHV OLNH *HUPDQ -DSDQHVH DQG )UHQFK 7KH IXQFWLRQDOLW\RIWKHZULWHULVVLPLODUWR2XWSXW6WUHDPVDQGLWLVSRVVLEOHWRZULWHRQHEORFN RI E\WHVRUFKDUDFWHUV Reader
7KHIROORZLQJVHFWLRQGHDOVZLWKDIHZVXEFODVVHVRI5HDGHU6RPHRIWKHVXEFODVVHVRI5HDGHU &ODVVDUH 1. FileReader
7KLVFODVVLVVLPLODUWR)LOH,QSXW6WUHDP&ODVV 2. CharArray Reader and StringReader
7KHVH FODVVHV DUH VLPLODU WR %\WH$UUD\,QSXW6WUHDP DQG 6WULQJ%XIIHU,QSXW6WUHDP FODVVHV 7KHLU FRQVWUXFWRUVDUHJLYHQEHORZ public CharArrayReader(char ch[]); public StringReader(String s);
3. InputStreamReader
7KLVFODVVZDVGHVLJQHGIURPE\WHRULHQWHGVLWXDWLRQVWRFKDUDFWHURULHQWHGVLWXDWLRQV,WUHDGV E\WHV IURP DQ ,QSXW6WUHDP5HDGHU DQG FRQYHUWV WKHP WR FKDUDFWHUV DFFRUGLQJ WR D PDSSLQJ DOJRULWKP 7KH GHIDXOW PDSSLQJ LGHQWLILHV E\WHV DV FRPPRQ $6&,, FKDUDFWHUV DQG FRQYHUWV WKHPWR-DYD81,&2'(FKDUDFWHUV
108
Comp-U-Learn
Streams and File Handling 4. BufferedReader Class
7KLVFODVVDFFHSWVDUHDGHUREMHFWDVLWVSDUDPHWHUDQGDGGVDEXIIHURIFKDUDFWHUVWRLW7KLVFODVV LVPDLQO\XVHIXOEHFDXVHRILWVUHDG/LQH Writer class
$IHZRIWKHVXEFODVVHVRI:ULWHUFODVVDUH
)LOH:ULWHU
&KDU$UUD\:ULWHU
3ULQW:ULWHU
)LOWHU:ULWHU
%XIIHUHG:ULWHU
$QH[DPSOHWRVKRZ5HDGHUDQG:ULWHUFODVVHV Example 5.12 import java.io.*; public class ex50 { public static void main(String args[]) { try { BufferedReader in = new BufferedReader(new FileReader(args[0])); String s,s1 = new String(); while ((s=in.readLine())!=null) s1+=s+'\n'; in.close(); BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in)); System.out.println("Enter a Line"); System.out.println("Usage of buffered reader and InputStreamReader"); System.out.println(stdin.readLine()); StringReader intwo = new StringReader(s1); int c; System.out.println("Printing individual chars of a file " + args[0]); while ((c=intwo.read())!=-1) System.out.println((char)c); BufferedReader in4 = new BufferedReader(new StringReader(s1)); PrintWriter p = new PrintWriter (new BufferedWriter(new FileWriter("str1")));
Comp-U-Learn
109
Java Programming I while((s=in4.readLine())!=null) p.println("Output "+s); p.close(); } catch(IOException e) { } } }
2XWSXWRIWKHSURJUDP C:\jdk1.1.5\bin>java ex50 ex41.java Enter a Line Usage of buffered reader and InputStreamReader india is my country // The contents of the file ex41.java will be displayed character by character, also the contents of the file will be stored in “str1”.
Summary The Streaming interface in Java provides a clean abstraction for a complex and often cumbersome task. The composition of the filtered stream classes allow us to dynamically build the custom streaming interface to suit our data transfer requirements. Streams are a method of receiving and sending information. The InputStream, OutputStream, DataStreams, PrintStream, RandomAccessFile Streams, BufferedInputStream and BufferedOutputStream are some of the important File Stream classes in Java. Java programs written to adhere to the abstract, high level InputStream and OutputStream classes will function properly in the future even when new and improved concrete stream classes are invented.
Going Over It Again I. Fill in the Blanks
BBBBBBBBBBBBBDQGBBBBBBBBKHOSLQUHDGLQJDQGZULWLQJGDWDIURPDFWXDOGLVNILOHV BBBBBBBBBBBDQGBBBBBBBBBBPDNHXVHRIWKHE\WHDUUD\DVDQLQSXWVRXUFHWRSHUIRUP UHDGLQJDQGZULWLQJRSHUDWLRQVRQWKDWDUUD\ BBBBBBBBKHOSVWREUHDNWKH,QSXW6WUHDPLQWRWRNHQV
110
Comp-U-Learn
Streams and File Handling
BBBBBBBLVXVHGWRILOWHUILOHVZLWKDVSHFLILHGSDWWHUQDQGWKHQOLVWWKHP BBBBBBBBBPHWKRGKHOSVLQFOHDULQJWKHEXIIHU BBBBBBBBBPHWKRGLQ-DYDLVXVHGWRFUHDWH'LUHFWRULHV BBBBBBBBBH[FHSWLRQLVUDLVHGLQ,QSXWDQG2XWSXW6WUHDPV II. State True or False
7KH5HDGHUDQGZULWHUFODVVHVDUHXVHGWRUHDGDQGZULWHFKDUDFWHUVLQVWHDGRIE\WHV )LOH2XWSXW6WUHDPGRHVQRWDOORZDSSHQGLQJGDWDWRDQH[LVWLQJILOH 5HDGLQJRUZULWLQJFDQEHGRQHHYHQDIWHUFORVLQJWKHLQSXWRXWSXWVRXUFH 7KHDFFHSW PHWKRGLVDYDLODEOHLQ)LOHFODVV ,Q-DYDGLUHFWRULHVDUHQRWILOHV III. One line Answers
:KDWLVD6WUHDP" :ULWHVKRUWQRWHVRQ%XIIHUHG6WUHDPV :ULWHWKHXVDJHRIDFFHSW DQGOLVW 'HILQHD3ULQW6WUHDP :KDWDUH)LOWHUHG6WUHDPV"
Comp-U-Learn
111
Session 6
Exception Handling and MultiThreading
On Completion of this Session We will be able to understand...
) Concepts of errors ) Need To handle errors ) Error Handling in Java ) Uncaught exceptions ) Usage of try, catch, finally and throw blocks ) The Throwable Class ) About Multithreading
In This Session...
Exception Handling – An Insight
Advantages of Exception Handling
Uncaught Exceptions
Multiple Catch Clauses
Implicit and Explicit Exceptions
Java.lang.Throwable
Finally Clause
Creating Own Exception subclasses
MultiThreading
Thread States
Thread Priority
Daemon Threads
Exception Handling and MultiThreading
Exception Handling – An Insight (UURUV DOZD\V RFFXU DQG LW LV LPSRUWDQW WR SURYLGH PHDQV WR KDQGOH WKHP (UURU KDQGOLQJ EHFRPHV D QHFHVVLW\ ZKLOH GHYHORSLQJ DSSOLFDWLRQV WR DFFRXQW IRU XQH[SHFWHG VLWXDWLRQV OLNH UXQQLQJRXWRIPHPRU\UHVRXUFHDOORFDWLRQHUURUVRULQDELOLW\WRILQGILOHV6WDWLVWLFVUHYHDOWKDW DVDUHVXOWRIHUURUKDQGOLQJWKHVL]HRIDSURJUDPLQFUHDVHVRQDQDYHUDJHE\PRUHWKDQ 7RPDLQWDLQD EDODQFHEHWZHHQ HUURU KDQGOLQJDQGWKHVL]H RIWKHVRXUFHFRGH-DYD RIIHUV DQ ([FHSWLRQ FODVV ZKLFK ZKHQ MXGLFLRXVO\ LPSOHPHQWHG LQ SURJUDPV ZRXOG WDNH FDUH RI WKH XQH[SHFWHGVLWXDWLRQV %DVLFDOO\WKHUHDUHWZRNLQGVRIHUURUV7KH\DUH &RPSLOHWLPHHUURUV7KHHUURUVWKDWRFFXUGXULQJFRPSLODWLRQRIDSURJUDP 5XQWLPHHUURUV²7KHHUURUVWKDWRFFXUGXULQJH[HFXWLRQ Sources of Errors User Input Errors
7KHVHDUHW\SLQJHUURUVV\QWD[HUURUVLQFRUUHFWRUQRQH[LVWHQW85/VHWF Device Errors
7KHVHHUURUVRFFXUZKHQWKHUHDUHSUREOHPVZLWKGHYLFHVVXFKDVSULQWHUVLPSURSHUO\FRQQHFWHG GHYLFHVSULQWHUVRXWRISDSHUVHWF Physical Limitations
7KHVHHUURUVRFFXUZLWKUHVSHFWWRWKHSK\VLFDOHQWLWLHVRUFDSDFLWLHV(J6SDFHLVQRWDYDLODEOH RQGLVNVRUPDLQPHPRU\ Code Errors
(UURUV WKDW RFFXU ZKHQ ORJLF LV ZURQJ SRSSLQJ HPSW\ VWDFN ORFDWLQJ QRQH[LVWHQW ILOHV GDWD VWUXFWXUHVHWF ,Q-DYDWKH5XQWLPHHUURUVDUHFDOOHGH[FHSWLRQVDQGWKHSURFHVVRIGHDOLQJZLWKWKHPLVFDOOHG H[FHSWLRQ KDQGOLQJ 7KH WHUP H[FHSWLRQ LV D VKRUW IRUP IRU H[FHSWLRQDO HYHQWV ,W FRXOG EH GHILQHGDVDQHYHQWWKDWRFFXUVGXULQJWKHH[HFXWLRQRIDSURJUDPWKDWGLVUXSWVWKHQRUPDOIORZ RILQVWUXFWLRQV :KHQ DQ HUURU RFFXUV LQ D -DYD PHWKRG WKH PHWKRG FUHDWHV DQ REMHFW RI W\SH ([FHSWLRQ DQG JLYHVLWWRWKHUXQWLPHV\VWHP7KH([FHSWLRQREMHFWFRQVLVWVRIWKHLQIRUPDWLRQSHUWDLQLQJWR Comp-U-Learn
115
Java Programming I
WKHH[FHSWLRQOLNHLWVW\SHDQGVWDWHRIWKHSURJUDPZKHQWKHH[FHSWLRQRFFXUUHG7KHUXQWLPH V\VWHP ORRNV RXW IRU WKH DSSURSULDWH PHWKRG WKDW ZRXOG KDQGOH WKH HUURU WKDW KDV EHHQ HQFRXQWHUHG 7KH SURFHVV RI FUHDWLQJ DQ ([FHSWLRQ REMHFW DQG KDQGOLQJ LW WR WKH UXQWLPH V\VWHPLVFDOOHGWKURZLQJDQH[FHSWLRQ7KHPHWKRGWKDWKDQGOHVWKHH[FHSWLRQWKURZQLVFDOOHG DQ H[FHSWLRQ KDQGOHU 7KH H[FHSWLRQ KDQGOHU LV XVHG WR FDWFK WKH H[FHSWLRQ WKURZQ 7KH UXQ WLPH V\VWHP VHDUFKHV IRU WKH H[FHSWLRQ KDQGOHU VWDUWLQJ IURP WKH PHWKRG ZKHUH WKH HUURU RFFXUUHG7KHVHDUFKJRHVRQWLOOWKHUXQWLPHV\VWHPILQGVDQDSSURSULDWHH[FHSWLRQKDQGOHU$ PHWKRGLVWHUPHGDQDSSURSULDWHH[FHSWLRQKDQGOHULIWKHW\SHRIWKHH[FHSWLRQFDXJKWE\WKH KDQGOHULVWKHVDPHDVWKHW\SHRIWKHH[FHSWLRQ ,I WKH DSSURSULDWH KDQGOHU LV QRW IRXQG WKHQ WKH UXQWLPH V\VWHP WHUPLQDWHV WKH DSSOLFDWLRQ 7KH H[FHSWLRQ KDQGOLQJ PHFKDQLVP WUDQVIHUV WKH FRQWURO IURP WKH HUURU RFFXUUHG WR WKH H[FHSWLRQKDQGOHUWKDWFDQGHDOZLWKWKHH[FHSWLRQV
Advantages of Exception Handling -DYDSURJUDPVKDYHWKHIROORZLQJDGYDQWDJHRYHUWUDGLWLRQDOHUURUPDQDJHPHQWWHFKQLTXHV ♦ ♦ ♦ ♦ ♦
Separating Error handling Code from Regular Code Propagating Errors Up the Call Stack Grouping Error Types and Error Differentiation Allows fixing the errors It prevents the program from automatic termination
([FHSWLRQV DUH D SDUW RI WKH LQKHULWDQFH KLHUDUFK\ DQG DUH GHULYHG IURP WKH 7KURZDEOH FODVV 7KDWLVDQH[FHSWLRQLVDQLQVWDQFHRI WKH 7KURZDEOH FODVV 7KH H[FHSWLRQ KLHUDUFK\ LV JLYHQ EHORZ Throwable
Error
Exception
IOException
Fig 6.1 116
Comp-U-Learn
RunTime Exception
Exception Handling and MultiThreading
$OOH[FHSWLRQW\SHVDUHVXEFODVVHVRIWKHEXLOWLQFODVV7KURZDEOH7KXV7KURZDEOHLVDWWKHWRS RIWKHH[FHSWLRQFODVVKLHUDUFK\,PPHGLDWHO\EHORZ7KURZDEOHDUHWZRVXEFODVVHVWKDWSDUWLWLRQ H[FHSWLRQVLQWRWZRGLVWLQFWEUDQFKHV2QHEUDQFKLVKHDGHGE\H[FHSWLRQ7KLVFODVVLVXVHGIRU H[FHSWLRQDOFRQGLWLRQVWKDWXVHUSURJUDPVVKRXOGFDWFK7KLVLVDOVRWKHFODVVWKDWZHZLOOVXE FODVVZKHQZHFUHDWHRXUFXVWRPH[FHSWLRQW\SHV7KHUHLVDQLPSRUWDQWVXEFODVVRIH[FHSWLRQ FDOOHGUXQWLPH ([FHSWLRQ([FHSWLRQVRIWKLVW\SHDUHDXWRPDWLFDOO\GHILQHGIRUWKHSURJUDPV WKDW ZH ZLOO ZULWH DQG LQFOXGH WKLQJV VXFK DV GLYLVLRQ E\ ]HUR DQG LQYDOLG DUUD\ LQGH[LQJ ([FHSWLRQVWKDWLQKHULWIURPWKLVFODVVLQFOXGH ♦ Bad cast ♦ Out of bound array access ♦ Null pointer access 7KHVHSUREOHPVDUHRXWRIZURQJSURJUDPPLQJORJLFDQGPXVWEHFRUUHFWHGE\WKHSURJUDPPHU KLPVHOI6RPHRIWKHVHH[FHSWLRQVDUH ♦ ArithmeticException ♦ NullPointerException ♦ ClassCastException ♦ ArrayIndexOutOfBoundsException
Other exceptions
7KHVHLQFOXGHH[FHSWLRQVIRUPXOWLWKUHDGLQJPDOIRUPHG85/UHDGLQJSDVWHQGRIILOHHWF6RPH RIWKHVXEFODVVHVDUH ♦ IOException ♦ AWTException ♦ ClassNotFoundException ♦ IllegalAccessException 7KH RWKHU EUDQFK LV WRSSHG E\ (UURU ZKLFK GHILQHV H[FHSWLRQV WKDW DUH QRW H[SHFWHG WR EH FDXJKWXQGHUQRUPDOFLUFXPVWDQFHVE\RXUSURJUDP([FHSWLRQVRIW\SH(UURUDUHXVHGE\WKH -DYDUXQWLPHV\VWHPWRLQGLFDWHHUURUVKDYLQJWRGRZLWKWKHUXQWLPHHQYLURQPHQWLWVHOI6WDFN RYHUIORZ LV DQ H[DPSOH RI VXFK DQ HUURU EHFDXVH WKHVH DUH W\SLFDOO\ FUHDWHG LQ UHVSRQVH WR FDWDVWURSKLFIDLOXUHVWKDWFDQQRWXVXDOO\EHKDQGOHGE\RXUSURJUDP Comp-U-Learn
117
Java Programming I
Uncaught Exceptions /RRNDWWKHSURJUDPJLYHQEHORZ,WKDVZLOOIXOO\LQFOXGHGDGLYLVLRQE\]HUR Example 6.1 class ex61 { public static void main(String args[]) { int d=0; int a=42/d; } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>javac ex61.java C:\jdk1.2\bin>java ex61 Exception in thread "main" java.lang.ArithmeticException: / by zero at ex61.main(ex61.java:6) C:\jdk1.2\bin>
:KHQ WKH -DYD UXQ WLPH V\VWHP GHWHFWV WKH DWWHPSW WR GLYLGH E\ ]HUR LW FRQVWUXFWV D QHZ H[FHSWLRQ REMHFW DQG WKHQ WKURZV WKLV H[FHSWLRQ 7KLV FDXVHV WKH H[HFXWLRQ RI H[ WR VWRS EHFDXVH RQFH DQ H[FHSWLRQ KDV EHHQ WKURZQ LW PXVW EH FDXJKW E\ DQ H[FHSWLRQ KDQGOHU DQG GHDOW ZLWK LPPHGLDWHO\ ,Q WKLV H[DPSOH ZH KDYHQ·W VXSSOLHG DQ\ H[FHSWLRQ KDQGOHUV RQ RXU RZQ VR WKH H[FHSWLRQ LV FDXJKW E\ WKH GHIDXOW KDQGOHU SURYLGHG E\ WKH -DYD UXQWLPH V\VWHP 7KH GHIDXOW KDQGOHU ZLOO XOWLPDWHO\ SURFHVV DQ\ H[FHSWLRQ WKDW LV QRW FDXJKW E\ RXU SURJUDP 7KH GHIDXOW KDQGOHU GLVSOD\V D VWULQJ GHVFULELQJ WKH H[FHSWLRQ SULQWV D VWDFN WUDFH IURP WKH SRLQWDWZKLFKWKHH[FHSWLRQRFFXUUHGDQGWHUPLQDWHVWKHSURJUDP1RWLFHKRZWKHFODVVQDPH H[WKHPHWKRGQDPHPDLQWKHILOHQDPHH[MDYDDQGWKHOLQHQXPEHUDUHDOOLQFOXGHGLQ WKHVLPSOH VWDFN WUDFH 1RWH WKDW WKH W\SH RI WKH H[FHSWLRQ WKURZQ LV D VXEFODVV RI ([FHSWLRQ FDOOHGDULWKPHWLF([FHSWLRQZKLFKPRUHVSHFLILFDOO\GHVFULEHVZKDWW\SHRIHUURUKDVRFFXUUHG -DYD H[FHSWLRQ KDQGOLQJ LV PDQDJHG YLD ILYH NH\ZRUGV WU\ FDWFK WKURZ WKURZV DQG ILQDOO\ 3URJUDPVWDWHPHQWVWKDWZHZDQWWRPRQLWRUIRUH[FHSWLRQVDUHFRQWDLQHGZLWKLQDWU\EORFN,I DQH[FHSWLRQRFFXUVZLWKLQWKHWU\EORFNLWLVWKURZQ2XUFRGHFDQFDWFKWKLVH[FHSWLRQ XVLQJ FDWFK DQG KDQGOH LW LQ VRPH UDWLRQDO PDQQHU 6\VWHP JHQHUDWHG H[FHSWLRQV DUH DXWRPDWLFDOO\ WKURZQE\WKH-DYDUXQWLPHV\VWHP7RPDQXDOO\WKURZDQH[FHSWLRQXVHWKHNH\ZRUGWKURZ $Q\H[FHSWLRQWKDWLVWKURZQRXWRIDPHWKRGPXVWEHVSHFLILHGDVVXFKE\DWKURZVFODXVH$Q\ FRGHWKDWDEVROXWHO\PXVWEHH[HFXWHGEHIRUHDPHWKRGUHWXUQVLVSXWLQDILQDOO\EORFN 118
Comp-U-Learn
Exception Handling and MultiThreading This is the general form of n exception handling try { //Block of code to monitor for errors } catch(ExceptionType1 exObj) { // exception handler for Exceptiontype 1 } catch(ExceptionType2 exObj2) { //exception handler for exception type 2 } //.......................... ........................... finally { // block of code to be executed before try block ends }
+HUHH[FHSWLRQW\SHLVWKHW\SHRIH[FHSWLRQWKDWKDVRFFXUUHG
Note We can throw many exceptions in one method, but we cannot throw exceptions inherited from Error class and those from RunTimeException $VDPSOHSURJUDPWRLOOXVWUDWHWKHXVDJHRIWKURZLQJDQH[FHSWLRQ Example 6.2 class ex62 { public static void main(String args[]) { System.out.println("enter a character "); char c=(char)System.in.read(); } }
2XWSXWRIWKHSURJUDP C:\jdk1.2\bin>javac ex62.java Ex62a.java:6: Exception java.io.IOException must be caught, or it must be declared in the throws clause of this method. char c=(char)System.in.read(); ^ 1 error
Comp-U-Learn
119
Java Programming I
1RZZHFDPUHZULWHWKHSURJUDPDVVKRZQEHORZDQGVHHWKHRXWSXW class ex62 { public static void main(String args[]) throws java.io.IOException { System.out.println("enter a character "); char c=(char)System.in.read(); } }
7KHRXWSXWRIWKHSURJUDPQRZLV C:\jdk1.2\bin>java ex62 java C:\jdk1.2\bin>java ex62 Enter a character i
1RZZHFDQUHZULWHWKHSURJUDPH[MDYDZKLFKWKURZVDQ$ULWKPHWLF([FHSWLRQ class ex61 { public static void main(String args[]) { int d,a; try { d=0; a=42/d; System.out.println("Test to see the try block } catch (ArithmeticException e) { System.out.println("Division by zero "); System.out.println("Inside catch block "); } System.out.println("After catch block "); } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>javac ex61.java C:\jdk1.2\bin>java ex61 Division by zero Inside catch block After catch block C:\jdk1.2\bin>
120
Comp-U-Learn
");
Exception Handling and MultiThreading
1RWLFHWKDWWKHFDOOWRWKHSULQWOQVWDWHPHQWLQVLGHWKHWU\EORFNKDVQ·WJRWH[HFXWHG2QFH DQ H[FHSWLRQLVWKURZQSURJUDPFRQWUROWUDQVIHUVRXWRIWKHWU\EORFNWRWKHFDWFKEORFNWRKDQGOH WKHH[FHSWLRQEHLQJWKURZQRXW7KHWU\EORFNGRHVQRWFDOODFDWFKEORFNDQGKHQFHFRQWUROZLOO QRWJHWWUDQVIHUUHGWRWU\EORFNRQFHPRUHDIWHUWKHH[FHSWLRQLVEHLQJKDQGOHG+HQFHWKHOLQH 6\VWHPRXWSULQOQ ´,QVLGHWU\EORFN ZLOOQRWEHGLVSOD\HGRQWKHVFUHHQ 2QFH WKH FDWFK EORFN LV H[HFXWHG SURJUDP FRQWLQXHV ZLWK WKH QH[W OLQH LQ WKH SURJUDP IROORZLQJ WKH HQWLUH WU\FDWFK EORFNV $ WU\ DQG D FDWFK IRUP D VLQJOH XQLW 7KH VFRSH RI WKH FDWFK VWDWHPHQW LV UHVWULFWHG WR WKRVH VWDWHPHQWV VSHFLILHG E\ WKH LPPHGLDWHO\ SUHFHGLQJ WU\ VWDWHPHQW7KHJRDORIPRVWZHOOFRQVWUXFWHGFDWFKFODXVHVVKRXOGEHWRUHVROYHWKHH[FHSWLRQDO FRQGLWLRQDQGWKHQFRQWLQXHRQDVLIQRHUURUKDVRFFXUUHG
Note Curly braces must surround the statements that are protected in a try statement. That is, they must be within a block. We cannot use try on a single statement. Displaying the description of an Exception
7KURZDEOH RYHUULGHV WKH WR6WULQJ PHWKRG GHILQHG E\ 2EMHFW VR WKDW LW UHWXUQV D VWULQJ FRQWDLQLQJ D GHVFULSWLRQ RI WKH H[FHSWLRQ :H FDQ GLVSOD\ WKLV GHVFULSWLRQ LQ D SULQWOQ VWDWHPHQWE\VLPSO\SDVVLQJWKHH[FHSWLRQDVDQDUJXPHQW)RUH[DPSOHWKHFDWFKEORFNLQWKH SUHFHGLQJSURJUDPFDQEHUHZULWWHQDV catch (ArithmeticException e) { System.out.println("Division by zero "); System.out.println("Inside catch block "); System.out.println(“Exception :”+e); }
7KLVZLOOJLYHWKHRXWSXW C:\jdk1.2\bin>java ex62 Division by zero Inside catch block Exception :java.lang.ArithmeticException: / by zero After catch block C:\jdk1.2\bin>
Comp-U-Learn
121
Java Programming I
Multiple Catch Clauses 0RUH WKDQ RQH H[FHSWLRQ FRXOG EH UDLVHG E\ D VLQJOH SLHFH RI FRGH 7R KDQGOH WKLV W\SH RI VLWXDWLRQZHFDQVSHFLI\WZRRUPRUHFDWFKFODXVHVHDFKFDWFKLQJDGLIIHUHQWW\SHRIH[FHSWLRQ :KHQDQH[FHSWLRQLVWKURZQHDFKFDWFKVWDWHPHQWLVLQVSHFWHGLQRUGHUDQGWKHILUVWRQHZKRVH W\SHPDWFKHVWKDWRIWKHH[FHSWLRQH[HFXWHG$IWHURQHFDWFKVWDWHPHQWH[HFXWHVWKHRWKHUVDUH E\SDVVHGDQGH[HFXWLRQFRQWLQXHVDIWHUWKHWU\FDWFKEORFN7KHIROORZLQJH[DPSOHWUDSVWZR GLIIHUHQWH[FHSWLRQW\SHV Example 6.3 class ex63 { public static void main(String args[]) { try{ int a=args.length; System.out.println("a = " +a); int b=42/a; int c[]= {1}; c[42]=99; System.out.println("Test to see the try } catch (ArithmeticException e) { System.out.println("Division by zero " } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index :" + e } System.out.println("After try and catch } }
block
");
+ e);
); block ");
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex63 a = 0 Division by zero java.lang.ArithmeticException: / by zero After try and catch block C:\jdk1.2\bin>java ex63 neem a = 1
:KHQZHXVHPXOWLSOHFDWFKVWDWHPHQWVLWLVLPSRUWDQWWRUHPHPEHUWKDWH[FHSWLRQVXEFODVVHV PXVW FRPH EHIRUH DQ\ RI WKHLU VXSHU FODVVHV 7KLV LV EHFDXVH D FDWFK VWDWHPHQW WKDW XVHV D VXSHUFODVVZLOOFDWFKH[FHSWLRQVRIWKDWW\SHSOXVDQ\RILWVVXEFODVVHV7KXVDVXEFODVVZRXOG QHYHU EH UHDFKHG LI LW FDPH DIWHU LWV VXSHUFODVV )XUWKHU LQ -DYD XQUHDFKDEOH FRGH LV DQ HUURU 7KHIROORZLQJFRGHZLOOLOOXVWUDWHWKLV 122
Comp-U-Learn
Exception Handling and MultiThreading
Example 6.4 class ex64 { public static void main(String args[]) { int d,a; try{ d=0; a=42/d; System.out.println("Test to see the try block "); } catch(Exception e) { System.out.println("General exception raised in catch " +e); } catch (ArithmeticException e) { System.out.println("Division by zero "); System.out.println("Inside catch block "); System.out.println("Exception :"+e); } System.out.println("After catch block "); } }
7KHRXWSXWRIWKHDERYHSURJUDPLVDVIROORZV C:\jdk1.2\bin>javac ex64.java Ex64.java:15: catch not reached. catch (ArithmeticException e) ^ 1 error C:\jdk1.2\bin>
Implicit and Explicit Exceptions $Q\ H[FHSWLRQ GHULYHG IURP (UURU FODVV RU 5XQ7LPH([FHSWLRQ DUH FDOOHG LPSOLFLW H[FHSWLRQV 7KHVH H[FHSWLRQV DUH EH\RQG RXU FRQWURO RU VKRXOG QRW KDYH RFFXUUHG LQ WKH ILUVW SODFH $OO RWKHU H[FHSWLRQV DUH H[SOLFLW H[FHSWLRQV $ PHWKRG PXVW GHFODUH DOO WKH H[SOLFLW H[FHSWLRQV LW WKURZV,IZHRYHUULGHDPHWKRGIURPDSDUHQWFODVVWKHFKLOGFODVVLQKHULWVWKHSDUHQWPHWKRG XQGHUVWDQGDEO\ EXW WKH FKLOG FDQQRW PDQXDOO\ IRUFH DQ H[FHSWLRQ XVLQJ WKURZ ,I WKH SDUHQW FODVVWKURZVQRH[SOLFLWH[FHSWLRQVDWDOOZHVKRXOGIROORZWKHVHVWHSVWRWKURZDQH[FHSWLRQ Comp-U-Learn
123
Java Programming I
)LQGWKHDSSURSULDWHH[FHSWLRQFODVV
00DNHDQREMHFWRIWKDWFODVV
7KURZWKDWREMHFW
Note We can create our Exception classes when the standard exceptions don’t meet our requirements.
Java.lang.Throwable public Throwable()
7KLVFRQVWUXFWVDQHZ7KURZDEOHREMHFWZLWKRXWDQ\REMHFW public Throwable(String message)
7KLV FRQVWUXFWV D QHZ 7KURZDEOH REMHFW ZLWK WKH PHVVDJH JLYHQ ,W FDQ EH XVHG WR SURYLGH LQIRUPDWLRQ IRU GHEXJJLQJ $OO GHULYHG H[FHSWLRQ FODVVHV VXSSRUW ERWK D GHIDXOW FRQVWUXFWRU ZLWKDGHWDLOHGPHVVDJH public String getMessage()
7KLVPHWKRGREWDLQVWKHGHWDLOHGPHVVDJHRIWKH7KURZDEOHREMHFW 7KHWU\VWDWHPHQWFDQEHQHVWHG7KDWLVDWU\VWDWHPHQWFDQEHLQVLGHWKHEORFNRIDQRWKHUWU\ (DFKWLPHDWU\VWDWHPHQWLVHQWHUHGWKHFRQWH[WRIWKDWH[FHSWLRQLVSXVKHGRQWKHVWDFN,IDQ LQQHU WU\ VWDWHPHQW GRHV QRW KDYH D FDWFK KDQGOHU IRU D SDUWLFXODU H[FHSWLRQ WKH VWDFN LV XQZRXQGDQGWKHQH[WWU\VWDWHPHQW·VFDWFKKDQGOHUVDUHLQVSHFWHGIRUDPDWFK7KLVFRQWLQXHV XQWLORQHRIWKHFDWFKVWDWHPHQWVXFFHHGVRUXQWLODOORIWKHQHVWHGWU\VWDWHPHQWVDUHH[KDXVWHG ,IQRFDWFKVWDWHPHQWPDWFKHVWKHQWKH-DYDUXQWLPHV\VWHPKDQGOHVWKHH[FHSWLRQ+HUHLVDQ H[DPSOHWRVKRZWKHQHVWHGWU\VWDWHPHQWV Example 6.5 class ex65 { public static void main(String args[]) { try { int a=args.length; int b=42/a; System.out.println("a = " + a);
124
Comp-U-Learn
Exception Handling and MultiThreading try{ if (a==1) a=a/(a-a); if (a==2) { int c[]={1}; c[42]=99; } } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index out of bounds : " +e); } }catch(ArithmeticException e) { System.out.println("Divide by 0 : " +e); } } }
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex65 Divide by 0 : java.lang.ArithmeticException: / by zero C:\jdk1.2\bin>java ex65 Uma a = 1 Divide by 0 : java.lang.ArithmeticException: / by zero C:\jdk1.2\bin>java ex65 Uma Uma2 a = 2 Array index out of bounds : java.lang.ArrayIndexOutOfBoundsException: 42 C:\jdk1.2\bin>
Throw
:KHQZHZDQWWRWKURZDQH[FHSWLRQH[SOLFLWO\ZHKDYHWRXVHDWKURZVWDWHPHQW7KHJHQHUDO IRUPRIWKURZLVVKRZQKHUH throw ThrowableInstance;
+HUH 7KURZDEOH,QVWDQFH PXVW EH DQ REMHFW RI W\SH 7KURZDEOH RU D VXEFODVV RI 7KURZDEOH 6LPSOHW\SHVVXFKDV LQW RU FKDU DV ZHOO DV QRQWKURZDEOH FODVVHV VXFK DV 6WULQJ DQG REMHFW FDQQRWEHXVHGDVH[FHSWLRQV 7KHUH DUH WZR ZD\V ZH FDQ REWDLQ D 7KURZDEOH REMHFW XVLQJ D SDUDPHWHULQWRDFDWFKFODXVHRUFUHDWLQJRQHZLWKWKHQHZRSHUDWRU 7KHIORZRIH[HFXWLRQVWRSVLPPHGLDWHO\DIWHUWKHWKURZVWDWHPHQW DQ\VXEVHTXHQWVWDWHPHQWV DUHQRWH[HFXWHG7KHQHDUHVWHQFORVLQJWU\EORFNLVLQVSHFWHGWRVHHLILWKDVDFDWFKVWDWHPHQW Comp-U-Learn
125
Java Programming I
WKDW PDWFKHV WKH W\SH RI WKH H[FHSWLRQ ,I LW ILQGV D PDWFK FRQWURO LV WUDQVIHUUHG WR WKDW VWDWHPHQW,IQRWWKHQWKHQH[WHQFORVLQJWU\VWDWHPHQWLVLQVSHFWHGDQGVRRQ,IQRPDWFKLQJLV IRXQGWKHQWKHGHIDXOWH[FHSWLRQKDQGOHUKDOWVWKHSURJUDPDQGSULQWVWKHVWDFNWUDFH 7KHVDPSOHSURJUDPLVJLYHQEHORZ Example 6.6 class ex66 { static void FnA() { try { throw new NullPointerException("demo"); }catch(NullPointerException e) { System.out.println("Caught inside the Function A"); throw e; } } public static void main(String args[]) { try { FnA(); }catch(NullPointerException e) { System.out.println(" Recaught: "+e); } } } The output of the program will be as follows C:\jdk1.2\bin>javac ex66.java C:\jdk1.2\bin>java ex66 Caught inside the Function A Recaught: java.lang.NullPointerException: demo C:\jdk1.2\bin>
Throws
,I D PHWKRG LV FDSDEOH RI FDXVLQJ DQ H[FHSWLRQ WKDW LW GRHV QRW KDQGOH LW PXVW VSHFLI\ WKLV EHKDYLRUVRWKDWFDOOHURIWKHPHWKRGFDQJXDUGKLPVHOIDJDLQVWWKDWH[FHSWLRQ7KLVLVGRQHE\ GHFODULQJ D WKURZV FODXVH LQ WKH PHWKRG·V GHFODUDWLRQ $ WKURZV FODXVH OLVWV WKH W\SHV RI 126
Comp-U-Learn
Exception Handling and MultiThreading
H[FHSWLRQVWKDWDPHWKRGPLJKWWKURZ7KLVLVQHFHVVDU\IRUDOOH[FHSWLRQVH[FHSWWKRVHRIW\SH (UURURU5XQWLPH([FHSWLRQRUDQ\RIWKHLUVXEFODVVHV$OORWKHUH[FHSWLRQVWKDWDPHWKRGFDQ WKURZPXVWEHGHFODUHGLQWKHWKURZVFODXVH,IDUHQRWDFRPSLOHWLPHHUURUZLOOUHVXOW 7KH IROORZLQJ H[DPSOH LOOXVWUDWHV WKLV +HUH WKH SURJUDP ZLOO QRW FRPSLOH EHFDXVH WKH WKURZV FODXVHLVQRWVSHFLILHG Example 6.7 class ex67 { static void demo() { System.out.println("inside the function demo"); throw new IllegalAccessException("demo"); } public static void main(String args[]) { demo(); } }
7KHSURJUDPSURGXFHVDFRPSLODWLRQHUURUOLNHWKLV C:\jdk1.2\bin>javac ex67.java Ex67.java:6: Exception java.lang.IllegalAccessException must be caught, or it must be declared in the throws clause of this method. throw new IllegalAccessException("demo"); ^ 1 error C:\jdk1.2\bin>
7KLVSURJUDPFRXOGEHFRUUHFWHGE\DGGLQJWKHFRGHLQPDLQIXQFWLRQDQGE\DGGLQJWKURZVLQ WKHGHPRIXQFWLRQ class ex67 { static void demo() throws IllegalAccessException { System.out.println("inside the function demo"); throw new IllegalAccessException("demo"); } public static void main(String args[]) { try{ demo(); }catch(IllegalAccessException e) {
Comp-U-Learn
127
Java Programming I System.out.println("Caught" +e); } } }
7KHRXWSXWRIWKHSURJUDPLVDVIROORZV C:\jdk1.2\bin>javac ex67.java C:\jdk1.2\bin>java ex67 inside the function demo Caughtjava.lang.IllegalAccessException: demo C:\jdk1.2\bin
Finally Clause )LQDOO\ FUHDWHV D EORFN RI FRGH WKDW ZLOO EH H[HFXWHG DIWHU D WU\FDWFK EORFN LV FRPSOHWHG DQG EHIRUHWKHFRGHIROORZLQJWKHWU\FDWFKEORFN7KHILQDOO\EORFNZLOOH[HFXWHZKHWKHURUQRWDQ H[HFXWLRQLVWKURZQ,IDQH[HFXWLRQLVWKURZQWKHILQDOO\EORFNZLOOH[HFXWHHYHQLIQRFDWFK VWDWHPHQWPDWFKHVWKHH[FHSWLRQ7KHILQDOO\EORFNZLOOEHH[HFXWHGXQGHUDOOFLUFXPVWDQFHV $FWXDOO\WKHWU\EORFNH[HFXWHVILUVW ♦ If no exception, then finally block executes and then executes the first line after the try block ♦ If an exception occurs, then the catch block executes and then the code in the finally block executes. ,QFDVHWKHUHLVDQH[FHSWLRQEXWWKHUHLVQRPDWFKLQJFDWFKVWDWHPHQWWKHQWKHFRGHH[HFXWLRQ VNLSVUHVWRIWKHFRGHDQGH[HFXWHVWKHILQDOO\EORFN7KLVH[HFXWLRQLVWKURZQEDFNWRWKHFDOOHU RIWKHPHWKRG Guidelines to exceptions
128
8VHH[FHSWLRQVIRUH[FHSWLRQDOFLUFXPVWDQFHVRQO\
$OZD\VSUHIHUWRXVHVLPSOHWHVWVLQSODFHRIH[FHSWLRQKDQGOLQJ
'RQRWKDYHWRRPDQ\WU\FDWFKRSHUDWLRQV
6HSDUDWHQRUPDOSURFHVVLQJIURPHUURUKDQGOLQJ
'RQRWLJQRUHDYRLGH[FHSWLRQVEXWKDQGOHWKHPFRUUHFWO\ Comp-U-Learn
Exception Handling and MultiThreading
Creating Own Exception Subclasses 7KH([FHSWLRQFODVVGRHVQRWGHILQHDQ\PHWKRGVRILWVRZQ,WLQKHULWVWKRVHPHWKRGVSURYLGHG E\ 7KURZDEOH &XVWRPL]HG H[FHSWLRQV DUH QHFHVVDU\ WR KDQGOH DEQRUPDO FRQGLWLRQV RI DSSOLFDWLRQV FUHDWHG E\ WKH XVHU 7KH DGYDQWDJH RI FUHDWLQJ VXFK DQ H[FHSWLRQ FODVV LV WKDW DFFRUGLQJWRVLWXDWLRQVGHILQHGE\WKHXVHUDQH[FHSWLRQFDQEHWKURZQ,WLVDOVRSRVVLEOHWRVHW DQ\ FRQGLWLRQ RU YDOXH WR D YDULDEOH DQG JHQHUDWH XVHUGHILQHG H[FHSWLRQ )RU H[DPSOH LW LV SRVVLEOH WR FKHFN LI WKH LQSXW LV JUHDWHU WKDQ HTXDO WR RU OHVV WKDQ D SUHGHILQHG QXPEHU DQG DFFRUGLQJO\JHQHUDWHH[FHSWLRQV7KHIROORZLQJSURJUDPLOOXVWUDWHVWKLV Example 6.8 class except extends Exception { private int detail; except(int a) { detail=a; } public String toString() { return "My Exception [" + detail + "] "; } } class ex68 { static void compute(int a) throws except { System.out.println("Called compute(" + a + ")"); if(a>10) throw new except(a); System.out.println("Normal exit"); } public static void main(String args[]) { try{ compute(1); compute(20); } catch(except e) { System.out.println("caught " + e); } } }
Comp-U-Learn
129
Java Programming I
7KLVH[DPSOHGHILQHVDVXEFODVVRI([FHSWLRQFDOOHGH[FHSW7KLVVXEFODVVLVTXLWHVLPSOH LWKDV RQO\DFRQVWUXFWRUSOXVDQRYHUORDGHGWR6WULQJ PHWKRGWKDWGLVSOD\VWKHYDOXHRIWKHH[FHSWLRQ 7KH FODVV H[MDYD GHILQHV D PHWKRG QDPHG FRPSXWH WKDW WKURZV DQ H[FHSW REMHFW 7KH H[FHSWLRQLVWKURZQZKHQFRPSXWH ·VLQWHJHUSDUDPHWHULVJUHDWHUWKDQ7KHPDLQPHWKRG VHWVXSDQH[FHSWLRQKDQGOHUIRUH[FHSWWKHQFDOOVWKHFRPSXWH ZLWKDOHJDOYDOXH OHVVWKDQ DQGDQLOOHJDORQHWRVKRZERWKSDWKVWKURXJKWKHFRGH+HUHLVWKHUHVXOW 7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex68 Called compute(1) Normal exit Called compute(20) caught My Exception [20] C:\jdk1.2\bin>
$QRWKHU([DPSOHWRVKRZWKHZRUNLQJRIXVHUFUHDWHGH[FHSWLRQV Example 6.9 class ex69 { static void FnA() { try{ System.out.println("inside function A"); throw new RuntimeException("demo"); }finally{ System.out.println(" Proc A finally method"); } } static void FnB() { try{ System.out.println("inside function B"); return; }finally{ System.out.println(" Proc B finally method"); } } static void FnC() { try{ System.out.println("inside function C"); }finally{ System.out.println(" Proc C finally method");
130
Comp-U-Learn
Exception Handling and MultiThreading } } public static void main(String args[]) { try{ FnA(); }catch(Exception e) { System.out.println("Execution Caught "); } FnB(); FnC(); } }
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>javac ex69.java C:\jdk1.2\bin>java ex69 inside function A Proc A finally method Execution Caught inside function B Proc B finally method inside function C Proc C finally method C:\jdk1.2\bin>
Quick View of Exceptions and their meanings
Exception ArithmeticException ArrayIndexOutOfBoundsException ArrayStoreException ClassCastException IllegalArgumentException IllegalMonitorStateExceptionIllegal IllegalThreadStateException IndexOutOfBoundsException NegativeArraySizeException
Meaning Arithmetic error such as divide by zero. Array index is out of bounds Assignment to an array element of an incompatible type Invalid cast Illegal argument used to invoke a method. monitor operation, such as waiting on an unlocked thread Requested operation not compatible with current thread state Some type of index is out-of bounds. Array created with a negative size
Comp-U-Learn
131
Java Programming I
Exception NullPointerException NumberFormatException
Meaning Invalid use of a null reference. Invalid conversion of a string to a numeric format
Exception
Meaning
SecurityException ClassNotfoundException CloneNotSupportedException
Attempt to violate security Class not found Attempt to clone an object that does not implement the Cloneable interface Access to a class is denied Attempt to create an object of an abstract class or interface One thread has been interrupted by another thread
IllegalAccessException InstantiationException InterruptedException
MultiThreading Thread
$ WKUHDG FDQ EH GHILQHG DV D VLQJOH VHTXHQWLDO IORZ RI FRQWURO 7KUHDGV DUH DOVR NQRZQ DV H[HFXWLRQFRQWH[WVRUOLJKWZHLJKWSURFHVVHV$SURJUDPLVQRUPDOO\EURNHQLQWRVPDOOFKXQNV FDOOHG WDVNV DQG WDVNV DUH IXUWKHU EURNHQ GRZQ LQWR VPDOOHU FKXQNV FDOOHG WKUHDGV /HW XV FRQVLGHUWKHSURFHVVLQYROYHGIRUSUHSDUDWLRQRIWHD,QRUGHUWRSUHSDUHWHDVRPHVPDOOWDVNV DUHLQYROYHG7KHVHDUH
%RLOLQJWKHWHDOHDYHVLQZDWHU
%RLOLQJPLON
)LOWHULQJWKHIURPWKHWHDOLTXHXUWHDOHDYHV
3RXULQJWHDDGGLQJVXJDUDQGPLONLQDFXS
6WLUULQJWKHFRQWHQWV
(DFKRIWKHDERYHWDVNVLVUHTXLUHGWRSUHSDUHWHDDQGFRXOGEHFRQVLGHUHGDVDWKUHDG6RPHRI WKHWDVNVFRXOGEHSHUIRUPHGVLPXOWDQHRXVO\6RZHFDQVD\WKDWSUHSDULQJWHDLQYROYHVYDULRXV WKUHDGV WR EH H[HFXWHG ,Q FRPSXWHU WHUPLQRORJ\ LI PRUH WKDQ RQH WKUHDG H[HFXWHV VLPXOWDQHRXVO\ WKHQ LW LV FDOOHG PXOWLWKUHDGLQJ $ WKUHDG LV WKH VPDOOHVW XQLW RI FRGH WKDW DQ RSHUDWLQJV\VWHPFDQH[HFXWH7KUHDGVUXQZLWKLQDSURFHVV ,WLVSRVVLEOHWRZRUNLQPRUHWKDQRQHDSSOLFDWLRQVLPXOWDQHRXVO\LQZLQGRZVHQYLURQPHQW,W LVSRVVLEOHWRZRUNLQ0LFURVRIW:RUGGRLQJVRPHIRUPDWWLQJRIWKHWH[WZKLOHDWWKHVDPHWLPH IURP ,QWHUQHW ([SORUHU GRZQORDGLQJ D :HE SDJH 7KDW LV KHUH ZH DUH ZRUNLQJ LQ PRUH WKDQ 132
Comp-U-Learn
Exception Handling and MultiThreading
RQHZLQGRZFRQFXUUHQWO\RULQPRUHWKDQRQHDSSOLFDWLRQ7KLVLVVDLGWREHPXOWLWDVNLQJ/HWV VHHZKDWLVPXOWLWKUHDGLQJ1RZLWLVLPSRUWDQWWRXQGHUVWDQGZKDWLVDSURFHVV 7KHUXQQLQJLQVWDQFHRIDSURJUDPLVFDOOHGDSURFHVV,WLVDSURJUDPLQH[HFXWLRQ1RZWKH V\VWHP UHVRXUFHV DQG WKH &38 WLPH DUH DOORFDWHG WR WKH YDULRXV UXQQLQJ SURFHVVHV :KHQ WKH WLPH VOLFH LV DOORFDWHG WR D SURFHVV WKH YDULRXV WKUHDGV LQ WKH SURFHVV PDNH XVH RI WKH RI WKH DYDLODEOH &38 WLPH ,Q RWKHUV ZRUGV WKH WKUHDGV DUH WKH XOWLPDWH XQLWV WKDW XVH D &38 WLPH 7KRXJKWKH\PDNHXVHRIWKHV\VWHPUHVRXUFHVWKH\DUHQRWDOORWWHGZLWKDQ\7KHWKUHDGVLQD SURFHVV PDNH XVH RI WKH V\VWHP UHVRXUFHV DOORFDWHG WR WKDW SDUWLFXODU SURFHVV 7KH GLIIHUHQFH EHWZHHQDWKUHDGDQGDSURFHVVLVWKDWDWKUHDGFDQQRWH[LVWRQLWVRZQZKHUHDVDSURFHVVFDQ 7KUHDGV DUH ZLWKLQ D SURFHVV 3URFHVV LV DOORFDWHG ZLWK WKH V\VWHP UHVRXUFHV DQG &38 WLPH 7KUHDGV PDNH XVH RI WKHP 7KH HQG XVHU GRHV QRW H[HFXWH D WKUHDG GLUHFWO\ $ SURFHVV FDQ FRQWDLQDVLQJOHWKUHDGRUPRUH3URFHVVWKDWLVPDGHRIDVLQJOHWKUHDGLVFDOOHGVLQJOHWKUHDGHG DSSOLFDWLRQDQGDSURFHVVKDYLQJPRUHLVFDOOHGPXOWLWKUHDGHG$QH[DPSOHRIPXOWLWKUHDGLQJLV WKH DELOLW\RI,QWHUQHW([SORUHUWR GRZQORDG ILOHV GLVSOD\ D :HE3DJHV $OVR WKH FRS\LQJ ILOHV IURPRQHIROGHUWRDQRWKHULVPXOWLWKUHDGHG7KHPDLQDGYDQWDJHRIPXOWLWKUHDGLQJLVWKHVSHHG RIH[HFXWLRQRIWKHSURJUDP /HWXVXQGHUVWDQGWKLVE\DQH[DPSOH$VVXPHWKDWZHKDYHWRSHUIRUPDFDOFXODWLRQOLNH (a+b) – (b*a)
1RZLIZHKDYHPXOWLSOHWKUHDGVWKHQFDOFXODWLQJDEZLOOEHGRQHE\DWKUHDGDQGFDOFXODWLQJ E DZLOO EH GRQH E\ DQRWKHU WKUHDG +HQFH H[HFXWLRQ RI WKLV SURFHVV LV IDVWHU 0XOWLWKUHDGLQJ DOORZVXVWRZULWHHIILFLHQWSURJUDPVWKDWPDNHPD[LPXPXVHRIWKH&38EHFDXVHLGOHWLPHFDQ EHNHSWWRWKHPLQLPXP:KHQDSURJUDPUHTXLUHVXVHULQSXWPXOWLWKUHDGLQJHQDEOHFUHDWLRQRI DVHSDUDWH WKUHDG IRU WKLV WDVN DORQH 7KH PDLQ WKUHDG FDQ FRQWLQXH ZLWK WKH H[HFXWLRQ RI WKH UHVWRIWKHSURJUDP3URJUDPVQRWXVLQJPXOWLWKUHDGLQJZLOOKDYHWRZDLWXQWLOWKHXVHUKDVLQSXW DYDOXHIRUWKHFRQWLQXDWLRQRIWKHSURJUDP 7KH EHQHILW RI -DYD·V PXOWLWKUHDGLQJ LV WKDW RQH WKUHDG WKDW FDQ SDXVH ZLWKRXW VWRSSLQJ RWKHU SDUWV RI WKH SURJUDP )RU H[DPSOH WKH LGOH WLPH FUHDWHG ZKHQ D WKUHDG UHDGV GDWD IURP D QHWZRUNRUZDLWVIRUWKHXVHULQSXWFDQEHXWLOL]HGHOVHZKHUH7KH-DYDUXQWLPHV\VWHPGHSHQGV RQ WKUHDGV IRU PDQ\ WKLQJV DQG DOO RI WKH FODVV OLEUDULHV DUH GHVLJQHG ZLWK PXOWLWKUHDGLQJ LQ PLQG The advantages of using threads are as follows
♦ ♦ ♦ ♦ ♦
Can be created faster Requires less overhead Interprocess communication ids are faster Context switching is faster Uses CPU time optimally. Comp-U-Learn
133
Java Programming I
Note Java assigns a priority to each thread. A higher priority thread does not run faster than a lower priority thread, if it is the only thread running. Instead a thread’s priority is used to decide when to switch from one running thread to the next. This is called a context switch. 7KH7KUHDGFODVVLPSOHPHQWVWKUHDGVLQ-DYD7KH7KUHDGFODVVLVSDUWRIWKHSDFNDJHMDYDODQJ DQG KHOSV WR LPSOHPHQW -DYD WKUHDGV ZKLFK DUH LQGHSHQGHQW 7KHUH DUH WZR ZD\V WR FUHDWH D FODVVWKDWFDQEHPXOWLWKUHDGHG ♦ Create a class that extends the Thread class ♦ Create a class that implements the Runnable interface. 7KHIROORZLQJDUHWKHWKUHDGVLQ7KUHDGFODVV public thread()
&RQVWUXFWVDQHZWKUHDG7KHWKUHDGPXVWKDYHDUXQPHWKRGDQGDVWDUWPHWKRGWRDFWLYDWHWKH UXQPHWKRG public void run()
7KLV PHWKRG ZKLFK PXVW EH RYHUULGGHQ VKRXOG FRQWDLQ WKH FRGH RI WKH WKUHDG 7KH WKUHDG·V ERG\LVLPSOHPHQWHGLQLWVUXQPHWKRG public void start()
6WDUWVWKHWKUHDG7KLVZLOOFDXVHWKHUXQ PHWKRGWREHFDOOHGDQGUHWXUQLPPHGLDWHO\VRWKDW WKHWKUHDGFDQUXQFRQFXUUHQWO\ public static void sleep(long millesecs)
7KH FXUUHQWO\ H[HFXWLQJ WKUHDG ZDLWV VOHHS IRU WKH VSHFLILHG WLPH LQ PLOOLVHFRQGV DQG WKHQ SHUPLWWLQJRWKHUWKUHDGVWRWDNHRYHUFRQWURO public void interrupt()
6HQGVDQLQWHUUXSWUHTXHVWWRDWKUHDG public static boolean interrupted()
5HWXUQVZKHWKHUDWKUHDGKDVEHHQLQWHUUXSWHGRUQRW
134
Comp-U-Learn
Exception Handling and MultiThreading
public static void yield()
7KHFXUUHQWWKUHDG\LHOGVWKHH[HFXWLRQWRWKHQH[WUXQQDEOHWKUHDG getName()
2EWDLQVDWKUHDGQDPH getPriority()
2EWDLQVDWKUHDG·VSULRULW\ isAlive()
'HWHUPLQHVLIDWKUHDGLVVWLOOUXQQLQJ join()
:DLWVIRUDWKUHDGWRWHUPLQDWH resume()
5HVXPHVH[HFXWLRQRIDVXVSHQGHGWKUHDG7KLVLVYDOLGRQO\LIVXVSHQG LVLQLWLDWHG suspend()
6XVSHQGVDWKUHDG public final void stop()
.LOOVDWKUHDG activeCount()
5HWXUQVWKHFXUUHQWQXPEHURIDFWLYHWKUHDGVLQWKLVWKUHDGJURXS currentThread()
5HWXUQVDUHIHUHQFHWRWKHFXUUHQWO\H[HFXWLQJ7KUHDGREMHFWDQGLVDVWDWLFPHWKRG setName(String)
6HWVWKHWKUHDG·VQDPH
Comp-U-Learn
135
Java Programming I
setPriority(int)
6HWVWKHWKUHDGSULRULW\ $QH[DPSOHRIFUHDWLQJWKUHDGXVLQJ7KUHDGFODVVLVVKRZQDVIROORZV Example 6.10 class mythread extends Thread { String name; Thread t; mythread(String s) { t=new Thread(this,s); System.out.println("New thread : " +t); t.start(); } public void run() { try { for(int i=5;i>0;i--) { System.out.println(name + i); Thread.sleep(500); } }catch(InterruptedException e) { } System.out.println(name+ "existing ........"); } } class ex610 { public static void main(String args[]) { mythread m1=new mythread("One"); mythread m2=new mythread("Two"); System.out.println("thread m1 is alive " + m1.t.isAlive()); System.out.println("thread m2 is alive " + m2.t.isAlive()); try{ System.out.println("Waiting ");
136
Comp-U-Learn
Exception Handling and MultiThreading m1.t.join(); m2.t.join(); }catch(InterruptedException e) { } System.out.println("thread m1 is alive " + m1.t.isAlive()); System.out.println("thread m2 is alive " + m2.t.isAlive()); System.out.println("Existing main thread "); } }
2XWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex610 New thread : Thread[One,5,main] New thread : Thread[Two,5,main] thread m1 is alive true null5 null5 thread m2 is alive true Waiting null4 null4 null3 null3 null2 null2 null1 null1 nullexisting ........ nullexisting ........ thread m1 is alive false thread m2 is alive false Existing main thread
Comp-U-Learn
137
Java Programming I
Thread States
Runnable
Start( ) or run expires
Dead
Not Runnable Start( )
Stop( ) New Thread Stop( )
New Thread
Fig 6.2 :KHQHYHU DQ LQVWDQFH RI WKH 7KUHDG FODVV LV FUHDWHG WKH WKUHDG HQWHUV LQWR WKH QHZ 7KUHDG 6WDWH7KHFRGHWKDWIROORZVLOOXVWUDWHVWKHLQVWDQWLDWLRQRIWKH7KUHDGFODVV Thread nThread=new Thread(this);
7KLV FUHDWHV D QHZ WKUHDG 1RZ QR UHVRXUFHV DUH DOORFDWHG WR WKH WKUHDG ,W LV RQO\ DQ HPSW\ REMHFW$VDUHVXOWRIWKLVRQO\WKHVWDUWDQGVWRSPHWKRGVFDQEHLQYRNHG,IDQDWWHPSWLVPDGH WRLQYRNHRWKHUPHWKRGVRIWKH7KUHDGFODVVWKHQLWZLOOWKURZ,OOHJDO7KUHDG6WDWH([FHSWLRQ Runnable
2QFHWKHWKUHDGUHFHLYHVWKHVWDUWPHWKRGLWHQWHUVLQWRWKHUXQQDEOHVWDWHDQGQRWUXQQLQJVWDWH 7KHWKUHDGPLJKWQRWEHH[HFXWLQJDWWKHUXQQDEOHVWDJH6LQFHDVLQJOHSURFHVVRUFDQQRWH[HFXWH PRUH WKDQ RQH WKUHDG DW RQH WLPH WKHUH LV D ZD\ RI VFKHGXOLQJ WKH SULRULWLHV IRU WKH WKUHDGV 7KLVLVFDOOHG7KUHDGSULRULW\
138
Comp-U-Learn
Exception Handling and MultiThreading
Not Runnable
$WKUHDGLVVDLGWREHLQWKHQRWUXQQDEOHVWDWHLILW ♦ ♦ ♦ ♦
Has been suspended Is sleeping Is waiting Is being blocked by another thread
$WKUHDGFDQEHVXVSHQGHGE\LQYRNLQJWKHVXVSHQGPHWKRGRIWKH7KUHDGFODVVZKHUHE\WKH WKUHDGLVQRWH[HFXWDEOH7RH[HFXWHWKHWKUHDGWKHUHVXPH KDVWREHLQYRNHG7KHVXVSHQG KRZHYHUGRHVQ·WNLOOWKHWKUHDG $WKUHDGLVSXWWRVOHHSZKHQWKHVOHHSPHWKRGLVLQYRNHG7KHWLPHLVJLYHQDVPLOOLVHFRQGVWR WKH VOHHS $ VOHHSLQJ WKUHDG ZLOO HQWHU LQWR WKH UXQQDEOH VWDWH DIWHU WKH VSHFLILHG WLPH KDV HODSVHG8QWLOWKDWWLPHWKUHDGZLOOQRWH[HFXWH7KHVOHHSLQJWKUHDGFDQQRWEHH[HFXWHGXVLQJ WKHUHVXPH $ WKUHDG FDQ EH PDGH WR ZDLW RQ D FRQGLWLRQDO YDULDEOH PDNLQJ LW ZDLW XQWLO WKH FRQGLWLRQ LV VDWLVILHG 7KH WKUHDG LV QRW UXQQDEOH WLOO WKH FRQGLWLRQ EHFRPHV WUXH 7KH FRQGLWLRQ FDQ EH QRWLILHGWRWKHWKUHDGE\LQYRNLQJQRWLI\ Dead
$WKUHDGFDQHLWKHUGLHQDWXUDOO\RULWFDQEHNLOOHG$WKUHDGXQGHUJRHVDQDWXUDOGHDWKZKHQWKH ORRSLQWKHUXQPHWKRGLVFRPSOHWHG$WKUHDGFDQEHNLOOHGE\LQYRNLQJWKHVWRSPHWKRG7KH LV$OLYH PHWKRGFDQEHXVHGWRILQGRXWZKHWKHUDWKUHDGKDVEHHQVWDUWHGRUVWRSSHG
Thread Priority (DFK WKUHDG KDV D SULRULW\ ZKLFK DIIHFWV WKH RUGHU LQ ZKLFK LW LV UXQ 7KUHDGV ZLWK D KLJKHU SULRULW\ VXSHUVHGH WKUHDGV ZLWK D ORZHU SULRULW\ $ WKUHDG LQKHULWV LWV SULRULW\ IURP WKH WKUHDG WKDW FUHDWHG LW 7KH SULRULW\ RI D WKUHDG FDQ EH VHW E\ XVLQJ WKH VHW3ULRULW\ RI WKH 7KUHDG IXQFWLRQ7KHSDUDPHWHUVWRWKLVPHWKRGDUH ♦ MIN_PRIORITY ♦ MAX_PRIORITY ♦ NORM_PRIORITY :KHQPRUHWKDQRQHWKUHDGLVUHDG\IRUH[HFXWLRQ-DYDUXQWLPHV\VWHPFKRRVHVWKHRQHZLWK WKH KLJKHVW SULRULW\ DQG H[HFXWHV LW :KHQ RQH WKUHDG LV EHLQJ H[HFXWHG DQG -DYD HQFRXQWHUV
Comp-U-Learn
139
Java Programming I
DQRWKHUZLWKDKLJKHUSULRULW\WKHQ-DYDSXVKHVWKHFXUUHQWO\H[HFXWLQJWKUHDGDQGWKHRQHZLWK DKLJKHUSULRULW\ZLOOEHH[HFXWHG
Daemon Threads $GDHPRQWKUHDGFDQEHFRQVLGHUHGWREHDWDVNPDQDJHUWKUHDGWKDWVXSSRUWVRWKHUWKUHDGV,WLV LQGHSHQGHQW LQ DQ DSSOLFDWLRQ DQG SURYLGHV VHUYLFHV WR RWKHU REMHFWV LQ WKH VDPH DSSOLFDWLRQ 7KHUXQPHWKRGRIDGDHPRQWKUHDGLVXVXDOO\DQLQILQLWHORRSZKLFKZDLWVIRUDVHUYLFHUHTXHVW 7RVSHFLI\WKDWDWKUHDGLVGDHPRQVHW'DHPRQ PHWKRGLVLQYRNHGZLWKWKHERROHDQSDUDPHWHU WUXH7KHLV'DHPRQ PHWKRGLVXVHGWRFKHFNZKHWKHUDWKUHDGLVD'DHPRQRUQRW 7KH IROORZLQJ SURJUDP LOOXVWUDWHV WKH ZRUNLQJ RI WKUHDGV +HUH WKH WKUHDG LV PDGH WR WLFN FRQWLQXRXVO\LUUHVSHFWLYHRIZKHWKHUWKHDSSOHWLVEHLQJPLQLPL]HGRUPD[LPL]HG Example 6.11 import java.awt.Graphics; import java.util.Date;import java.applet.*; public class time extends Applet implements Runnable { Thread t1; public void start() { if(t1==null) { t1=new Thread(this); t1.start(); } } public void run() { while(t1!=null) { repaint(); try { t1.sleep(1000); } catch(InterruptedException e) { } } } public void paint(Graphics g) { Date d=new Date();
140
Comp-U-Learn
Exception Handling and MultiThreading g.drawString(d.getHours() +":"+d.getMinutes()+":"+d.getSeconds(),5,10); } public void stop() { t1.stop(); t1=null; } }
7KHRXWSXWRIWKHSURJUDPLVDVIROORZV
Fig 6.3 $QRWKHUH[DPSOHWRVKRZWKHZRUNLQJRIWKUHDGVXVLQJDSSOLFDWLRQ Example 6.12 class mythread implements Runnable { Thread t; mythread() { t=new Thread(this," Demo Thread"); System.out.println("child thread : " +t); t.start(); } public void run() { try { for(int i=5;i>0;i--) {
Comp-U-Learn
141
Java Programming I System.out.println("Child Thread : " + i); Thread.sleep(500); } }catch(InterruptedException e) { System.out.println("Child Thread interrupted ."); } System.out.println("Existing child thread "); } } class ex54 { public static void main(String args[]) { new mythread(); try{ for(int i=6;i>0;i--) { System.out.println("Main Thread : " + i); Thread.sleep(1000); } }catch(InterruptedException e) { System.out.println("Main thread Interrupted "); } System.out.println("Existing main thread "); } }
,QVLGHWKHFRQVWUXFWRUP\WKUHDGZHDUHFUHDWLQJDQHZWKUHDGXVLQJWKHVWDWHPHQW T=new Thread(this,”Demo Thread”);
7KLVREMHFWKHUHVSHFLILHVWKDWWKHQHZO\FUHDWHGWKUHDGFUHDWHGZLOOFDOOWKHUXQ PHWKRG1H[W VWDUW LV FDOOHG ZKLFK VWDUWV WKH WKUHDG DQG EHJLQV H[HFXWLQJ WKH UXQ PHWKRG 7KLV FDXVHV WKH FKLOGWKUHDG·VIRUORRSWREHJLQDIWHUFDOOLQJWKHVWDUWPHWKRGP\WKUHDG·VFRQVWUXFWRUUHWXUQVWR PDLQ 7KHPDLQWKUHDGQRZHQWHUVLQWRWKHIRUORRS %RWK WKH WKUHDGV UXQQLQJ VLPXOWDQHRXVO\ VKDULQJ WKH &38 WLPH XQWLO WKH XSSHU ERXQG RI WKH ORRSLVUHDFKHG 7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>javac ex54.java C:\jdk1.2\bin>java ex54 child thread : Thread[ Demo Thread,5,main] Main Thread : 6
142
Comp-U-Learn
Exception Handling and MultiThreading Child Thread : 5 Child Thread : 4 Main Thread : 5 Child Thread : 3 Child Thread : 2 Main Thread : 4 Child Thread : 1 Existing child thread Main Thread : 3 Main Thread : 2 Main Thread : 1 Existing main thread C:\jdk1.2\bin>
Summary Exception handling provides a powerful mechanism to control complex programs that have many dynamic run time characteristics. Errors and abnormal situations arising while executing a program needs to be handled. Java provides well-defined methods for exception handling. There are various exception handling classes which are subclasses of Exception. The try, catch ,throw, finally and throws are the keywords involved in exception handling. Multithreading enables the program to make optimum utilization of the available CPU time. It is a feature of the programming environment to make best use of the available resources. Multithreading in Java is offered through Thread class and Runnable interface. The start(), run(), sleep(), stop(), suspend() and resume() are some of the important methods related to threading in Java.
Going Over It Again I. Fill in the Blanks
([FHSWLRQVDUHGHULYHGIURPBBBBBBBBBBBFODVV 0DQXDOO\FUHDWHGH[FHSWLRQVDUHUDLVHGXVLQJBBBBBBBBBBBBBBNH\ZRUG ([FHSWLRQV WKDW DUH WKURZQ RXW RI D PHWKRG PXVW EH VSHFLILHG XVLQJ BBBBBBBBBBBBB FODXVH 7KHDELOLW\WRSHUIRUPPRUHWKDQRQHSURFHVVVLPXOWDQHRXVO\LVFDOOHGBBBBBBBBBBBB BBBBBBBBBBBBBBPHWKRGLVXVHGWRGHWHUPLQHWKHSULRULW\RIDWKUHDG BBBBBBBBBBBBBBBBBBBLVWRNQRZZKHWKHUDWKUHDGKDVEHHQVWDUWHGRUVWRSSHG Comp-U-Learn
143
Java Programming I
II. State True or False
([FHSWLRQKDQGOLQJDOORZV\RXWRIL[HUURUV (UURUFODVVKDQGOHVWKHHUURUVWKDWDUHQRWFDXJKWXQGHUQRUPDOFLUFXPVWDQFHV 'LYLVLRQE\]HURFDXVHV1XOO3RLQWHU([FHSWLRQ 7U\FDQEHXVHGRQDVLQJOHVWDWHPHQWZLWKRXWFXUO\EUDFHV 7KUHDGVFDQH[LVWLQGHSHQGHQWO\ 7KHVXVSHQG NLOOVDWKUHDG III. One line Answers
/LVWWKHVRXUFHVRIHUURUV :KDWLVH[FHSWLRQKDQGOLQJ" :KDWZLOOKDSSHQLIDQH[FHSWLRQWKURZQGRHVQRWKDYHDQKDQGOHU" ([SODLQWKHXVDJHRIILQDOO\EORFN ([SODLQ'DHPRQ7KUHDG :KDWLVLPSOLFLWDQGH[SOLFLWH[FHSWLRQ" :KDWLVDWKUHDG"
144
Comp-U-Learn
Session 7
Java Applets
On Completion of this Session We will be able to understand...
) Java Applet ) Applet in Html ) Basic methods of Applet ) Various Applet classes ) Image class in Applet ) Animation in Applet
In This Session...
Introduction to Applet
Applet vs Application
Applet Architecture
Developing an Applet
Applet in HTML
Basic Methods in Applet
Parameter passing to Applets
Graphics Class
Font Class
Color Class
Images
Animation using Images
Java Applets
Introduction to Applet 7KHPDLQIHDWXUHWKDW-DYDSURYLGHVRYHURWKHUODQJXDJHVLVWKHIDFLOLW\WRZULWHDSSOHWV$SSOHWLV DSURJUDPWKDWFDQEHGRZQORDGHGDQGH[HFXWHGRQDQ\PDFKLQHLQWKHZRUOG7KHDGYDQWDJHV RIIHUHGE\WKHDSSOHWVDUHPXFKPRUHWKDQRQHFDQWKLQNRI$SSOHWVRSHQXSWKHSRVVLELOLW\RI FUHDWLQJDQLPDWLRQRQZHESDJHV:LWKRXWDSSOHWVWKHZHESDJHVDUHMXVWOLNHPDJD]LQHSDJHV ZLWKDSSOHWVWKH\EHFRPHOLNHPRYLHVDQGFRPPXQLFDWHPXFKPRUHHIIHFWLYHO\ ,Q DGGLWLRQ WR WKH DSSOHW LWVHOI WKH ZHE SDJH FDQ FRQWDLQV DOO RWKHU +70/ HOHPHQWV ZH KDYH OHDUQW$SSOHWVDUHMXVWRQHSDUWRIWKHK\SHUWH[WSDJH,WLVDOZD\VZRUWKNHHSLQJLQPLQGWKDW -DYDLVQRWDWRROIRUGHVLJQLQJ+70/SDJHV$FWXDOO\DSSOHWVDUHWKHWRROIRUEULQJLQJWKHPWR OLIH7KLVLVQRWWRVD\WKDWWKH*8,GHVLJQHOHPHQWVLQD-DYDDSSOHWDUHQRWLPSRUWDQWEXWWKH\ PXVWZRUNZLWKWKHXQGHUO\LQJ+70/GHVLJQRIWKHZHESDJH 7KLV VHVVLRQ ILUVW VKRZV KRZ WR FUHDWH D -DYD DSSOHW DQG YLHZ WKHP LQ RXU WHUPLQDO XVLQJ DSSOHWYLHZHU RU DQ\ RWKHU EURZVHUV ZLWK GLIIHUHQW YLVXDO HIIHFWV OLNH IRQWV FRORUV DQG YDULRXV VKDSHV7KHVXFFHHGLQJVHVVLRQVZLOOGLVFXVVKRZWRFRSHZLWKZLQGRZLQJUHTXLUHPHQWVDQGDOO WKHLPSRUWDQWDVSHFWVRI-DYDDSSOHWV
Applet vs Application -DYDDSSOLFDWLRQVDUHVLPSOHVWDQGDORQHSURJUDPVWKDWFDQEHUXQE\WKHMDYDLQWHUSUHWHU:HJHW WKH RXWSXW RI WKH DSSOLFDWLRQ SURJUDPV LQ WKH FRPPDQG OLQH RQO\ %XW MDYD DSSOHWV FDQ UXQ LQVLGHWKH:RUOG:LGH:HEEURZVHUDQGZHJHWRXUDSSOHWRXWSXWLQD*8,IRUPDW$SSOHWVFDQ EHORDGHGRYHUWKHQHWZRUNDQGKDYHPRUHFDSDELOLWLHVWKDQWKHMDYDDSSOLFDWLRQSURJUDPV $SDUWIURPWKDWDSSOHWVKDYHWKHIROORZLQJDGYDQWDJHVWKDWQRWHYHQWKHMDYDDSSOLFDWLRQVKDYH 7KH\DUH ♦ Applets have built-in support for multimedia. ♦ Applets running within a Web browser can easily be embedded in a Web page. ♦ Applets can make use of the GUI based pre-defined packages. ♦ Applet provides a frame, event-handling facility and graphics context. ♦ Applets can invoke public methods of other applets on the same page. (YHQWKRXJKWKHDSSOHWVKDYHWKHDERYHIDFLOLWLHVWKH\KDYHKDVVHFXULW\UHVWULFWLRQVWRSUHYHQW WKHPIURPEHLQJDIIHFWHGE\YLUXVHV-DYDDSSOHWVGRHVQ·WVXSSRUWWKHIROORZLQJDVSHFWVGXHWR VHFXULW\UHVWULFWLRQV Comp-U-Learn
147
Java Programming I
♦ ♦ ♦ ♦
Applets cannot load libraries or define native methods. An applet cannot ordinarily read or write files on the host that is executing it. An applet cannot make network connections except to the host that it came from. An applet cannot read certain system properties.
Applet Architecture :H KDYH DOUHDG\ VHHQ WKDW DQ DSSOHW LV D VLPSOH MDYD FODVV WKDW XOWLPDWHO\ H[WHQGV WKH MDYDDSSOHW$SSOHWFODVV1RWHWKDWWKHDSSOHWSDFNDJHLVQRWSDUWRIWKH$:7FRPSRQHQW7KH DUFKLWHFWXUHVKRZQLQWKHIROORZLQJILJXUHLOOXVWUDWHVWKLV ,QWKHVXFFHHGLQJVHVVLRQVZHZLOOXVHWKH6ZLQJVHWWRLPSOHPHQWDSSOHWV$OORIWKHDSSOHWVZLOO H[WHQGWKH$SSOHWFODVVWKHVXSHUFODVVIRU6ZLQJDSSOHWV$VZHFDQVHHLQWKHIROORZLQJILJXUH $SSOHWLVDQLPPHGLDWHVXEFODVVRIWKHRUGLQDU\$SSOHWFODVV Object
Component
Container
Window
Panel
Frame
Applet
JFrame
JApplet
Fig 7.1.
148
Comp-U-Learn
Java Applets
Developing an Applet ,QWKLVVHFWLRQZHDUHJRLQJWROHDUQDERXWWKHFUHDWLRQRIDVLPSOHDSSOHWSURJUDP7KHFUHDWLRQ RIDQDSSOHWFRQVLVWVRIWKHIROORZLQJIRXUVWHSV ♦ ♦ ♦ ♦
Importing the necessary built-in java packages Defining applet subclasses Applet implementation Passing this Java applet’s .class file into HTML file.
&RQVLGHUWKHIROORZLQJDSSOHWH[DPSOH VD\ VDPSOHMDYD ,WLOOXVWUDWHVWKHGHWDLOVWRFUHDWH DQDSSOHW Example 7.1 import java.awt.*; import java.applet.*; public class sample extends Applet { public void paint(Graphics g) { g.drawString("Java Applet Welcomes You!",100,100); } }
,QWKHDERYHSURJUDPWKHILUVWWZROLQHVDUHXVHGWRLPSRUWVRPHSDFNDJHVDQGFODVVHVZKLFKDUH EHLQJXVHGZLWKLQRXUDSSOHW $VLQDQDSSOLFDWLRQKHUHWRRZHKDYHWRVSHFLI\WKHFODVVGHFODUDWLRQDWWKHEHJLQQLQJ+HUH WKHH[WHQGVNH\ZRUGLVXVHGWRH[WHQGVRPHSUHGHILQHGFODVVHVWRRXUSURJUDP 7KHQZHKDYHWRLPSOHPHQWWKHDSSOHWE\PHDQVRIDSSOHWPHWKRGV,QWKLVSURJUDPWKHSDLQW PHWKRGRIDSSOHWLVXVHGWRSULQWVRPHWH[WLQWKHZLQGRZ7KHGUDZ6WULQJPHWKRGRIWKHFODVV *UDSKLFVLVXVHGIRUSDLQWLQJWKHWH[WLQWKHVFUHHQ )LQDOO\ZHKDYHWRSDVVWKLVVRXUFHILOH VDPSOHFODVV LQWRDQ+70/ILOH)RUWKDWZHKDYHWR FUHDWHDQRWKHU+70/ILOH VD\VDPSOHKWPO ZKLFKVKRXOGFRQWDLQWKHIROORZLQJFRGH
1RZFRPSLOHWKLVVDPSOHMDYDILOHRQWKHFRPPDQGOLQHXVLQJMDYDF7KHQUXQWKLVVDPSOHKWPO ILOHXVLQJDSSOHWYLHZHU7KHIROORZLQJILJXUHVKRZVWKHRXWSXWRIWKLVDSSOHW Comp-U-Learn
149
Java Programming I
Fig 7.2 $IWHUFRPSLOLQJRXUMDYDILOHZHFDQDOVRJHWWKHRXWSXWIRUWKHDERYHSURJUDPE\EURZVLQJWKH VDPSOHKWPO ILOH LQ WKH ,QWHUQHW H[SORUHU 7KH IROORZLQJ ILJXUH VKRZV WKH RXWSXW RI WKH VDPSOHSURJUDPLQWKHLQWHUQHWH[SORUHU
Fig 7.3
Note Look at the applet code. There is no main method. Applets don’t need it. The main method is actually in the browser or the appletviewer, not in the Applet itself.
Applet in HTML %HIRUH-DYDZHXVHG+70/WRGHVFULEHWKHOD\RXWRIDZHESDJH+70/LVDVLPSOHYHKLFOHWR LQGLFDWHHOHPHQWVRIDK\SHUWH[WSDJH7KH+70/SDJHPXVWWHOOWKHEURZVHUZKLFKDSSOHWVWR ORDGDQGZKHUHWRSXWHDFKDSSOHWRQWKHZHESDJH7KH $33/(7!DQG $33/(7!WDJV DUHFDOOHG+70/MDYDWDJV7KHMDYDHQDEOHGEURZVHUVZLOOXQGHUVWDQGWKDWFRGHEHWZHHQWKHVH WDJVDUHWKHMDYDFRGH)RUWKDWZLWKLQWKHVHWDJVZHPXVWSDVVWKHIROORZLQJ
150
Comp-U-Learn
Java Applets
♦ The name of the class files ♦ The location of the class files ♦ How the applet sits on the web page )RUWKHDERYHUHTXLUHPHQWVWKH $33/(7!WDJKDVWKHIROORZLQJDWWULEXWHV:HFDQXVHWKHVH DWWULEXWHVDFFRUGLQJWRRXUUHTXLUHPHQWV <APPLET>
7KLVWDJWKDWLVXQGHUVWRRGE\WKHDSSOHWYLHZHURUDQ\%URZVHU <EMBED>
7KLVWDJWKDWLVXQGHUVWRRGE\WKH1HWVFDSH1DYLJDWRU
Version July 2000 Second Impression
The Team Production / Series Supervision Jambu Krishnamurthy Vice President – Product Development The Head Sridhar Subramaniam Head – Training Solutions Technical Writers Thiru Murugan .H Uma .S Ajay Balaji Review Jambu Krishnamurthy Sridhar Subramaniam Production/Design Vijay. V Editor Nurjehan Dhanani
Copyright 1999, Comp-U-Learn Inc. All Rights Reserved
No Part of this Book may be reproduced in any form by any means, stored in a retrieval system, or transmitted by any mode, electronic, mechanical, photocopying, recording, or otherwise, without written permission from the publisher. Exceptions are made to the program listings, which can be typed, stored in a Computer System and executed. No patent liability is assumed with respect to the use of the information contained herein. Although every precaution has been taken in the preparation of this book, the publisher assumes no responsibility for errors or omissions. Neither is any liability assumed for damages resulting from the use of the information contained herein.
All Trade Marks Acknowledged
The Book at a Glance , %HIRUH:H%HJLQ L ,, +RZWRXVHWKLV%RRN LL ,,, 2EMHFWLYHVRIWKLV%RRN LLL ,9 &RQYHQWLRQVXVHGLQWKLV%RRN LLL -DYD²$Q,QWURGXFWLRQ )XQGDPHQWDOVRI-DYD 223VLQ-DYD ,QWHUIDFHV 3DFNDJHV 6WUHDPV )LOHV+DQGOLQJ ([FHSWLRQ+DQGOLQJDQG0XOWLWKUHDGLQJ -DYD$SSOHWV $EVWUDFW:LQGRZLQJ7RRONLW +DQGOLQJ$:7(YHQWV 0RUHDERXW$:7 -DYD'DWD%DVH&RQQHFWLYLW\ 1HWZRUNLQJLQ-DYD ,*ORVVDU\ ,,$SSHQGL[HV ,,,,QGH[
Table of Contents ,%HIRUH:H%HJLQ L ,,+RZWRXVHWKLV%RRN LL ,,,2EMHFWLYHVRIWKLV%RRN LLL ,9&RQYHQWLRQVXVHGLQWKLV%RRN LLL -DYD²$Q,QWURGXFWLRQ
,QWURGXFWLRQWR-DYD +LVWRU\RI-DYD )HDWXUHVLQ-DYD -DYDDQGWKH,QWHUQHW -DYD$Q223/DQJXDJH &YV-DYD -DYD7RROV $SSOLFDWLRQ3URJUDPPLQJ &UHDWLQJDQ$SSOLFDWLRQ $SSOHW3URJUDPPLQJ &UHDWLQJDQ$SSOHW 2YHUYLHZRI-DYD
)XQGDPHQWDOVRI-DYD²
'DWDW\SHV 9DULDEOHVLQ-DYD /LWHUDOV.H\ZRUGV ,GHQWLILHUV 2SHUDWRUVLQ-DYD ([SUHVVLRQ(YDOXDWLRQ 2SHUDWRU3UHFHGHQFH 6FRSHRI9DULDEOHV &RPPHQWLQJLQ-DYD
7DEOHRI&RQWHQWV &RQWG
'HFLVLRQ0DNLQJ )RUORRS :KLOH 'R«:KLOH/RRS 6ZLWFK %UHDN6WDWHPHQWV $UUD\VLQ-DYD 6WULQJVLQ-DYD
2236LQ-DYD²
7UDGLWLRQDO3URJUDPPLQJ0RGHO 2EMHFW2ULHQWHG3URJUDPPLQJ$SSURDFK )HDWXUHVRI2EMHFW2ULHQWHG3URJUDPPLQJ %DVLF&RQFHSWVRI223V &UHDWLQJ&ODVVHVDQG2EMHFWVLQ-DYD &RQVWUXFWRUV *DUEDJH&ROOHFWLRQ )LQDOL]H0HWKRG ,QKHULWDQFH 3RO\PRUSKLVP 5HFXUVLRQ $GYDQWDJHVRI223VLQ-DYD
,QWHUIDFHV 3DFNDJHV
,QWURGXFWLRQWR,QWHUIDFHV :KDWLVDQLQWHUIDFH" ,QWULFDFLHVLQDQ,QWHUIDFH ,QWHUIDFH5HIHUHQFHV ([WHQGLQJWKH,QWHUIDFH
7DEOHRI&RQWHQWV &RQWG
7KH&ORQHDEOH,QWHUIDFH ,QQHU&ODVVHV 3DFNDJHV 1HHGIRU3DFNDJHV &/$663$7+9DULDEOH $FFHVV3URWHFWLRQ 2YHUYLHZRI-DYD%XLOWLQ3DFNDJHV
6WUHDPV )LOH+DQGOLQJ²
-DYD6WUHDP&ODVV 3ULQW6WUHDP 6\VWHP3URSHUWLHV ,QSXWDQG2XWSXW6WUHDPV )LOHVDQG'LUHFWRULHV )LOH,QSXWDQG2XWSXW6WUHDPV 'DWD,QSXWDQG2XWSXW6WUHDPV )LOWHUHG6WUHDPV %XIIHUHG6WUHDPV 3XVKEDFN,QSXW6WUHDP 5DQGRP$FFHVV)LOH 5HDGHUDQG:ULWHU&ODVVHV
([FHSWLRQ+DQGOLQJDQG0XOWLWKUHDGLQJ
([FHSWLRQ+DQGOLQJ²$Q,QVLJKW $GYDQWDJHVRI([FHSWLRQ+DQGOLQJ 8QFDXJKW([FHSWLRQV 0XOWLSOH&DWFK&ODXVHV
7DEOHRI&RQWHQWV &RQWG
,PSOLFLWDQG([SOLFLW([FHSWLRQV -DYDODQJ7KURZDEOH )LQDOO\&ODXVH &UHDWLQJ2ZQ([FHSWLRQ6XEFODVVHV 0XOWL7KUHDGLQJ 7KUHDG6WDWHV 7KUHDG3ULRULW\ 'DHPRQ7KUHDGV
-DYD$SSOHWV
,QWURGXFWLRQWR$SSOHW $SSOHWYV$SSOLFDWLRQ $SSOHW$UFKLWHFWXUH 'HYHORSLQJDQ$SSOHW $SSOHWLQ+70/ %DVLF0HWKRGVLQ$SSOHW 3DUDPHWHUSDVVLQJWR$SSOHWV *UDSKLFVFODVV )RQW&ODVV &RORU&ODVV ,PDJHV $QLPDWLRQXVLQJ,PDJHV
$EVWUDFW:LQGRZLQJ7RRONLW $:7 $Q$:72YHUYLHZ $:7$UFKLWHFWXUH %DVLF8,&RPSRQHQWV
7DEOHRI&RQWHQWV &RQWG
%XWWRQV &KHFN%R[HV 5DGLR%XWWRQV &KRLFHV 7H[W)LHOGV 7H[W$UHDV /LVWV 6FUROOEDUVDQG6OLGHUV &DQYDVHV
+DQGOLQJ$:7(YHQWV
,QWURGXFWLRQWR(YHQWV $SSOHW(YHQWV %XWWRQ(YHQWV +DQGOLQJ0XOWLSOH(YHQWV ,WHP(YHQWV 0RXVH(YHQW+DQGOLQJ 'RXEOHFOLFNV 0RXVH0RYHPHQWV 0RXVH'UDJDQG0RXVH0RYH(YHQWV 0RXVH(QWHUDQG0RXVH([LW(YHQWV .H\ERDUG(YHQWV 'HIDXOW.H\V
0RUH$ERXW$:7 /D\RXW0DQDJHUV )ORZ/D\RXW
7DEOHRI&RQWHQWV &RQWG %RUGHU/D\RXW &DUG/D\RXW *ULG/D\RXWV *ULG%DJ/D\RXW ,QVHWV 3DQHOV )UDPHV 0HQXV 0HQX$FWLRQV 'LDORJ%R[ -DYD'DWD%DVH&RQQHFWLYLW\ ,QWURGXFWLRQWR-'%& 0LFURVRIW V2'%& 7LHULQJ -'%&$UFKLWHFWXUH -'%&'ULYHUV 'ULYHU3URSHUW\,QIR&ODVV &RQQHFWLRQ&ODVV 'DWDEDVH0HWD'DWD,QWHUIDFH 3UHSDUHG6WDWHPHQW &DOODEOH6WDWHPHQW ([HFXWLQJ64/XVLQJ-'%& 7UDQVDFWLRQ3URFHVVLQJ
7DEOHRI&RQWHQWV &RQWG 1HWZRUNLQJLQ-DYD 1HWZRUNLQJLQ-DYD 'DWDJUDPV :KDWLVD'DWDJUDP" 'DWDJUDP3DFNHW 'DWDJUDP6RFNHW 'XSOLFDWLRQRI6RFNHW &UHDWLQJ/LQNV,QVLGH$SSOHWV 2SHQLQJ:HE&RQQHFWLRQV 7KH85/&RQQHFWLRQ&ODVV 6RFNHWV 2WKHU$SSOHW+LQWV &RPPXQLFDWLQJ%HWZHHQ$SSOHWV , *ORVVDU\ ,,$SSHQGL[HV L$SSHQGL[ LL$SSHQGL[ LLL$SSHQGL[ ,,,,QGH[
Before We Begin 6RPHERG\ VDLG WKDW RQH·V JRDO LV WR HYROYH DQG ILQG JUHDWHU KHLJKWV
i
How to use this Book 7KLV ERRN LV ZULWWHQ LQ D OXFLG VW\OH LQ DQ DWWHPSW WR SURYLGH FODULW\ RQ FRPSOH[WHFKQLFDOWRSLFV6LQFHWKHUHDGHUVDUHQHZWRWKHVXEMHFWWKHXQGHU PHQWLRQHGGHWDLOVZLOOPDNHWKHPXVHWKHERRNLQWKHPRVWHIILFLHQWPDQQHU $OVR LW ZLOO HQDEOH WKH UHDGHUV WR NQRZ DERXW WKH RUJDQL]DWLRQ DQG WKH SDWWHUQDGRSWHGLQWKLVERRN 7KH%RRNDWD*ODQFHJLYHV\RXDQRYHUYLHZRIWKHYDULRXVWRSLFVFRYHUHGLQ WKH %RRN 7KHVH DUH WKH VHVVLRQV ZKLFK ZLOO EH FRYHUHG LQ $GYDQFHG 7HFKQRORJLHV HPHUJLQJ DW WKH -DYD IURQW ,W DOVR SURMHFWV DQ RXWORRN RI WKH PRGXOHFRYHUDJHDQGLWVFRQWHQWVZKLFKZLOOVSDQIRUVHVVLRQV 7KH7DEOHRI&RQWHQWVHQDEOHV\RXWRNQRZDERXWWKHYDULRXVWRSLFVXQGHU HDFK 6HVVLRQ 7KH WRSLFV JLYHQ XQGHU 6HVVLRQ WLWOH UHIOHFW WKH 3RLQW SURJUDP7KHVXEMHFWLPSDUWHGLQWKHFODVVURRPVHVVLRQZLOOEHDFFRUGLQJWR WKHVH JLYHQ KHDGLQJV ,W EDVLFDOO\ KHOSV WR SUHSDUH IRU HYHU\ FODVV URRP VHVVLRQE\OHWWLQJ\RXNQRZDERXWWKHVHVVLRQFRYHUDJH$JDLQWKHVHSRLQWV ZLOODOVREHFRYHUHGLQWKHEHJLQQLQJRIHYHU\VHVVLRQXQGHUWKHWLWOH´,QWKLV 6HVVLRQµ (DFK VHVVLRQ EHJLQV ZLWK DQ REMHFWLYH 7KHVH REMHFWLYHV DUH OLVWHG RQ WKH VHVVLRQFRYHUSDJH7KLVZLOOIDFLOLWDWH\RXWR NQRZ WKH \DUGVWLFNV E\ ZKLFK \RXFDQHYDOXDWH\RXUNQRZOHGJHDFTXDLQWDQFHLQHDFKVHVVLRQ)ROORZLQJWKH FRXUVHZDUH GXULQJ FODVVURRP VHVVLRQ ZLOO HQDEOH \RX WR KDYH D EHWWHU XQGHUVWDQGLQJ RI WKH VXEMHFW ([DPSOHV DUH FLWHG WR JLYH PRUH FODULW\ DQG KHOS\RXWRKDYHDQLGHDDERXWWKHLPSOHPHQWDWLRQRIWKHFRQFHSWGHILQHG,W LVVXJJHVWHGWKDW\RXWU\WRZRUNWKHH[DPSOHVJLYHQLQ\RXUODEVHVVLRQVE\ \RXUVHOILQRUGHUWRKDYHDFOHDUXQGHUVWDQGLQJRIWKHFRQFHSW$WWKHHQGRI HYHU\VHVVLRQVHOISUDFWLFHH[HUFLVHVDUHSURYLGHG
Objectives of this Book 7KLVERRNLVLQWHQGHGWRJLYHSUHOLPLQDU\DQGLQWHUPHGLDWHH[SRVXUHRQ-DYD /DQJXDJH $W WKH HQG RI WKLV PRGXOH \RX VKRXOG EH DEOH WR ZULWH D -DYD $SSOLFDWLRQ RU -DYD $SSOHWV FRPIRUWDEO\ FRPSLOH LW DQG H[HFXWH LW
Conventions Used in this Book ♦ Each session is divided into 12 topics. It is called the Twelve Point Program (12pp). In every session, these points are distinctly shown in an underlined bigger font. ♦ Subheadings appear in bold without underlining. ♦ Note is shown inside a box. It is information which is necessary to understand the subject discussed but does not come as a part of the text flow. ♦ Summary is at the end of each session, shown in a special table, italicized. ♦ Each session ends with a ‘Going Over It Again’. This helps the student in recapitulating the session contents. ♦ Figure numbers and descriptions are given below each picture, diagram or screen for proper navigation.
iii
Session 1
Java-An Introduction
On Completion of this Session We will be able to understand...
) ) )
Basic concepts in Java
) ) )
About Java Application
Java as an OOP language Tools in Java About Java Applet Features of Java
In This Session...
Introduction to Java
History of Java
Features in Java
Java and Internet
Java-An OOP Language
C++ vs Java
Java Tools
Application Programming
Creating an Application
Applet Programming
Creating an Applet
Overview of Java
JAVA-An Introduction
Introduction to Java -DYD LV DQ REMHFW RULHQWHG PXOWLWKUHDGHG SURJUDPPLQJ ODQJXDJH GHYHORSHG E\ 6XQ 0LFURV\VWHPV-DYDLVQRWRQO\DQREMHFWRULHQWHGSURJUDPPLQJODQJXDJHEXWDOVRDFRQFXUUHQW SURJUDPPLQJODQJXDJH:HFDQFUHDWHFODVVHVREMHFWVDQGXVHLQKHULWDQFHWKDWUHIOHFWWKHW\SLFDO REMHFWRULHQWHG IHDWXUHV :H FDQ DOVR FUHDWH DQG PDQLSXODWH WKUHDGV 7KHVH SRZHUV WRJHWKHU PDNH -DYD TXLWH SRZHUIXO 0DQ\ RI -DYD·V FKDUDFWHULVWLFV FRPHV IURP RWKHU ODQJXDJHV ,W KDV ERUURZHGFRQVWUXFWVIURPPDQ\RIWRGD\·VPRGHUQREMHFWRULHQWHGODQJXDJHV,QDGGLWLRQ-DYD LVDSODWIRUPLQGHSHQGHQWRUPDFKLQHLQGHSHQGHQWODQJXDJH)URPWKHSURFHHGLQJSDUDJUDSKV ZHFDQHDVLO\XQGHUVWDQGZK\-DYDLVSODWIRUPLQGHSHQGHQW $WUDGLWLRQDOODQJXDJHDOORZVXVWRZULWHSURJUDPVWKDWQHHGVWREHFRPSLOHGXVLQJDFRPSLOHU $FRPSLOHUFRPSLOHVRXUSURJUDPLQWRVRPHWKLQJFDOOHGWKHPDFKLQHODQJXDJHZKLFKYDULHVIRU GLIIHUHQWPDFKLQHVGHSHQGLQJXSRQWKHLULQWHUQDOFRQILJXUDWLRQ$IWHUFRPSLODWLRQZHKDYHWR H[HFXWH WKLV FRPSLOHG SURJUDP RQ RXU PDFKLQH 6LQFH GLIIHUHQW FRPSXWHUV KDYH GLIIHUHQW PDFKLQH ODQJXDJHV D SURJUDP FRPSLOHG IRU RQH PDFKLQH FDQQRW EH H[HFXWHG RQ DQRWKHU PDFKLQH)RUSXWWLQJDSURJUDPRQDZHESDJHWKHEURZVHUVKRXOGFRPSLOHWKHSURJUDPHDFK WLPH DQG WKHQ UXQ 0RUHRYHU WKH ULVN LQYROYHG LV RI YLUXVHV JHWWLQJ WUDQVIHUUHG IURP VXFK D SURJUDPGXULQJWKHFRPSLODWLRQSURFHVV ,Q-DYDWKHVLWXDWLRQLVFRPSOHWHO\GLIIHUHQW7KHFRPSLOHUKDVDVSHFLDOW\LQWKDWLWJHQHUDWHVWKH VDPH PDFKLQH FRGH IRU HDFK DQG HYHU\ PDFKLQH W\SH LQ WKH ZRUOG WR EH SUHFLVH 7KH -DYD FRPSLOHU DVVXPHV D WKHRUHWLFDOO\ GHILQHG PDFKLQH FDOOHG -DYD 9LUWXDO 0DFKLQH DQG FRPSLOHV FRGHIRULW6XFKFRPSLOHGFRGHLVNQRZQDVE\WHFRGH7KLVE\WHFRGHLVPDFKLQHLQGHSHQGHQW VRWKDWZHFDQUXQWKLVH[HFXWDEOHFRGHLQDQ\W\SHRIPDFKLQHDFURVVWKH,QWHUQHW7KLVUHVXOWV LQ-DYDEHLQJUHIHUUHGWRDVD0DFKLQHLQGHSHQGHQWRUSODWIRUPLQGHSHQGHQWODQJXDJH
History of Java 7KH -DYD ODQJXDJH ZDV GHYHORSHG E\ 6XQ 0LFURV\VWHPV LQ 6XQ EHJDQ D SURMHFW IRU VRIWZDUHWRUXQ79 9&5VHWVLQWHUDFWLYH79DQG9&5,Q DJURXSRI6XQHQJLQHHUV OHG E\ 3DWULFN 1DXJKWRQ DQG 6XQ IHOORZ -DPHV *RVOLQJ ZDQWHG WR GHVLJQ D VPDOO ODQJXDJH ZKLFKFRXOGEHXVHGIRULQWHUDFWLYHFRQVXPHUGHYLFHV,Q6HSWHPEHU WKHEDVLFV\VWHPZDV GUDIWHG7KHLQWHUDFWLYHFRQVXPHUGHYLFHZDVFDOOHG6WDU6HYHQDQGZDVSDUWRIDODUJHUSURMHFW FDOOHG*UHHQ3URMHFW-DYD·VRULJLQDOQDPHZDV2DNQDPHGDIWHUWKHWUHHRXWVLGH-DPHV*RVOLQJ RIILFH+RZHYHUVLQFHWKHUHZDVDOUHDG\DODQJXDJHQDPHG2DNH[LVWLQJ6XQQDPHGLW-DYD-DYD LVQRWDQDFURQ\P,WLVDWUDGHPDUNRI6XQ0LFURV\VWHPV 7KH*UHHQ3URMHFWVSHQWDOORI DQGKDOIRI ORRNLQJIRUSHRSOHWREX\LWVWHFKQRORJ\ 1HYHUWKHOHVVQRERG\ZDVUHDG\WREX\LW$WWKLVWLPHWKH:RUOG:LGH:HE ::: DSDUWRI WKH ,QWHUQHW ZDV JURZLQJ ELJJHU 7KH NH\ WR WKH :HE LV WKH EURZVHU WKDW WUDQVODWHV K\SHUWH[W
Comp-U-Learn
3
Java Programming I
SDJHWRVFUHHQ7KHUHIRUH6XQUHOHDVHGWKHQHZ-DYDFDSDEOH+RW-DYDDEURZVHUZULWWHQLQ-DYD DV D YHKLFOH IRU GRZQORDGLQJ DQG UXQQLQJ WKH DSSOHWV )LQDOO\ WKH -DYD ODQJXDJH ZDV RIILFLDOO\ UHOHDVHGLQPLG 6XQ UHOHDVHG WKH ILUVW YHUVLRQ RI -DYD LQ HDUO\ ,W ZDV IROORZHG E\ -DYD D FRXSOH RI PRQWKVODWHU+RZHYHULQWKLVYHUVLRQDOVR6XQPLVVHGVRPHWKLQJWRVDWLVI\WKH,7SHRSOH6RLQ 0D\ 6XQUHOHDVHG-DYDYHUVLRQZLWKDVHHPLQJO\HQGOHVVVWUHDPRILPSURYHPHQWVDQG QHZ OLEUDULHV ZKLFK EHFDPH D PRVW LPSRUWDQW DVSHFW LQ -DYD ,Q 6XQ 0LFURV\VWHPV UHOHDVHGWKHODWHVWYHUVLRQDV-DYDZKLFKUHSODFHVWKHHDUO\WR\OLNH*8,DQGJUDSKLFVWRRONLWV ZLWKVRSKLVWLFDWHGDQGVFDODEOHYHUVLRQVWKDWFRPHDORWFORVHUWRWKHSURPLVHRI´:ULWHRQFH 5XQDQ\ZKHUHµWKDQWKHLUSUHGHFHVVRUV
Features in Java 7KLVVHFWLRQEULHIO\GLVFXVVHVWKHW\SLFDOIHDWXUHVRI-DYDZKLFKKDVKHOSHGLWEHFRPHDUHOHJDWH LWWRWKHSRVLWLRQRIEHLQJDGLVWLQJXLVKHGSURJUDPPLQJODQJXDJHRIWRGD\·VWHFKQRORJ\ Java is an easy programming language
-DYD LV WKH RQH RI WKH HDVLHVW SURJUDPPLQJ ODQJXDJHV LQ WKH ZRUOG QRZ 1R SURJUDPPLQJ ODQJXDJHDVSRZHUIXODV-DYDLVDQ\HDVLHU6LQFH-DYDLVREMHFWRULHQWHGSURJUDPPLQJLQ-DYDLV YHU\VLPSOH,WKDVDOOWKHPRGHUQIHDWXUHVWKDWZHZDQWLQDSURJUDPPLQJODQJXDJH,WZLOOPDNH DVPRRWKUHSODFHPHQWRI&DQG&LQGXHFRXUVHRIWLPHEXWWKDWLVQRWWKHRQO\WKLQJ,Q DGGLWLRQZHFDQXVHWKH-DYDSUHGHILQHGOLEUDULHVDQGSDFNDJHVLQRXUSURJUDP$OVRLQ-DYD WKHUHDUHQRUHVWULFWLRQVUHODWHGWRV\QWD[DQGSURJUDPPLQJFRQVWUXFWVFRPSDUHGWRDQ\RWKHU SURJUDPPLQJODQJXDJHV Java is portable and architecturally neutral
:ULWHRQFHDQGUXQDQ\ZKHUHLVWKHVORJDQIRU-DYD$OUHDG\ZHKDYHVHHQWKHFRQFHSWRIE\WH FRGH%HFDXVHRIWKLVE\WHFRGH-DYDLVFDOOHGDSODWIRUPLQGHSHQGHQWSURJUDPPLQJODQJXDJH DUFKLWHFWXUDOO\ QHXWUDO D VLQJOH SURJUDP FDQ UXQ RQ DQ\ W\SH RI PDFKLQH 7KLV PDNHV WKH FRQFHSW RI SRUWLQJ IURP RQH SODWIRUP WR DQRWKHU UHGXQGDQW 7KH VDPH YHUVLRQ RI WKH DSSOLFDWLRQ UXQV RQ DOO SODWIRUPV 6XFK SODWIRUP LQGHSHQGHQW ODQJXDJH LV QRW RQO\ XVHIXO IRU QHWZRUNVEXWDOVRIRUVLQJOHV\VWHPVRIWZDUHGLVWULEXWLRQ Java is a Distributed language
,Q D GLVWULEXWHG V\VWHP REMHFWV FDQ EH RQ D ORFDO RU D UHPRWH V\VWHP -DYD DSSOHWV DQG DSSOLFDWLRQVFDQRSHQDQGDFFHVVREMHFWVDFURVVWKHQHWDVHDVLO\DVWKH\FDQDFFHVVDILOHIURPD ORFDOILOHV\VWHP7KHH[WHQVLYHOLEUDU\RIURXWLQHVEXLOWLQWRWKHODQJXDJHDOORZV-DYDDSSOLFDWLRQ DQGDSSOHWWRHDVLO\ZRUNZLWK7&3,3SURWRFROVOLNH+773DQG)737KHEHDXW\RI-DYDEHLQJ
4
Comp-U-Learn
JAVA-An Introduction
DGLVWULEXWHGV\VWHPLVWKDWPDQ\GHVLJQHUVDWGLIIHUHQWUHPRWHORFDWLRQVFDQFROODERUDWHRQD VLQJOHSURMHFWEHFDXVHWKHE\WHFRGHLVLQWHUSUHWHGLQZHESDJHVDORQJZLWK-DYDDSSOHWV7KRXJK WKLVPDNHVWKHZHESDJHVWDNHDORQJHUWLPHWRORDG Java provides security
-DYD SURJUDPV DUH UHODWLYHO\ VDIH EHFDXVH WKH\ GR QRW KDYH SHUPLVVLRQ WR DFFHVV DOO RI RXU FRPSXWHU·V PHPRU\ DQG GLVF VSDFH -DYD KDV D EXLOWLQ PHFKDQLVP WR VDIHJXDUG RXU PDFKLQH IURPYLUXVHV6R-DYDLVLQWHQGHGWREHXVHGLQQHWZRUNHGGLVWULEXWHGHQYLURQPHQWV Java is Robust
-DYD EDVHG DSSOLFDWLRQV RU DSSOHWV DUH ZHOO EHKDYHG DQG ZLOO QRW OHW D V\VWHP FUDVK 7KH\ DOVR EHKDYHXQLIRUPO\DFURVVGLIIHUHQWSODWIRUPV7KLVIHDWXUHLVDOVRYHU\XVHIXO7KH-DYDFRPSLOHU GHWHFWV PDQ\ SUREOHPV GXULQJ FRPSLODWLRQ WLPH LWVHOI ZKLFK LQ RWKHU ODQJXDJHV ZRXOG EH VKRZQXSRQO\DWUXQWLPH$OVR-DYDGRHVQRWVXSSRUWSRLQWHUDULWKPHWLF6RDQ\RQHFDQZULWH D-DYDSURJUDPZLWKRXWKDYLQJWRZRUU\DERXWWKHPHPRU\OHDNDJHRUPHPRU\FRUUXSWLRQWKDW LVXVXDOO\DIHDWXUHRIEDGSRLQWHUPDQDJHPHQW ([FHSWLRQ FRQGLWLRQV LQ WUDGLWLRQDO HQYLURQPHQWV RIWHQ DULVH LQ VLWXDWLRQV VXFK DV GLYLVLRQ E\ ]HUR RU ILOH QRW IRXQG DQG PXVW EH PDQDJHG ZLWK FOXPV\ DQG KDUG WR UHDG FRQVWUXFWV -DYD KHOSV LQ WKLV DUHD E\ SURYLGLQJ REMHFW RULHQWHG H[FHSWLRQ KDQGOLQJ ,Q D ZHOOZULWWHQ -DYD SURJUDPDOOUXQWLPHHUURUVFDQDQGVKRXOGEHPDQDJHGE\RXUSURJUDP Java is a Multithreaded Language
-DYD ZDV GHVLJQHG WR PHHW WKH UHDOZRUOG UHTXLUHPHQW RI FUHDWLQJ LQWHUDFWLYH QHWZRUNHG SURJUDPV 7R DFFRPSOLVK WKLV -DYD VXSSRUWV PXOWLWKUHDGHG SURJUDPPLQJ ZKLFK DOORZV XV WR ZULWH SURJUDPV WKDW GR PDQ\ WKLQJV DW RQFH 7KH -DYD UXQ WLPH FRPHV ZLWK DQ HOHJDQW \HW VRSKLVWLFDWHG VROXWLRQ IRU PXOWLSURFHVV V\QFKURQL]DWLRQ WKDW PDNHV LW SRVVLEOH WR FRQVWUXFW VPRRWKO\ UXQQLQJ LQWHUDFWLYH V\VWHPV -DYD LV DQ HDV\ WR DSSURDFK PXOWLWKUHDGLQJ ODQJXDJH ,W DOORZVXVWRWKLQNDERXWWKHVSHFLILFEHKDYLRURIRXUSURJUDPQRWWKHPXOWLWDVNLQJVXEV\VWHP DVDZKROH Java is dynamic
-DYD LV D PRUH G\QDPLF ODQJXDJH WKDQ WKH RWKHU ODQJXDJHV ,W ZDV GHVLJQHG WR DGDSW WR DQ HYROYLQJ HQYLURQPHQW -DYD SURJUDPV FDUU\ ZLWK WKHP VXEVWDQWLDO DPRXQWV RI UXQ WLPH LQIRUPDWLRQWKDWDUHXVHGWRYHULI\WKHREMHFWDWUXQWLPH7KLVPDNHVLWSRVVLEOHWRG\QDPLFDOO\ OLQNFRGHLQDVDIHDQGH[SHGLHQWPDQQHU
Comp-U-Learn
5
Java Programming I
Java and the Internet %\XVLQJ-DYDXVHUVZLOOGRZQORDG-DYDE\WHFRGHIURPWKH,QWHUQHWDQGUXQWKHPRQWKHLURZQ PDFKLQHV-DYDSURJUDPVWKDWZRUNRQZHESDJHVDUHFDOOHGDSSOHWV7RXVHWKLVDSSOHWZHQHHG D-DYDHQDEOHGEURZVHUZKLFKLQWHUSUHWVWKHE\WHFRGHIRUXV6LQFH6XQOLFHQVHVWKH-DYDVRXUFH FRGHLWLQVLVWVWKDWWKHUHEHQRFKDQJHVLQWKHODQJXDJHDQGEDVLFOLEUDU\VWUXFWXUHV'XHWRWKLV ZHDUHVXUHWKDWDQDSSOHWUXQVRQDQ\EURZVHUWKDWLVDGYHUWLVHGDV-DYDHQDEOHG 7KH ,QWHUQHW KHOSHG FDWDSXOW -DYD WR WKH IRUHIURQW RI SURJUDPPLQJ 7KH UHDVRQ LV WKDW -DYD H[SDQGVWKHXQLYHUVHRIREMHFWVWKDWFDQPRYHDERXWIUHHO\LQF\EHUVSDFH,QDQHWZRUNWKHUH DUH WZR YHU\ EURDG FDWHJRULHV RI REMHFWV WKDW DUH WUDQVPLWWHG EHWZHHQ WKH VHUYHU DQG RXU SHUVRQDOFRPSXWHUQDPHO\SDVVLYHDQGDFWLYHSURJUDPV :KHQZHUHDGRXUHPDLOZHDUHYLHZLQJWKHSDVVLYHGDWD(YHQZKHQZHGRZQORDGDSURJUDP WKHFRGHIRUWKHSURJUDPLVVWLOORQO\SDVVLYHXQWLOZHH[HFXWHLW+RZHYHULQWKHVHFRQGW\SHRI REMHFWWKDWFDQEHWUDQVPLWWHGWRRXUFRPSXWHUDVDG\QDPLFVHOIH[HFXWLQJSURJUDPLWLVFDOOHG DVDQDFWLYHSURJUDP $SSOHWVFDQEHXVHGWRDGGEXWWRQVDQGLQSXWILHOGVWRZHESDJH+RZHYHUGRZQORDGLQJWKRVH DSSOHWVRYHUDGLDOXSOLQHLVVORZDQGZHFDQGRPXFKWKHVDPHZLWK'\QDPLF+70/+70/ IRUPV DQG D VFULSWLQJ ODQJXDJH VXFK DV -DYD6FULSW ,Q HDUO\ GD\V DSSOHWV ZHUH XVHG IRU DQLPDWLRQV OLNH VSLQQLQJ JOREHV FDUWRRQV +RZHYHU DQLPDWHG *,) FDQ GR PXFK RI WKLV DQG '\QDPLF+70/FRPELQHGZLWKVFULSWLQJFDQGRHYHQPRUHRIZKDW-DYDDSSOHWVZHUHXVHGIRU
Java- An OOP Language 7KHREMHFWRULHQWHGFRQFHSWKDVSURYHQLWVZRUWKLQWKHODVWWKLUW\\HDUV,WLVRQHRIWKHPRVW SRSXODUWHFKQRORJLHV0DQ\RIXVPLJKWKDYHKHDUGWKLVZRUGPD\EHSHUKDSVZLWKRXWNQRZLQJ ZKDWLWPHDQV:KDWHYHULWPD\EH223LVRQHRIWKHVLPSOHVWDQGSODLQWKLQJVZHFDQFRPH DFURVV LQ RXU SURJUDPPLQJ FDUHHU 223 ODQJXDJH SURYLGHV VLPSOH FRQVWUXFWV WR HQDEOH XV WR H[SUHVVRXUQDWXUDOLGHDVHIILFLHQWO\7KLVDOORZVXVWRWDONDERXWYDULRXVREMHFWV 6LQFH-DYDLVDQREMHFWRULHQWHGSURJUDPPLQJODQJXDJHZHFDQXVHPRVWRIWKHREMHFWRULHQWHG FRQFHSWV LQ RXU -DYD SURJUDPPLQJ -DYD IRFXVHV RQ GHILQLQJ GDWD DQG IXQFWLRQV WKDW PD\ EH DSSOLHGWRWKRVHREMHFWV7KLVIDFLOLWDWHVSURJUDPGHYHORSPHQWXVLQJQDWXUDOSDUDGLJPV,Q-DYD ZHFDQFRQVWUXFWDSURJUDPXVLQJWKHIROORZLQJREMHFWRULHQWHGFRQFHSWV ♦ ♦ ♦ ♦
6
Encapsulation Inheritance Polymorphism Interfaces
Comp-U-Learn
JAVA-An Introduction
$OWKRXJK -DYD VXSSRUWV WKH REMHFWRULHQWDWLRQ LW GRHV QRW VXSSRUW PXOWLSOH LQKHULWDQFH ,W VXSSRUWVVLQJOHLQKHULWDQFHZKHUHRQHFODVVFDQLQKHULWIURPRQO\RQHRWKHUFODVV2QWKHRWKHU KDQG-DYDVXSSRUWVDEVWUDFWFODVVHV LQWHUIDFHVXVLQJZKLFKSURJUDPPHUVFDQVLPXODWHPXOWLSOH LQKHULWDQFH7KHDEVWUDFWEDVHFODVVIRUDOO-DYDFODVVHVLVDFODVVFDOOHGREMHFW
C++ vs. Java $OWKRXJK-DYDLVREMHFWRULHQWHGWKHUHDUHVRPHGLIIHUHQFHVEHWZHHQ-DYDDQG&DQREMHFW RULHQWHG SURJUDPPLQJ ODQJXDJH LWVHOI $SDUW IURP WKH REMHFWRULHQWHG FRQFHSWV -DYD GLIIHUV IURP&LQYDULRXVZD\V7KHIROORZLQJOLVWVWKHGLIIHUHQFHV ♦ Java omits header files, pre-processor, goto statement and multi dimensional arrays. ♦ Like C, C++, Java does not support the pointer arithmetic. In addition, Java omits the important elements, union and structures. ♦ Java does not support the multiple inheritance. Through interfaces, we can simulate multiple inheritance. ♦ Java does not support stand-alone functions. All Java functions including the main function should be declared within the class. ♦ Although Java supports polymorphism, it does not support the operator overloading. ♦ In Java, the main function should take one parameter, which is a string type variable. The String class object itself determines the number of arguments. ♦ Java has an auto garbage collection mechanism. Therefore, we do not need to worry about freeing memory. ♦ In Java we can comment the lines by using the “/**” and “*/”. It can be used by the javadoc tool, which will be discussed later. ♦ The boolean data types, unlike in C++, are not an interpretation of the integers 0 and 1. Therefore in Java, Java boolean cannot be typecast into integers. They can have values either true or false.
Java Tools -DYDLVDFRPSOHWHSURJUDPPLQJHQYLURQPHQWDQGFRPHVZLWKLWVRZQVHWRI WRROV(DFK-DYD WRROKDVDVLJQLILFDQWIHDWXUH7KHIROORZLQJDUHWKH-DYDWRROVXVHGIRU-DYDSURJUDPPLQJ JDK
6WDQGVIRU-DYD'HYHORSHUV.LWDYDLODEOHIRULWVVXSSRUWHGSODWIRUPVRQZKLFKZHKDYHWRZULWH RXU-DYDSURJUDP,WLQFOXGHVIROORZLQJWRROVIRUIXUWKHUIDFLOLWLHV
Comp-U-Learn
7
Java Programming I Javac
6WDQGVIRU-DYDFRPSLOHUE\ZKLFKZHFRPSLOHRXU-DYDDSSOLFDWLRQDVZHOODVWKHDSSOHW$IWHU FRPSLOLQJ RXU -DYD SURJUDP D FODVV ILOH ZLOO DXWRPDWLFDOO\ EH FUHDWHG LQ WKH VDPH GLUHFWRU\ ZKLFKFRQWDLQVWKHE\WHFRGHRIWKHSURJUDP7KHV\QWD[WRFRPSLOHWKHSURJUDPLV javac
< type our Java file here with the .Java extension.>
E.g.: C:/jdk1.2/bin/javac example.java
Java
7KLV LV WKH -DYD LQWHUSUHWHU 8VLQJ WKLV ZH ZLOO EH DEOH WR UXQ RXU DSSOLFDWLRQ SURJUDP LQ WKH FRPPDQG OLQH 7KLV VKRXOG EH GRQH DIWHU FRPSLOLQJ WKH -DYD ILOH %HFDXVH ZKHQ ZH UXQ RXU -DYDILOHWKH-DYDLQWHUSUHWHUZLOOORRNIRUWKHFODVVILOHRIWKDWSDUWLFXODUSURJUDPWRH[HFXWHWKH RXWSXW7KHV\QWD[WRUXQRXUDSSOLFDWLRQSURJUDPLV Java
< Java file without the .Java extension.>
Example 1.1 C:/jdk1.2/bin/java example
Appletviewer
:HFDQUXQRXUDSSOHWSURJUDPXVLQJWKLVVWDQGDORQHEURZVHUDQGJHWRXURXWSXWLQDZLQGRZ :HFDQDOVRXVHDQ\RWKHUEURZVHUOLNH,QWHUQHW([SORUHU7KHV\QWD[DWFRPPDQGOLQHLV Appletviewer < HTML file.html extension.>
$QDSSOHWLVW\SLFDOO\YLHZHGOLNHWKLV Example 1.2 C:/jdk1.2/bin/appletviewer example.html
javadoc
7KLV WRRO UHFRJQL]HV WKH WKLUG FRPPHQW GHOLPLWHU ´
µ DQG XVHV LW WR DXWRPDWLFDOO\ JHQHUDWH GRFXPHQWDWLRQ 7KLV WRRO XVHV WKHVH W\SH RI FRPPHQWV -DYDGRF XQGHUVWDQGV D QXPEHU RI SDUDPHWHUVWKDWZHFDQHPEHGLQWKHVHFRPPHQWV7KHMDYDGRFRQO\ZRUNVRQSXEOLFFODVVHV 8
Comp-U-Learn
JAVA-An Introduction Jdb
7KLV WRRO LV FDOOHG -DYD GHEXJJHU ZKLFK LV XVHG WR GHEXJ RXU SURJUDP ,I ZH KDYH DQ\ FRPSLODWLRQHUURUVZHFDQHDVLO\ILQGRXWWKHHUURUORFDWLRQE\XVLQJWKH-DYDGHEXJJHUWRRO $OVRWKH-DYDHQYLURQPHQWKDVVRPHRWKHUWRROVOLNHMDYDSURIZKLFKLVWRJHQHUDWHSURILOHIRU RXUSURJUDPMDYDKZKLFKLVXVHGWRJHQHUDWH WKH KHDGHUILOHVIRULQWHJUDWLQJ&LQWR RXU-DYD FRGH
Application Programming -DYDDSSOLFDWLRQVDUHVLPLODUWRRWKHUSURJUDPPLQJODQJXDJHV,Q-DYDWKHUHDUHWZRSDUWVLQWKH SURJUDPPLQJHQYLURQPHQWDSSOLFDWLRQDQGDSSOHW,QDQDSSOLFDWLRQZHFDQZULWHRXUSURJUDP DQG LW UXQV VWDQG DORQH RQ WKH -DYD 9LUWXDO 0DFKLQH 7KDW PHDQV WKDW ZH FDQ UXQ RXU -DYD DSSOLFDWLRQSURJUDPLQRXUVWDQGDORQHPDFKLQH7KHMDYDFFRPSLOHULVXVHGWRFRPSLOHWKH-DYD DSSOLFDWLRQ7KH-DYDLQWHUSUHWHULVXVHGWRUXQWKH-DYDDSSOLFDWLRQLQWKHFRPPDQGOLQH 7KH DSSOLFDWLRQ LV ORDGHG IURP WKH ORFDO ILOH V\VWHP EHFDXVH LW LV DVVXPHG WKDW XVHUV ORDG DSSOLFDWLRQ IURP WKH ORFDO ILOH V\VWHP 7KHUH DUH IHZHU ILOHV DQG QHWZRUN VHFXULW\ UHVWULFWLRQV LPSRVHG $QLPSRUWDQWDGYDQWDJHIRUODUJHDSSOLFDWLRQVLVWKDWWKHPHPRU\VSDFHFDQEHFRQWUROOHG)URP WKH -90 ZH FDQ FRQWURO LQLWLDO OLPLWV IRU WKH VWDFN DQG KHDS ,I RXU DSSOLFDWLRQ XVHV D ODUJH DPRXQWRIPHPRU\ZHZLOOKDYHFRPSOHWHFRQWURORIWKHVHVHWWLQJV :LQGRZV DSSOLFDWLRQV DUH VLPLODU WR UXQQLQJ DQ DSSOHW IURP ZLWKLQ D ZHE EURZVHU 7KH PDLQ GLIIHUHQFH LV WKDW WKHUH DUH IHZHU ILOH DQG QHWZRUN VHFXULW\ UHVWULFWLRQV 6WDQGDORQH ZLQGRZ DSSOLFDWLRQVPXVWDOVRSURYLGHWKHLURZQFRQQHFWLRQWRUHVRXUFHVVXFKDVSLFWXUHVDQGVRXQG 7KH\GLIIHUIURPDSSOHWVLQWKDWWKH\GRQRWUXQIURP:HEEURZVHUV
Creating an Application ,Q-DYDFUHDWLQJDQDSSOLFDWLRQSURJUDPFRQVLVWVRIWKHIROORZLQJVWHSV ♦ Create a Java Source file with .Java extension. ♦ Compile this source file by using javac compiler. ♦ Run this application by using Java interpreter. 7KH IROORZLQJ H[DPSOH LOOXVWUDWHV WKH SUHOLPLQDU\ WKLQJV DERXW FUHDWLRQ RI DQ DSSOLFDWLRQ SURJUDP
Comp-U-Learn
9
Java Programming I
Example 1.3 class first_program public static void main(String args[]) { System.out.println(“Welcome to Comp-U-Learn!”); } }
$-DYDDSSOLFDWLRQVKRXOGFRQWDLQWKHIROORZLQJVWHSV &ODVV GHILQLWLRQ 7KH ILUVW OLQH VKRXOG FRQWDLQ WKH NH\ZRUG FODVV DQG WKH FODVV QDPH ILUVWBSURJUDPLVWKHVRXUFHILOHQDPH 0DLQPHWKRG ,QWKHVHFRQGOLQHZHVKRXOGGHILQHWKHPDLQPHWKRG,QWKLVOLQHZHDOVRVSHFLI\ WKHDFFHVVPRGHUHWXUQW\SHDQGWKHPDLQNH\ZRUGZLWKWKHVLQJOHSDUDPHWHU,QDGGLWLRQZH FDQ KDYH DQ\ QXPEHU RI FODVV PHWKRGV DQG YDULDEOHV ZLWKLQ D FODVV GHILQLWLRQ ,Q WKH DERYH SURJUDP ♦ 3XEOLFLQGLFDWHVWKDWWKHPDLQPHWKRGFDQEHFDOOHGE\DQ\REMHFW ♦ 6WDWLFLQGLFDWHVWKDWWKHPDLQPHWKRGLVLQWKHFODVVGHILQLWLRQ,Q-DYDDSSOLFDWLRQ WKH PDLQPHWKRGVKRXOGEHLQVLGHWKHFODVVGHILQLWLRQ ♦ 9RLGGHQRWHVWKDWWKHPDLQPHWKRGKDVQRUHWXUQW\SH ♦ 7KHPDLQPHWKRGWDNHVDVLQJOHDUJXPHQWDVDQDUUD\RIVWULQJV7KHVHVWULQJVZKHQ JLYHQ DV DUJXPHQWV WR WKH SURJUDP DW FRPPDQG OLQH DUH FDOOHG FRPPDQG OLQH DUJXPHQWV
Note In Java the source file name should be same as the class name. When we run our program, the interpreter will look for the .class file of that source file name 1RZW\SHLQWKHDERYHSURJUDPLQ1RWHSDG'26HGLWRU DQGVDYHLWDVILUVWBSURJUDPMDYDLQ -DYD·VELQGLUHFWRU\IROORZWKHVWHSVJLYHQEHORZLQWKHFRPPDQGOLQHWRJHWWKHRXWSXW 1. Compile the program using javac ( javac first_program.java) 2. Press Enter and wait until the compilation is over without any errors. 3. Then run the program using the interpreter ( java first_program) 1RZZHFDQJHWWKHRXWSXWLQWKHFRPPDQGOLQHDVIROORZV
10
Comp-U-Learn
JAVA-An Introduction
Fig 1.1
Applet Programming $QDSSOHWLVDG\QDPLFDQGLQWHUDFWLYHSURJUDPWKDWFDQUXQLQVLGHDZHESDJHGLVSOD\HGE\D -DYDHQDEOHGEURZVHUVXFKDV+RW-DYDRU1HWVFDSH-DYDDSSOHWVKDYHUHVWULFWLRQVWRHQVXUH VHFXULW\WRSUHYHQWWKHPIURPEHLQJDIIHFWHGE\YLUXVHV $SSOHWV DUH D FRPPRQ ZD\ RI ZULWLQJ LQWHUDFWLYH XVHU LQWHUIDFH -DYD DSSOLFDWLRQV ,QWHJUDWLQJ ZHE EDVHG VRXQG DQG JUDSKLFV LQWR DSSOLFDWLRQV LV VLPSOLILHG E\ XVLQJ PHWKRGV LQ WKH DSSOHW FODVV$SSOHWVDUHHVVHQWLDOO\SURJUDPVWKDWUXQIURPZLWKLQDZHEEURZVHU7KH\DSSHDUDVSDUW RI +70/ GRFXPHQWV LQ WKH VDPH ZD\ WKDW SLFWXUHV DUH UHSUHVHQWHG $SSOHWV RQO\ UXQ IURP ZLWKLQ-DYDHQDEOHGEURZVHUVVXFKDV1HWVFDSH+RW-DYDDQGWKH,QWHUQHW([SORUHU
Creating an Applet ,QWKLVVHFWLRQZHDUHJRLQJWROHDUQDERXWWKHFUHDWLRQRIDVLPSOHDSSOHWSURJUDP7KHGHWDLOV UHJDUGLQJDSSOHWVZLOOEHGLVFXVVHGLQWKHVXFFHHGLQJVHVVLRQV7KHFUHDWLRQRIDQDSSOHWFRQVLVWV RIWKHIROORZLQJIRXUVWHSV ♦ ♦ ♦ ♦
Importing the necessary built-in Java packages Defining applet subclasses Applet implementation Passing this Java applet’s .class file into HTML file.
&RQVLGHU WKH IROORZLQJ DSSOHW H[DPSOH VD\ ILUVWBDSSOHWMDYD ,W ZLOO JLYH WKH GHWDLOV WR FUHDWHDQDSSOHW Comp-U-Learn
11
Java Programming I
Example 1.4 import java.awt.*; import java.applet.*; public class first_applet extends Applet { public void paint(Graphics g) { g.drawString("Welcome to Comp-U-Learn!",50,20); } }
,QWKHDERYHSURJUDPWKHILUVWWZROLQHVDUHXVHGWRLPSRUWVRPHSDFNDJHVDQGFODVVHVZKLFK DUH EHLQJ XVHG ZLWKLQ WKH DSSOHW /LNH DSSOLFDWLRQV KHUH WR ZH KDYH WR VSHFLI\ WKH FODVV GHFODUDWLRQ DW WKH EHJLQQLQJ 7KH H[WHQGV NH\ZRUG LV XVHG KHUH WR H[WHQG VRPH SUHGHILQHG FODVVHVWRRXUSURJUDP 7KHQZHKDYHWRLPSOHPHQWWKHDSSOHWE\PHDQVRIWKHDSSOHWPHWKRGV,QWKLVSURJUDPWKH SDLQWPHWKRGRIDSSOHWLVXVHGWRSULQWVRPHWH[WLQWKHZLQGRZ)LQDOO\ZHKDYHWRSDVVWKLV VRXUFHILOH ILUVWBDSSOHWFODVV LQWRDQ+70/ILOH)RUWKDWZHKDYHWRFUHDWHDQ+70/ILOH VD\ ILUVWBDSSOHWKWPO ZKLFKVKRXOGFRQWDLQWKHIROORZLQJFRGH
1RZFRPSLOHWKLVILUVWBDSSOHWMDYDILOHRQWKHFRPPDQGOLQHXVLQJMDYDF7KHQUXQWKLV ILUVWBDSSOHWKWPOILOHXVLQJDSSOHWYLHZHU 7KH IROORZLQJ ILJXUH VKRZV WKH RXWSXW RI WKH DERYH DSSOHWSURJUDP
Fig 1.2
12
Comp-U-Learn
JAVA-An Introduction
$IWHU FRPSLOLQJ WKH -DYD ILOH ZH JHW WKH RXWSXW IRU WKH DERYH SURJUDP E\ EURZVLQJ WKH ILUVWBDSSOHWKWPOILOHLQWKH,QWHUQHWH[SORUHU
Fig 1.3
Overview of Java 6RIDUZHKDYHGLVFXVVHGDERXW-DYDLWVIHDWXUHVDQGLWVVLPSOHSURJUDPPLQJHQYLURQPHQW7KLV VHFWLRQLVDTXLFNRYHUYLHZRI-DYD -DYDDVRIWRGD\LVSRSXODUGXHLWV,QWHUQHWIDFLOLWLHVEURZVLQJHWFEXWLWKDVPRUHSRWHQWLDOWR EHFRPHDVHULRXVSURJUDPPLQJODQJXDJHLQIXWXUH7RGD\PDQ\SHRSOHIDLOWRYLVXDOL]HWKLVEXW ZHFDQEHFRQILGHQWWKDWLWZLOOSURYHWREHVR,QIDFWWKLVLVWKHPDMRUUHDVRQZK\-DYDDWWUDFWV PDQ\ SHRSOH ,W KDV DOO WKH JRRG SRLQWV RI D ZHOOWKRXJKW RXW ODQJXDJH OLNH 3DVFDO WKDW LV D VWUXFWXUDO ODQJXDJH ,WV V\QWD[ ORRNV VLPLODU WR & EXW LW KDV YHU\ FDUHIXOO\ DYRLGHG DOO WKH SUREOHPDWLFFRQVWUXFWVRI&OLNHSRLQWHUVVWUXFWXUHVDQGXQLRQV ,QDGGLWLRQWKHPDMRUPLVWDNHPDGHLQWKH&GHVLJQWRSDWFKXS&ZLWKWKH223IDFLOLWLHV KDVEHHQDYRLGHGLQ-DYD,Q&DQ\&SURJUDPFDQEHDFFHSWHGDVD&SURJUDP WKXV HYHQWXDOO\DOOWKHDGYDQWDJHVRI223JRWNLOOHG-DYDGRHVQRWDOORZWKLVDQGIRUFHVWKHVRIWZDUH SURJUDPPHUWRGHYHORSFRGHLQDV\VWHPDWLFVWUXFWXUHGWRSGRZQDQG223PDQQHU )RUDOOWKHVHUHDVRQV-DYDZRXOGEHWKHODQJXDJHRIIXWXUH$IWHU\HDUVPRVWSUREDEO\SHRSOH ZLOO VD\ WKDW ´ LW DOVR KDV DOO WKH IDFLOLW\µ +HUH LW UHPLQGV XV RI VRPHWKLQJ VLPLODU WKDW KDG KDSSHQHGZLWK&DURXQG 7KDWWLPHHYHU\ERG\UHJDUGHGLWWREHWKH ´6\VWHPVSURJUDPPLQJµODQJXDJHDQGPDQ\H[SHUWVDOVRIDLOHGWRVHHLWVRWKHUSRWHQWLDOVDVD JHQHUDOSURJUDPPLQJODQJXDJH$IWHU\HDUVLQ HYHU\RQHXQGHUVWRRGLWDVDGHYHORSPHQW ODQJXDJH DQG DGGHG D OLQH VD\LQJ ´LW LV EHWWHU VXLWHG WR GR ORZOHYHO V\VWHPRULHQWHG SURJUDPPLQJµ 7KXV -DYD ZLOO EHFRPH D SRZHUIXO JHQHUDO SXUSRVH SURJUDPPLQJ ODQJXDJH LQ WKHQH[WFHQWXU\ Comp-U-Learn
13
Java Programming I
Summary In this session, we learnt about the Java language and how Java is an objectoriented language. Now we can appreciate the relationship between the Java and the Internet. In this session we also learnt how Java differs from the other programming languages. After this Java preliminary, we learnt about Java tools and its uses. We also learnt to write a simple Java application program and create a simple applet.
Going Over It Again I. Fill in the Blanks
-DYDLVRIILFLDOO\UHOHDVHGLQBBBBBBBBBBBBB ,Q D QHWZRUN WKHUH DUH WZR YHU\ EURDG FDWHJRULHV RI REMHFWV WKH\ DUH BBBBBBBBB DQG BBBBBBBBBBBB 7KURXJKBBBBBBBBBBBZHFDQVLPXODWHPXOWLSOHLQKHULWDQFH ,Q-DYDWKHVRXUFHILOHQDPHVKRXOGEHVDPHDVWKHBBBBBBBQDPH $IWHUFRPSLOLQJRXU-DYDSURJUDPDBBBBBBBILOHZLOOEHDXWRPDWLFDOO\FUHDWHGLQWKHVDPH GLUHFWRU\E\BBBBBBBFRPSLOHU
II. State True or False
-DYDLVDVWUXFWXUDODQGREMHFWRULHQWHGODQJXDJH -DYDVXSSRUWVDOOWKHSRO\PRUSKLVPFRQFHSWV :HFDQUXQ$SSOHWVE\WKHVWDQGDORQHLQWHUSUHWHU ,QDSSOHWVWKHUHLVQRQHHGIRUPDLQPHWKRG :HFDQXVHWKHMDYDFWRROIRUGHEXJJLQJRXUSURJUDP
14
Comp-U-Learn
JAVA-An Introduction III. One line Answers
:KDWDUHWKHWZRSURJUDPPLQJW\SHVRIIHUHGE\-DYD" :KDWLV-90" /LVWRXWWKH-90WRROV +RZGRZHLPSOHPHQWPXOWLSOHLQKHULWDQFHLQ-DYD" :KDWLVDQDSSOHW" IV. Match the following
$SSOHW
DPXOWLSOHLQKHULWDQFH
-DYDGRF
EE\WHFRGH
LQWHUIDFHV
FEURZVHU
+773)73
GGRFXPHQWDWLRQ
-DYDF
H,QWHUQHWSURWRFROV
Comp-U-Learn
15
Session 2
Fundamentals of Java
On Completion of this Session We will be able to understand...
) Java Syntax & Identifiers ) Java variables and its scope ) About commenting in Java ) Java programming constructs ) Arrays & Strings in Java
In This Session...
Data types & Variables in Java
Literals, Keywords & Identifiers
Operators in Java
Expression Evaluations & Operator Precedence
Scope of Variables
Commenting in Java
Decision Making
For Loop
While & Do… While Loop
Switch & Break Statements
Arrays in Java
Strings in Java
Fundamentals of Java
Data types & Variables in Java ,Q WKLV VHFWLRQ ZH ZLOO EH GLVFXVVLQJ DERXW WKH GDWD W\SHV DQG YDULDEOHV XVHG LQ -DYD ,Q -DYD WKHUHDUHWZRW\SHVRIGDWDNLQGV7KH\DUH ♦ Primitive data types ♦ Reference data types 7KHSULPLWLYHGDWDW\SHVFRQWDLQDVLQJOHYDOXH,QWHJHUIORDWFKDUDFWHUDQGERROHDQGDWDW\SHV FRPHXQGHUWKLVW\SH7KHUHIHUHQFHW\SHVDUHFDOOHGVXFKEHFDXVHWKHYDOXHRIUHIHUHQFHYDULDEOH LVDUHIHUHQFHWRDQDFWXDOYDOXHUHSUHVHQWHGE\DQRWKHUYDULDEOH)RUH[DPSOHDUUD\VFODVVHVDQG LQWHUIDFHV IDOO XQGHU WKLV FDWHJRU\ ,Q DGGLWLRQ ZKHQ D FODVV LV FUHDWHG LQ HVVHQFH D QHZ GDWD W\SHLVFUHDWHG:H·OOVHHWKHVHGDWDW\SHVLQGHWDLO 7KHIROORZLQJWDEOHOLVWVWKHPRVWRISULPLWLYHGDWDW\SHVWKHLUVL]HDQGUDQJH Type Byte Short Int Long Float Double Char Boolean
Size 1 2 4 8
Range -128 to 127 -32,768 to 32, 767 -2,147,483,648 to 2,147,483,647 -9,223,372,036,854,775,808 To 9,223,372,036,854,775,807 approx. ±3.40282347E+38F approx. ±1.79769313486231570E+308 true or false
4 8 2 -
Variables in Java
,Q -DYD ZH KDYH WR GHFODUH WKH W\SH RI YDULDEOH ZH DUH JRLQJ WR XVH 7KH YDULDEOH GHFODUDWLRQ DOZD\VFRQWDLQVWZRSDUWV2QHLVGDWDW\SHDQGDQRWKHULVYDULDEOHQDPH7KHIROORZLQJV\QWD[ VKRXOGEHXVHGWRGHFODUHDYDULDEOH
(e.g.: int
no;)
,Q-DYDZKLOHGHFODULQJDYDULDEOHZHKDYHVRPHUHVWULFWLRQV ♦ A variable name must be a legal identifier of a series of Unicode characters. ♦ A variable name should not be the same as any keywords or literals. Comp-U-Learn
19
Java Programming I
♦ They must not have the same name as another variable. ♦ Java is case sensitive. So int Myint, myInt, MyInt, and myint are different variables. Variable initialization
/RFDO YDULDEOHV ZKLFK DUH YDULDEOHV GHFODUHG LQ PHWKRGV PXVW EH LQLWLDOL]HG EHIRUH WKH\ DUH XVHG,IQRWDFRPSLOHWLPHHUURUZLOORFFXU$YDOXHDVVLJQHGWRWKHYDULDEOHPXVWPDWFKWKH YDULDEOHW\SH E.g.:
int
number = 0;
Using Variables
7KHIROORZLQJH[DPSOHLOOXVWUDWHVWKHXVHRIYDULDEOHVLQ-DYD Example 2.1 class var_usage { public static void main(String args[]) { int a=10; double b=4.5; char c='n'; System.out.println(" This is the Usage of System.out.println(" The value of a is: " System.out.println(" The value of b is: " System.out.println(" The value of c is: " } }
Variables"); +a); +b); +c);
,QWKLVH[DPSOHWKH 6\VWHPRXWSULQWOQ VWDWHPHQW LV XVHG WR SULQW VRPH WH[W RQ WKH VFUHHQ ,Q DGGLWLRQKHUHZHDUHSULQWLQJWKHLQLWLDOL]HGYDULDEOHVVRZHKDYHWRXVH´µRSHUDWRUDORQJZLWK WKHYDULDEOHQDPH$IWHUUXQQLQJWKHDERYHSURJUDPZHJHWWKHRXWSXWDVIROORZV This is the Usage of Variables The value of a is: 10 The value of b is: 4.5 The value of c is: n
Note For printing text on consecutive lines, System.out.println statement is used. If we use the System.out.print statement, the text will be printed in the same line. 20
Comp-U-Learn
Fundamentals of Java
Literals, Keywords & Identifiers ,Q -DYD WKHUH DUH VRPH OLWHUDOV DQG UHVHUYHG ZRUGV $ OLWHUDO UHSUHVHQWV WKH YDOXH RI D FHUWDLQ W\SHZKHUHWKHW\SHGHVFULEHVKRZWKDWYDOXHEHKDYHV7KHUHDUHGLIIHUHQW W\SHVRIOLWHUDOYL] QXPHULFFKDUDFWHUERROHDQDQGVWULQJ Number
,QWKLVW\SHZHFDQKDYHOLWHUDOVOLNHLQWORQJRFWDOKH[DGHFLPDOHWFDQXPEHUEHJLQQLQJZLWK LVFDOOHGRFWDOQXPEHU$OHDGLQJ[QXPEHULVFDOOHGKH[DGHFLPDOQXPEHU8VLQJWKHOHWWHU(RU HIROORZHGE\WKHH[SRQHQWFDQXVHWKHH[SRQHQWVZLWKIORDWLQJSRLQWOLWHUDOV Boolean
7KHUHDUHRQO\WZRW\SHVRIERROHDQOLWHUDOV7KH\DUHWUXHDQGIDOVH Character
$VLQJOHFKDUDFWHUHQFORVHGZLWKLQVLQJOHTXRWHVH[SUHVVHVWKHFKDUDFWHUOLWHUDOV7KHVHDUHVWRUHG DV8QLFRGHFKDUDFWHUV Escape Sequences
7KHVH DUH DOVR D IRUP RI FKDUDFWHU OLWHUDO EXW DUH QRW SULQWHG RQ WKH VFUHHQ7KH\ FRXOG EH FRPELQHGZLWKDQ\RWKHUOLWHUDO7KHIROORZLQJWDEOHVKRZVHVFDSHVHTXHQFHVXVHGLQ-DYD Literals \n \t \b \r \f \\ \” \ddd \xdd \udddd
Usage To insert a new line (line feed) For tab control To give backspace For carriage return To give form feed For backslash to print a “ symbol For octal For Hexadecimal For Unicode character
Key words
.H\ZRUGVDUHDOVRFDOOHGUHVHUYHGZRUGV+HUHLVDFRPSOHWHOLVWRIWKHNH\ZRUGVLQ-DYDIRU RXUIXUWKHUUHIHUHQFH$OORIWKHPDUHQRWFXUUHQWO\LQXVH VRPHRIWKHPDUHUHVHUYHGIRUIXWXUH HQKDQFHPHQWV Comp-U-Learn
21
Java Programming I
DEVWUDFWERROHDQEUHDNE\WH FDVHFDVWFDWFKFKDUFODVVFRQVWFRQWLQXH GHIDXOWGRGRXEOHHOVHH[WHQGVILQDOILQDOO\IORDWIXWXUH JHQHULFLILPSOHPHQWVLPSRUWLQQHULQVWDQFHRILQWLQWHUIDFH ORQJQDWLYHQHZQXOORSHUDWRURXWHU SDFNDJHSXEOLFSURWHFWHGDQGSULYDWH UHVWUXQUHWXUQVKRUWVWDWLFVXSHUVZLWFKV\QFKURQL]HG WKLVWKURZWUDQVLHQWWU\YDUYRLGYRODWLOHZKLOH Identifiers
7KHLGHQWLILHUVDUHWKHV\PEROVXVHGLQD-DYDSURJUDP,GHQWLILHUVFDQQRWVWDUWZLWKDQXPEHU DOWKRXJKQXPEHUVDUHDOORZHGLQVLGHLGHQWLILHUV7KHV\PEROVWKDWFDQEHXVHGDVLGHQWLILHUVLQ -DYDDUH #A ?^`>@aa_ !" ´DQGHWF.
Operators in Java ,Q -DYD RSHUDWRUV FRPH LQ VHYHUDO W\SHV 7KH\ FDQ EH XVHG ZLWK YDULDEOHV WR LQGLFDWH PDWKHPDWLFDOUHODWLRQVKLSEHWZHHQWZRRUPRUHLWHPVWRFUHDWHORJLFDOVWUXFWXUHVRUWRSHUIRUP FRPSXWDWLRQV 7KH RSHUDWRUV VXSSRUWHG E\ -DYD DUH $ULWKPHWLF $VVLJQPHQW /RJLFDO DQG &RPSDULVRQ $ULWKPHWLFRSHUDWRUV $OOEDVLFDULWKPHWLFRSHUDWRUVVXFKDV DQGXQDU\RSHUDWRUVFRPHVXQGHUWKLVW\SH 7KHIROORZLQJWDEOHOLVWVWKH$ULWKPHWLFRSHUDWRUV Description Multiplication Division Addition Subtraction Modulus Increment Decrement Bit-wise complement
22
Operators * / + % ++ -~
Function Multiply the given two numbers Divide two numbers Add two numbers Subtract two numbers Determine the remainder in a division operation Increase the value of a specified variable by one Decrease the value of a specified variable by one Change the bit values of a specified variable, Converting all ones to zeros and vice versa
Comp-U-Learn
Fundamentals of Java
7KHIROORZLQJH[DPSOHVKRZVWKHXVDJHRIWKHDULWKPHWLFRSHUDWRUVLQ-DYD Example 2.2 class arithmetic { public static void main(String { int a=20; int b=10; double c=4.5; System.out.println(" The Usage System.out.println(" The value System.out.println(" The value System.out.println(" The value System.out.println(" The value System.out.println(" The value a++; b--; System.out.println(" System.out.println(" System.out.println(" System.out.println(" } }
Now, Now, Now, Now,
the the the the
args[])
of of of of of of
Arithmetic operators"); (a+b) is: " +(a+b)); (a-b) is: " +(a-b)); (a*b) is: " +(a*b)); (b+c) is: " +(b+c)); (a*c) is: " +(a*c));
second value of a is: " +a); second value of b is: " +b); final value of a is: " +(--a)); final value of b is: " +(++b));
$IWHUVDYLQJWKLVILOHDVDULWKPHWLFMDYDUXQWKHSURJUDP:HJHWWKHIROORZLQJRXWSXW 7KH8VDJHRI$ULWKPHWLFRSHUDWRUVDUHVKRZQEHORZ The value of (a+b) is: 30 The value of (a-b) is: 10 The value of (a*b) is: 200 The value of (b+c) is: 14.5 The value of (a*c) is: 90.0 Now, the second value of a is: 21 Now, the second value of b is: 9 Now, the final value of a is: 20 Now, the final value of b is: 10 Assignment operators
,Q-DYDWKHDVVLJQPHQWRSHUDWRUDSSOLHVWKHYDOXHRIWKHH[SUHVVLRQIURPWKHULJKWVLGHWRWKH YDULDEOHLQWKHOHIWVLGH:HFDQDOVRXVHWKHVH$VVLJQPHQWRSHUDWRUVLQWKHVKRUWFXWIRUPV)RU H[DPSOHWKHIROORZLQJWZRH[SUHVVLRQVZLOOJLYHWKHVDPHUHVXOW Comp-U-Learn
23
Java Programming I int int
xy = xy + 10 xy += 10
//using normal assignment // using shortcut assignment
7KHIROORZLQJWDEOHOLVWVWKHDVVLJQPHQWRSHUDWRUVDQGIXQFWLRQV Description Assign Addition Subtraction Multiplication Division Bitwise right Bitwise left Bitwise and Bitwise xor Bitwise or
Operator = += -= *= /= >>= <<= &= ^= |=
Function Assign right operand to left operand Add right from left & assign the value Subtract right from left & assign the value Multiply two values & assign it to left operand Divide two values & assign it to left operand Perform bitwise right shift Perform bitwise left shift Perform bitwise and operation Perform bitwise xor operation Perform bitwise or operation
Logical operators
/RJLFDORSHUDWRUVDUHXVHGWRHYDOXDWHDQH[SUHVVLRQWRFKHFNZKHWKHUWKHH[SUHVVLRQLVWUXHRU IDOVH6RWKHVHORJLFDORSHUDWRUVSHUIRUPWKHHYDOXDWLRQDQGUHWXUQWKHYDOXHDVD%RROHDQW\SH Description And Or
Operator && ||
Not
!
Function returns true if both operands are true returns true if any one of operands are true. returns reverse Boolean value of the expression
Comparison operators
7KHVHDUHXVHGWRFRPSDUHWKHRSHUDQGV$%RROHDQYDOXHLVUHWXUQHGZKHQXVLQJYDULDEOHVRU OLWHUDOV ZLWK WKH FRPSDULVRQ RSHUDWRUV &RQGLWLRQDO RSHUDWLRQ LV DOVR D VSHFLDO W\SH RI FRPSDULVRQ WKDW LV RQO\ ZLWK WKH DVVLJQPHQW RSHUDWRUV 7KH WDEOH JLYHQ EHORZ OLVWV WKH FRPSDULVRQRSHUDWRUV Description Less than Greater than Equal to 24
Operator < > ==
Function return true when result is less than return true when result is greater than the compared return true when result is equal Comp-U-Learn
Fundamentals of Java
Description Less than or equal to Greater than or equal to Not equal to Conditional
Operator <= >=
Function return true when result is less than or equal return true when result is greater than or equal
!= ?:
return true when result is not equal return first value of expression when result is true.
:H FDQ XVH WKHVH ORJLFDO ELWZLVH DQG FRPSDULVRQ RSHUDWRUV LQ WKH FRQGLWLRQDO VWDWHPHQWV ([DPSOHVLQWKHFRPLQJVHFWLRQVZLOOJLYHWKHXVDJHRIWKHVHRSHUDWRUV
Expression Evaluation & Operator Precedence $QH[SUHVVLRQLVDFROOHFWLRQRIYDULDEOHVDQGRSHUDWRUVWKDWVSHFLI\DFRPSXWDWLRQ([SUHVVLRQV DUHXVHGWRSHUIRUPRSHUDWLRQVRQWKHGDWDLQDSURJUDP7KHH[SUHVVLRQVDUHQRWVWDWHPHQWV )RUH[DPSOHFRQVLGHUWKHH[SUHVVLRQ int a= 20 * 3 + 7
,QWKHDERYHH[SUHVVLRQLQWHJHUDZLOOJHWDYDOXHRI:K\FDQ·WLWJHW"7KLVLVEHFDXVHWKH RSHUDWRUVKDYHSUHFHGHQFHLQWKLVH[SUHVVLRQ-DYDZLOOWUHDWWKHDERYHH[SUHVVLRQDV ,IZHZDQWWKHYDOXHZHKDYHWRJLYHWKHH[SUHVVLRQDV int a= 20 * (3 + 7)
7KH RSHUDWRUV DQG ² ZLOO KDYH VDPH SUHFHGHQFH $QG KDYH HTXDO SUHFHGHQFH &RPSDULQJ WKHVH WZR JURXSLQJV RI SUHFHGHQFH WKH RSHUDWRUV DQG HQMR\ KLJKHU SUHFHGHQFHWKDQWKHRSHUDWRUVDQG
Scope of Variables ,QWKLVVHFWLRQZHZLOOOHDUQDERXWWKHVFRSHRIYDULDEOHVZLWKLQDSURJUDP$YDULDEOH·VVFRSHLV WKHEORFNRIFRGHZLWKLQZKLFKWKHYDULDEOHLVDFFHVVLEOH$OVRWKHVFRSHRIDYDULDEOHGHWHUPLQHV ZKHQWKHYDULDEOHLVFUHDWHGDQGGHVWUR\HG:HFDQHVWDEOLVKWKHVFRSHRIDSDUWLFXODUYDULDEOHDW WKHWLPHRIGHFODUDWLRQ7KHIROORZLQJDUHWKHPDLQW\SHRIVFRSHRIDYDULDEOH ♦ Local variable ♦ Member variable 7KH ORFDO YDULDEOHV DUH GHFODUHG ZLWKLQ D PHWKRG RU EORFN RI FRGH LQ D PHWKRG &RQVLGHU WKH H[DPSOH:HFDQVHHWKHYDULDEOHVDEDQGF7KH\DUHGHFODUHGZLWKLQWKHPDLQPHWKRG6R Comp-U-Learn
25
Java Programming I
ZH FDQ XVH WKHVH YDULDEOHV ZLWKLQ WKH PDLQ PHWKRG RQO\ ,Q JHQHUDO D ORFDO YDULDEOH FDQ EH DFFHVVHGIURPLWVGHFODUDWLRQSDUWWRWKHHQGRIWKHFRGHEORFNLQZKLFKLWZDVGHFODUHG $ PHPEHU YDULDEOH LV D PHPEHU RI D FODVV RU DQ REMHFW DQG LV GHFODUHG ZLWKLQ D FODVV %XW LW VKRXOGQRWEHZLWKLQDQ\RIWKHFODVVPHWKRGV,IZHGHFODUHDYDULDEOHLQVLGHDPHWKRGZHFDQ DFFHVV WKDW YDULDEOH ZLWKLQ WKDW PHWKRG RQO\ :KLFK PHDQV LW ZLOO EH FRQVLGHUHG DV D ORFDO YDULDEOHRIWKDWPHWKRG7KHVWDWLFPHWKRGRIDFODVVFDQDFFHVVRQO\VWDWLFYDULDEOHVWKH\FDQ·W DFFHVVWKHYDULDEOHVZKLFKDUHGHFODUHGRWKHUZLVH
Commenting in Java ,Q -DYD SURJUDPV ZH FDQ FRPPHQW OLQHV E\ XVLQJ VLQJOH RU PXOWLSOH OLQH FRPPHQWLQJ V\QWD[ 8VLQJWKHIROORZLQJSURJUDPZHFDQXQGHUVWDQGWKHFRPPHQWLQJV\QWD[ Example 2.3: class comment { public static void main(String args[]) { int a=20; int b=10; // The following lines give us an idea about operators System.out.println(" The Usage of Arithmetic operators"); System.out.println(" The value of (a+b) is: " +(a+b)); System.out.println(" The value of (a-b) is: " +(a-b)); // Now a, b are going to be changed a++; b--; /* In the next two lines we are going to use the changed value of a, b and c */ System.out.println(" Now, the second value of a is: " +a); System.out.println(" Now,the second value of b is: " +b); } }
5XQWKHDERYHSURJUDPDQGVHHWKHRXWSXW2QO\SULQWVWDWHPHQWVJLYHQLQWKHSURJUDPZLOOEH SULQWHGLQWKHRXWSXW$Q\WKLQJWKDWDSSHDUVDIWHU´µXQWLOWKHHQGRIWKDWVLQJOHOLQHLVFDOOHG DVLQJOHOLQHFRPPHQWDQGLVLJQRUHGE\WKHMDYDFFRPSLOHU ,QDGGLWLRQDQ\WKLQJWKDWDSSHDUVDIWHU XSWR LVFDOOHGDVPXOWLSOHOLQHFRPPHQWLQJ:H FDQJLYHDQ\QXPEHURIOLQHVLQEHWZHHQWKH DQG 7KH-DYDFRPSLOHUZLOOLJQRUHDOOWKHVH OLQHV,QWKHDERYHH[DPSOHZHFDQVHHWZRW\SHVRIFRPPHQWLQJ
26
Comp-U-Learn
Fundamentals of Java
&RPPHQWVDUHDGGHGIRUWKHUHDGHUWRXQGHUVWDQGWKHSURJUDPEHWWHU WKH\DUHRIQRXVHWRWKH PDFKLQH7KHFRPSLOHULJQRUHVWKHVHFRPPHQWV:HFDQDOVRIROORZWKLVVW\OHLQRXUSURJUDPV WRPDNHRXU SURJUDP DQXQGHUVWDQGDEOHRQH:KHQZHZULWHDUHODWLYHO\ ELJJHU SURJUDP DQG UHDG LW DIWHU VL[ PRQWKV FRPPHQWV ZLOO SURYLGH D ORW RI LQIRUPDWLRQ WKDW ZRXOG RWKHUZLVH EH GLIILFXOWWRJXHVVIURPWKHSURJUDPDORQH
Decision Making /LNH DOO RWKHU SURJUDPPLQJ ODQJXDJHV -DYD KDV LWV RZQ SURJUDPPLQJ FRQVWUXFWV ,Q WKH IROORZLQJ VHFWLRQV ZH FDQ VHH YDULRXV -DYD SURJUDPPLQJ FRQVWUXFWV 7KHVH SURJUDPPLQJ FRQVWUXFWV LQFOXGHV WKH FRQGLWLRQDO VWDWHPHQWV FRQWURO VWDWHPHQWV DQG YDULRXV ORRSV %HIRUH JRLQJWRWKHVHWKLQJVZHKDYHWRXQGHUVWDQGWKHFRQFHSWRIGHFLVLRQPDNLQJ &RPSXWHUVDUHXVHIXOQRWRQO\EHFDXVHWKH\KDYHWKHDELOLW\WRVWRUHDQGPDQLSXODWHQXPEHUV EXW DOVR EHFDXVH WKH\ KDYH WKH DELOLW\ WR SLFN XS WKH ULJKW DOWHUQDWLYH E\ PHDQV RI GHFLVLRQ PDNLQJ(YHU\SURJUDPPLQJODQJXDJHRIIHUVDIDFLOLW\WRZULWHGRZQDOWHUQDWLYHVWREHIROORZHG ,Q -DYD WKHUH LV QR H[FHSWLRQ WR WKDW -DYD SURYLGHV WKH WZR SURJUDPPLQJ FRQVWUXFWV LI DQG VZLWFKVWDWHPHQWV 8VLQJ WKH ORJLFDO RSHUDWRUV DQG FRPSDULVRQ RSHUDWRUV ZH FDQ FUHDWH D FRQVWUXFW IRU GHFLVLRQ PDNLQJ0RVWRIWKHVHGHFLVLRQPDNLQJLVGRQHGHSHQGLQJXSRQWKHUHWXUQYDOXHWKDWLVHLWKHU WUXHRUIDOVH :KHQ LVXVHGWKHULJKWGHFLVLRQZLOOEHFDUULHGRXWGHSHQGLQJRQWKHIROORZLQJUHWXUQW\SH LIERWKVWDWHPHQWVDUHWUXH True && true = true True && false = false False && true = false False && false = false :KHQ__ $1' RSHUDWRULVXVHGLQRXUFRQGLWLRQDOVWDWHPHQWVWKHULJKWGHFLVLRQZLOOEHGRQH LIDQ\RQHWKHVWDWHPHQWVLVWUXH7KHGHVFULSWLRQIROORZV True || true = true True || false = true False || true = true False || false = false
Comp-U-Learn
27
Java Programming I
$OVRZHFDQXVHWKHVHFRQGLWLRQVMRLQWO\OLNH WUXH IDOVH __WUXH 7KHUHWXUQW\SHRIWKH DERYHFRQGLWLRQZLOOEHWUXH7KHRWKHURSHUDWRUZLOOZRUNDVIROORZV (true) = ! true = false !(false) = ! false = true if… and If.. else statements
7KLV LV D FRQGLWLRQDO VWDWHPHQW WKDW H[HFXWHV WKH ILUVW VHW RI VWDWHPHQWV LI WKH FRQGLWLRQ LV WUXH DQGWKHVWDWHPHQWIROORZLQJHOVHLIWKHFRQGLWLRQLVIDOVH7KHVHLIHOVHFDQEHQHVWHGDWDQ\OHYHO 7KHV\QWD[LV if (condition) { statements } else { statements }
7KHIROORZLQJH[DPSOHZLOOJLYHWKHXVDJHRIWKHLIDQGLI«HOVHVWDWHPHQWV Example 2.4 class sample { public static void main(String args[]) { int mark1=73; int mark2=60; { if ((mark1>=75) && (mark2>=75)) { System.out.println("Grade A"); } else if (((mark1>=50) && (mark2>=50)) && ((mark1<=74) && (mark2<=74))) { System.out.println("Grade B"); } else { System.out.println("Grade C"); } } } }
28
Comp-U-Learn
Fundamentals of Java
7KHRXWSXWRIWKHDERYHSURJUDPZLOOEH*UDGH%%HFDXVHWKHJLYHQPDUNDQGPDUNEHORQJV WRWKHVHFRQGFRQGLWLRQ
For loop ,QDIRUORRSZHKDYHWRSDVVWKUHHSDUDPHWHUVVHSDUDWHGE\VHPLFRORQVIROORZHGE\WKHVHWRI VWDWHPHQWVWREHH[HFXWHGGXULQJWKHORRSRSHUDWLRQ The syntax is for (initialization; condition; increment ) { Statements }
♦ In the initialization part, we have to initialize the variable, which can be a new one declared as any of the datatypes. ♦ In second part, we have to give an expression as a condition. The return value of this expression may be true or false. Depending upon the return value, the loop statements will be executed. ♦ Last part is used to increase/decrease the counter variable. It is also optional and can be updated programmatically within the loop statements. ♦ The loop will be terminated when the condition becomes false. The following example illustrates the use of for loop. Example 2.5 class loop_example { public static void main(String args[]) { for (int i=1; i<=5;i++) { System.out.println("This is No: " +i +" execution!"); } System.out.println("Loop terminated!"); } }
7KHRXWSXWZLOOEH This is No: This is No:
1 execution! 2 execution!
Comp-U-Learn
29
Java Programming I This is No: 3 execution! This is No: 4 execution! This is No: 5 execution! For Loop terminated!
While & Do… While Loop :KLOHORRSH[HFXWHVWKHVWDWHPHQWVXQWLODQH[SUHVVLRQLVWUXH:KHQWKHFRQGLWLRQLVQRORQJHU WUXHH[HFXWLRQFRQWLQXHVIURPWKHILUVWVWDWHPHQWDIWHUWKHZKLOHVWDWHPHQWV 7KHV\QWD[LV while (condition)
{ statements } ,QDGRZKLOHORRSWKHH[SUHVVLRQLVHYDOXDWHGRQO\DIWHUDOOWKHVWDWHPHQWVDUHH[HFXWHGDWOHDVW RQFH7KHV\QWD[LV do { statements } while(condition);
7KHIROORZLQJH[DPSOHLOOXVWUDWHVWKHXVDJHRIZKLOHORRS:H·OOJHWWKHRXWSXWVLPLODUWRWKH SUHYLRXVRQH Example 2.6 class loop1 { public static void main(String args[]) { int i=1; // Initialization while(i<=5) // Condition { System.out.println("This is No: " +i +" execution!"); i++; // Incrementation } System.out.println("While Loop terminated!"); } }
30
Comp-U-Learn
Fundamentals of Java
Switch & Break Statements 7KRXJKZHFDQXVH,I«HOVHVWDWHPHQWVWRGHDOZLWKPXOWLSOHFRQGLWLRQVZHFDQXVHWKHVZLWFK VWDWHPHQWVEHFDXVHWKH\DUHPRUHHIILFLHQWVLPSOHHDV\DQGUHDGDEOH7KLVRSHUDWRUDOORZVXVWR JURXS WRJHWKHU WKH FRQGLWLRQ DQG DVVRFLDWHG DFWLRQ WR SHUIRUP :KHQ WKH EUHDN NH\ZRUG LV HQFRXQWHUHGWKHUHVWRIWKHFRQGLWLRQVRIWKHVZLWFKDUHQRWHYDOXDWHG7KHV\QWD[IRUWKHVZLWFK VWDWHPHQWLV switch (variable) { case(value1): statements break; case(value2): statements break; default: statements break; }
Break
7KLV EUHDN NH\ZRUG WHUPLQDWHV WKH FXUUHQW IRU ZKLOH DQG VZLWFK SDVVHV WKH FRQWURO WR WKH ILUVW VWDWHPHQWDIWHUWKHORRS7KHPDLQXVHRIEUHDNLVWREUHDNWKHORRSDQGFRQWLQXHWKHH[HFXWLRQ RIWKHUHPDLQLQJVWDWHPHQWVDIWHUWKHORRS 7KHV\QWD[LV While(condition) { statements break; /* After executing the above the loop will be terminated.*/ }
statements
Continue
,QFRQWLQXHWKHFRQWUROSDVVHVWRWKHFRQGLWLRQLQDZKLOHORRSDQGWRWKHXSGDWHH[SUHVVLRQLQD IRUORRS
Note The important difference between the break and continue is that the loop is not terminated in continue. 7KHIROORZLQJH[DPSOHEULHIO\LOOXVWUDWHVWKHVZLWFKVWDWHPHQWZLWKXVLQJEUHDNNH\ZRUG,WDOVR JLYHVWKHRXWSXWDV´7KXUVGD\µ Comp-U-Learn
31
Java Programming I
Example 2.7 class var_usage { public static void main(String args[]) { int i=5; switch(i) { case 1: System.out.println("Sunday!"); break; case 2: System.out.println("Monday!"); break; case 3: System.out.println("Tuesday!"); break; case 4: System.out.println("Wednesday!"); break; case 5: System.out.println("Thursday!"); break; case 6: System.out.println("Friday!"); break; case 7: System.out.println("Saturday!"); break; default: System.out.println("Holiday!"); break; } } }
Arrays in Java $QDUUD\LQ-DYDLVDQHIIHFWLYHPHDQVRIVWRULQJDFROOHFWLRQRUVHULHVRUDJURXSRIYDULDEOHVDQG UHIHUULQJWRWKHPE\DFRPPRQQDPH7KHQXPEHURIYDOXHVWKDWFDQEHVWRUHGLQDQDUUD\LV FDOOHGDUUD\VL]H(DFKYDULDEOHLVFDOOHGDVDUUD\HOHPHQWRULWHP7KHUHDUHWKUHHVWHSVWRFUHDWH DQDUUD\ GHFODUDWLRQPHPRU\DOORFDWLRQDQGLQLWLDOL]DWLRQ Array declaration
/LNHDYDULDEOHZHKDYHWRGHFODUHDQDUUD\XVLQJWKHIROORZLQJV\QWD[7KHDUUD\PD\EHRIDQ\ GDWDW\SH
32
Comp-U-Learn
Fundamentals of Java <array type> <array name>
Example: int [] array1; double [] array2;
Memory allocation
$IWHU GHFODULQJ DQ DUUD\ ZH KDYH WR DOORFDWH WKH PHPRU\ IRU WKDW DUUD\ 2QO\ WKHQ DUH ZH DFWXDOO\FUHDWLQJDQDUUD\7KHQHZNH\ZRUGLVXVHGIRUWKLV7KHV\QWD[LV <array name> = new <array type with no of items> e.g.:array1 = new int[4]; array2 = new double[7];
Array initialization
$IWHUWKHGHFODUDWLRQDQGWKHPHPRU\DOORFDWLRQZHFDQLQLWLDOL]HWKHDUUD\HOHPHQWVLQGLYLGXDOO\ RUWRWDOO\:HFDQLQLWLDOL]HDQDUUD\XVLQJWKHLQGH[YDOXHZKLFKVWDUWVIURPWRODVWEXWEHIRUH WKHDUUD\HOHPHQW7RDFFHVVDSDUWLFXODUDUUD\HOHPHQWZHKDYHWRXVHWKHFRUUHVSRQGLQJLQGH[ YDOXH7KHV\QWD[LV array1[0]=1; array1[1]=2; and so on upto n-1 th element.
$OVRZHFDQGRDOOWKUHHRSHUDWLRQVDWWKHVDPHWLPHDVSHUWKHIROORZLQJH[DPSOHFRGH
int[]
array1 = new int[4]; double array2[] = new double[7];
Multidimensional Array
-DYDGRHVQRWVXSSRUWPXOWLGLPHQVLRQDODUUD\+RZHYHUDQDUUD\RIDUUD\VFDQEHFUHDWHG7KLV FDQEHGRQHZLWKDQLQGLYLGXDODUUD\LQLWLDOL]DWLRQ)RUH[DPSOHDWZRGLPHQVLRQDODUUD\FDQEH FUHDWHGDV VD\$UUD\ Array1[0][0]=20; Array1[0][1]=34; Array1[1][0]=23; Array1[1][1]=45;
DQGVRRQ
Comp-U-Learn
33
Java Programming I
Strings in Java 6WULQJV DUH VHTXHQFHV RI FKDUDFWHUV ,Q -DYD 6WULQJV DUH LQVWDQFHV RI WKH FODVV 6WULQJ :KHQ D VWULQJ OLWHUDO LV XVHG LQ WKH SURJUDP -DYD DXWRPDWLFDOO\ FUHDWHV DQ REMHFW RI WKH 6WULQJ FODVV 6WULQJVDUHXQXVXDOLQWKLVDVSHFW 7KHUHDUHYDULRXVPHWKRGVDYDLODEOHLQ6WULQJFODVV)UHTXHQWO\XVHGRQHVDUHHTXDOVOHQJWKDQG VXEVWULQJ7KHHTXDOVFRPSDUHVD6WULQJREMHFWZLWKWKHJLYHQREMHFWDQGUHWXUQVWUXHLIWKH\DUH HTXDO7KHQH[WRQHLVXVHGWRUHWXUQWKH6WULQJOHQJWK7KHVXEVWULQJLVXVHGIRUH[WUDFWLRQ 7KHIROORZLQJ H[DPSOH LOOXVWUDWHV DOO WKH GHWDLOV UHJDUGLQJ DQ DUUD\ EDVLFV DQG DERXW WKH 6WULQJ FODVV Example 2.8 class exarray { public static void main(String args[]) { int array1[] = {10,20,30}; // integer type array declaration and initialization // The following are the String type array declaration and initialization String array2[] = {"First","Second","Third"}; String sample=”Hai! Students!”; for (int i=0; i<=2; i++) { System.out.println("The " +array2[i] +" element is: " +array1[i]); } System.out.println("The Extracted String is: " +(sample.substring(0,4))); } }
7KHRXWSXWZLOOEHDVIROORZV The First element is: 10 The Second element is: 20 The Third element is: 30 The Extracted String is: Hi!
34
Comp-U-Learn
Fundamentals of Java
Summary In this session we have learnt various Java data types, literals, reserved words and identifiers. Now we have a brief idea about operators and expression evaluation using operator precedence. We also tried our hands on decision making using if.. else statement, switch statement and various loops such as for/while. At the end of this session, we learnt all the concepts regarding arrays and strings in Java. We have a full-fledged knowledge about Java fundamentals and Java programming constructs.
Going Over It Again I. Fill in the Blanks
BBBBBBBBBBBVWDWHPHQWLVXVHGWRSULQWVRPHWH[WRQWKHVFUHHQ 7KHERROHDQOLWHUDOVDUHBBBBBBBBBBBDQGBBBBBBBBBBBB ,QIRUORRSBBBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBDUHWKHSDUDPHWHUV 7KHVXEVWULQJPHWKRGLVXVHGIRUVWULQJBBBBBBBBBBB ,QGHFLVLRQPDNLQJWKHULJKWGHFLVLRQZLOOEHWDNHQGHSHQGLQJRQWKHBBBBBBBBW\SH
II. State True or False
$YDULDEOHFDQKDYHWKHVDPHQDPHDVWKDWRIDQ\UHVHUYHGZRUG ([SUHVVLRQHYDOXDWLRQGHSHQGVRQWKHRSHUDWRUSUHFHGHQFH ,Q-DYDPXOWLSOHOLQHFRPPHQWFDQEHGRQHE\ DQG :KHQWKHEUHDNNH\ZRUGLVHQFRXQWHUHGWKHUHVWRIWKHFRQGLWLRQVRIWKHVZLWFKZLOOQRWEH H[HFXWHG $UUD\VDUHSULPLWLYHGDWDW\SHV -DYDVXSSRUWVPXOWLGLPHQVLRQDODUUD\V
Comp-U-Learn
35
Java Programming I III. One line Answers
:KDWDUHWKHWZRGDWDW\SHVDYDLODEOH" :KDWLVDOLWHUDOLQ-DYD" ([SODLQORFDOYDULDEOHV :KDWLVWKHXVHRI RSHUDWRU" /LVWRXWWKHPHWKRGVDYDLODEOHLQ6WULQJFODVV IV. Define the Following
3ULPLWLYHGDWDW\SH 5HIHUHQFHGDWDW\SHV ,GHQWLILHUV $UUD\V 0HPEHUYDULDEOH
36
Comp-U-Learn
Session 3
OOPs In Java
On Completion of this Session We will be able to understand...
) Traditional Programming Model ) Object Oriented Programming Approach ) Basic concepts of OOPs and its features ) Java Programming using OOPs ) Understanding various modifiers in Java ) Super and Sub classes ) Constructors and overloaded constructors ) Garbage collection in
In This Session...
Traditional Programming Model
Object Oriented Programming Approach
Features of Object Oriented Programming
Basic concepts of OOPS
Creating Classes and Objects in Java
Constructors
Garbage Collection
Finalize Method
Inheritance
Polymorphism
Recursion
Advantages of OOPs in Java
OOPs In Java
Traditional Programming Model %HIRUHDSSO\LQJWKHSURJUDPPLQJFRQVWUXFWVLQ-DYDZKLFKZHKDYHVHHQLQWKHODVWVHVVLRQZH QHHG WR NQRZ DERXW WKH FRQFHSWV RI 2EMHFW 2ULHQWHG 3URJUDPPLQJ ,Q WKLV VHFWLRQ DQG WKH VXFFHHGLQJRQHVZHDUHJRLQJWROHDUQDERXW223DQGLWVKLVWRU\,QODWHUVHVVLRQVZH·OODSSO\ WKHVH223FRQFHSWVLQ-DYD ,Q HDUOLHU GD\V WUDGLWLRQDO SURJUDPPLQJ XVLQJ KLJK OHYHO ODQJXDJHV VXFK DV &2%2/ )2575$1DQG&ZHUHFRPPRQO\NQRZQDVSURFHGXUHRULHQWHGSURJUDPPLQJ7KLVPHWKRGRI SURJUDPPLQJWKRXJKVWUXFWXUHGZDVQRWPHHWLQJPRVWRIWKHUHTXLUHPHQWVRISURJUDPPHUV,Q WKLV DSSURDFK WKH LPSHWXV LV JLYHQ RQO\ WR WKH VHTXHQFH RI WKLQJV WR EH GRQH ZKLFK LV DFFRPSOLVKHG WKURXJK D QXPEHU RI IXQFWLRQV ,W DOVR DLPV WR SURYLGH D WRS GRZQ PRGXODU DSSURDFKLQSURJUDPPLQJPHWKRGRORJ\$W\SLFDOVWUXFWXUHRIDSURFHGXUHRULHQWHGSURJUDPLV VKRZQEHORZ
Main Program
Function 1
Function 2
Function 3
Function 4
Fig 3.1
7KHIROORZLQJDUHWKHFRQVWUDLQWVWKDWZHUHHQFRXQWHUHGLQWKHSURFHGXUDODSSURDFK ♦ Greater emphasis is laid on the process of the application (Sequences involved to do the task). This means that more stress is enforced on the function or methods and not on the data.
Comp-U-Learn
39
Java Programming I
♦ The procedural approach does not model real world problems very well because the functions are action oriented. They don’t really correspond to the elements of the problem. ♦ Modules are tightly inter-woven, inter dependent and difficult to separate. As a result of this inter-dependency between modules, modification of one program could affect all other programs that depend on it. This led to the complexity of code especially for huge programs. ♦ Most often, applications with almost similar features have to be re-written and recompiled resulting in higher software maintenance costs as the applications lack portability to run in multiple servers and in heterogeneous environments. ♦ Most functions use global data resulting in the data moving around the system openly throughout all modules. When functions transform data from one form to another, the true state and nature of the data is not available throughout all the modules. 7KHPDMRUPRWLYDWLQJIDFWRULQWKHLQYHQWLRQRI2EMHFW2ULHQWHGDSSURDFKLVWRVDOYDJHVRPHRI WKHIODZVHQFRXQWHUHGLQWKHSURFHGXUDODSSURDFK223ODQJXDJHVVXFKDV&6PDOOWDON-DYD HWFRYHUFRPHWKHVHGUDZEDFNV7KH\DUHPRGHOHGDIWHUUHDOZRUOGFKDUDFWHULVWLFVDQGKHQFHDUH VLPSOHDQGHDV\WRXQGHUVWDQG
Object Oriented Programming Approach 223WUHDWVGDWDDVDFULWLFDOHOHPHQWLQWKHSURFHVVRISURJUDPGHYHORSPHQWDQGGRHVQRWDOORZ LWWRIORZIUHHO\DURXQGWKHV\VWHP,WWLHVGDWDPRUHFORVHO\WRWKHIXQFWLRQVWKDWRSHUDWHRQLW DQG SURWHFWV LW IURP DFFLGHQWDO PRGLILFDWLRQV IURP RXWVLGH IXQFWLRQV 223 DOORZV XV WR GHFRPSRVH D SUREOHP LQWR D QXPEHU RI HQWLWLHV FDOOHG REMHFWV DQG WKHQ EXLOGV GDWD DQG IXQFWLRQV DURXQG WKHVH HQWLWLHV 7KH RUJDQL]DWLRQ RI GDWD DQG IXQFWLRQV LQ REMHFW RULHQWHG SURJUDPVLVVKRZQEHORZ
40
Comp-U-Learn
OOPs In Java
Object A
Object B
Data
Data
Function
Function
Functio
Data
Object C
Fig. 3.2
Features of Object Oriented Programming 1. 2. 3. 4. 5. 6. 7. 8.
Emphasis is more on data rather than procedure. Programs are divided into what are known as objects. Data structures are designed so that they characterize objects. Functions that operate on data of an object are tied together in the data structure. Data is hidden and cannot be accessed by external functions. Objects may communicate with each other through functions. New data and functions can be easily added whenever necessary. Follows bottom-up approach in program design.
Note
2EMHFW RULHQWHG SURJUDPPLQJ LV DQ DSSURDFK WKDW SURYLGHV D ZD\ RI PRGXODUL]LQJSURJUDPVE\FUHDWLQJSDUWLWLRQHGPHPRU\DUHDIRUERWKGDWDDQG IXQFWLRQVWKDWFDQEHXVHGDVWHPSODWHVIRUFUHDWLQJFRSLHVRIVXFKPRGXOHVRQ GHPDQG
Comp-U-Learn
41
Java Programming I
+HUHZH FRQVLGHU DQ REMHFW WR DFFHVV DQG RSHUDWH RQ D SDUWLWLRQHG DUHD RI FRPSXWHU PHPRU\ WKDWVWRUHVGDWDDQGDVHWRIRSHUDWLRQVWKDWFDQDFFHVVWKDWGDWD6LQFHPHPRU\SDUWLWLRQV DUH LQGHSHQGHQWWKHREMHFWVFDQEHXVHGLQDYDULHW\RIGLIIHUHQWSURJUDPVZLWKRXWPRGLILFDWLRQV
Basic Concepts of OOPS $Q\223ODQJXDJHVKRXOGVXSSRUWWKHIROORZLQJIHDWXUHV-DYDVXSSRUWVWKHVH223VFRQFHSWV H[FHSWIHZRILWVLQWHUQDOSURSHUWLHV ♦ Classes ♦ Objects ♦ Data Abstraction ♦ Data Encapsulation ♦ Inheritance ♦ Polymorphism Classes
$ FODVV LV D WHPSODWH WKDW GHILQHV WKH YDULDEOHV DQG WKH PHWKRGV FRPPRQ WR DOO REMHFWV RI D FHUWDLQNLQG)RUH[DPSOHOHWXVFRQVLGHUGLIIHUHQWNLQGVRIRUQDPHQWVVXFKDVULQJVEDQJOHV EUDFHOHWVFKDLQVVWXGVHWF$OORIWKHPKDYHDJHQHUDOEHKDYLRUDQGVWDWH$OOWKHVHMHZHOVFDQ EHSXWXSLQWRDEURDGHUFDWHJRU\FDOOHGMHZHOVRURUQDPHQWV+HQFHLQWKLVFDVHZHFDOO-HZHOV RURUQDPHQWVDVDFODVV
Note A class is a user-defined datatype that encompasses the entire set of data and code of an object. Objects
2EMHFWV FDQ EH UHDO RU LPDJLQDU\ 7KH\ DUH WKH LQVWDQFHV RI FODVVHV 2EMHFWV DUH WKH EDVLF UXQ WLPHHQWLWLHVLQDQREMHFWRULHQWHGV\VWHP7KH\PD\EHDSHUVRQDSODFHDEDQNDFFRXQWDWDEOH RI GDWD RU DQ\ LWHP WKDW WKH SURJUDP PXVW KDQGOH ,Q VRIWZDUH WHUPV DQ REMHFW LV D VRIWZDUH EXQGOH RI YDULDEOHV DQG UHODWHG PHWKRGV 3UREOHPV LQ SURJUDPPLQJ DUH DQDO\]HG LQ WHUPV RI REMHFWV DQG WKH QDWXUH RI FRPPXQLFDWLRQ EHWZHHQ WKHP 3URJUDP REMHFWV VKRXOG EH FKRVHQ VXFKWKDWWKH\PDWFKFORVHO\ZLWKWKHUHDOZRUOGREMHFWV
42
Comp-U-Learn
OOPs In Java
Note Each object contains data and code to manipulate the data. Objects can interact without having to know details of each other’s data or code. Examples of objects are 5HDOREMHFWV²0DUXWKL9DQRXUFODVVURRPEDOOHWF ,PDJLQDU\²5HFRUG2UJDQL]DWLRQHWF &RPSOH[²'DWDEDVHVSUHDGVKHHWVSDFNDJHVHWF 2QFH D FODVV LV GHILQHG ZH FDQ FUHDWH DQ\ QXPEHU RI REMHFWV EHORQJLQJ WR WKDW FODVV (DFK REMHFW LV DVVRFLDWHG ZLWK WKH GDWD RI W\SH FODVV ZLWK ZKLFK WKH\ DUH FUHDWHG )RU H[DPSOH PDQJRDSSOHDQGRUDQJHDUHPHPEHUVRIWKHFODVVIUXLW&ODVVHVDUHXVHUGHILQHGGDWDW\SHVDQG EHKDYHOLNHWKHEXLOWLQW\SHVRIDSURJUDPPLQJODQJXDJH7KHV\QWD[XVHGWRFUHDWHDQREMHFWLV QRGLIIHUHQWWKDQWKHV\QWD[XVHGWRFUHDWHDQLQWHJHUREMHFWLQ&,IIUXLWKDVEHHQGHILQHGDVD FODVVWKHQWKHVWDWHPHQW )UXLWPDQJR ZLOO FUHDWH DQ REMHFW PDQJR EHORQJLQJ WR WKH FODVV IUXLW 7KLV FRXOG EH H[SODLQHG IXUWKHU E\ FRPSDULQJZLWK int k;
+HUHNLVDQREMHFWRILQWHJHUGDWDW\SHDQGKDVDOOWKHSURSHUWLHVSHUWDLQLQJWRDQLQWHJHU Data Abstraction
$EVWUDFWLRQUHIHUVWRWKHDFWRIUHSUHVHQWLQJHVVHQWLDOIHDWXUHVZLWKRXWLQFOXGLQJWKHEDFNJURXQG GHWDLOV RU H[SODQDWLRQV &ODVVHV XVH WKH FRQFHSW RI DEVWUDFWLRQ DQG DUH GHILQHG DV D OLVW RI DEVWUDFWDWWULEXWHVVXFKDVVL]HZHLJKWFRVWDQGIXQFWLRQVWRRSHUDWHRQWKHVHDWWULEXWHV7KH\ HQFDSVXODWHDOOWKHHVVHQWLDOSURSHUWLHVRIWKHREMHFWVWKDWDUHWREHFUHDWHG6LQFHWKHFODVVHVXVH WKHFRQFHSWRIGDWDDEVWUDFWLRQWKH\DUHNQRZQDV$EVWUDFW'DWD7\SHV $'7 )RUH[DPSOH LIZHWDNHPDQJRDVDQREMHFWWKHQWKHSURSHUWLHVVXFKDVFRORUWDVWHYDULHW\FRVWVL]HHWFDUH QRW H[SOLFLWO\ TXRWHG RQ WKH IDFH RI PHUHO\ VD\LQJ LW DV D )UXLW 7KHVH SURSHUWLHV DUH WRWDOO\ HQFDSVXODWHGLQ)UXLW+HQFHZHFDOOLWRQO\DV)UXLWDQGWKHLQKHUHQWSURSHUWLHVRIWKHIUXLWDUH WRWDOO\KLGGHQLQVLGHE\PDNLQJWKHWHUP)UXLWDEVWUDFW 7KHUHDUHWZRNLQGVRI$EVWUDFWLRQ ♦ Data Abstraction ♦ Functional abstraction Comp-U-Learn
43
Java Programming I
,IZHWDNHDFDUDVDQH[DPSOHIRUDFODVVWKHQ Data Abstraction
(QJLQHQXPEHUVSHHGHWF Functional Abstraction
6WDUW6WRSHWF Data Encapsulation
7KH ZUDSSLQJ XS RI GDWD DQG IXQFWLRQV LQWR D VLQJOH XQLW FDOOHG FODVV LV NQRZQ DV HQFDSVXODWLRQ 'DWD HQFDSVXODWLRQ LV WKH PRVW VWULNLQJ IHDWXUH RI D FODVV 7KH GDWD LV QRW DFFHVVLEOH WR WKH RXWVLGH ZRUOG DQG RQO\ WKRVH IXQFWLRQV ZKLFK DUH ZUDSSHG LQ WKH FODVV FDQ DFFHVVLW7KHVHIXQFWLRQVSURYLGHWKHLQWHUIDFHEHWZHHQWKHREMHFW·VGDWDDQGWKHSURJUDP7KLV LQVXODWLRQ RI WKH GDWD IURP GLUHFW DFFHVV E\ WKH SURJUDP LV FDOOHG GDWD KLGLQJ (QFDSVXODWLRQ HPERGLHVLQIRUPDWLRQKLGLQJ
Creating Classes and Objects in Java ,Q-DYDZHFDQFUHDWHDQREMHFWE\FUHDWLQJDQLQVWDQFHRIDFODVV)RUH[DPSOH Date today=new Date(); Rectangle rect=new Rectangle();
+HUH'DWHLVDEXLOWLQFODVVDYDLODEOHLQWKHMDYDXWLOSDFNDJH WRGD\LVDYDULDEOHRIW\SH'DWH DQGLVLQLWLDOL]HGXVLQJWKHQHZRSHUDWRU1RWHWKDWWKHQHZRSHUDWRULQVWDQWLDWHGWKH'DWHFODVV E\FUHDWLQJDQHZREMHFWIRU'DWHDQGWKHQLQLWLDOL]HVLW ,WLVQRWHVVHQWLDOWKDWHYHU\WLPHDQREMHFWFUHDWLRQVKRXOGKDYHVLPXOWDQHRXVLQLWLDOL]DWLRQDOVR ,WLVSRVVLEOHWRKDYHRQO\REMHFWFUHDWLRQDORQH Example 3:1 Date
today;
7KHJHQHUDOV\QWD[LV Classname Objectname;
/HWXVWDNHDQRWKHUH[DPSOH 796HWV6RQ\3KLOLSV 44
Comp-U-Learn
OOPs In Java
+HUHZHKDYHFUHDWHGWZRREMHFWVRIWKHFODVV796HWV7KH\FDQEHLQLWLDOL]HGRUWKH\FDQEHVHW WRQXOO +RZWR,QLWLDOL]H" Sony=new TVSets; Philips=Sony;
2EMHFWV FDQ HLWKHU EH LQLWLDOL]HG WKURXJK WKH QHZ RSHUDWRU RU LW FDQ DOVR EH LQLWLDOL]HG XVLQJ DQRWKHU LQVWDQFH 7KH QHZ RSHUDWRU LV XVHG IRU DOORFDWLQJ PHPRU\ WR WKH REMHFW ,Q WKLV FDVH ERWK 6RQ\ DQG 3KLOLSV UHIHU WR WKH VDPH REMHFW 1RZ DVVXPLQJ WKH PHWKRGV 3OD\ 0XWH &RQWUDVWDUHLQWKH796HWVFODVVWKH\FDQEHLQYRNHGDV Sony.Play(); Philips.Contrast();
+RZWR,QLWLDOL]HWR1XOO Sony=null;
Note Local object variables are not automatically initialized to null. We must initialize them, either by calling new or by setting them to null. Creating a Class in Java
$ FODVV LV D EOXHSULQW RU SURWRW\SH WKDW FDQ EH XVHG WR FUHDWH PDQ\ REMHFWV 7KH FODVV FRQVWUXFWLRQKDVWZRSKDVHV ♦ Class Declaration ♦ Class Body Class Declaration
$ FODVV GHFODUDWLRQ PXVW FRQWDLQ WKH FODVV NH\ZRUG DQG WKH QDPH RI WKH FODVV WKDW LV WR EH GHILQHG class ClassName { ........... .......... ........... }
Comp-U-Learn
45
Java Programming I
$W\SLFDOFODVVGHFODUDWLRQZLOOEHOLNHWKLV >PRGLILHUV@FODVV&ODVV1DPH>H[WHQGVVXSHU&ODVV1DPH@>LPSOHPHQWV,QWHUIDFH1DPHV@ { ............................ ....................... };
7KH LWHPV EHWZHHQ > DQG @ DUH RSWLRQDO &ODVV QDPHV PXVW EH D OHJDO -DYD LGHQWLILHU DQG E\ FRQYHQWLRQ EHJLQ ZLWK D FDSLWDO OHWWHU :H ZLOO VHH HDFK RQH RI WKHP LQ GHWDLO 2I WKH DERYH PHQWLRQHG FODVV GHFODUDWLRQ IRUPDW RQO\ WKH FODVV NH\ZRUG DQG WKH FODVV QDPH DUH YHU\ LPSRUWDQW DQG PRVW UHTXLUHG 7KH RWKHU LWHPV DUH RSWLRQDO ,I ZH GRQ·W PDNH DQ H[SOLFLW GHFODUDWLRQIRUWKHRSWLRQDOLWHPVWKH-DYDFRPSLOHUDVVXPHVFHUWDLQGHIDXOWVDQRQILQDOQRQ SXEOLFQRQDEVWUDFWVXEFODVVHVRI2EMHFWWKDWLPSOHPHQWVQRLQWHUIDFHV
Class Modifiers
$PRGLILHULVRWKHUZLVHFDOOHGDQDFFHVVVSHFLILHU7KH\GHILQHWKHVFRSHRIWKHFODVVDQGDOVRWKH XVDJHRIWKH REMHFWV RIWKDWSDUWLFXODUFODVV $ FODVV FDQ KDYH DQ\ RI WKUHH PRGLILHUV ² SXEOLF DEVWUDFWRUILQDO 7KHSXEOLFPRGLILHUGHFODUHVWKDWWKHFODVVFDQEHXVHGE\REMHFWVRXWVLGHWKHFXUUHQWSDFNDJH %\GHIDXOWDFODVVFDQRQO\EHXVHGE\RWKHUFODVVHVLQWKHVDPHSDFNDJHLQZKLFKLWLVGHFODUHG
Note Package is a collection of classes grouped together. Packages are convenient for organizing our work and separating our code libraries provided with others. 7KHDEVWUDFWPRGLILHUGHFODUHVWKDWWKHFODVVLVDQDEVWUDFWFODVV$QDEVWUDFWFODVVLVXVHGZKHQ ZHQHHGDPRUHJHQHULFFODVVDQGSUREDEO\PRUHDEVWUDFW$EVWUDFWFODVVHVDUHQRWLQVWDQWLDWHG 7KDWLVLIDFODVVLVGHFODUHGDVDEVWUDFWQRREMHFWVRIWKDWFODVVFDQEHFUHDWHG:HZLOOKDYHWR H[WHQGWKDWFODVVLQRUGHUWRFUHDWHDQLQVWDQFHRIWKHFODVV$EVWUDFWFODVVHVFDQKDYHFRQFUHWH GDWDIXQFWLRQVDQGDOVRPD\FRQWDLQVRPHDEVWUDFWPHWKRGVDOVR$QDEVWUDFWFODVVPXVWKDYH DWOHDVWRQHDEVWUDFWPHWKRG &ODVVHVWKDWFDQQRWEHSDUHQWFODVVHVDUHFDOOHGILQDOFODVVDQGZHXVHWKHILQDOPRGLILHULQWKH GHILQLWLRQRIWKHFODVVWRLQGLFDWHWKLV)LQDONH\ZRUGLVXVHGWRSUHYHQWLQKHULWDQFH&ODVVHVDUH PDGHILQDOIRUWKHSXUSRVHRIHIILFLHQF\DQGIRUVHFXULW\UHDVRQV
46
Comp-U-Learn
OOPs In Java
Super Class and Sub Classes
6XSHUFODVVHVDQG6XEFODVVHVDUHWKHPHDQVWKURXJKZKLFKLQKHULWDQFHLVLPSOHPHQWHGLQ-DYD 7KHSDUHQWRUWKHEDVHFODVVLVFDOOHGD6XSHUFODVV7KHGHULYHGFODVVLVFDOOHGD6XEFODVV-DYD XVHV WKH H[WHQGV NH\ZRUG LQ RUGHU WR LPSOHPHQW LQKHULWDQFH ,QKHULWDQFH LQ -DYD LV SXEOLF LQ QDWXUH Example 3.2 class Employee { ........ .......... } class Manager extends Employee { ............ ............. }
+HUHWKHFODVV0DQDJHULVDGHULYHGFODVVDQGFODVV(PSOR\HHLVDEDVHFODVV Object Class – The universal Super Class
7KHREMHFWFODVVLVWKHXOWLPDWHDQFHVWRUYHU\FODVVLQ-DYDH[WHQGV2EMHFW+RZHYHUWKHUHLV QRQHHGWRVD\ class Employee extends Object
6LQFHWKHXOWLPDWHSDUHQWFODVV2EMHFWLVWDNHQIRUJUDQWHGLIQRSDUHQWLVH[SOLFLWO\PHQWLRQHG 2EMHFWFODVVLVORFDWHGLQWKHSDFNDJHMDYDODQJ(YHU\FODVVLQ-DYDH[WHQGVIURP2EMHFW6RPH PHWKRGVLQWKH2EMHFWFODVVDUHDVIROORZV public Boolean equals(Object obj)
7KLV PHWKRG WHVWV ZKHWKHU RU QRW RQH REMHFW LV HTXDO WR DQRWKHU 7KH HTXDOV PHWKRG DV LW LV LPSOHPHQWHG LQ WKH 2EMHFW SDUHQW FODVV GHWHUPLQHV ZKHWKHU RU QRW WZR REMHFWV SRLQW WR WKH VDPHDUHDRIPHPRU\ $QRWKHU LPSRUWDQW PHWKRG LQ 2EMHFW LV WKH WR6WULQJ PHWKRG WKDW UHWXUQV D VWULQJ WKDW UHSUHVHQWV WKH YDOXH RI WKLV REMHFW 7KH WR6WULQJ PHWKRG LV XQLTXH IRU DQ LPSRUWDQW UHDVRQ ZKHQHYHU DQ REMHFW LV FRQFDWHQDWHG ZLWK D VWULQJ XVLQJ WKH ´µ RSHUDWRU WKH -DYD FRPSLOHU
Comp-U-Learn
47
Java Programming I
DXWRPDWLFDOO\LQYRNHVWKHWR6WULQJPHWKRGWRREWDLQDVWULQJUHSUHVHQWDWLRQRIWKHREMHFW)RU H[DPSOH Date today=new today(1998,12,26); String last=“ Today date is “ + today; //automatically invokes today.toString public Object clone()
7KLV LV XVHG WR FORQH WKH REMHFW E\ DOORFDWLQJ PHPRU\ DQG FRS\LQJ WKH FXUUHQW REMHFW LQWR LW &ORQLQJLVQRWKLQJEXWPDNLQJDELWE\ELWFRS\,WLVVLPSO\DQRWKHUREMHFWZLWKWKHVDPHEDVH W\SHVDQGILHOGV The class called Class
-DYD PDLQWDLQV D 5XQ 7LPH 7\SH ,GHQWLILFDWLRQ ZKLFK NHHSV WUDFN RI WKH FODVV WR ZKLFK HDFK REMHFW EHORQJV 7KLV HQVXUHV WKDW WKH FXUUHQW PHWKRGV DUH VHOHFWHG DW UXQWLPH 7KH FODVV WKDW KROGVWKLVLQIRUPDWLRQLVFDOOHG&ODVV7KHJHW&ODVV PHWKRGRI2EMHFWUHWXUQVDQLQVWDQFHRI WKLVFODVV Class Body
7KHFODVVERG\FRPSRQHQWRIDFODVVLPSOHPHQWDWLRQFDQLWVHOIFRQWDLQWZRGLIIHUHQWVHFWLRQV 9DULDEOHGHFODUDWLRQV 0HWKRGV class ClassName { Membervariable Declarations Method Declarations }
Member Variable Declarations
$PHPEHUYDULDEOHGHFODUDWLRQORRNVOLNHWKLV >DFFHVVVSHFLILHU@>VWDWLF@>ILQDO@>WUDQVLHQW@>YRODWLOH@GDWDW\SHYDULDEOH1DPH $PHPEHUYDULDEOHGHFODUDWLRQGHILQHVWKHIROORZLQJDVSHFWVRIDYDULDEOH $FFHVVVSHFLILHUGHILQHVZKLFKRWKHUFODVVHVKDYHDFFHVVWRWKHYDULDEOH7KHIROORZLQJLVWKHOLVW RIPRGLILHUVWKDWFDQEHXVHGZLWKWKHPHWKRGVDQGPHPEHUYDULDEOHGHFODUDWLRQVLQ-DYD
48
Comp-U-Learn
OOPs In Java
Public
7KHNH\ZRUGSXEOLFPHDQVWKDWDQ\FODVVLQDQ\SDFNDJHFDQ DFFHVVWKHYDULDEOHVRUPHWKRGV 0HWKRGVGHFODUHGDVSXEOLFDUHDFFHVVLEOHWRDOO Example 3:3 public void shape() { }
Protected
$Q\FODVVLQWKHVDPHSDFNDJHDVWKHFODVVLQZKLFKLWLVGHFODUHGFDQDFFHVVSURWHFWHGYDULDEOHV RUPHWKRGV)RUH[DPSOHLQSDFNDJH3DFN class A { protected int min; }
+HUHPLQFDQEHXVHGE\DQ\FODVVLQWKHSDFNDJH3DFNLUUHVSHFWLYHRIZKHWKHUWKH\KDYHEHHQ GHULYHGRUQRW$OVRZKHQWKHUHDUHDQ\RWKHUFODVVHVWKDWKDYHEHHQGHULYHGIURPFODVV$WKH\ FDQPDNHXVHRIWKHSURWHFWHGGDWD´LQWPLQµHYHQWKRXJKWKHVXEFODVVHVPD\UHVLGHLQRWKHU SDFNDJHV QRWLQ3DFN Private
3ULYDWH YDULDEOHV RU PHWKRGV FDQ RQO\ EH DFFHVVHG ZLWKLQ WKH FRQILQHV RI WKH GHFODULQJ FODVV 2QO\ WKH PHPEHUV DQG PHWKRGV RI WKDW SDUWLFXODU FODVV FDQ DFFHVV WKH SULYDWH GDWD 1R RWKHU PHWKRGVFODVVHVDQGQRWHYHQVXEFODVVHVZKHWKHULQVLGHRURXWVLGHWKHSDFNDJHFDQKDYHDFFHVV WRWKHSULYDWHGDWD class Hour { private int hr, min, sec; private void input(); }
+HUHWKHPHWKRGLQSXWFDQPDNHXVHRIWKHSULYDWHGDWDKUPLQDQGVHF Static
:KHQZHZDQWDPHWKRGWREHDFODVVPHWKRGXVHWKHVWDWLFNH\ZRUGLQWKHPHWKRGGHFODUDWLRQ 6WDWLFILHOGVGRQRWFKDQJHIURPRQHLQVWDQFHRIDFODVVWRDQRWKHU6WDWLFPHWKRGVEHORQJWRD
Comp-U-Learn
49
Java Programming I
FODVVDQGGRQRWRSHUDWHRQDQ\LQVWDQFHRIDFODVV6WDWLFPHWKRGVFDQRQO\DFFHVVVWDWLFILHOGV 6WDWLFLQLWLDOL]DWLRQRFFXUVZKHQWKHFODVVLVILUVWORDGHG6WDWLFPHWKRGVFDQQRWEHRYHUORDGHG 6WDWLFPHWKRGVEHORQJWRDFODVVDQGGRQRWRSHUDWHRQDQ\LQVWDQFHRIWKHFODVV Example 3.4 class Myclass { static private int i; static public int output() { return i; } static public void input(int j) { i=j; } }
Note Overloading refers to the existence of more than one function with the same name but with different function signature. The parameters passed to a method is called its signature. Final
9DULDEOHV RU PHWKRGV GHFODUHG DV ILQDO FDQQRW EH RYHUORDGHG RU FKDQJHG &ODVV YDULDEOHV DUH RIWHQ XVHG ZLWK WKH NH\ZRUG ILQDO WR GHILQH FRQVWDQWV 7KLV RIIHUV EHWWHU PHPRU\ HIILFLHQF\ WKDQ ILQDO LQVWDQFH YDULDEOHV EHFDXVH FRQVWDQWV FDQQRW FKDQJH $ ILQDO PHWKRG KDV DQ LPSOHPHQWDWLRQ WKDW ZLOO QRW EH FKDQJHG DQ\ZKHUH LQ WKH PRGXOH DQG LV FULWLFDO WR WKH FRQVLVWHQWVWDWHRIWKHREMHFW)LQDOPHWKRGVFDQQRWEHRYHUULGGHQLQWKHVXEFODVVHV Transient
7UDQVLHQW YDULDEOHV DUH QRW SDUW RI WKH REMHFWV SHUVLVWHQW VWDWH ,W PDUNV WKH GDWD QRW WR EH SHUVLVWHQW 0HPEHU YDULDEOHV WKDW DUH SDUW RI WKH SHUVLVWHQW VWDWH RI DQ REMHFW PXVW EH VDYHG ZKHQWKHREMHFWLVDUFKLYHG:HXVHWKHWUDQVLHQWNH\ZRUGWRLQGLFDWHWKDWWKHSDUWLFXODUYDULDEOH LVQRWSDUWRIWKHSHUVLVWHQWVWDWHRIWKHREMHFW class Some { transient int hai; }
50
Comp-U-Learn
OOPs In Java
Volatile
7KLVPHDQVWKDWWKHYDULDEOHLVPRGLILHGLQYDULDEO\E\GLIIHUHQWPHWKRGVZLWKRXWDQ\FRUUHODWLRQ ,WLVQRWXVHGFRPPRQO\7KHIROORZLQJYDULDEOHGHFODUDWLRQLVDQH[DPSOHRIKRZWRGHFODUH WKDWDYDULDEOHFDQEHPRGLILHGDV\QFKURQRXVO\ Example 3.5 class Anything { volatile int r; }
Implementing Methods in Java
$PHWKRGLPSOHPHQWDWLRQFRQWDLQVWZRSDUWV ♦ Method declaration ♦ Method body Method Declaration
$PHWKRGGHFODUDWLRQSURYLGHVDORWRILQIRUPDWLRQDERXWWKHPHWKRGWRWKHFRPSLOHUWKHUXQ WLPHV\VWHPDQGWRRWKHUFODVVHVDQGREMHFWV7KLVFRQWDLQVWKHQDPHRIWKHPHWKRGWKHUHWXUQ W\SHRIWKHPHWKRGWKHW\SHRIDUJXPHQWVUHTXLUHGE\WKHPHWKRGDQGWKHPRGLILHUVIRUWKDW PHWKRG Method body
7KLV FRQWDLQV WKH FRGH VHJPHQW WR EH H[HFXWHG E\ WKH PHWKRG ,Q FDVH WKH SDUWLFXODU PHWKRG UHWXUQVDQ\YDOXHWKHQWKHERG\ZLOOFRQWDLQWKHUHWXUQNH\ZRUG Example 3.6 class some { public int dummy(int a) { int b=a+5; return b; } }
7KHUHWXUQYDOXHYRLGVLJQLILHVWKDWWKHPHWKRGZLOOQRWUHWXUQDQ\YDOXH,QWKHDERYHH[DPSOH WKH PHWKRG GXPP\ DFFHSWV DQ LQWHJHU YDULDEOH DV DQ DUJXPHQW -DYD VXSSRUWV PHWKRG RYHUORDGLQJ 7KH PHWKRG WKDW KDV D VDPH QDPH DV WKDW RI WKH FODVV LV FDOOHG WKH FRQVWUXFWRU 0HWKRGVFDQDOVREHRYHUULGGHQ Comp-U-Learn
51
Java Programming I
7KLVPHDQVWKDWWKHPHWKRGVLQWKHVXSHUFODVVHVFDQEHZULWWHQLQWKHVXEFODVVHVZLWKUHOHYDQW FKDQJHVWRPHHWWKHQHHGVRIWKHVXEFODVV%XWLQWKLVFDVHWKHRYHUULGLQJPHWKRGPXVWKDYH WKHVDPHQDPHUHWXUQW\SHDQGSDUDPHWHUOLVWLVWKHPHWKRGLWRYHUULGHV,Q-DYDDUJXPHQWVDUH SDVVHG E\ YDOXH RQO\ WR WKH PHWKRGV 3DVVLQJ YDULDEOHV E\ YDOXHV DVVXUHV WKDW WKH PHWKRGV XQLQWHQWLRQDOO\FDQQRWPRGLI\DYDULDEOH·VYDOXHWKDWLVRXWVLGHLWVVFRSH
Note When a method returns a value, the datatype of the value returned by the return statement must match the datatype that the method is actually returning. There cannot be a mismatch in the declaration and in the actual return statement. $VLPSOHH[DPSOHKHUHWRVKRZKRZWRFDOODPHWKRGLQ-DYD class ex2 { public static void main(String args[]) { System.out.println(" We are in the main function "); System.out.println(); System.out.println("Call to the method sample "); sample(); System.out.println(); System.out.println("Back to main function "); } static void sample() { int a= 10; a= a* 10; System.out.println("Now we are in the sample method "); System.out.println(a); } }
2XWSXW2IWKHSURJUDP We are in the main function Call to the method sample Now we are in the sample method 100 Back to main function
Note A method is a collection of statements that performs a series of operations. In languages like C, they are called functions.
52
Comp-U-Learn
OOPs In Java
Constructors &RQVWUXFWRUVDUHVSHFLDOPHWKRGVSURYLGHGLQHDFK-DYDFODVVWKDWDUHUHVSRQVLEOHIRULQLWLDOL]LQJ QHZREMHFWVRIWKDWW\SH7KHQHZRSHUDWRUFUHDWHVWKHREMHFWDQGWKHFRQVWUXFWRULQLWLDOL]HVLW$ FODVV PD\ SURYLGH PXOWLSOH FRQVWUXFWRUV WR SHUIRUP GLIIHUHQW NLQGV RI LQLWLDOL]DWLRQ RQ QHZ REMHFWV$FRQVWUXFWRUWKDWWDNHVQRDUJXPHQWVLVFDOOHGDGHIDXOWFRQVWUXFWRU7KLVLVLQYRNHG DXWRPDWLFDOO\ZKHQWKHREMHFWLVLQLWLDOL]HG Example 3.7 Date today=new Date(); TVSets Philips=new TVSets(); TVSets Sony=new Sony();
:KHQ WKH FRQVWUXFWRU WDNHV DUJXPHQWV LW LV FDOOHG DQ RYHUORDGHG FRQVWUXFWRU 7KH FRPSLOHU PDNHV WKH GHFLVLRQ UHJDUGLQJ LQYRFDWLRQ RI WKH DSSURSULDWH FRQVWUXFWRU GHSHQGLQJ XSRQ WKH W\SHDQGWKHQXPEHURIDUJXPHQWVSDVVHGWRLW7KLVFRQFHSWLVFDOOHGRYHUORDGLQJ
Note Overloading refers to the concept where there are more than one function with the same name but with different parameters. These parameters may differ in number, sequence and data type of the arguments. Calls to the functions are bound according to the nature of the arguments passed. Examples 3.8 Date today = new Date(1998,10,28); TVSets Sony = new Sony(14,Portable); Rectangle rect = new Rectangle(10,10,200,200);
+HUH WRGD\ REMHFW LV LQLWLDOL]HG ZLWK DUJXPHQWV \HDU PRQWK DQG GD\ 7KH FRQVWUXFWRU ZLWK WKUHHDUJXPHQWVDYDLODEOHLQ'DWHFODVVLVLQYRNHG$QHZUHFWDQJOHUHFWRIVL]H ZLOOEHFUHDWHGDQGLQLWLDOL]HG Referring an Object variable
/HWXVVD\WKDWZHZDQWWRPRYHWKHUHFWDQJOHWRDQHZORFDWLRQ&KDQJLQJ WKHUHFWDQJOHWRD QHZORFDWLRQFRXOGEHGRQHE\WKHIROORZLQJPHWKRGV ♦ Manipulate the object’s variables directly rect.x=80; rect.y=100;
Comp-U-Learn
53
Java Programming I
ZKHUH[\DUHWKHQHZORFDWLRQVRIWKHUHFWDQJOH *HQHUDOV\QWD[ ObjectReference.Variable
♦ Call the move method which is available in the Rectangle class rect.move(80,100);
7KLVVWDWHPHQWZLOOPRYHWKHREMHFWUHFWWRDQHZORFDWLRQ0HWKRGFDOOVDUHGLUHFWHGDWD VSHFLILF REMHFW WKH REMHFW VSHFLILHG LQ WKH PHWKRG FDOO LV WKH REMHFW WKDW UHVSRQGV WR WKH LQVWUXFWLRQ 0HWKRG FDOOV DUH NQRZQ DV PHVVDJHV ,Q WKH H[DPSOH RQ 3RO\PRUSKLVP ZKLFK LV JRLQJWREHGHDOWODWHUZLOOH[SODLQWKHEDVLFFRQFHSWVRI&RQVWUXFWRUV
Garbage Collection 0DQ\REMHFWRULHQWHGODQJXDJHVUHTXLUHWKDWZHNHHSWUDFNRIDOOWKHREMHFWVZHFUHDWHDQGFDQ GHVWUR\ WKHP ZKHQ ZH QR ORQJHU QHHG WKHP :ULWLQJ FRGH WR PDQDJH PHPRU\ LQ WKLV ZD\ LV WHGLRXVDQGRIWHQHUURUSURQH-DYDWDNHVFDUHRIWKLVPHPRU\PDQDJHPHQWWHFKQLTXH7KH-DYD UXQWLPHHQYLURQPHQWGHOHWHVREMHFWVZKHQLWGHWHUPLQHVWKDWWKH\DUHQRORQJHUEHLQJXVHG7KLV SURFHVVLVNQRZQDVJDUEDJHFROOHFWLRQ$QREMHFWLVHOLJLEOHIRUJDUEDJHFROOHFWLRQZKHQWKHUH DUH QR PRUH UHIHUHQFHV WR WKDW REMHFW 5HIHUHQFHV WKDW DUH KHOG LQ D YDULDEOH DUH QDWXUDOO\ GURSSHGZKHQWKHYDULDEOHJRHVRXWRIVFRSH7KHJDUEDJHFROOHFWRUUXQVV\QFKURQRXVO\ZKHQ WKHV\VWHPUXQVRXWRIPHPRU\RULQUHVSRQVHWRDUHTXHVWIURPD-DYDSURJUDP-DYD3URJUDPV FDQDVNIRUWKHJDUEDJHFROOHFWRUWRUXQDWDQ\WLPHE\FDOOLQJ6\VWHPJF 7KHILQDOL]H PHWKRGZLOOEHFDOOHGEHIRUHWKHJDUEDJHFROOHFWRUVZHHSVDZD\WKHREMHFW&DOOWKH VWDWLFPHWKRG6\VWHPUXQ)LQDOL]HUV2Q([LW 758( WRJXDUDQWHHWKDWILQDOL]HUPHWKRGVDUHFDOOHG EHIRUH -DYD VKXWV GRZQ $VNLQJ WKH JDUEDJH FROOHFWLRQ WR UXQ GRHV QRW JXDUDQWHH WKDW RXU REMHFWVZLOOEHJDUEDJHFROOHFWHG
Finalize Method %HIRUHDQREMHFWLVJDUEDJHFROOHFWHGWKHUXQWLPHV\VWHPFDOOVLWVILQDOL]HPHWKRG,WLVLQWHQGHG WRUHOHDVHV\VWHPUHVRXUFHVVXFKDVRSHQILOHVRURSHQVRFNHWVEHIRUHJHWWLQJFROOHFWHG2XUFODVV FDQSURYLGHIRUILQDOL]DWLRQVLPSO\E\GHFODUDWLRQRIDPHWKRGFDOOHGILQDOL]HDQGLPSOHPHQWLQJ LW)RU([DPSOH protected void finalize() { … statements }
54
Comp-U-Learn
OOPs In Java
Inheritance ,Q UHDO OLIH ZH FDQ REVHUYH LQKHULWDQFH DOPRVW HYHU\ZKHUH $ FKLOG IRU H[DPSOH WDNHV RQ WKH FKDUDFWHULVWLFV RI WKH SDUHQWV ,QKHULWDQFH LV WKH PHFKDQLVP WKURXJK ZKLFK D FODVV FDQ EH GHILQHG LQ WHUPV RI DQ H[LVWLQJ FODVV ,QKHULWDQFH LV WKH SURFHVV E\ ZKLFK REMHFWV RI RQH FODVV DFTXLUH WKH SURSHUWLHV RI REMHFWV RI DQRWKHU FODVV ,W VXSSRUWV WKH FRQFHSW RI KLHUDUFKLFDO FODVVLILFDWLRQ7KHIROORZLQJH[DPSOHVKRZVWKHSURSHUW\LQKHULWDQFHRIREMHFWV
Vehicles Attributes: Have engine Carry people Carry luggage Used for transport
Four Wheelers
Two Wheelers
Attributes :
Attributes :
Cars
Jeep
Motor Bikes
Scooters
Attributes:
Attributes:
Attributes:
Attributes:
Fig 3.3 ,Q2236WKHFRQFHSWRILQKHULWDQFHSURYLGHVWKHLGHDRIUHXVDELOLW\7KLVPHDQVWKDWZHFDQ DGGDGGLWLRQDOIHDWXUHVWRDQH[LVWLQJFODVVZLWKRXWPRGLI\LQJLW7KLVLVSRVVLEOHE\GHULYLQJD QHZ FODVV IURP WKH H[LVWLQJ RQH 7KH QHZ FODVV ZLOO KDYH WKH FRPELQHG IHDWXUHV RI ERWK WKH FODVVHV)RUH[DPSOHKHUH9HKLFOHVLVDEURDGFDWHJRU\ZKLFKH[SODLQVWKHYDULRXVDWWULEXWHVRI DOOWKHYHKLFOHVFRPPRQO\7KLVFRXOGEHIXUWKHUGLYLGHGLQWRWZRVSHFLILFFDWHJRULHVOLNH7ZR Comp-U-Learn
55
Java Programming I
ZKHHOHUV DQG )RXU ZKHHOHUV %RWK WKHVH FODVVHV ZLOO KDYH WKH SURSHUWLHV RI WKH JHQHUDO FODVV ´9HKLFOHVµ$JDLQWZRZKHHOHUVFODVVFRXOGEHGHULYHGRUEURNHQLQWRFODVV´0RWRU%LNH´DQG FODVV´6FRRWHUV´ZKLFKKDYHWKHVSHFLILFDWWULEXWHVRIWKHVHWZRW\SHVRIYHKLFOHV7KXVWKURXJK LQKHULWDQFHZHDUHDEOHWRJHQHUDWHDQHZFODVVIURPDQH[LVWLQJRQH7KHSURSHUWLHVFRPPRQWR ERWK WKHVH FODVVHV DUH QRW UHZULWWHQ EXW DUH UHXVHG ,QKHULWDQFH HQDEOHV WKH UHILQHPHQW RU VSHFLDOL]DWLRQRIDQH[LVWLQJFODVV7KRXJKDFKLOGLQKHULWVWKHFKDUDFWHULVWLFVIURPLWVSDUHQWVLW DOVRKDVLWVRZQIHDWXUHV $ FODVV FDQ LQKHULW WKH DWWULEXWHV RI WZR RU PRUH FODVVHV 0XOWLSOH LQKHULWDQFH DOORZV XV WR FRPELQHWKHIHDWXUHVRIVHYHUDOH[LVWLQJFODVVHVDVDVWDUWLQJSRLQWIRUGHILQLQJQHZFODVVHV,WLV OLNHDFKLOGLQKHULWLQJWKHFRORURIWKHIDWKHUDQGWKHIDFHFXWRIWKHPRWKHU
Mammals
Birds
Platypus
Fig 3.4 ,QWKLVH[DPSOHLIPDPPDOVDQGELUGVDUHWZRFODVVHVWKHQSODW\SXVH[KLELWVWKHFKDUDFWHULVWLFV RIERWKWKHVHFODVVHV Note Java does not support multiple inheritance due to difficulty in maintaining and keeping track of the code. ,Q-DYDZHFDQLQKHULWDVXSHUFODVVE\WKH.H\ZRUGH[WHQGV7KHIROORZLQJH[DPSOHLOOXVWUDWHV LQKHULWDQFHLQ-DYD class base { public String name="Peter"; public int age=23; }
56
Comp-U-Learn
OOPs In Java class base1 extends base { private int acc_no=4566; public void disp() { System.out.println("The name is : " +name); System.out.println("The Age is : " +age); System.out.println("The account No. is : " +acc_no); } public static void main(String args[]) { base1 b = new base1(); b.disp(); } }
6DYHWKHILOHDVEDVHMDYD7KHRXWSXWLVDVIROORZV The name is : Peter The Age is : 23 The account No. is : 4566
Polymorphism 3RO\PRUSKLVPLV\HWDQRWKHULPSRUWDQW223FRQFHSW3RO\PHDQVPDQ\0RUSKPHDQVIRUPV 3RO\PRUSKLVPPHDQVWKHDELOLW\WRWDNHPRUHWKDQRQHIRUP)RUH[DPSOHLIZHWDNHPRYHDV DQRSHUDWLRQWKHQWKHPDQZDONVILVKVZLPVELUGVIO\DQGZRUPVFUDZO7KLVLVQRWKLQJEXWDQ RSHUDWLRQ H[KLELWLQJ GLIIHUHQW EHKDYLRU LQ GLIIHUHQW LQVWDQFHV 7KH EHKDYLRU GHSHQGV XSRQ WKH W\SHVRIGDWDXVHGLQWKHRSHUDWLRQ )RUH[DPSOHFRQVLGHUWKHRSHUDWLRQRIGUDZLQJ)RUGUDZLQJYDULRXVVKDSHVZHFDQXVHVDPH GUDZ PHWKRG E\ JLYLQJ WKH FRUUHVSRQGLQJ SDUDPHWHUV 7KLV LV FDOOHG 2YHUORDGLQJ %DVLFDOO\ 223 VXSSRUWV )XQFWLRQ RYHUORDGLQJ DQG 2SHUDWRU RYHUORDGLQJ %XW -DYD GRHV QRW VXSSRUW 2SHUDWRURYHUORDGLQJ 3RO\PRUSKLVPLVH[SODLQHGFOHDUO\LQWKHIROORZLQJGLDJUDP
Comp-U-Learn
57
Java Programming I Shape Draw()
Circle Object
Box Object
Triangle Object
Draw(Circle)
Draw(Box)
Draw(Triangle)
Fig 3.5 /HWXVORRNDWDFRPSOHWHH[DPSOHRIDFODVVLQ-DYD7KLVH[SODLQVWKHFRQFHSWRI&RQVWUXFWRUV DQG2YHUORDGLQJFRQFHSWRI3RO\PRUSKLVP Example 3.9 // Creation of a
Class called AddSub
class AddSub { int num1,num2; public AddSub() { num1=20; num2=10; System.out.println("Default constructor invoked "); } public AddSub(int x, int y) { num1=x; num2=y; System.out.println("Overloaded Constructor Invoked "); } public int AddNum() { int num3; num3=num1 + num2; return num3; } public int SubNum()
58
Comp-U-Learn
OOPs In Java { int num3; num3=num1-num2; return num3; } } public class ex3 { public static void main(String args[]) { AddSub a=new AddSub(); AddSub b=new AddSub(60,50); System.out.println(" The value of num1 of object a is "+ a.num1); System.out.println(" The value of num2 of object a is "+ a.num2); System.out.println(); System.out.println(" The result of addition of object a is "+a.AddNum()); System.out.println(); System.out.println(" The result of subtraction of object a is "+a.SubNum()); System.out.println(); System.out.println(" The value of num1 of object b is "+ b.num1); System.out.println(" The value of num2 of object b is "+ b.num2); System.out.println(); System.out.println(" The result of addition of object b is "+b.AddNum()); System.out.println(); System.out.println(" The result of subtraction of object b is "+b.SubNum()); } }
2XWSXWRIWKH3URJUDPLVVKRZQEHORZ Default constructor invoked Overloaded Constructor Invoked The value of num1 in object a is 20 The value of num2 in object a is 10 The The The The The The
result of addition of object a is result of subtraction of object a value of num1 in object b is 60 value of num2 in object b is 50 result of addition of object b is result of subtraction of object b
30 is 10
110 is 10
Comp-U-Learn
59
Java Programming I Keywords this & super
,QDPHWKRGWKHNH\ZRUGWKLVUHIHUVWRWKHREMHFWRQZKLFKWKHPHWKRGRSHUDWHV:KHQWKLVLV XVHGLQVLGHDFRQVWUXFWRUWKHQWKHFRQVWUXFWRUFDOOVDQRWKHUFRQVWUXFWRURIWKHVDPHFODVV7KLV LVDFDOOWRRQHRIWKHFXUUHQWREMHFWV$JDLQLWLVUHTXLUHGRQO\ZKHQWKHUHLVDQDPELJXLW\LQWKH PHWKRGQDPHDQGLVRIWHQXVHGWRPDNHWKHLQWHQWRIWKHFRGHFOHDUHU)RUH[DPSOH class Book { int NoPages; int Weight; Book(int NoPages, int Weight) { this.NoPages=NoPages; this.weight=Weight; } }
Super
7KHNH\ZRUGVXSHUDOZD\VUHIHUVWRWKHVXSHUFODVV Example 3.10 class Employee { int salary; Employee(int i) { this.salary=i; } } class Manager extends Employee { Manager(int l) { super(l); }
+HUHWKHVXSHULVXVHGWRFDOOWKHFRQVWUXFWRURIWKHEDVHFODVV,QVKRUWWKHVXSHUUHIHUVWKHEDVH FODVV,QFDVHRIRYHUULGLQJWKHEDVHFODVVPHWKRGVLQWKHVXEFODVVHVWKHVXEFODVVHVPD\FDOOWKH EDVHFODVVPHWKRGXVLQJ Super.BaseClassMethodName();
60
Comp-U-Learn
OOPs In Java
Recursion 5HFXUVLRQLVDJHQHUDOPHWKRGZKHUHE\DIXQFWLRQFDOOVLWVHOILQDUHSHDWHGIDVKLRQ7KLVFRXOG EH H[SODLQHG DV D UHFXUVLYH PHWKRG UHSHDWHGO\ FDOOLQJ LWVHOI XQWLO D VSHFLILF FULWHULRQ LV PHW :KHQ WKH FRQGLWLRQ EHFRPHV IDOVH WKH UHFXUVLRQ WHUPLQDWHV 7KHUH DUH DFWXDOO\ WZR W\SHV RI UHFXUVLRQSRVVLEOH 'LUHFW5HFXUVLRQ +HUHWKHVXESURJUDPVFDOOVRQO\LWVHOI ,QGLUHFW5HFXUVLRQ +HUHDVXESURJUDPFDOOVDQRWKHUVXESURJUDPZKLFKLQWXUQFDOOVWKHILUVW VXESURJUDP Example 3.11 Direct Recursion Static int recu(int x) { if (x=1) return x; else return x * recursion(x-1); } Indirect Recursion Static int even (int x) { if )x=0) return true; else return odd(x-1); } static int odd(int x) { if(x=0) return false; else return even(x-1); }
Accessor and Mutator Methods
0HWKRGV WKDW FKDQJH LQVWDQFH ILHOGV DUH FDOOHG PXWDWRU PHWKRGV DQG WKRVH WKDW ZLOO DFFHVV LQVWDQFH ILHOGV ZLWKRXW PRGLI\LQJ WKHP DUH FDOOHG DFFHVVRU PHWKRGV 7KH FRQYHQWLRQ XVHG LQ -DYDLVWRXVHWKHORZHUFDVHSUHIL[JHWIRUDFFHVVRUPHWKRGVDQGVHWIRUPXWDWRUPHWKRGV
Comp-U-Learn
61
Java Programming I
Example of Accessor methods are as follows : int getDate() int getMonth() int getYear()
Example of Mutator methods are as follows : void setDate(int) void setMonth(int) void setYear(int)
Message Communication
$QREMHFWRULHQWHGSURJUDPFRQVLVWVRIDVHWRIREMHFWVWKDWFRPPXQLFDWHZLWKHDFKRWKHU7KH SURFHVV RI SURJUDPPLQJ LQ DQ REMHFWRULHQWHG ODQJXDJH WKHUHIRUH LQYROYHV WKH IROORZLQJ EDVLF VWHSV &UHDWLQJFODVVHVWKDWGHILQHREMHFWVDQGWKHLUEHKDYLRU &UHDWLQJREMHFWVIURPFODVVGHILQLWLRQV (VWDEOLVKLQJFRPPXQLFDWLRQDPRQJREMHFWV $PHVVDJHIRUDQREMHFWLVDUHTXHVWIRUH[HFXWLRQRIDSURFHGXUHDQGWKHUHIRUHZLOOLQYRNHD IXQFWLRQ SURFHGXUH LQ WKH UHFHLYLQJ REMHFW WKDW JHQHUDWHV WKH GHVLUHG UHVXOW 0HVVDJH SDVVLQJ LQYROYHV VSHFLI\LQJ WKH QDPH RI WKH REMHFW WKH QDPH RI WKH IXQFWLRQ PHVVDJH DQG WKH LQIRUPDWLRQWREHVHQW
Note Message passing supports all possible interactions between objects. Objects that send and receive messages need not be in the same process or even in the same machine
Advantages of OOPS in Java 7KURXJKLQKHULWDQFHZHFDQHOLPLQDWHUHGXQGDQWFRGHDQGH[WHQGWKHXVHRIH[LVWLQJFODVVHV :HFDQPDNHXVHRIWKHH[LVWLQJPRGXOHVWREXLOGRWKHUSURJUDPVLIWKH\ZDQWWRFRPPXQLFDWH ZLWKRQHDQRWKHUUDWKHUWKDQGHYHORSLQJWKHPRGXOHIURPWKHVFUDWFK 7KH SULQFLSOH RI GDWD KLGLQJ KHOSV WKH SURJUDPPHU WR EXLOG VHFXUH SURJUDPV WKDW FDQQRW EH WDPSHUHGE\RWKHUSURJUDPVRUHYHQWKHRWKHUFRGHLQWKHVDPHSURJUDP 62
Comp-U-Learn
OOPs In Java
,WLVSRVVLEOHWRKDYHPXOWLSOHLQVWDQFHVRIDQREMHFWWRFRH[LVWZLWKRXWDQ\LQWHUIHUHQFH ,WLVHDV\WRSDUWLWLRQWKHZRUNLQDSURMHFWEDVHGRQSURMHFWV 2EMHFWRULHQWHGV\VWHPVFDQEHHDVLO\XSJUDGHGIURPVPDOOWRODUJHV\VWHPV 0HVVDJH SDVVLQJ WHFKQLTXHV IRU FRPPXQLFDWLRQ EHWZHHQ REMHFWV PDNHV WKH LQWHUIDFH GHVFULSWLRQVZLWKH[WHUQDOV\VWHPVPXFKVLPSOHU $OOFODVVHVDQGREMHFWVWKHUHRIFDQEHWUHDWHGDVVHSDUDWHPRGXOHV7KLVPDNHVGHVLJQLQJVLPSOHU ,QKHULWDQFHHQDEOHVXVLQUHXVDELOLW\RIDFRGH 7KHVRIWZDUHV\VWHPEDVHGRQ223LVFORVHWRUHDOZRUOGDQGKHQFHVLPSOHWRXQGHUVWDQG Summary In this session, we learnt basic concepts, advantages and features of OOP. We are able to apprise the traditional programming model with the Object oriented approach. The application of OOP in Java, the concept of super and sub classes tries to bring forth inheritance in Java. Also the usage of the various modifiers like public, private, abstract, final, static, volatile, transient will enable the programmer to achieve an absolute proficiency and have an concrete knowledge of OOP. The garbage collection in Java frees the programmer from worrying about the pains of memory leakage.
Going Over It Again I. Fill in the Blanks
$FODVVFRQWDLQVBBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBVSHFLILHUSUHYHQWVLQKHULWDQFHLQ-DYD BBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBBBBBBBBBBBDUHWKHWZRNLQGVRIDEVWUDFWLRQ 7KHBBBBBBBBLVXVHGWRLQLWLDOL]HDQGDOORFDWHPHPRU\WRWKHREMHFWV BBBBBBBBBBBBBBBBBLVWKHXQLYHUVDOVXSHUFODVVLQ-DYDIRUDOOREMHFWV 7KHWZRW\SHVRIUHFXUVLRQDUHBBBBBBBBBBBBBBBBBBBBDQGBBBBBBBBBBBBBBBBBBBBBB
Comp-U-Learn
63
Java Programming I II. State True or False
7KHWUDGLWLRQDOPRGHOGRHVQRWVLPXODWHUHDOZRUOGSUREOHPV -DYDVXSSRUWVPXOWLSOHLQKHULWDQFH &RQVWUXFWRUVDUHLQYRNHGDWWKHHQGRIWKHFODVV 7KHPHWKRGWR6WULQJ LVDYDLODEOHLQWKH'DWHFODVV 3ULYDWHDFFHVVVSHFLILHGGDWDDQGPHWKRGVFDQEHDFFHVVHGDQ\ZKHUHLQWKHSDFNDJH III. One line Answers
'HILQHLQKHULWDQFH :KDWLVSRO\PRUSKLVP" 'HILQHUHFXUVLRQ %ULHIO\H[SODLQWKHXVDJHRIVXSHUPHWKRG ([SODLQSUHFLVHO\WKHQHHGIRUILQDOL]HPHWKRG %ULHIO\GHVFULEHWKHJDUEDJHFROOHFWRULQ-DYD :KDWLVIXQFWLRQRYHUORDGLQJ"
64
Comp-U-Learn
Session 4
Interfaces and Packages
On Completion of this Session We will be able to understand...
) Introduction to Interfaces ) Implementing the Interfaces ) Cloneable Interface ) About Inner classes ) Importance of packages ) Creating packages ) Access Protection ) Overview of Java Built in Packages
In This Session...
Introduction to Interfaces
What is an interface?
Intricacies in an Interface
Interface References
Extending the Interface
The Cloneable Interface
Inner Classes
Packages
Need for Packages
CLASSPATH Variable
Access Protection
Overview of Java Built-in Packages
Interfaces and Packages
Introduction to Interfaces ,QWKHHDUOLHUVHVVLRQVZHIRXQGWKDWZHFDQFUHDWHVXEFODVVHVLQ-DYDE\H[WHQGLQJDQDOUHDG\ GHILQHG FODVV ,Q -DYD PXOWLSOH LQKHULWDQFH LV QRW SRVVLEOH 8VLQJ WKH NH\ZRUG H[WHQGV LW LV SRVVLEOHWRLQKHULWWKHSURSHUWLHVRIMXVWDFODVVRQO\7KHUHPD\EHVRPHFLUFXPVWDQFHVZKLFK UHTXLUHWKHSURSHUWLHVRIWZRFODVVHVWREHLQKHULWHG /HW XV WDNH DQ H[DPSOH &RQVLGHU D FODVV FDOOHG FRRUGLQDWH ZKLFK WDONV DERXW [ DQG \ FRRUGLQDWHV RI SRLQWV DQG D FODVV FDOOHG SURSHUWLHV WKDW WDONV DERXW WKH IRUHJURXQG DQG EDFNJURXQGFRORUVXVHGWRGUDZVKDSHV1RZLIZHZDQWWRGHILQHVRPHJHRPHWULFILJXUHVD\ VTXDUHZHZRXOGQDWXUDOO\OLNHWRWDONDERXWLWVFRRUGLQDWHVDVZHOODVFRORUV6RLWLVUHTXLUHGWR LQKHULW IURP ERWK WKHVH FODVVHV $Q DOWHUQDWH ZD\ RI LPSOHPHQWLQJ WKH PHWKRG RI D GLIIHUHQW FODVVLVWKURXJKDQLQWHUIDFH7KLVVHVVLRQSURYLGHVDQRYHUYLHZRILQWHUIDFHV
What is an interface? $Q LQWHUIDFH LV YHU\ PXFK OLNH D FODVV ZLWK FRQVWDQW YDOXHV DQG PHWKRG GHFODUDWLRQV 7KH GLIIHUHQFHLVWKDWPHWKRGVLQDQLQWHUIDFHDUHRQO\GHFODUHGEXWQRWLPSOHPHQWHG$QLQWHUIDFHLV H[DFWO\ OLNH D FODVV EXW ZLWK WKH NH\ZRUG FODVV EHLQJ UHSODFHG E\ WKH NH\ZRUG LQWHUIDFH $Q LQWHUIDFH LV VLPLODU WR DQ DEVWUDFW FODVV ZLWK D UHVWULFWLRQ WKDW DOO PHWKRGV LQ DQ LQWHUIDFH DUH DEVWUDFW7KHIROORZLQJH[DPSOHH[SODLQVGHFODUDWLRQRIDQLQWHUIDFH interface ExampleInterface { void xx(); // abstract by default; no body void yy(); }
7KH DERYH H[DPSOH VXJJHVWV WKDW WKHUH DUH WZR SDUWV LQ DQ LQWHUIDFH WKH LQWHUIDFH GHFODUDWLRQ DQG WKH LQWHUIDFH ERG\ 7KH GHFODUDWLRQ SDUW FRQVLVWV RI QDPH RI WKH LQWHUIDFH DQG ZKHWKHU LW LQKHULWV IURP DQ\ RWKHU LQWHUIDFH 7KH LQWHUIDFH ERG\ FRQVLVWV RI WKH FRQVWDQW YDOXHV LQ WKH LQWHUIDFHDQGWKHGHFODUDWLRQRIWKHPHWKRGVRIWKHLQWHUIDFH1RZWRXVHWKHLQWHUIDFHDFODVV PXVWLPSOHPHQWWKHFRUUHVSRQGLQJDEVWUDFWIXQFWLRQV:HPD\GHILQHDFODVVFDOOHGVRPHDV public class some implements ExampleInterface { void xx(); // write the code here void yy(); // write the code here7 }
Comp-U-Learn
67
Java Programming I
+HUHWKHFODVVVRPHFDQLPSOHPHQWPRUHWKDQRQHLQWHUIDFHEXWLWFDQQRWH[WHQGPRUHWKDQRQH FODVV,Q-DYDDQLQWHUIDFHLVDUHIHUHQFHGDWDW\SHDQGDVVXFKFDQEHXVHGLQDOOSODFHVZKHUHD W\SHFDQEHXVHG:HZLOOVHHWKLVLQGHWDLOXQGHUWKHKHDGLQJ´8VLQJDQ,QWHUIDFHDVD7\SHµ
Intricacies in an Interface ,QWHUIDFHV DUH XVHG WR GHILQH D SURWRFRO RI EHKDYLRU WKDW FDQ EH LPSOHPHQWHG E\ DQ\ FODVV DQ\ZKHUH LQ WKH FODVV KLHUDUFK\ /HW XV WU\ WR GLIIHUHQWLDWH EHWZHHQ LQWHUIDFHV DQG DEVWUDFW FODVVHV$EVWUDFWFODVVHVDUHXVHGRQO\ZKHQWKH\DUHVXSHUFODVVHVDQGWKHVXEFODVVHVLPSOHPHQW WKHPHWKRGV
Note In the case of interfaces, the methods can be implemented even by classes, which are not inherited. 2IWHQLQWHUIDFHVDUHWKRXJKWRIDVDQDOWHUQDWLYHWRPXOWLSOHFODVVLQKHULWDQFH:KLOHLQWHUIDFHV PD\VROYHVRPHRIWKHVDPHSUREOHPVWKDWPXOWLSOHFODVVLQKHULWDQFHGRWKH\DUHTXLWHGLIIHUHQW ,QSDUWLFXODU ♦ We cannot inherit variables from an interface ♦ We cannot inherit method implementations from an interface. ♦ The interface hierarchy is independent of the class hierarchy- classes that implement the same interface may or may not be related through the class hierarchy. This is not true for multiple inheritance. 7KHVWUHQJWKRIWKHLQWHUIDFHOLHVLQWKHIDFWWKDWDQXQUHODWHGFODVVZKLFKGRHVQRWEHORQJWRWKH KLHUDUFK\ FDQ LPSOHPHQW WKH PHWKRGV RI DQ LQWHUIDFH 7KHUHIRUH LQKHULWDQFH GRHV QRW WDNH SODFHLQWKLVFRQFHSW+HUHLVDQH[DPSOHWKDWWHOOVPRUHDERXWDQLQWHUIDFH Example 4.1 interface one { public void xx(); } interface two extends { public void yy(); }
one
class cl1 implements one { public void xx() {
68
Comp-U-Learn
Interfaces and Packages System.out.println(“The function xx of class cl1 implements interface one“); } public void yy() { System.out.println(“Original yy in class but not in interface “); } } class cl2 implements two { public void xx() { System.out.println(“The function xx of class cl2 implements interface two “); } public void yy() { System.out.println(“The function yy of class cl2 implements interface two “); } }
$QLQWHUIDFHFDQH[WHQGDQRWKHULQWHUIDFH OLNHWZRH[WHQGVRQHDQGKDVWZRPHWKRGV[[DQG\\ EXW DQ LQWHUIDFH FDQQRW H[WHQG D FODVV DQG D FODVV FDQQRW H[WHQG DQ LQWHUIDFH D FODVV FDQ LPSOHPHQWDQLQWHUIDFH $FODVVFDQMXVWLPSOHPHQWDOOPHWKRGVRIDQLQWHUIDFH FOLPSOHPHQWV WZR RULWFDQKDYHLWVRZQPHWKRGVDOVRLQDGGLWLRQWRWKHPHWKRGVRIWKHLQWHUIDFH FOKDVLWV RZQPHWKRG\\ZKLFKLVQRWDPHWKRGRIWKHLQWHUIDFHRQH
Note All methods in an interface are always public, static, final and abstract; even if we do not use the word public, they are public in one and two above. But for their implementations within a class, omitting the word public creates problems. An interface can extend multiple interfaces. 7KHVWHSVLQYROYHGLQFUHDWLQJDQLQWHUIDFHDUH 'HFODUHWKHLQWHUIDFH $GGDEVWUDFWPHWKRGVWRWKHLQWHUIDFHERG\ 6DYHWKHILOHZLWKDMDYDH[WHQVLRQ &RPSLOHWKHLQWHUIDFHFUHDWHG 7KHVWHSVLQYROYHGLQLPSOHPHQWLQJDQLQWHUIDFHDUH 'HFODUHWKHFODVVDQGXVHWKHLPSOHPHQWNH\ZRUGIROORZHGE\WKHQDPHRIWKHLQWHUIDFH ,PSOHPHQWHYHU\DEVWUDFWPHWKRGWKDWKDVEHHQGHFODUHGZKLOHFUHDWLQJWKHLQWHUIDFH 6DYHWKHILOHZLWKDMDYDH[WHQVLRQ &RPSLOHWKHDSSOHWRUDSSOLFDWLRQFUHDWHG
Comp-U-Learn
69
Java Programming I
7KH IROORZLQJ DUH VRPH RI WKH JXLGHOLQHV WR EH IROORZHG ZKLOH FUHDWLQJ DQG LPSOHPHQWLQJ LQWHUIDFHV ♦ An interface can be declared as public, whereby it can be implemented even outside a package. ♦ An interface cannot be considered a substitute for multiple inheritance, which is not supported by Java. ♦ While declaring members in an interface, we may not use the private and protected access specifiers. ♦ Constants declared in an interface are implicitly public, static and final. ♦ All methods declared in an interface are implicitly public and abstract. ♦ A class can implement as many interfaces as required with each interface name being separated by a comma(,).
Note If the parent class already implements an interface, its subclasses do not need to explicitly use the implement keyword. $VDPSOHSURJUDPWRVKRZWKHZRUNLQJRIDQLQWHUIDFH Example 4.2 package Display; public interface DisplayInterface { public String GetDlsplayText(); //no implementation of this method } // This applet implements the method declared in the interface import java.awt.*; import java.applet.*; import java.lang.*; import Display.DisplayInterface; public class ex13 extends Applet implements DisplayInterface { public void paint(Graphics g) { String str=GetDisplayText(); g.drawString(str,80,100); } public String GetDisplayText() { return " Display Text "; } }
70
Comp-U-Learn
Interfaces and Packages
Note Member declarations in an interface disallow some of the use of declaration modifiers and discourage the use of others. We may not use transient, volatile or synchronized in a member declaration in an interface. Also, we may not use the private and protected specifiers when declaring members of an interface.
Interface References :HFDQGHFODUHYDULDEOHVDVREMHFWUHIHUHQFHVWKDWXVHDQLQWHUIDFHUDWKHUWKDQDFODVVW\SH$Q\ LQVWDQFHRIDFODVVWKDWLPSOHPHQWVWKHGHFODUHGLQWHUIDFHFDQEHVWRUHGLQVXFKDYDULDEOH:KHQ ZHFDOODPHWKRGWKURXJKRQHRIWKHVHUHIHUHQFHVWKHFRUUHFWYHUVLRQZLOOEHFDOOHGEDVHGRQWKH DFWXDOLQVWDQFHRIWKHLQWHUIDFHEHLQJUHIHUUHGWR7KLVLVRQHRIWKHNH\IHDWXUHVRILQWHUIDFHV 7KHPHWKRGWREHH[HFXWHGLVORRNHGXSG\QDPLFDOO\DWUXQWLPHDOORZLQJFODVVHVWREHFUHDWHG ODWHU WKDQ WKH FRGH ZKLFK FDOOV PHWKRGV RQ WKHP 7KH FDOOLQJ FRGH FDQ GLVSDWFK WKURXJK DQ LQWHUIDFHZLWKRXWKDYLQJWRNQRZDQ\WKLQJDERXWWKHFDOOHGFRGH Example 4.3 interface Iface { void callfn(int i); } class One implements Iface { public void callfn(int a) { System.out.println(“Calling the callfn with “ + a); } } class Two implements Iface { public void callfn(int a) { System.out.println(“Call from class two of method of callfn”); System.out.println(“a squared is “ + (a * a)); } } class ex12 { public static void main(String args[]) { Iface i=new One(); Two j=new Two(); i.callfn(100);
Comp-U-Learn
71
Java Programming I i=j; i.callfn(100); } }
Extending the Interface $QLQWHUIDFHFDQLQKHULWDQRWKHUE\XVHRIWKHNH\ZRUGH[WHQGV7KHV\QWD[LVWKHVDPHDVIRU LQKHULWLQJFODVVHV:KHQDFODVVLPSOHPHQWVDQLQWHUIDFHWKDWLQKHULWVDQRWKHULQWHUIDFHLWPXVW SURYLGHLPSOHPHQWDWLRQVIRUDOOPHWKRGVGHILQHGZLWKLQWKHLQWHUIDFHLQKHULWDQFHFKDLQ7KLVFDQ EHLOOXVWUDWHGWKURXJKDQH[DPSOH Example 4.4 interface A { void meth1(); void meth2(); } interface B extends A { void meth3(); } class cl1 implements B { public void meth1() { System.out.println(“implementing method 1 in Interface A”); } public void meth2() { System.out.println(“implementing method 2 in Interface A”); } public void meth3() { System.out.println(“implementing method 3 in Interface B”); } } class ex14 { public static void main(String args[]) { cl1 obj=new cl1(); obj.meth1(); obj.meth2(); obj.meth3(); } }
72
Comp-U-Learn
Interfaces and Packages
$VDQH[SHULPHQWZKHQZHWU\WRUHPRYHWKHLPSOHPHQWDWLRQIRUPHWKRGPHWK LQWKHFODVV FO LW ZLOO FDXVH D FRPSLODWLRQ HUURU EHFDXVH DQ\ FODVV WKDW LPSOHPHQWV DQ LQWHUIDFH PXVW LPSOHPHQWDOOPHWKRGVGHILQHGE\WKDWLQWHUIDFH
The Cloneable Interface :KHQ ZH PDNH D FRS\ RI WKH YDULDEOH WKH RULJLQDO DQG WKH FRS\ DUH UHIHUHQFHV WR WKH VDPH REMHFW7KLVPHDQVDFKDQJHWRHLWKHUYDULDEOHDOVRDIIHFWVWKHRWKHU Day Bday=new Day(1998,8,16); Day d=Bday; d.advance(100); //Oops will also change Bday
7KLVLVGHSLFWHGEHORZ
Bday
Day
D
Day 16 Month 8 Year 1998
Fig. 4.1 ,IZHZRXOGOLNH'WREHDQHZREMHFWWKDWEHJLQVLWVOLIHEHLQJLGHQWLFDOWR%GD\EXWZKRVHVWDWH FDQGLYHUJHRYHUWLPHWKHQZHXVHWKHFORQH PHWKRG Day Bday=new Bday(1998,8,16); Day d=(Day)Bday.clone(); // must cast because clone() returns an Object d.advance(100); //Bday will not be changed.
7KHFORQHPHWKRGLVDSURWHFWHGPHWKRGRI2EMHFWZKLFKPHDQVWKDWRXUFRGHFDQQRWVLPSO\ FDOO LW 7KH FORQH PHWKRG LV LPSOHPHQWHG WKURXJK WKH &ORQHDEOH LQWHUIDFH 7KH FORQH PHWKRG ZLOOPDNHDELWZLVHFRS\RIWKHFODVV·VREMHFWV
Comp-U-Learn
73
Java Programming I
Day
Bday
Day 16 Month 8 Year 1998
Day
D
Day 16 Month 8 Year 1998
Fig. 4.2
Inner Classes $QLQQHUFODVVLVDFODVVWKDWLVGHILQHGLQVLGHDQRWKHUFODVV7KHQHHGIRULQQHUFODVVHVFDQEH VWDWHGDVIROORZV ♦ An object of an inner class can access the implementation of the object that created it – including data that would otherwise be private. ♦ Inner classes can be hidden from other classes in the same package. ♦ Anonymous inner classes are handy when we want to define callbacks on the fly. ♦ Inner classes are very convenient when we are writing event-driven programs. Example 4.5 class LinkedList { ............ ............. ................... private: class Node
74
Comp-U-Learn
Interfaces and Packages { public Node *Next; int data; } class Iterator { public : void insert(int x); int erase(); } ................. }
+HUH WKH /LQNHG /LVW FODVV LV WKH RXWHU FODVV DQG WKH FODVVHV 1RGH DQG ,WHUWRU DUH WZR LQQHU FODVVHV 1RWH WKDW WKH H[DPSOH VKRZQ DERYH LV ZULWWHQ LQ & 7KLV LV MXVW WR VKRZ WKH VLPLODULWLHVDQGWKHGLIIHUHQFHEHWZHHQ-DYDDQG&
Note An object that comes from an inner class has an implicit reference to the outer class object that instantiated it. Through this pointer, it gains access to the total state of the outer object. A static inner class can be used whenever the inner class does not need to access an outer class.
Packages ,Q-DYDHYHU\WKLQJLVGHVFULEHGLQWHUPVRIFODVVHVDQGVRWKHQXPEHURIFODVVHVXVHGE\DVLQJOH SURJUDPLVYHU\ODUJH7KHUHIRUHLWEHFRPHVLQHYLWDEOHWRSURSHUO\RUJDQL]HWKHVHFODVVHVIURP WKH SRLQW RI WKHLU UHXVDELOLW\ LQ PXOWLSOH SURJUDPV -DYD SURYLGHV VXFK D IDFLOLW\ WKURXJK SDFNDJHV $ SDFNDJH LV D JURXS RI FODVVHV ,W FRXOG EH FRPSDUHG WR WKH OLEUDULHV RIIHUHG E\ SURJUDPPLQJ ODQJXDJHV OLNH & DQG & 7KH FODVVHV RIIHUHG E\ -DYD DUH RUJDQL]HG LQWR SDFNDJHVZKLFKPD\EHLPSRUWHGLQDQDSSOLFDWLRQZLWKWKHLPSRUWVWDWHPHQWDVLOOXVWUDWHGLQ WKHH[DPSOHEHORZ import java.awt.*; import java.applet.*; import java.awt.Button;
%\UXOHHYHU\FODVVLQ-DYDEHORQJVWRVRPHSDFNDJH,IZHGRQ·WPHQWLRQDERXWDSDFNDJHWKH FRPSLOHUDVVXPHVWKDWZHDUHSXWWLQJWKHFODVVHVLQWKHGHIDXOWSDFNDJH7KLVGHIDXOWSDFNDJHKDV QRQDPHLQ-DYD
Comp-U-Learn
75
Java Programming I
Need for Packages /HW XV VHH WKH QHHG IRU SDFNDJHV EHIRUH WU\LQJ WR GHILQH D SDFNDJH ,I WKH FRQFHSW RI LPSRUW VWDWHPHQWGRHVQRWH[LVWLQ-DYDZHDQGKDGWRIRUH[DPSOHFUHDWHD%XWWRQREMHFWZHZRXOG KDYHWRVD\ java.awt.Button MyButton=new java.awt.Button(“sample”);
7KLVLVDYHU\WHGLRXVZD\RIFUHDWLQJD%XWWRQZLWKWKHDGGLWLRQDORYHUORDGRIQHHGLQJWRNQRZ WKHIXOO\TXDOLILHGQDPHVZKHQUHIHUULQJWRDFODVVRI-DYD7KHVDPHWKLQJFRXOGEHDSSURDFKHG LQDVWUDLJKWIRUZDUGPDQQHU import java.awt.button; ............................................. ............................................. Button MyButton = new Button(“sample”);;
7RFUHDWHSDFNDJHVVLPSO\LQFOXGHDSDFNDJHFRPPDQGDVWKHILUVWVWDWHPHQWLQD-DYDVRXUFH ILOH $Q\ FODVV GHFODUHG ZLWKLQ WKDW ILOH ZLOO EHORQJ WR WKH VSHFLILHG SDFNDJH 7KH SDFNDJH VWDWHPHQWGHILQHVDQDPHVSDFHLQZKLFKFODVVHVDUHVWRUHG,IZHRPLWWKHSDFNDJHVWDWHPHQW WKHQWKHFODVVQDPHVDUHSXWLQWRDGHIDXOWSDFNDJHZKLFKKDVQRQDPH$WWKHEHJLQQLQJRIWKH FODVVGHFODUDWLRQDGGWKHIROORZLQJFRGH package Packagename;
Example package pkg;
+HUH SNJ LV WKH QDPH RI WKH SDFNDJH -DYD XVHV ILOH V\VWHP GLUHFWRULHV WR VWRUH SDFNDJHV )RU H[DPSOHWKHFODVVILOHVIRUDQ\FODVVHVWKDWDUHGHFODUHGWREHSDUWRIWKHSDFNDJHSNJPXVWEH VWRUHGLQDGLUHFWRU\FDOOHGSNJ0RUHWKDQRQHILOHFDQLQFOXGHWKHVDPHSDFNDJHVWDWHPHQW7KH SDFNDJHVWDWHPHQWVLPSO\VSHFLILHVWRZKLFKSDFNDJHVWKHFODVVHVGHILQHGLQDILOHEHORQJ Creation of a Package The following are the steps involved in the creation of a package
,GHQWLI\WKHKLHUDUFK\LQZKLFKZHZRXOGOLNHWRSODFHWKHFODVVILOHV &UHDWHDGLUHFWRU\ZKLFKKDVWKHVDPHQDPHDVWKDWRIWKHSDFNDJH ,QFOXGHSDFNDJHVWDWHPHQWDORQJWKHSDFNDJHQDPHDVWKHILUVWVWDWHPHQWLQWKHSURJUDP 'HFODUHWKHFODVVHVUHTXLUHGLQWKHSDFNDJH
76
Comp-U-Learn
Interfaces and Packages
6DYHWKHILOHQRZZLWKWKHQDPHRIWKHFODVVDORQJZLWKMDYDH[WHQVLRQ &RPSLOHWKHILOHXVLQJMDYDFWRFUHDWHWKHFODVVILOHLQWKHVDPHGLUHFWRU\ LHWKHGLUHFWRU\WKDW KDVWKHQDPHRIWKHSDFNDJH ([HFXWHWKHFODVVILOH
CLASSPATH Variable :KHQZHDUHZULWLQJVPDOOSURJUDPVLWGRHVQRWPDWWHULIWKHSDFNDJHQDPHLVQRWPHQWLRQHG %HFDXVHLWZLOOEHLQWKHGHIDXOWSDFNDJH-DYDFRPSLOHUDQGLQWHUSUHWHUVHDUFKHVWKHFODVVILOHVLQ WKH SDWK VSHFLILHG LQ &/$663$7+ YDULDEOH 7KH FXUUHQW ZRUNLQJ GLUHFWRU\ LV E\ GHIDXOW LQFOXGHG LQ WKLV YDULDEOH +HQFH LW LV SRVVLEOH WR FRPSLOH DQG H[HFXWH ILOHV IURP WKH H[LVWLQJ FXUUHQWGLUHFWRU\,QFDVHRIFUHDWLQJDSDFNDJHLWVKRXOGEHHQVXUHGWKDWWKHURRWGLUHFWRU\RI WKHSDFNDJHLVLQFOXGHGLQWKH&/$663$7+YDULDEOH7KLVLVEHFDXVHWKHVSHFLILFORFDWLRQWKDW WKH -DYD FRPSLOHU ZLOO FRQVLGHU DV WKH URRW RI DQ\ SDFNDJH KLHUDUFK\ LV FRQWUROOHG E\ &/$663$7+ 6LQFHFODVVHVFRXOGEHDQ\ZKHUHZHPXVWLQGLFDWHWRWKH-DYDLQWHUSUHWHUZKHUHLWFDQILQGWKH FODVVHVWKDWZHDUHWU\LQJWRUXQ7KLVLVGRQHWKURXJKWKH&/$663$7+HQYLURQPHQWYDULDEOH 7KH&/$663$7+YDULDEOHFRPSULVHVDOLVWRIGLUHFWRU\QDPHVWKDWFRQWDLQ-DYDFRPSLOHG-DYD FODVVHV 7KH DFWXDO FRQVWUXFW RI &/$663$7+ GHSHQGV RQ WKH V\VWHP ZH DUH UXQQLQJ 7KH FODVVHV LQFOXGHG ZLWK WKH -DYD GHYHORSPHQW HQYLURQPHQW DUH DXWRPDWLFDOO\ DYDLODEOH WR XV EHFDXVHWKHLQWHUSUHWHUDXWRPDWLFDOO\DSSHQGVWKHFRUUHFWGLUHFWRU\WRRXU&/$663$7+ZKHQLW VWDUWVXS Snapshot on Packages
♦ As default, every class belongs to some package in Java. ♦ A package statement before the class statement is necessary. ♦ Two or more packages can be grouped. This creates a hierarchy of packages. ♦ Package hierarchy is denoted by writing the dot (.) after every level; aaa.bbb.ccc means that the package ccc is in the bbb package which is in the aaa package. ♦ Java restriction is that we should keep the packages/classes into corresponding directories/files. ♦ It is possible to create a class called cla in ccc as well as in bbb or in ttt. There is no conflict; they actually have different full names to be qualified. ♦ A package can contain only one public class.
Comp-U-Learn
77
Java Programming I
Example 4.6 package mainpack; public class Class1 { public static void meth1() { System.out.println(“Hello Friends”); } }
&UHDWHDGLUHFWRU\FDOOHGPDLQSDFNXQGHUELQDQGVDYHWKLVILOHDV&ODVVMDYD package mainpack.child; public class Class2 { public static void meth2() { System.out.println(“Good Bye Friends”); } }
1RZFUHDWHDVXEGLUHFWRU\FDOOHGFKLOGXQGHUWKHGLUHFWRU\PDLQSDFN6DYHWKLVILOHDV&ODVVMDYD LQWKHVXEGLUHFWRU\FKLOG1RZXQGHUELQGLUHFWRU\RSHQDQHZILOHDQGZULWHWKHIROORZLQJFRGH import mainpack.*; import mainpack.child.*; class ex14 { public static void main(String args[]) { Class1.meth1(); Class2.meth2(); } }
6DYHWKLVILOHDVH[MDYDFRPSLOHXVLQJMDYDFDQGH[HFXWHWKHFODVVILOH
Note The star form may increase compilation time especially if we import several large packages. For this reason it is a good idea to explicitly name the classes that we want to use rather importing whole packages. $OORIWKHVWDQGDUG-DYDFODVVHVLQFOXGHGZLWK-DYDDUHVWRUHGLQDSDFNDJHFDOOHGMDYD7KHEDVLF ODQJXDJHIXQFWLRQVDUHVWRUHGLQDSDFNDJHLQVLGHRIWKHMDYDSDFNDJHFDOOHGMDYDODQJ1RUPDOO\ ZHKDYHWRLPSRUWHYHU\SDFNDJHRUFODVVWKDWZHZDQWWRXVHEXWVLQFH-DYDLVXVHOHVVZLWKRXW PXFKRIWKHIXQFWLRQDOLW\LQMDYDODQJWKHFRPSLOHUIRUDOOSURJUDPVLPSOLFLWO\LPSRUWVLW
78
Comp-U-Learn
Interfaces and Packages
Access Protection &ODVVHVDQGSDFNDJHVDUHERWKPHDQVRIHQFDSVXODWLQJDQGFRQWDLQLQJWKHQDPHVSDFHDQGVFRSH RI YDULDEOHV DQG PHWKRGV 3DFNDJHV DFW DV FRQWDLQHUV IRU FODVVHV DQG RWKHU VXERUGLQDWH SDFNDJHV &ODVVHV DFW DV FRQWDLQHUV IRU GDWD DQG FRGH 7KH FODVV LV -DYD·V VPDOOHVW XQLW RI DEVWUDFWLRQ %HFDXVH RI WKH LQWHUSOD\ EHWZHHQ FODVVHV DQG SDFNDJHV -DYD DGGUHVVHV IRXU FDWHJRULHVRIYLVLELOLW\IRUFODVVPHPEHUV ♦ ♦ ♦ ♦
Subclasses in the same package Non subclasses in the same package Sub classes in different packages Classes that are neither in the same package nor subclasses
7KHWKUHHDFFHVVVSHFLILHUVSULYDWHSXEOLFDQGSURWHFWHGSURYLGHDYDULHW\RIZD\VWRSURGXFH WKHPDQ\OHYHOVRIDFFHVVUHTXLUHGE\WKHVHFDWHJRULHV7KHIROORZLQJWDEOHVKRZVWKHXVDJHRI YDULRXVDFFHVVVSHFLILHUVDQGWKHLUVFRSHLQWKHSDFNDJHV Description Same class Same package Subclass Same package Non subclass Different package Sub class Different package Non Sub class
Private Yes No No
No modifier Yes Yes Yes
Protected Yes Yes Yes
Public Yes Yes Yes
No
No
Yes
Yes
No
No
Yes
Yes
$FODVVKDVRQO\WZRSRVVLEOHDFFHVVOHYHOV GHIDXOWDQGSXEOLF:KHQDFODVVLVGHFODUHGDVSXEOLF LWLVDFFHVVLEOHE\DQ\RWKHUFRGH,IDFODVVKDVGHIDXOWDFFHVVWKHQLWFDQRQO\EHDFFHVVHGE\ RWKHUFRGHZLWKLQLWVVDPHSDFNDJH Access Control Rules
$OOWKHFODVVHVDUHSXWLQWRWKHVHFDWHJRULHV This class (T). Subclasses of this class in the same package (SP) Non subclasses of this class in the same package (NP) Subclasses of this class in the other package (SO) Non subclasses of this class in other packages (NO) As the access attributes, Java provides these five alternatives
Comp-U-Learn
79
Java Programming I
1RQH QRWVSHFLI\LQJDQ\WKLQJ Private Public Private protected Protected 7KHUXOHVIRUXVLQJWKHVHDWWULEXWHVDUHDVIROORZV ,I ZH GRQ·W VSHFLI\ DQ\WKLQJ WKLV FODVV DQG WKH GDWDPHWKRGV GHILQHG LQVLGH LW DUH YLVLEOH DFFHVVLEOH WKURXJKRXWWKHSDFNDJHFRQWDLQLQJWKLVFODVV YLVLEOHDFFHVVLEOHWR76313 ,IZHGHFODUHVRPHWKLQJ WKLVFODVVRUWKHGDWDPHWKRGVGHILQHGLQVLGHLW DVSULYDWHLWLVYLVLEOH DFFHVVLEOH RQO\ LQ WKLV FODVV YLVLEOH WR 7 7KH ZRUG SULYDWH LV JHQHUDOO\ XVHG IRU KLGLQJ LQIRUPDWLRQIURPRWKHUFODVVHV ,IZHGHFODUHVRPHWKLQJDVSULYDWHSURWHFWHGLWLVYLVLEOH DFFHVVLEOH LQVLGHDOOWKHVXEFODVVHVLQ WKLVSDFNDJHDVZHOODVLQRWKHUSDFNDJHV YLVLEOHWR76362 ,I ZH GHFODUH VRPHWKLQJ DV SURWHFWHG LW LV YLVLEOH LQVLGH DOO FODVVHV RI WKLV SDFNDJH DQG DOVR LQVLGHWKHVXEFODVVHV RIRWKHUSDFNDJHV YLVLEOHWR 763136R ,WLVQRWYLVLEOHRQO\IRUWKH QRQVXEFODVVHVRIRWKHUSDFNDJHV QRWYLVLEOHWR12 ,IZHGHILQHVRPHWKLQJSXEOLFLWLVYLVLEOHHYHU\ZKHUH YLVLEOHWR763136212
Overview of Java Built-in Packages 7KH-'.$3,FRQVLVWVRISDFNDJHVDOORIZKLFKDUHLQWKH&RUH$3,2IWKH&RUH$3, SDFNDJHV DUH SDUW RI WKH -DYD )RXQGDWLRQ &ODVVHV -)& 7KH &RUH $3, JUHZ VLJQLILFDQWO\ IURP-'.WR2IWKH&RUH$3,SDFNDJHVWKDWZHUHDUHDGGHGLQ-'. DUHLQ WKH-)&6ZLQJDQG 1RQVZLQJ DUH-DYD,'/ &25%$DQG&RV1DPLQJ DUHVHFXULW\ DUH XWLOLW\ SDFNDJHV -$5 DQG 0,0( VXSSRUW LV -DYD %HDQV LV 50, DQG LV 2EMHFW 5HIHUHQFHV MDYDODQJUHI 7KHEXONRIWKHQHZ-'.SDFNDJHVDUH-)&DQG&25%$ &RUH$3,SDFNDJHVDUHOLVWHGKHUHXQGHU ♦ ♦ ♦ ♦ ♦ 80
Java.applet Java.awt Java.beans Java.io Java.lang Comp-U-Learn
Interfaces and Packages
♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦
Java.math Java.net Java.rmi Java.security Java.sql Java.text Java.util Com.sun.java.swing Com.sun.java.image.codec.jpeg Com.sun.java.accessibility Org.omg.CORBA
The java.applet
7KHMDYDDSSOHWSDFNDJHLVRQHRIWKHVPDOOHVWSDFNDJHVLQWKHFRUH$3,,WFRQVLVWVRIRQHFODVV DQGWKUHHLQWHUIDFHVWKDWSURYLGHWKHEDVLFIXQFWLRQDOLW\QHHGHGWRLPSOHPHQWDSSOHWV7KHDSSOHW FODVV SURYLGHV PHWKRGV WR GLVSOD\ LPDJHV SOD\ DXGLR ILOHV UHVSRQG WR HYHQWV DQG REWDLQ LQIRUPDWLRQ DERXW DQ DSSOHW·V H[HFXWLRQ HQYLURQPHQW 7KH $SSOHW&RQWH[W LQWHUIDFH GHILQHV PHWKRGV WKDW DOORZ DQ DSSOHW WR DFFHVV WKH FRQWH[W LQ ZKLFK LW LV EHLQJ UXQ 7KH $SSOHW6WXE LQWHUIDFHVXSSRUWVFRPPXQLFDWLRQEHWZHHQDQDSSOHWDQGLWVEURZVHUHQYLURQPHQWDQGLVXVHG WR GHYHORS FXVWRP DSSOHW YLHZHUV 7KH $XGLR&OLS LQWHUIDFH SURYLGHV PHWKRGV WKDW VXSSRUW SOD\LQJDXGLRFOLSV The java.awt
7KH MDYDDZW SDFNDJH LPSOHPHQWV WKH FRUH FODVVHV DQG LQWHUIDFHV RI WKH $EVWUDFW ZLQGRZ 7RRONLW,WLVDODUJHSDFNDJHFRQWDLQLQJFODVVHVDQGLQWHUIDFHV7KHVHFODVVHVDQGLQWHUIDFHV SURYLGHWKHVWDQGDUG$:7*8,FRQWUROVDVZHOODVGUDZLQJSULQWLQJDQGRWKHUFDSDELOLWLHV The Javabeans
7KLVSDFNDJHKDVEHHQDGGHGWRVXSSRUWWKHLPSOHPHQWDWLRQIRUDEHDQFRQWDLQHUWKDWSURYLGHV DQH[HFXWLRQFRQWH[WIRUEHDQVGXULQJGHVLJQDQGUXQWLPHH[HFXWLRQ7KLVSDFNDJHFRQWDLQV FODVVHVDQGHLJKWLQWHUIDFHVWKDWSURYLGHWKHEDVLF-DYD%HDQVIXQFWLRQDOLW\ The java.io
7KLV SURYLGHV D VHW RI LQSXW DQG RXWSXW VWUHDPV XVHG WR UHDG DQG ZULWH GDWD WR ILOHV RU RWKHU LQSXWDQGRXWSXWVRXUFHV Comp-U-Learn
81
Java Programming I
The java.lang
7KHMDYDODQJSDFNDJHSURYLGHV FODVVHVDQGWKUHHLQWHUIDFHVWKDWLPSOHPHQWIXQGDPHQWDO-DYD REMHFWV %HFDXVH RI LWV LPSRUWDQFH WKH MDYDODQJ SDFNDJH LV LQFOXGHG ZLWK DOO -DYD SODWIRUPV UDQJLQJIURP(PEHGGHG-DYDWRWKHIXOOEORZQ-'. The java.math
7KH -DYDPDWK SDFNDJH SURYLGHV WZR FODVVHV %LJ'HFLPDO DQG %LJ,QWHJHU WKDW SURYLGH WKH FDSDELOLW\ WR SHUIRUP DUELWUDU\ SUHFLVLRQ DULWKPHWLF ,W SURYLGHV D OLEUDU\ RI PDWK URXWLQHV DQG YDOXHVVXFKDV3, The java.net
7KHMDYDQHWSDFNDJHKDVFODVVHVDQGILYHLQWHUIDFHVIRU7&3,3QHWZRUNSURJUDPPLQJ The java.rmi
7KH 5HPRWH 0HWKRG ,QYRFDWLRQ SDFNDJHV SURYLGH WKH FDSDELOLW\ WR XVH GLVWULEXWHG REMHFWV ZLWKLQ-DYD7KLVLVDQHZDGGLWLRQWR-'.,WVXSSRUWVSHUVLVWHQWUHPRWHREMHFWUHIHUHQFHV DQGDXWRPDWLFREMHFWDFWLYDWLRQ The java.security
7KHILYHMDYDVHFXULW\SDFNDJHVVXSSRUWLPSOHPHQWDWLRQRI-'.FRQILJXUDEOHVHFXULW\SROLF\ DQG FU\SWRJHQLF VHFXULW\ PHFKDQLVPV ,W SURYLGHV VSHFLDO VSHFLILFDWLRQV IRU WKH NH\V XVHG LQ FRPPRQFU\SWRJUDSKLFDOJRULWKPV 7KLV SDFNDJH KDV FODVVHV DQG HLJKW LQWHUIDFHV WKDW IRUP WKHIRXQGDWLRQIRUWKH6HFXULW\$3, The Swing
6ZLQJ LV D MDYD H[WHQVLRQ WR WKH $:7 WKDW SURYLGHV PDQ\ QHZ *8, FRPSRQHQWV LPSURYHPHQWVWRH[LVWLQJFRPSRQHQWVDQGWKHFDSDELOLW\WRVHOHFWIURPDYDULHW\RI*8,ORRN DQG IHHOV VXFK DV 0HWDO :LQGRZV 0RWLI DQG 0DFLQWRVK ,W SURYLGHV FODVVHV WR LPSOHPHQW ERUGHUVDQGERUGHUVW\OHVWKHWDEOHFRPSRQHQWWH[WSURFHVVLQJFRPSRQHQWV The java.utility
7KLVFRQWDLQVDFROOHFWLRQRIXWLOLW\FODVVHV$PRQJWKHPDUHWKHVHYHUDOJHQHULFGDWDVWUXFWXUHV OLNH 'LFWLRQDU\ 6WDFN 9HFWRU DQG +DVKWDEOH ,W DOVR FRQWDLQV FODVVHV WR PDQLSXODWH FDOHQGDU GDWHV7KH-DYDXWLOSDFNDJHDOVRFRQWDLQVWKH2EVHUYHULQWHUIDFHDQG2EVHUYDEOHFODVVZKLFK DOORZREMHFWVWRQRWLI\RQHDQRWKHUZKHQWKH\FKDQJH 82
Comp-U-Learn
Interfaces and Packages
Summary Interfaces are declared like classes but using the keyword interface. Interface has two parts the interface declaration and the interface body. Any class outside the hierarchy can implement interfaces. Interfaces are mainly used to draw a similarity between unrelated classes. Interfaces are not a substitute for multiple inheritance. All the methods declared in the interface are abstract. Implementing the interface results in the implementation of the methods declared in the interface. A package is a group of classes similar to the libraries offered by most programming languages. Packages help simplify programming and remove the overhead of remembering fully qualified package names to refer a class. The keyword package identifies the package. The import statement is used to import classes of a package in other programs. Some of the standard Java packages are java.applet, java.lang, java.net, java.util, java.awt and java.io.
Going Over It Again I. Fill in the Blanks
$QLQWHUIDFHLVGHFODUHGXVLQJBBBBBBBBBNH\ZRUG $OOWKHPHWKRGVLQDQLQWHUIDFHDUHBBBBBBBB $SDFNDJHDOZD\VFRQWDLQBBBBBBBSXEOLFFODVV BBBBBBBSDFNDJHSURYLGHVDOLEUDU\RIPDWKURXWLQHV BBBBBBBBSDFNDJHSURYLGHVDVHWRILQSXWDQGRXWSXWVWUHDPVXVHGWRUHDGDQGZULWHGDWD WRILOHVRURWKHULQSXWDQGRXWSXWVRXUFHV II. State True or False
,QWHUIDFHLVDQDOWHUQDWLYHWRPXOWLSOHLQKHULWDQFH $FODVVFDQH[WHQGPRUHWKDQRQHFODVV 0HWKRGLPSOHPHQWDWLRQVDQGYDULDEOHVDUHLQKHULWHGIURPDQLQWHUIDFH $QLQWHUIDFHFDQQRWH[WHQGRWKHULQWHUIDFHV 3URWHFWHGGDWDFDQEHDFFHVVHGE\WKHQRQVXEFODVVHVRIRWKHUSDFNDJHV
Comp-U-Learn
83
Java Programming I
III. One line Answers
'HILQHLQWHUIDFH 'LIIHUHQWLDWHPXOWLSOHLQKHULWDQFHDQGLQWHUIDFH 'HILQHLQQHUFODVVHV :KDWLVWKHDGYDQWDJHRILPSOHPHQWLQJFORQH PHWKRG" :ULWHDVKRUWQRWHRQSDFNDJHV
84
Comp-U-Learn
Session 5
Streams and File Handling
On Completion of this Session We will be able to understand...
) Stream class and its functions ) System Properties ) Input Stream and its methods ) Output Streams and its methods ) Directory Structure ) File Input and Output Streams ) Buffered Streams & Filtered Streams
In This Session...
Java Stream Class
Print Stream
System Properties
Input and Output Streams
Files and Directories
File Input and Output Streams
Data Input and Output Streams
Filtered Streams
Buffered Streams
Pushback Input Streams
Random Access File
Reader and Writer Classes
Streams and File Handling
Java Stream Class 6WUHDP LQ -DYD LV D JHQHUDO DEVWUDFWLRQ RI WKH GDWD WUDQVIHU PHFKDQLVP 6HSDUDWH VWUHDPV DUH SURYLGHGIRULQSXWDQGRXWSXW$OOLQSXWRXWSXWRSHUDWLRQVLQ-DYDDUHGRQHXVLQJWKHEDVLFW\SH E\WH&KDUDFWHUVDUHGHDOWWKURXJKWKHLUVSHFLILFFRGHZKRVHYDOXHVDUHE\WHW\SH-DYDSURJUDPV DOO UHDG IURP DQG ZULWH WR VWUHDPV $ VWUHDP LV D IORZLQJ VHTXHQFH RI FKDUDFWHUV 7KH LQSXW VRXUFH FDQ EH IURP D NH\ERDUG D ILOH RU WKH QHWZRUN DQG WKH RXWSXW GHVWLQDWLRQ FDQ EH WKH VFUHHQRUDILOHRUWKHQHWZRUN7KHGDWHLVVHQWRUUHFHLYHGDVDVHTXHQFHRIE\WHV The Stream Classes
-DYDLPSOHPHQWVVWUHDPVZLWKLQDFODVVKLHUDUFK\GHILQHGLQWKHMDYDLRSDFNDJH$WWKHWRS RI WKHKLHUDUFK\DUHWZRDEVWUDFWFODVVHV ,QSXW6WUHDPDQG2XWSXW6WUHDP-DYDKDVVHYHUDOFRQFUHWH VXEFODVVHVRIHDFKWRKDQGOHWKHGLIIHUHQFHVEHWZHHQYDULRXVGHYLFHVVXFKDVGLVNILOHVQHWZRUN FRQQHFWLRQVDQGHYHQPHPRU\EXIIHUV
Print Stream 7KH3ULQW6WUHDPFODVVSURYLGHVDOORI WKHIRUPDWWLQJ FDSDELOLWLHVZH KDYH EHHQ XVLQJ IURP WKH 6\VWHP ILOH KDQGOH 6\VWHPRXW -DYD·V 3ULQW6WUHDP REMHFWV VXSSRUW WKH SULQW DQG SULQWOQ PHWKRGV IRU DOO W\SHV LQFOXGLQJ REMHFWV 7KH PHWKRGV RI WKLV FODVV DUH ZLGHO\ XVHG LQ -DYD DSSOLFDWLRQV 7KH WZR PHWKRGV WKDW DUH YHU\ IDPLOLDU WR XV DUH 6\VWHPRXWSULQWOQ DQG 6\VWHPRXWSULQW 7KH6\VWHPHUUPHWKRGLVXVHGWRSULQWHUURUPHVVDJHVDQG6\VWHPLQLVDQ ,QSXW6WUHDP Print, println and write methods
7KHSULQWDQGSULQWOQPHWKRGVDUHHVVHQWLDOO\WKHVDPH WKH\ERWKZULWHWKHLUVWULQJDUJXPHQWWR WKHVWUHDP7KHRQHGLIIHUHQFHEHWZHHQWKHWZRLVWKDWSULQWOQDGGVDQHZOLQHFKDUDFWHUWRWKH HQGRILWVRXWSXWZKHUHDVSULQWGRHVQ·W System.out.println(“welcome to Java streams “);
,VWKHVDPHDV System.out.print(“Welcome to Java steams \n”);
7KHZULWHPHWKRGLVOHVVIUHTXHQWO\XVHGWKDQSULQWRUSULQWOQFRPPDQGV:ULWHLVXVHGWRZULWH E\WHVWRWKHVWUHDP7KH\DUHXVHGWRZULWH1RQ$6&,,GDWD Comp-U-Learn
87
Java Programming I Java’s Stream Input Output Classes
Stream Class BufferedInputStream BufferedOutputStream ByteArrayInputStream ByteArrayOutputStream DataInputStream DataOutput Stream File File Descriptor FileInputStream FileOutputStream FilterInputStream FilterOutputStream InputStream LineNumberInputStream OutputStream PipedInputStream PipedOutputStream PrintStream PushbackInputStream RandomAccessFile SequenceInputStream
Stream Tokenizer String BufferInputStream
Definition Buffered input stream Buffered output stream Input stream that reads from a byte array Output stream that writes to a byte array An input stream that contains methods for reading Java standard data types An output stream that contains methods for writing Java standard data types Deals directly with files and the file system Deals with record pointers, file descriptions and file access mechanisms Input stream that reads from a file Output stream that writes to a file Implements Input Stream Implements Output Stream Abstract class that describes stream input Input stream that counts lines Abstract class that describes stream output Input pipe Output pipe Output stream that contains print() and println() Input stream that supports one-byte “unget” which returns a byte to the input stream Supports random access file I/O Input stream that is a combination of two or more input streams which will be read sequentially, one after the other Tokenizing input stream Input streams that read from a string
Built-in streams in Java
$OO-DYDSURJUDPVDXWRPDWLFDOO\LPSRUWWKHMDYDODQJSDFNDJH7KLVSDFNDJHGHILQHVDFODVVFDOOHG 6\VWHPZKLFKHQFDSVXODWHVVHYHUDODVSHFWVRIWKHUXQWLPHHQYLURQPHQW,WDOVRFRQWDLQVWKUHH SUHGHILQHGYDULDEOHVFDOOHGLQRXWDQGHUU7KHVHILHOGVDUHGHFODUHGDVSXEOLFDQGVWDWLFZLWKLQ 6\VWHP 7KLV PHDQV WKDW WKH\ FDQ EH XVHG E\ DQ\ RWKHU SDUW RI RXU SURJUDP DQG ZLWKRXW UHIHUHQFHWRDVSHFLILF6\VWHPREMHFW 88
Comp-U-Learn
Streams and File Handling
6\VWHPRXWUHIHUVWRWKHVWDQGDUGRXWSXWVWUHDP%\GHIDXOWWKLVUHIHUVWRWKHPRQLWRU6\VWHPLQ UHIHUVWRWKHVWDQGDUGLQSXWVWUHDPZKLFKLVE\GHIDXOWWKHNH\ERDUG6\VWHPHUUUHIHUVWRWKH VWDQGDUG HUURU VWUHDP ZKLFK LV DOVR WKH VFUHHQ E\ GHIDXOW +RZHYHU WKHVH VWUHDPV FDQ EH UHGLUHFWHGWRDQ\FRPSDWLEOH,2GHYLFH
System Properties 7KH6\VWHPFODVVPDLQWDLQVDVHWRISURSHUWLHVNH\YDOXHSDLUVWKDWGHILQHWUDLWVRUDWWULEXWHVRI WKH FXUUHQW ZRUNLQJ HQYLURQPHQW :KHQ WKH UXQWLPH V\VWHP ILUVW VWDUWV XS WKH V\VWHP SURSHUWLHV DUH LQLWLDOL]HG WR FRQWDLQ LQIRUPDWLRQ DERXW WKH UXQWLPH HQYLURQPHQW LQFOXGLQJ LQIRUPDWLRQ DERXW WKH FXUUHQW XVHU WKH FXUUHQW YHUVLRQ RI WKH -DYD UXQWLPH DQG HYHQ WKH FKDUDFWHU XVHG WR VHSDUDWH FRPSRQHQWV RI D ILOH QDPH 7KH 6\VWHP FODVV SURYLGHV VHYHUDO PHWKRGV WR UHDG DQG ZULWH V\VWHP SURSHUWLHV ,W LV SRVVLEOH WR FKDQJH WKH VHW RI V\VWHP SURSHUWLHVFRPSOHWHO\7KH6\VWHPFODVVFRQWDLQVWZRSURSHUWLHVJHW3URSHUW\DQGJHW3URSHUWLHV 7KH*HW3URSHUW\PHWKRGUHWXUQVDVWULQJFRQWDLQLQJWKHYDOXHRIWKHSURSHUW\3URYLGHGDVDQ DUJXPHQW)RUH[DPSOH System.getProperty(“home.name”);
,IWKHDUJXPHQWGRHVQRWKDYHDYDOXHRUWKHSURSHUW\GRHVQRWH[LVWWKHQ1XOO3RLQWHU([FHSWLRQ ZLOOEHUDLVHG7RDYRLGWKLVZHFDQXVHOLNH System.getProperty(“home.name”,”Nothing “);
7KLV PHWKRG ZLOO UHWXUQ WKH YDOXH ´1RWKLQJµ LI WKH DUJXPHQW KRPHQDPH GRHV QRW KDYH DQ\ YDOXH 7KH JHW3URSHUWLHV PHWKRG UHWXUQV D 3URSHUWLHV REMHFW WKDW FRQWDLQV D FRPSOHWH VHW RI V\VWHPSURSHUW\NH\YDOXHSDLUV 7KHVHW3URSHUWLHV PHWKRGLVXVHGWRPRGLI\WKHH[LVWLQJVHWRIV\VWHPSURSHUWLHV7KLVPHWKRG WDNHV D 3URSHUWLHV REMHFW WKDW KDV EHHQ LQLWLDOL]HG WR FRQWDLQ WKH NH\YDOXH SDLUV IRU WKH SURSHUWLHVWKDWKDVWREHVHW7KLVPHWKRGUHSODFHVWKHHQWLUHVHWRIV\VWHPSURSHUWLHVZLWKWKH QHZ VHW UHSUHVHQWHG E\ WKH 3URSHUWLHV REMHFW 7KH VHW3URSHUWLHV PHWKRG FKDQJHV WKH VHW RI V\VWHP SURSHUWLHV IRU WKH FXUUHQW UXQQLQJ DSSOLFDWLRQ 7KHVH FKDQJHV DUH QRW SHUVLVWHQW &KDQJLQJV\VWHPSURSHUWLHVZLWKLQDQDSSOLFDWLRQZLOOQRWDIIHFWIXWXUHLQYRFDWLRQVRIWKH-DYD LQWHUSUHWHU IRU WKLV RU DQ\ RWKHU DSSOLFDWLRQ 7KH UXQ WLPH V\VWHP UHLQLWLDOL]HV WKH V\VWHP SURSHUWLHV HDFK WLPH LWV VWDUWV XS $Q ([DPSOH WR VKRZ WKH JHW3URSHUWLHV DQG VHW3URSHUWLHV 0HWKRGVLVJLYHQEHORZ
Comp-U-Learn
89
Java Programming I
Example 5.1 import java.io.FileInputSteeam; import java.util,Properties; class PropertiesTest { public static void main(String args[]) { try { FileInputStream pfile=new FileInputStream(“MyProps.txt”); Properties p=new Properties(System.getProperties()); p.load(pfile); System.setProperties(p); System.getProperties().list(System.out); } catch(java.io.FileNotFoundException e) { System.err.println(“Cannot find the file MyProps.txt”); } catch(java.io.IOException e) { System.err.printlln(“Input Output Error “); } } }
+HUHWKHJHW3URSHUWLHV PHWKRGZLOOUHWXUQD3URSHUWLHVREMHFWZLWKWKHFXUUHQWVHWRIV\VWHP SURSHUWLHV LQLWLDOL]HG E\ WKH UXQWLPH V\VWHP DORQJ ZLWK WKH SURSHUWLHV DYDLODEOH LQ WKH ILOH ´0\3URSVW[Wµ2QFHGRQHWKHVHSURSHUWLHVDUHVHWXVLQJWKHVHW3URSHUW\PHWKRG
Note Finalization can be forced to occur by the method System.runFinalization and the garbage collector can be made to run at anytime using System.gc(). Method read()
7KHORZHVWOHYHOLQSXWPHWKRGLVUHDG ,WFRPHVLQVHYHUDOIRUPV(DFKWLPHUHDG LVFDOOHGLW UHDGVDVLQJOHE\WHIURPWKHLQSXWVWUHDPDQGUHWXUQVLWDVDQLQWHJHUYDOXH,WUHWXUQV²ZKHQ WKH HQG RI WKH VWUHDP LV HQFRXQWHUHG ,W FDQ WKURZ DQ ,2([FHSWLRQ ([FHSWLRQV UHIHU WR QRQ KDQGOHGHUURUVDQGDEQRUPDOLWLHVRFFXULQJGXULQJDSURJUDPH[HFXWLRQVXFKDVGLYLVLRQE\]HUR ILOH QRW IRXQG HWF ([FHSWLRQV DUH KDQGOHG LQ GHWDLO LQ WKH IROORZLQJ VHVVLRQ 7KH IROORZLQJ SURJUDPGHPRQVWUDWHVUHDG ,WUHDGVFKDUDFWHUVIURPWKHVWDQGDUGLQSXWXQWLOWKHXVHUW\SHVD ´Tµ
90
Comp-U-Learn
Streams and File Handling
Example 5.2 import java.io.*; class ex22 { public static void main(String args[]) throws IOException { char c; System.out.println("enter characters, q to quit. "); do{ c=(char)System.in.read(); System.out.println(c); }while(c!='q'); } }
7KHRXWSXWLVGLIIHUHQWEHFDXVH6\VWHPLQLVOLQHEXIIHUHGE\GHIDXOW 7KHRXWSXWRIWKHSURJUDPLV enter characters, q to quit. 123456q 1 2 3 4 5 6
Reading a String
-DYD SURYLGHV D EXLOW LQ PHWKRG FDOOHG UHDG/LQH ZKLFK DXWRPDWLFDOO\ UHDGV D VHTXHQFH RI FKDUDFWHUVIURPWKHLQSXWVWHDPDQGUHWXUQVWKHPLQ DQREMHFW RIW\SH6WULQJ 7KLVPHWKRG LV SDUW RI WKH 'DWD,QSXW6WUHDP FODVV ZKLFK SURYLGHV PHWKRGV IRU UHDGLQJ DOO RI -DYD·V VLPSOH W\SHVSOXVOLQHVRIWH[W7KHJHQHUDOIRUPRIUHDG/LQH LV Final String readLine() throws IOException
UHDG/LQH UHWXUQV D VWULQJ REMHFW %HIRUH XVLQJ UHDG/LQH ZH PXVW REWDLQ D 'DWD,QSXW6WUHDP REMHFWWKDWLVOLQNHGWRDQLQSXWVWUHDP7KHJHQHUDOIRUPLV DataInputStream(InputStream istream)
+HUHLVWUHDPLVWKHVWUHDPWKDWLVOLQNHGWRWKHLQVWDQFHRI'DWD,QSXW6WUHDPEHLQJFUHDWHG7R UHDG FRQVROH LQSXW ZH FDQ XVH 6\VWHPLQ IRU WKLV SDUDPHWHU $Q H[DPSOH WR GHPRQVWUDWH WKH DERYHFRQFHSWLVJLYHQEHORZ
Comp-U-Learn
91
Java Programming I
Example 5.3 import java.io.*; class ex23 { public static void main(String args[]) throws IOException { DataInputStream in=new DataInputStream(System.in); String str; System.out.println("Enter lines of text "); System.out.println("Enter 'End' to quit"); do{ str=in.readLine(); System.out.println(str); }while(!str.equals("End")); } }
7KHRXWSXWRIWKHSURJUDPZLOOEH Enter lines of text Enter ‘End’ to quit Ba ba Black Sheep Ba ba Black Sheep Have you any wool Have you any wool End End
$QRWKHUH[DPSOHWRVKRZWKHEHKDYLRURI,2VWUHDPVLVJLYHQEHORZ Example 5.4 import java.io.*; class ex24 { public static void main(String args[]) throws IOException { DataInputStream in=new DataInputStream(System.in); String str[]=new String[50]; System.out.println("Enter lines of text "); System.out.println("Enter 'End' to quit"); for(int i=0;i<50;i++) { str[i]=in.readLine(); if(str[i].equals("End")) break;
92
Comp-U-Learn
Streams and File Handling } System.out.println("The file is for(int i=0;i<50;i++) { if(str[i].equals("end")) break; System.out.println(str[i]); } } }
");
7KHRXWSXWRIWKHSURJUDP Enter lines of text Enter ‘End’ to quit Ba ba black sheep Have you any wool End The file is Ba ba black sheep Have you any wool End
Input and Output Streams Input Stream
7KH ,QSXW6WUHDP FODVV KDQGOHV DQ\ NLQG RI LQSXW $OO WKH PHWKRGV RI WKLV FODVV WKURZ DQ ,2([FHSWLRQ LI DQ\ HUURU RFFXUV 7KH VXPPDU\ RI WKH PHWKRGV DYDLODEOH LQ WKLV FODVV LV OLVWHG KHUHXQGHU read()
Returns an int representation of the next available byte. read(byte b[])
$WWHPSWV WR UHDG V E\WHV LQWR WKH DUUD\ E ZKHUH V LV WKH VL]H RI WKH DUUD\ E V EOHQJWK ,W UHWXUQVDQLQWWHOOLQJKRZPDQ\E\WHVDUHDFWXDOO\UHDG WKHDFWXDOE\WHVUHDGPD\EHOHVVWKDQWKH DUUD\VL]H read(byte b[],int off,int len)
$WWHPSWV WR UHDG XS WR FK E\WHV DQG VWRUHV WKHP LQ E IURP E>RII@ RQZDUGV ,W UHWXUQV DQ LQW WHOOLQJKRZPDQ\E\WHVDUHDFWXDOO\UHDG
Comp-U-Learn
93
Java Programming I skip(long n)
:LOOVNLSQQH[WE\WHVDQGZLOOUHWXUQWKHQXPEHURIDFWXDOE\WHVVNLSSHG available()
5HWXUQVWKHQXPEHURIE\WHVFXUUHQWO\DYDLODEOHIRUUHDGLQJ WKHVHDUHMXVWWKHUHPDLQLQJXQUHDG E\WHV close()
&ORVHVWKHFXUUHQW,QSXW6WUHDP)XUWKHUDWWHPSWWRUHDGWKURHVDQ,2([FHSWLRQ mark(int rr)
3ODFHVDPDUNDWWKHFXUUHQWSRVLWLRQ7KLVPDUNZLOOUHPDLQYDOLGXQWLOQH[WUUE\WHV DUHUHDG 8VLQJWKLVPDUNZHPD\FRPHEDFNWRWKLVSRVLWLRQDQGVWDUWDIUHVKUHDGLQJ reset()
5HWXUQVWKHLQSXWSRLQWHUWRWKHSUHYLRXVO\PDUNHGSRVLWLRQ mark supported()
5HWXUQVWUXHLIPDUN DQGUHVHW PHWKRGVDUHVXSSRUWHGRQWKLVVWUHDP Output Stream
/LNH ,QSXW6WUHDP -DYD GHILQHV 2XWSXW6WUHDP DV DQ DEVWUDFW FODVV WR GHDO ZLWK DOO NLQGV RI RXWSXWV $OO PHWKRGV RI WKLV FODVV UHWXUQ YRLG DQG WKURZ DQ ,2([FHSWLRQ LQ FDVH RI IDLOXUHV +HUHLVWKHOLVWRILWVPHWKRGV write(int b)
:ULWHVDVLQJOHE\WHWRDQRXWSXWVWUHDP DIWHUFRQYHUWLQJLWWRE\WHW\SH 6LQFHWKHW\SHRIELV LQW ZH FDQ FRQVWUXFW H[SUHVVLRQV RI DOUHDG\ GHILQHG LQW YDULDEOHV IRU SDVVLQJ DV WKH GXPP\ SDUDPHWHUE write(byte b[])
:LOOZULWHDFRPSOHWHDUUD\RIE\WHVRQWKHRXWSXWVWUHDP
94
Comp-U-Learn
Streams and File Handling write(byte b[]. Int off, int len)
:ULWHOHQE\WHVIURPWKHDUUD\EVWDUWLQJIURPE>RII@ flush()
)OXVKHVDQ\E\WHVWKDWKDYHEHHQZULWWHQWRWKHORJLFDO2XWSXW6WUHDPEXWKDYHQRWUHDFKHGWR WKHDFWXDOGHYLFH OLNHDILOHRQWKHGLVN close()
&ORVHVWKHVWUHDP)XUWKHUDWWHPSWWRZULWHZLOOJHQHUDWHDQHUURU
Files and Directories )LOHVDUHWKHSULPDU\VRXUFHDQGGHVWLQDWLRQIRUGDWDZLWKLQPRVWSURJUDPV)LOHLQSXWRXWSXW RSHUDWLRQLVFRPPRQLQDQ\ODQJXDJH-DYDGHYRWHVDZKROHUDQJHRIPHWKRGVIRXQGLQDFODVV FDOOHG)LOHLQWKHMDYDLRSDFNDJHWRGRWKHVHRSHUDWLRQV)LOHLVDVXEFODVVRI6WUHDPLQ-DYD7KLV LV WKH RQO\ VXEFODVV WKDW GHDOV ZLWK WKH ILOHV LQ WKH GLVN ILOH V\VWHP 8VDJH RI ILOHV KDV VHYHUH UHVWULFWLRQVLQDSSOHWVWRHQVXUHWKDWWKHGLVNRIWKHGHVWLQDWLRQ UXQWLPHHQYLURQPHQW LVQRW FRUUXSWHG E\ DQ\ FKDQFH %XW ILOHV DUH UHTXLUHG IRU DQ\ RWKHU DSSOLFDWLRQ SURJUDP WKDW GRHV VRPHWKLQJXVHIXOIRUWKHDYDLODEOHGDWDDQGSURGXFHVUHVXOWVRISHUPDQHQW QDWXUH-DYDWHDWVD GLUHFWRU\DOVRDVDILOHEXWFHUWDLQPHWKRGVIRUILOHVDQGGLUHFWRULHVDUHGLIIHUHQW$)LOHREMHFWLV XVHGWRREWDLQRUPDQLSXODWHWKHLQIRUPDWLRQDVVRFLDWHGZLWKDGLVNILOHVXFKDVWKHSHUPLVVLRQV WLPHDQGGDWHDQGGLUHFWRU\SDWKDQGWRQDYLJDWHVXEGLUHFWRU\KLHUDUFKLHV6LQFH)LOHGRHVQRW RSHUDWH RQ VWUHDPV LW LV QRW D VXEFODVV RI ,QSXW6WUHDP RU 2XWSXW6WUHDP 7KH IROORZLQJ FRQVWUXFWRUVDUHXVHGWRFUHDWH)LOHREMHFWV ♦ File(String dirpath) ♦ File(String dirpath, String filename) ♦ File(File dirObj, String filename) +HUHWKHGLUSDWKLVWKHSDWKQDPHRIWKHILOHILOHQDPHLVWKHQDPHRIWKHILOHDQGGLU2EMLVDILOH REMHFWWKDWVSHFLILHVDGLUHFWRU\ 7KHIROORZLQJH[DPSOHFUHDWHVWKUHHILOHV ILIDQGI7KHILUVW)LOHREMHFWLVFRQVWUXFWHGZLWKD GLUHFWRU\SDWKDVWKHRQO\DUJXPHQW7KHVHFRQGLQFOXGHVWZRDUJXPHQWV²WKHSDWKDQGWKHILOH QDPH7KHWKLUGLQFOXGHVWKHILOHSDWKDVVLJQHGWRIDQGDILOHQDPH IUHIHUVWRWKHVDPHILOHDV I 7KH QH[W LQFOXGHV WKH GLUHFWRU\ XQGHU ZKLFK WKH SDUWLFXODU ILOH ´DXWRH[HFEDWµ KDV WR EH FUHDWHG Comp-U-Learn
95
Java Programming I File File File File
f1=new f2=new f3=new f3=new
File(“/”); File(“/”, “autoexec.bat”); File(f1,”autoexec.bat”); File(“user”,”autoexec.bat”);
Note The Java convention is to use the UNIX and URL style forward slash for path separators. Methods of File Class
7KHIROORZLQJDUHVRPHRIWKHLPSRUWDQWPHWKRGVDYDLODEOHLQWKH)LOHFODVV getName()
7KLVPHWKRGLVXVHGWRREWDLQWKHQDPHRIWKHILOHVSHFLILHG getPath()/ getAbsolutePath()
7KHVH PHWKRGV KHOS WR JHW WKH SDWK RI WKH ILOH VSHFLILHG DQG WKH DEVROXWH SDWK RI WKH ILOH VSHFLILHGUHVSHFWLYHO\ exists()
7KLVPHWKRGLVXVHGWRFKHFNLIWKHQDPHGILOHH[LVWVLQWKDWGLUHFWRU\RUQRW isFile()/isDirectory()
7KHVHDUHXVHGWRFKHFNLIWKHQDPHGILOHLVDQRUGLQDU\ILOHRUDGLUHFWRU\UHVSHFWLYHO\ canRead()/canWrite()
7KHVH PHWKRGV DUH XVHG WR FKHFN LI WKH VSHFLILHG ILOH LV UHDGDEOHZULWDEOH UHVSHFWLYHO\ 7KHVH PHWKRGVUHWXUQD%RROHDQYDOXHGHSHQGLQJRQWKHLUUHDGDELOLW\ZULWDELOLW\ lastModified()
7KLVPHWKRGUHWXUQVWKHODVWPRGLILFDWLRQWLPHRIWKHILOH length()
7KLVPHWKRGLVXVHGWRNQRZWKHILOHVL]HLQE\WHV
96
Comp-U-Learn
Streams and File Handling delete()
7KLVPHWKRGLVXVHGWRGHOHWHWKHVSHFLILHGILOH renameTo()
7KLVPHWKRGLVXVHGWRUHQDPHDVSHFLILHGILOH,WWDNHVDILOHREMHFWWKDWEHFRPHVWKHGHVWLQDWLRQ ILOHRUWKHUHQDPHGILOHDVLWVSDUDPHWHU isFile()
7KLVUHWXUQVWUXHPRVWRIWKHWLPHEXWVRPHVSHFLDOILOHVVXFKDVGHYLFHGULYHUVDQGQDPHGSLSHV PD\QRWEHKDYHOLNHQRUPDOILOHVVRWKLVPHWKRGFDQEHXVHGWRPDNHVXUHWKDWWKHHQWLW\ZH DFFHVVLVDILOH isAbsolute()
7KLVPHWKRGUHWXUQVWUXHLIWKHILOHKDVDQDEVROXWHSDWKIDOVHLIUHODWLYH $QH[DPSOHWRVKRZWKHZRUNLQJRIYDULRXVPHWKRGV&UHDWHDVLPSOHWH[WILOHFDOOHGGXPP\W[W XQGHUF ?H[DPSOHWRUXQWKLVSURJUDP Example 5.5 import java.io.File; class ex25 { static void a(String s) { System.out.println(s); } public static void main(String args[]) { File f1=new File("c:/example/dummy.txt"); a("File Name : " + f1.getName()); a("Path : "+f1.getPath()); a("Absolute Path is :" + f1.getAbsolutePath()); a("Parent : " +f1.getParent()); a(f1.exists() ? "File exists " : "File does not exist "); a(f1.canWrite() ? "is writable " : " is not writable "); a(f1.canRead() ? "readable " : " is not readable"); a("is" +(f1.isDirectory() ? "" : "not" +" a directory")); a(f1.isFile() ? "is normal file" : "is not a normal file"); a(f1.isAbsolute() ? "is absolute " : "is not absolute "); a("file last modified : " + f1.lastModified()); a("file size : " + f1.length() + "Bytes "); } }
Comp-U-Learn
97
Java Programming I
7KHRXWSXWRIWKHSURJUDPLV File name : dummy.txt Path : c:\example\dummy.txt Absolute Path : c:\example\dummy.txt Parent : c:\example File exists is writable readable isnot a directory is normal file is absolute file last modified : 934007788000 file size : 217 Bytes
Directories
$ GLUHFWRU\ LV D )LOH WKDW FRQWDLQV D OLVW RI RWKHU ILOHV DQG GLUHFWRULHV :KHQ ZH FUHDWH D )LOH REMHFWDQGLWLVDGLUHFWRU\WKHLV'LUHFWRU\ PHWKRGZLOOUHWXUQWUXH,QWKLVFDVHZHFDQFDOOWKH OLVWPHWKRGRQWKDWREMHFWWRH[WUDFWWKHOLVWRIRWKHUILOHVDQGGLUHFWRULHVLQVLGH7KHOLVWRIILOHV LVUHWXUQHGLQDQDUUD\RI6WULQJREMHFWV7KHSURJUDPVKRZQKHUHZLOOGHPRQVWUDWHWKHXVDJHRI OLVWPHWKRGWRH[DPLQHWKHFRQWHQWVRIDGLUHFWRU\&DOOLQJWKHOLVWPHWKRGRQD)LOHREMHFWWKDW LVQRWDGLUHFWRU\ZLOOFDXVHUXQWLPH1XOO3RLQWHU([FHSWLRQ Example 5.6 import java.io.File; class ex26 { public static void main(String args[]) { int i; String dname="C:/jdk1.2"; File f1=new File(dname); if(f1.isDirectory()) { System.out.println("Directory contents of "+dname); String s[]=f1.list(); for(i=0;i<s.length;i++) { File f=new File(dname + "/" + s[i]); if (f.isDirectory()) System.out.println(s[i] + " is a Directory"); else System.out.println(s[i] + " is a file"); } } else
98
Comp-U-Learn
Streams and File Handling System.out.println(dname+ " is not a Directory"); } }
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex26 Directory contents of C:/jdk Uninst.isuis a file binis a Directory READMEis a file LICENSEis a file COPYRIGHTis a file README.htmlis a file jreis a Directory libis a Directory includeis a Directory include-oldis a Directory demois a Directory src.jaris a file
FilenameFilter
7KLVLVXVHGWROLPLWWKHQXPEHURIILOHVUHWXUQHGE\WKHOLVW PHWKRGWRLQFOXGHRQO\WKRVHILOHV ZKLFKPDWFKDFHUWDLQILOHQDPHSDWWHUQRUILOWHU7KHQOLVWPHWKRGLVXVHGDVIROORZV String[] list(FilenameFilter ffobject);
)LOHQDPHILOWHULVDQLQWHUIDFH DQGIIREMHFWLVDQREMHFWRIWKLVLQWHUIDFH7KLVLQWHUIDFH GHILQHV RQO\DVLQJOHPHWKRGFDOOHGDFFHSW ZKLFKLVFDOOHGRQFHIRUHDFKILOHLQDOLVW7KLVPHWKRGLV XVHGIRUH[WUDFWLQJILOHVZLWKDSDUWLFXODUH[WHQVLRQ7KHJHQHUDOV\QWD[IRUDFFHSW LV Boolean accept(File dir,String filename)
7KHDFFHSW PHWKRGUHWXUQVWUXHIRUILOHVLQWKHGLUHFWRU\E\GLUWKDWVKRXOGEHLQFOXGHGLQWKH OLVWWKDWLVWKRVHPDWFKWKHILOHQDPHDUJXPHQWDQGIDOVHIRUWKRVHWKDWVKRXOGEHH[FOXGHG$Q H[DPSOHWRVKRZWKHZRUNLQJRI)LOHQDPH)LOWHUIROORZV Example 5.7 import java.io.*; public class OnlyExt implements FilenameFilter { String ex; public OnlyExt(String ex) { this.ex="." +ex;
Comp-U-Learn
99
Java Programming I } public boolean accept(File dir,String fname) { return fname.endsWith(ex); } }
6DYHWKLVILOHZLWKWKHH[WHQVLRQ2QO\([WMDYDXQGHUELQ import java.io.*; class ex27 { public static void main(String args[]) { String dirname="C:/example"; File f1=new File(dirname); FilenameFilter ff=new OnlyExt("doc"); String s[]=f1.list(ff); for(int i=0; i<s.length;i++) System.out.println(s[i]); } }
7KHRXWSXWRIWKHSURJUDPH[MDYDLVDVIROORZV C:\jdk1.2\bin>javac ex27.java C:\jdk1.2\bin>java ex27 OOPs In Java.doc ~$ided tour-3 qns.doc ~$terfaces.doc ~$treams.doc Answers to guide tour-3.doc guided tour-3 qns.doc Interfaces.doc Streams.doc Cover Page.doc C:\jdk1.2\bin>
File Input and Output Streams FileInput Stream
)LOH VWUHDP FRQVLVWV RI WKH )LOH,QSXW6WUHDP DQG )LOH2XWSXW6WUHDP 7KH )LOH,QSXW6WUHDP FODVV FUHDWHVDQ,QSXW6WUHDPWKDWZHFDQXVHWRUHDGWKHFRQWHQWVRIDILOH7KLVFODVVUHDGVGDWDIURP WKHDFWXDOGLVNILOHV7KHWZRPRVWFRPPRQFRQVWUXFWRUVDUH 100
Comp-U-Learn
Streams and File Handling
FileInputStream(String filepath) FileInputStream(File fileobj) (LWKHUFDQWKURZXSD)LOHQRW)RXQG([FHSWLRQ+HUHILOHSDWKLVWKHIXOOQDPHRIDILOHDQGILOHREM LVD)LOHREMHFWWKDWGHVFULEHVWKHILOH 7KHIROORZLQJH[DPSOHFUHDWHVWZR)LOH,QSXW6WUHDPVWKDWXVHWKHVDPHGLVNILOHDQGHDFKRIWKH WZRFRQVWUXFWRUV FileInputStream f1=new FileInputStream(“c:/jdk1.2/bin/ex27.java”); File f=new File(“c:/jdk1.2/bin/ex27.java”); FileInputStream f1=new FileInputStream(f);
$OWKRXJKWKHILUVWFRQVWUXFWRULVSUREDEO\PRUHFRPPRQO\XVHGWKHVHFRQGDOORZVXVWRFORVHO\ H[DPLQH WKH ILOH XVLQJ WKH )LOH PHWKRGV EHIRUH ZH DWWDFK LW WR DQ LQSXW VWUHDP :KHQ D )LOH,QSXW6WUHDP LV FUHDWHG LW LV RSHQHG IRU UHDGLQJ )LOH,QSXW6WUHDP RYHUULGHV VL[ RI WKH PHWKRGVLQWKHDEVWUDFWFODVV,QSXW6WUHDP7KHPDUN DQGUHVHW PHWKRGVDUHQRWRYHUULGGHQ DQGDQ\DWWHPSWWRXVHWKHVHPHWKRGVRQD)LOH,QSXW6WUHDPZLOOJHQHUDWHDQ,2([FHSWLRQ FileOutput Stream
)LOH2XWSXW6WUHDP FUHDWHV DQ 2XWSXW6WUHDP WKDW ZH FDQ XVH WR ZULWH WR D ILOH ,WV WZR PRVW FRPPRQFRQVWUXFWRUVDUH FileOutputStream(String filePath) FileOutputStream(File fileObj) (LWKHUFDQWKURZDQ,2([FHSWLRQRUDVHFXULW\H[FHSWLRQ+HUHILOH3DWKLVWKHIXOOSDWKQDPHRI DILOHDQGILOH2EMLVD)LOHREMHFWWKDWGHVFULEHVWKHILOH&UHDWLRQRID)LOH2XWSXW6WUHDPLVQRW GHSHQGHQWRQWKHILOHDOUHDG\H[LVWLQJ)LOH2XWSXW6WUHDPZLOOFUHDWHWKHILOHEHIRUHRSHQLQJLWIRU RXWSXWZKHQZHFUHDWHWKHREMHFW,QFDVHZKHQZHWU\WRRSHQDUHDGRQO\ILOHDQ,2([FHSWLRQ ZLOO EH WKURZQ 7KH IROORZLQJ H[DPSOH LOOXVWUDWHV WKH XVDJH RI )LOH,QSXW6WUHDP DQG )LOH2XWSXW6WUHDP Example 5.8 import java.io.*; class ex28 { public static byte[] getInput() throws Exception { byte inp[]=new byte[150]; System.out.println("enter text"); System.out.println("only 150 bytes ");
Comp-U-Learn
101
Java Programming I System.out.println("Press enter after each line to get input into the program "); for(int i=0;i<150;i++) inp[i]=(byte)System.in.read(); return inp; } public static void main(String args[]) throws Exception { byte input[]=getInput(); OutputStream f=new FileOutputStream("c:/jdk1.2/bin/new.txt"); for(int i=0;i<150;i++) f.write(input[i]); f.close(); int size; InputStream fi=new FileInputStream("c:/jdk1.2/bin/new.txt"); size=fi.available(); for(int i=0;i<size;i++) System.out.print((char)fi.read()); f.close(); } }
2XWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex28 enter text only 10 bytes Press enter after each line to get input into the program Serialized Serialized C:\jdk1.2\bin>
Data Input and Output Streams 7KLVFODVVFRQWDLQVDVHWRIPHWKRGVWRDFFHSWYDULRXVW\SHVRIGDWD6RPHRIWKHPDUH Int readInt throws IOException Char readChar throws IOException $ VHW RI PHWKRGV H[LVWV LQ WKLV FODVV WR ZULWH WKH GDWD WR WKH RXWSXW VRXUFH 6RPH RI WKH PHWKRGVDUH void writeBytes(String s) void writeInt(int k) void writeChar(char c) $OO WKHVH PHWKRGV WKURZ ,2([FHSWLRQ $Q H[DPSOH WR VKRZ 'DWD,QSXW DQG 'DWD2XWSXW VWUHDPVLVJLYHQKHUHXQGHU 102
Comp-U-Learn
Streams and File Handling
Example 5.9 import java.io.*; class ex31 { public static void main(String args[]) throws IOException { BufferedReader d=new BufferedReader (new InputStreamReader(new FileInputStream("c:/example/dummy.txt"))); DataOutputStream o=new DataOutputStream (new FileOutputStream("c:/uma/dummy1.txt")); String l; while((l=d.readLine())!= null) { String a=l.toUpperCase(); System.out.println(a); o.writeBytes(a+ "\r\n"); } d.close(); o.close(); } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex31 DUMMY FILE CONTENTS THIS IS USED AS TEST FILE FOR ALL EXAMPLES ROSE IS A BEAUTIFUL FLOWER TIGER IS A MAJESTIC ANIMAL BE GOOD DO GOOD
ByteArrayInputStream
%\WH$UUD\,QSXW6WUHDP LV DQ LPSOHPHQWDWLRQ RI DQ LQSXW VWUHDP WKDW XVHV D E\WH DUUD\ DV WKH VRXUFH7KLVFODVVKDVWZRFRQVWUXFWRUVHDFKRIZKLFKUHTXLUHVDE\WHDUUD\WRSURYLGHWKHGDWD VRXUFH %\WH$UUD\,QSXW6WUHDP E\WHDUUD\>@ %\WH$UUD\,QSXW6WUHDP E\WHDUUD\>@LQWVWDUWLQWQXP%\WHV +HUHDUUD\LVWKHLQSXWVRXUFH7KHVHFRQGFRQVWUXFWRUFUHDWHVDQ,QSXW6WUHDPIURPDVXEVHWRI WKHE\WHDUUD\WKDWEHJLQVZLWKWKHFKDUDFWHUDWWKHLQGH[VSHFLILHGE\VWDUWDQGLVQXP%\WHVORQJ $ %\WH$UUD\,QSXW6WUHDP LPSOHPHQWV RQH DGGLWLRQDO PHWKRG WKDW LV QRW VXSSRUWHG E\ D )LOH,QSXW6WUHDP UHVHW 7KLV PHWKRG UHVHWV WKH VWUHDP SRLQWHU WR UHIHU WR WKH VWDUW RI WKH Comp-U-Learn
103
Java Programming I
VWUHDP ZKLFK LQ WKLV FDVH LV WKH VWDUW RI WKH E\WH DUUD\ SDVVHG WR WKH FRQVWUXFWRU %\WH$UUD\2XWSXW LV DQ LPSOHPHQWDWLRQ RI DQ RXWSXW VWUHDP WKDW XVHV D E\WH DUUD\ DV WKH GHVWLQDWLRQ%\WH$UUD\2XWSXW6WUHDPKDVWZRFRQVWUXFWRUV ByteArrayOutputStream() ByteArrayOutputStream(int numBytes) ,QWKHILUVWIRUPDEXIIHURIE\WHVLVFUHDWHG,QWKHVHFRQGDEXIIHULVFUHDWHGZLWKDVL]H HTXDOWRWKDWVSHFLILHGE\QXP%\WHV7KHEXIIHUVL]HZLOOEHLQFUHDVHGDXWRPDWLFDOO\LIQHHGHG 7KHIROORZLQJH[DPSOHDFFHSWVVSHFLILHGQXPEHURIFKDUDFWHUVDVLQSXWDQGFRQYHUWVWKHPLQWR XSSHUFDVHFKDUDFWHUV Example 5.10 import java.io.*; class ex29 { public static void main(String args[]) throws Exception { ByteArrayOutputStream f=new ByteArrayOutputStream(12); System.out.println("enter 10 chars and then press enter key"); System.out.println("these will be converted into uppercase characters "); while(f.size()!=10) { f.write(System.in.read()); } System.out.println("accepted characters into an array"); byte b[]=f.toByteArray(); System.out.println("displaying characters in the array"); for(int i=0;i
104
Comp-U-Learn
Streams and File Handling
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex29 enter 10 chars and then press enter key these will be converted into uppercase characters Acrobatics accepted characters into an array displaying characters in the array A c r o b a t i c s Converted to upper case characters ACROBATICS
StringBufferInputStream
6WULQJ%XIIHU,QSXW6WUHDPLVVLPLODUWR%\WH$UUD\,QSXW6WUHDPH[FHSWWKDWWKHLQWHUQDOEXIIHULVD 6WULQJ LQVWHDG RI D E\WH DUUD\ DQG WKHUH LV QR FRUUHVSRQGLQJ RXWSXW FODVV ,W KDV RQO\ RQH FRQVWUXFWRU StringBufferInputStream(String str)
,QWKLVFRQVWUXFWRUVWULVWKH6WULQJREMHFWXVHGDVWKHLQSXWVRXUFH
Filtered Streams )LOWHUHG VWUHDPV DUH VLPSO\ ZUDSSHUV DURXQG XQGHUO\LQJ LQSXW RU RXWSXW VWUHDPV WKDW WUDQVSDUHQWO\SURYLGHVRPHH[WHQGHGOHYHORIIXQFWLRQDOLW\7KHVHVWUHDPVDUHW\SLFDOO\DFFHVVHG E\PHWKRGVWKDW DUHH[SHFWLQJDJHQHULFVWUHDPZKLFKLVDVXSHUFODVVRIWKHILOWHUHGVWUHDPV 7\SLFDOH[WHQVLRQVDUHEXIIHULQJFKDUDFWHUWUDQVODWLRQDQGUDZGDWDWUDQVODWLRQ 7KHVH ILOWHUHG VWUHDPV KDYH WKH DGGLWLRQDO IXQFWLRQ RI SURYLGLQJ V\QFKURQL]DWLRQ $OO RI WKH FRQVWUXFWRUV DQG PHWKRGV SURYLGHG LQ WKHVH FODVVHV DUH LGHQWLFDO WR ,QSXW6WUHDP DQG 2XWSXW6WUHDPH[FHSWWKDWWKH\DUHV\QFKURQL]HG
Comp-U-Learn
105
Java Programming I
Buffered Streams %XIIHUHG VWUHDPV H[WHQG WKH ILOWHUHG VWUHDP FODVVHV E\ DWWDFKLQJ D PHPRU\ EXIIHU WR WKH ,2 VWUHDPV 7KLV EXIIHU DOORZV -DYD WR GR ,2 RSHUDWLRQV RQ PRUH WKDQ D E\WH DW D WLPH KHQFH LQFUHDVLQJSHUIRUPDQFH%HFDXVHWKHEXIIHULVDYDLODEOHVNLSSLQJPDUNLQJDQGUHVHWWLQJRIWKH VWUHDPEHFRPHVSRVVLEOH BufferedInputStream
%XIIHULQJ ,2 LV D YHU\ FRPPRQ SHUIRUPDQFH RSWLPL]DWLRQ -DYD·V %XIIHUHG,QSXW6WUHDP FODVV DOORZV XV WR ZUDS DQ\ ,QSXW6WUHDP LQWR D EXIIHUHG VWUHDP DQG DFKLHYH WKLV SHUIRUPDQFH LPSURYHPHQW %XIIHULQJ DQ LQSXW VWUHDP DOVR SURYLGHV WKH IRXQGDWLRQ UHTXLUHG WR VXSSRUW PRYLQJ EDFNZDUG LQ WKH VWUHDP RI WKH DYDLODEOH EXIIHU 7KLV FODVV DFFHSWV LQSXW E\ XVLQJ D EXIIHUHG DUUD\ RI E\WHV WKDW DFWV DV D FDFKH DQG LW XWLOL]HV WKH PDUN DQG UHVHW PHWKRG $ FKXQNRIE\WHVIURPWKHEXIIHUHGDUUD\FDQEHFKRVHQDQGUHDG BufferedOutputStream
$%XIIHUHG2XWSXW6WUHDPLVVLPLODUWRDQ\2XWSXW6WUHDPZLWKWKHH[FHSWLRQRIDQDGGHGIOXVK PHWKRGWKDWLVXVHGWRHQVXUHWKDWGDWDEXIIHUVDUHSK\VLFDOO\ZULWWHQWRWKHDFWXDORXWSXWVWUHDP 6LQFHWKHSRLQWRID%XIIHUHG2XWSXW6WUHDPLVWRLPSURYHSHUIRUPDQFHE\UHGXFLQJWKHQXPEHU RIWLPHVWKHV\VWHPDFWXDOO\ZULWHVWKHGDWDZHPD\QHHGWRFDOOIOXVK WRFDXVHDQ\GDWDWKDWLV LQ WKH EXIIHU WR EH ZULWWHQ 8QOLNH %XIIHUHG,QSXW6WUHDP EXIIHUHG RXWSXW GRHVQ·W SURYLGH DQ\ DGGLWLRQDOIXQFWLRQDOLW\%XIIHUVIRURXWSXWLQ-DYDDUHPHDQWWRLQFUHDVHWKHSHUIRUPDQFH
Pushback Input Stream 3XVKEDFN LV XVHG RQ DQ LQSXW VWUHDP WR DOORZ D FKDUDFWHU WR EH UHDG DQG WKHQ UHWXUQHG LH SXVKHGEDFN WRWKHVWUHDP7KH3XVKEDFN,QSXW6WUHDPFODVVLPSOHPHQWVWKLVLGHD,WSURYLGHVD PHFKDQLVPWRSHHNDWZKDWLVFRPLQJIURPDQLQSXWVWUHDPZLWKRXWGLVUXSWLQJLW+RZHYHUDQ\ DWWHPSWWRSXVKEDFNPRUHWKDQDVLQJOHFKDUDFWHUUHVXOWVLQDQ,2([FHSWLRQEHLQJWKURZQ$Q H[DPSOHWRVKRZWKH3XVKEDFN,QSXW6WUHDPDQGXQUHDG Example 5.11 import java.io.*; class ex30 { public static void main(String args[]) throws IOException { String s="if (a== 4) a=0 \n"; byte buf[]=new byte[s.length()]; s.getBytes(0,s.length(),buf,0); ByteArrayInputStream in=new ByteArrayInputStream(buf);
106
Comp-U-Learn
Streams and File Handling PushbackInputStream f=new PushbackInputStream(in); int c; while((c=f.read()) !=-1) { switch(c) { case '=': if((c=f.read())=='=') System.out.print(".eq."); else { System.out.print("<-"); f.unread(c); } break; default: System.out.print((char)c); break; } } } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex30 if (a.eq. 4) a<-0
Stream Tokenizer
7KLVFODVVKHOSVLQLGHQWLI\LQJWKHSDWWHUQVLQWKHLQSXWVWUHDP,WLVUHVSRQVLEOHIRUEUHDNLQJXS WKH ,QSXW6WUHDP LQWR WRNHQV ZKLFK DUH GHOLPLWHG E\ D VHW RI FKDUDFWHUV 7KH EHVW XVH RI WKLV FODVVLVWRLGHQWLI\WKHQXPEHURIZRUGVRUOLQHVZLWKLQDILOH
Random Access File 5DQGRP$FFHVV)LOH HQFDSVXODWHV D UDQGRP DFFHVV ILOH ,W LV QRW GHULYHG IURP ,QSXW6WUHDP RU 2XWSXW6WUHDP,QVWHDGLWLPSOHPHQWVWKHLQWHUIDFH'DWD,QSXWDQG'DWD2XWSXWZKLFKGHILQHV WKHEDVLF,2PHWKRGV,WDOVRVXSSRUWVSRVLWLRQLQJUHTXHVWVLHZHFDQSRVLWLRQWKHILOHSRLQWHU ZLWKLQWKHILOH,WKDVWKHIROORZLQJFRQVWUXFWRUV RandomAccessFile(File fObj, string acc) RandomAccessFile(String fname, String acc)
,Q WKH ILUVW IRUP I2EM VSHFLILHV WKH QDPH RI WKH ILOH WR RSHQ DV D )LOH REMHFW ,Q WKH VHFRQG PHWKRGWKHQDPHRIWKHILOHLVSDVVHGDVIQDPH,QERWKWKHFDVHVDFFGHWHUPLQHVZKDWW\SHRI Comp-U-Learn
107
Java Programming I
ILOH DFFHVV LV SHUPLWWHG ,I LW LV ¶U· WKHQ WKH ILOH KDV UHDG DFFHVV DQG LI LW LV ¶UZ· WKHQ WKH ILOH LV RSHQHG LQ UHDGZULWH PRGH 7KH PHWKRG VHHN LV XVHG WR VHW WKH FXUUHQW SRVLWLRQ RI WKH ILOH SRLQWHUZLWKLQWKHILOH void seek(long newPos)
+HUHQHZSRVVSHFLILHVWKHQHZSRVLWLRQLQE\WHVRUWKHILOHSRLQWHUIURPWKHEHJLQQLQJRUHQG RIWKHILOH$IWHUDFDOOWRWKHVHHNPHWKRGWKHQH[WUHDGRUZULWHRSHUDWLRQVZLOORFFXUDWWKH QHZILOHSRVLWLRQ
Reader and Writer Classes 7KH GLIIHUHQFH EHWZHHQ 5HDGHUV DQG ,QSXW6WUHDPV LV WKDW ZKLOH UHDGHUV DUH DEOH WR UHDG FKDUDFWHUVLQSXWVWUHDPVUHDGE\WHV7KLVLQFUHDVHVWKHSRZHURIWKH-DYD,26WUHDPFODVVHVE\ EHLQJ DEOH WR UHDG DQ\ FKDUDFWHUV DQG WKXV HQDEOLQJ LQWHUQDWLRQDOL]DWLRQ ,Q VLPSOH WHUPV LW LV SRVVLEOH WR ZULWH -DYD SURJUDPV LQ ODQJXDJHV OLNH *HUPDQ -DSDQHVH DQG )UHQFK 7KH IXQFWLRQDOLW\RIWKHZULWHULVVLPLODUWR2XWSXW6WUHDPVDQGLWLVSRVVLEOHWRZULWHRQHEORFN RI E\WHVRUFKDUDFWHUV Reader
7KHIROORZLQJVHFWLRQGHDOVZLWKDIHZVXEFODVVHVRI5HDGHU6RPHRIWKHVXEFODVVHVRI5HDGHU &ODVVDUH 1. FileReader
7KLVFODVVLVVLPLODUWR)LOH,QSXW6WUHDP&ODVV 2. CharArray Reader and StringReader
7KHVH FODVVHV DUH VLPLODU WR %\WH$UUD\,QSXW6WUHDP DQG 6WULQJ%XIIHU,QSXW6WUHDP FODVVHV 7KHLU FRQVWUXFWRUVDUHJLYHQEHORZ public CharArrayReader(char ch[]); public StringReader(String s);
3. InputStreamReader
7KLVFODVVZDVGHVLJQHGIURPE\WHRULHQWHGVLWXDWLRQVWRFKDUDFWHURULHQWHGVLWXDWLRQV,WUHDGV E\WHV IURP DQ ,QSXW6WUHDP5HDGHU DQG FRQYHUWV WKHP WR FKDUDFWHUV DFFRUGLQJ WR D PDSSLQJ DOJRULWKP 7KH GHIDXOW PDSSLQJ LGHQWLILHV E\WHV DV FRPPRQ $6&,, FKDUDFWHUV DQG FRQYHUWV WKHPWR-DYD81,&2'(FKDUDFWHUV
108
Comp-U-Learn
Streams and File Handling 4. BufferedReader Class
7KLVFODVVDFFHSWVDUHDGHUREMHFWDVLWVSDUDPHWHUDQGDGGVDEXIIHURIFKDUDFWHUVWRLW7KLVFODVV LVPDLQO\XVHIXOEHFDXVHRILWVUHDG/LQH Writer class
$IHZRIWKHVXEFODVVHVRI:ULWHUFODVVDUH
)LOH:ULWHU
&KDU$UUD\:ULWHU
3ULQW:ULWHU
)LOWHU:ULWHU
%XIIHUHG:ULWHU
$QH[DPSOHWRVKRZ5HDGHUDQG:ULWHUFODVVHV Example 5.12 import java.io.*; public class ex50 { public static void main(String args[]) { try { BufferedReader in = new BufferedReader(new FileReader(args[0])); String s,s1 = new String(); while ((s=in.readLine())!=null) s1+=s+'\n'; in.close(); BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in)); System.out.println("Enter a Line"); System.out.println("Usage of buffered reader and InputStreamReader"); System.out.println(stdin.readLine()); StringReader intwo = new StringReader(s1); int c; System.out.println("Printing individual chars of a file " + args[0]); while ((c=intwo.read())!=-1) System.out.println((char)c); BufferedReader in4 = new BufferedReader(new StringReader(s1)); PrintWriter p = new PrintWriter (new BufferedWriter(new FileWriter("str1")));
Comp-U-Learn
109
Java Programming I while((s=in4.readLine())!=null) p.println("Output "+s); p.close(); } catch(IOException e) { } } }
2XWSXWRIWKHSURJUDP C:\jdk1.1.5\bin>java ex50 ex41.java Enter a Line Usage of buffered reader and InputStreamReader india is my country // The contents of the file ex41.java will be displayed character by character, also the contents of the file will be stored in “str1”.
Summary The Streaming interface in Java provides a clean abstraction for a complex and often cumbersome task. The composition of the filtered stream classes allow us to dynamically build the custom streaming interface to suit our data transfer requirements. Streams are a method of receiving and sending information. The InputStream, OutputStream, DataStreams, PrintStream, RandomAccessFile Streams, BufferedInputStream and BufferedOutputStream are some of the important File Stream classes in Java. Java programs written to adhere to the abstract, high level InputStream and OutputStream classes will function properly in the future even when new and improved concrete stream classes are invented.
Going Over It Again I. Fill in the Blanks
BBBBBBBBBBBBBDQGBBBBBBBBKHOSLQUHDGLQJDQGZULWLQJGDWDIURPDFWXDOGLVNILOHV BBBBBBBBBBBDQGBBBBBBBBBBPDNHXVHRIWKHE\WHDUUD\DVDQLQSXWVRXUFHWRSHUIRUP UHDGLQJDQGZULWLQJRSHUDWLRQVRQWKDWDUUD\ BBBBBBBBKHOSVWREUHDNWKH,QSXW6WUHDPLQWRWRNHQV
110
Comp-U-Learn
Streams and File Handling
BBBBBBBLVXVHGWRILOWHUILOHVZLWKDVSHFLILHGSDWWHUQDQGWKHQOLVWWKHP BBBBBBBBBPHWKRGKHOSVLQFOHDULQJWKHEXIIHU BBBBBBBBBPHWKRGLQ-DYDLVXVHGWRFUHDWH'LUHFWRULHV BBBBBBBBBH[FHSWLRQLVUDLVHGLQ,QSXWDQG2XWSXW6WUHDPV II. State True or False
7KH5HDGHUDQGZULWHUFODVVHVDUHXVHGWRUHDGDQGZULWHFKDUDFWHUVLQVWHDGRIE\WHV )LOH2XWSXW6WUHDPGRHVQRWDOORZDSSHQGLQJGDWDWRDQH[LVWLQJILOH 5HDGLQJRUZULWLQJFDQEHGRQHHYHQDIWHUFORVLQJWKHLQSXWRXWSXWVRXUFH 7KHDFFHSW PHWKRGLVDYDLODEOHLQ)LOHFODVV ,Q-DYDGLUHFWRULHVDUHQRWILOHV III. One line Answers
:KDWLVD6WUHDP" :ULWHVKRUWQRWHVRQ%XIIHUHG6WUHDPV :ULWHWKHXVDJHRIDFFHSW DQGOLVW 'HILQHD3ULQW6WUHDP :KDWDUH)LOWHUHG6WUHDPV"
Comp-U-Learn
111
Session 6
Exception Handling and MultiThreading
On Completion of this Session We will be able to understand...
) Concepts of errors ) Need To handle errors ) Error Handling in Java ) Uncaught exceptions ) Usage of try, catch, finally and throw blocks ) The Throwable Class ) About Multithreading
In This Session...
Exception Handling – An Insight
Advantages of Exception Handling
Uncaught Exceptions
Multiple Catch Clauses
Implicit and Explicit Exceptions
Java.lang.Throwable
Finally Clause
Creating Own Exception subclasses
MultiThreading
Thread States
Thread Priority
Daemon Threads
Exception Handling and MultiThreading
Exception Handling – An Insight (UURUV DOZD\V RFFXU DQG LW LV LPSRUWDQW WR SURYLGH PHDQV WR KDQGOH WKHP (UURU KDQGOLQJ EHFRPHV D QHFHVVLW\ ZKLOH GHYHORSLQJ DSSOLFDWLRQV WR DFFRXQW IRU XQH[SHFWHG VLWXDWLRQV OLNH UXQQLQJRXWRIPHPRU\UHVRXUFHDOORFDWLRQHUURUVRULQDELOLW\WRILQGILOHV6WDWLVWLFVUHYHDOWKDW DVDUHVXOWRIHUURUKDQGOLQJWKHVL]HRIDSURJUDPLQFUHDVHVRQDQDYHUDJHE\PRUHWKDQ 7RPDLQWDLQD EDODQFHEHWZHHQ HUURU KDQGOLQJDQGWKHVL]H RIWKHVRXUFHFRGH-DYD RIIHUV DQ ([FHSWLRQ FODVV ZKLFK ZKHQ MXGLFLRXVO\ LPSOHPHQWHG LQ SURJUDPV ZRXOG WDNH FDUH RI WKH XQH[SHFWHGVLWXDWLRQV %DVLFDOO\WKHUHDUHWZRNLQGVRIHUURUV7KH\DUH &RPSLOHWLPHHUURUV7KHHUURUVWKDWRFFXUGXULQJFRPSLODWLRQRIDSURJUDP 5XQWLPHHUURUV²7KHHUURUVWKDWRFFXUGXULQJH[HFXWLRQ Sources of Errors User Input Errors
7KHVHDUHW\SLQJHUURUVV\QWD[HUURUVLQFRUUHFWRUQRQH[LVWHQW85/VHWF Device Errors
7KHVHHUURUVRFFXUZKHQWKHUHDUHSUREOHPVZLWKGHYLFHVVXFKDVSULQWHUVLPSURSHUO\FRQQHFWHG GHYLFHVSULQWHUVRXWRISDSHUVHWF Physical Limitations
7KHVHHUURUVRFFXUZLWKUHVSHFWWRWKHSK\VLFDOHQWLWLHVRUFDSDFLWLHV(J6SDFHLVQRWDYDLODEOH RQGLVNVRUPDLQPHPRU\ Code Errors
(UURUV WKDW RFFXU ZKHQ ORJLF LV ZURQJ SRSSLQJ HPSW\ VWDFN ORFDWLQJ QRQH[LVWHQW ILOHV GDWD VWUXFWXUHVHWF ,Q-DYDWKH5XQWLPHHUURUVDUHFDOOHGH[FHSWLRQVDQGWKHSURFHVVRIGHDOLQJZLWKWKHPLVFDOOHG H[FHSWLRQ KDQGOLQJ 7KH WHUP H[FHSWLRQ LV D VKRUW IRUP IRU H[FHSWLRQDO HYHQWV ,W FRXOG EH GHILQHGDVDQHYHQWWKDWRFFXUVGXULQJWKHH[HFXWLRQRIDSURJUDPWKDWGLVUXSWVWKHQRUPDOIORZ RILQVWUXFWLRQV :KHQ DQ HUURU RFFXUV LQ D -DYD PHWKRG WKH PHWKRG FUHDWHV DQ REMHFW RI W\SH ([FHSWLRQ DQG JLYHVLWWRWKHUXQWLPHV\VWHP7KH([FHSWLRQREMHFWFRQVLVWVRIWKHLQIRUPDWLRQSHUWDLQLQJWR Comp-U-Learn
115
Java Programming I
WKHH[FHSWLRQOLNHLWVW\SHDQGVWDWHRIWKHSURJUDPZKHQWKHH[FHSWLRQRFFXUUHG7KHUXQWLPH V\VWHP ORRNV RXW IRU WKH DSSURSULDWH PHWKRG WKDW ZRXOG KDQGOH WKH HUURU WKDW KDV EHHQ HQFRXQWHUHG 7KH SURFHVV RI FUHDWLQJ DQ ([FHSWLRQ REMHFW DQG KDQGOLQJ LW WR WKH UXQWLPH V\VWHPLVFDOOHGWKURZLQJDQH[FHSWLRQ7KHPHWKRGWKDWKDQGOHVWKHH[FHSWLRQWKURZQLVFDOOHG DQ H[FHSWLRQ KDQGOHU 7KH H[FHSWLRQ KDQGOHU LV XVHG WR FDWFK WKH H[FHSWLRQ WKURZQ 7KH UXQ WLPH V\VWHP VHDUFKHV IRU WKH H[FHSWLRQ KDQGOHU VWDUWLQJ IURP WKH PHWKRG ZKHUH WKH HUURU RFFXUUHG7KHVHDUFKJRHVRQWLOOWKHUXQWLPHV\VWHPILQGVDQDSSURSULDWHH[FHSWLRQKDQGOHU$ PHWKRGLVWHUPHGDQDSSURSULDWHH[FHSWLRQKDQGOHULIWKHW\SHRIWKHH[FHSWLRQFDXJKWE\WKH KDQGOHULVWKHVDPHDVWKHW\SHRIWKHH[FHSWLRQ ,I WKH DSSURSULDWH KDQGOHU LV QRW IRXQG WKHQ WKH UXQWLPH V\VWHP WHUPLQDWHV WKH DSSOLFDWLRQ 7KH H[FHSWLRQ KDQGOLQJ PHFKDQLVP WUDQVIHUV WKH FRQWURO IURP WKH HUURU RFFXUUHG WR WKH H[FHSWLRQKDQGOHUWKDWFDQGHDOZLWKWKHH[FHSWLRQV
Advantages of Exception Handling -DYDSURJUDPVKDYHWKHIROORZLQJDGYDQWDJHRYHUWUDGLWLRQDOHUURUPDQDJHPHQWWHFKQLTXHV ♦ ♦ ♦ ♦ ♦
Separating Error handling Code from Regular Code Propagating Errors Up the Call Stack Grouping Error Types and Error Differentiation Allows fixing the errors It prevents the program from automatic termination
([FHSWLRQV DUH D SDUW RI WKH LQKHULWDQFH KLHUDUFK\ DQG DUH GHULYHG IURP WKH 7KURZDEOH FODVV 7KDWLVDQH[FHSWLRQLVDQLQVWDQFHRI WKH 7KURZDEOH FODVV 7KH H[FHSWLRQ KLHUDUFK\ LV JLYHQ EHORZ Throwable
Error
Exception
IOException
Fig 6.1 116
Comp-U-Learn
RunTime Exception
Exception Handling and MultiThreading
$OOH[FHSWLRQW\SHVDUHVXEFODVVHVRIWKHEXLOWLQFODVV7KURZDEOH7KXV7KURZDEOHLVDWWKHWRS RIWKHH[FHSWLRQFODVVKLHUDUFK\,PPHGLDWHO\EHORZ7KURZDEOHDUHWZRVXEFODVVHVWKDWSDUWLWLRQ H[FHSWLRQVLQWRWZRGLVWLQFWEUDQFKHV2QHEUDQFKLVKHDGHGE\H[FHSWLRQ7KLVFODVVLVXVHGIRU H[FHSWLRQDOFRQGLWLRQVWKDWXVHUSURJUDPVVKRXOGFDWFK7KLVLVDOVRWKHFODVVWKDWZHZLOOVXE FODVVZKHQZHFUHDWHRXUFXVWRPH[FHSWLRQW\SHV7KHUHLVDQLPSRUWDQWVXEFODVVRIH[FHSWLRQ FDOOHGUXQWLPH ([FHSWLRQ([FHSWLRQVRIWKLVW\SHDUHDXWRPDWLFDOO\GHILQHGIRUWKHSURJUDPV WKDW ZH ZLOO ZULWH DQG LQFOXGH WKLQJV VXFK DV GLYLVLRQ E\ ]HUR DQG LQYDOLG DUUD\ LQGH[LQJ ([FHSWLRQVWKDWLQKHULWIURPWKLVFODVVLQFOXGH ♦ Bad cast ♦ Out of bound array access ♦ Null pointer access 7KHVHSUREOHPVDUHRXWRIZURQJSURJUDPPLQJORJLFDQGPXVWEHFRUUHFWHGE\WKHSURJUDPPHU KLPVHOI6RPHRIWKHVHH[FHSWLRQVDUH ♦ ArithmeticException ♦ NullPointerException ♦ ClassCastException ♦ ArrayIndexOutOfBoundsException
Other exceptions
7KHVHLQFOXGHH[FHSWLRQVIRUPXOWLWKUHDGLQJPDOIRUPHG85/UHDGLQJSDVWHQGRIILOHHWF6RPH RIWKHVXEFODVVHVDUH ♦ IOException ♦ AWTException ♦ ClassNotFoundException ♦ IllegalAccessException 7KH RWKHU EUDQFK LV WRSSHG E\ (UURU ZKLFK GHILQHV H[FHSWLRQV WKDW DUH QRW H[SHFWHG WR EH FDXJKWXQGHUQRUPDOFLUFXPVWDQFHVE\RXUSURJUDP([FHSWLRQVRIW\SH(UURUDUHXVHGE\WKH -DYDUXQWLPHV\VWHPWRLQGLFDWHHUURUVKDYLQJWRGRZLWKWKHUXQWLPHHQYLURQPHQWLWVHOI6WDFN RYHUIORZ LV DQ H[DPSOH RI VXFK DQ HUURU EHFDXVH WKHVH DUH W\SLFDOO\ FUHDWHG LQ UHVSRQVH WR FDWDVWURSKLFIDLOXUHVWKDWFDQQRWXVXDOO\EHKDQGOHGE\RXUSURJUDP Comp-U-Learn
117
Java Programming I
Uncaught Exceptions /RRNDWWKHSURJUDPJLYHQEHORZ,WKDVZLOOIXOO\LQFOXGHGDGLYLVLRQE\]HUR Example 6.1 class ex61 { public static void main(String args[]) { int d=0; int a=42/d; } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>javac ex61.java C:\jdk1.2\bin>java ex61 Exception in thread "main" java.lang.ArithmeticException: / by zero at ex61.main(ex61.java:6) C:\jdk1.2\bin>
:KHQ WKH -DYD UXQ WLPH V\VWHP GHWHFWV WKH DWWHPSW WR GLYLGH E\ ]HUR LW FRQVWUXFWV D QHZ H[FHSWLRQ REMHFW DQG WKHQ WKURZV WKLV H[FHSWLRQ 7KLV FDXVHV WKH H[HFXWLRQ RI H[ WR VWRS EHFDXVH RQFH DQ H[FHSWLRQ KDV EHHQ WKURZQ LW PXVW EH FDXJKW E\ DQ H[FHSWLRQ KDQGOHU DQG GHDOW ZLWK LPPHGLDWHO\ ,Q WKLV H[DPSOH ZH KDYHQ·W VXSSOLHG DQ\ H[FHSWLRQ KDQGOHUV RQ RXU RZQ VR WKH H[FHSWLRQ LV FDXJKW E\ WKH GHIDXOW KDQGOHU SURYLGHG E\ WKH -DYD UXQWLPH V\VWHP 7KH GHIDXOW KDQGOHU ZLOO XOWLPDWHO\ SURFHVV DQ\ H[FHSWLRQ WKDW LV QRW FDXJKW E\ RXU SURJUDP 7KH GHIDXOW KDQGOHU GLVSOD\V D VWULQJ GHVFULELQJ WKH H[FHSWLRQ SULQWV D VWDFN WUDFH IURP WKH SRLQWDWZKLFKWKHH[FHSWLRQRFFXUUHGDQGWHUPLQDWHVWKHSURJUDP1RWLFHKRZWKHFODVVQDPH H[WKHPHWKRGQDPHPDLQWKHILOHQDPHH[MDYDDQGWKHOLQHQXPEHUDUHDOOLQFOXGHGLQ WKHVLPSOH VWDFN WUDFH 1RWH WKDW WKH W\SH RI WKH H[FHSWLRQ WKURZQ LV D VXEFODVV RI ([FHSWLRQ FDOOHGDULWKPHWLF([FHSWLRQZKLFKPRUHVSHFLILFDOO\GHVFULEHVZKDWW\SHRIHUURUKDVRFFXUUHG -DYD H[FHSWLRQ KDQGOLQJ LV PDQDJHG YLD ILYH NH\ZRUGV WU\ FDWFK WKURZ WKURZV DQG ILQDOO\ 3URJUDPVWDWHPHQWVWKDWZHZDQWWRPRQLWRUIRUH[FHSWLRQVDUHFRQWDLQHGZLWKLQDWU\EORFN,I DQH[FHSWLRQRFFXUVZLWKLQWKHWU\EORFNLWLVWKURZQ2XUFRGHFDQFDWFKWKLVH[FHSWLRQ XVLQJ FDWFK DQG KDQGOH LW LQ VRPH UDWLRQDO PDQQHU 6\VWHP JHQHUDWHG H[FHSWLRQV DUH DXWRPDWLFDOO\ WKURZQE\WKH-DYDUXQWLPHV\VWHP7RPDQXDOO\WKURZDQH[FHSWLRQXVHWKHNH\ZRUGWKURZ $Q\H[FHSWLRQWKDWLVWKURZQRXWRIDPHWKRGPXVWEHVSHFLILHGDVVXFKE\DWKURZVFODXVH$Q\ FRGHWKDWDEVROXWHO\PXVWEHH[HFXWHGEHIRUHDPHWKRGUHWXUQVLVSXWLQDILQDOO\EORFN 118
Comp-U-Learn
Exception Handling and MultiThreading This is the general form of n exception handling try { //Block of code to monitor for errors } catch(ExceptionType1 exObj) { // exception handler for Exceptiontype 1 } catch(ExceptionType2 exObj2) { //exception handler for exception type 2 } //.......................... ........................... finally { // block of code to be executed before try block ends }
+HUHH[FHSWLRQW\SHLVWKHW\SHRIH[FHSWLRQWKDWKDVRFFXUUHG
Note We can throw many exceptions in one method, but we cannot throw exceptions inherited from Error class and those from RunTimeException $VDPSOHSURJUDPWRLOOXVWUDWHWKHXVDJHRIWKURZLQJDQH[FHSWLRQ Example 6.2 class ex62 { public static void main(String args[]) { System.out.println("enter a character "); char c=(char)System.in.read(); } }
2XWSXWRIWKHSURJUDP C:\jdk1.2\bin>javac ex62.java Ex62a.java:6: Exception java.io.IOException must be caught, or it must be declared in the throws clause of this method. char c=(char)System.in.read(); ^ 1 error
Comp-U-Learn
119
Java Programming I
1RZZHFDPUHZULWHWKHSURJUDPDVVKRZQEHORZDQGVHHWKHRXWSXW class ex62 { public static void main(String args[]) throws java.io.IOException { System.out.println("enter a character "); char c=(char)System.in.read(); } }
7KHRXWSXWRIWKHSURJUDPQRZLV C:\jdk1.2\bin>java ex62 java C:\jdk1.2\bin>java ex62 Enter a character i
1RZZHFDQUHZULWHWKHSURJUDPH[MDYDZKLFKWKURZVDQ$ULWKPHWLF([FHSWLRQ class ex61 { public static void main(String args[]) { int d,a; try { d=0; a=42/d; System.out.println("Test to see the try block } catch (ArithmeticException e) { System.out.println("Division by zero "); System.out.println("Inside catch block "); } System.out.println("After catch block "); } }
7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>javac ex61.java C:\jdk1.2\bin>java ex61 Division by zero Inside catch block After catch block C:\jdk1.2\bin>
120
Comp-U-Learn
");
Exception Handling and MultiThreading
1RWLFHWKDWWKHFDOOWRWKHSULQWOQVWDWHPHQWLQVLGHWKHWU\EORFNKDVQ·WJRWH[HFXWHG2QFH DQ H[FHSWLRQLVWKURZQSURJUDPFRQWUROWUDQVIHUVRXWRIWKHWU\EORFNWRWKHFDWFKEORFNWRKDQGOH WKHH[FHSWLRQEHLQJWKURZQRXW7KHWU\EORFNGRHVQRWFDOODFDWFKEORFNDQGKHQFHFRQWUROZLOO QRWJHWWUDQVIHUUHGWRWU\EORFNRQFHPRUHDIWHUWKHH[FHSWLRQLVEHLQJKDQGOHG+HQFHWKHOLQH 6\VWHPRXWSULQOQ ´,QVLGHWU\EORFN ZLOOQRWEHGLVSOD\HGRQWKHVFUHHQ 2QFH WKH FDWFK EORFN LV H[HFXWHG SURJUDP FRQWLQXHV ZLWK WKH QH[W OLQH LQ WKH SURJUDP IROORZLQJ WKH HQWLUH WU\FDWFK EORFNV $ WU\ DQG D FDWFK IRUP D VLQJOH XQLW 7KH VFRSH RI WKH FDWFK VWDWHPHQW LV UHVWULFWHG WR WKRVH VWDWHPHQWV VSHFLILHG E\ WKH LPPHGLDWHO\ SUHFHGLQJ WU\ VWDWHPHQW7KHJRDORIPRVWZHOOFRQVWUXFWHGFDWFKFODXVHVVKRXOGEHWRUHVROYHWKHH[FHSWLRQDO FRQGLWLRQDQGWKHQFRQWLQXHRQDVLIQRHUURUKDVRFFXUUHG
Note Curly braces must surround the statements that are protected in a try statement. That is, they must be within a block. We cannot use try on a single statement. Displaying the description of an Exception
7KURZDEOH RYHUULGHV WKH WR6WULQJ PHWKRG GHILQHG E\ 2EMHFW VR WKDW LW UHWXUQV D VWULQJ FRQWDLQLQJ D GHVFULSWLRQ RI WKH H[FHSWLRQ :H FDQ GLVSOD\ WKLV GHVFULSWLRQ LQ D SULQWOQ VWDWHPHQWE\VLPSO\SDVVLQJWKHH[FHSWLRQDVDQDUJXPHQW)RUH[DPSOHWKHFDWFKEORFNLQWKH SUHFHGLQJSURJUDPFDQEHUHZULWWHQDV catch (ArithmeticException e) { System.out.println("Division by zero "); System.out.println("Inside catch block "); System.out.println(“Exception :”+e); }
7KLVZLOOJLYHWKHRXWSXW C:\jdk1.2\bin>java ex62 Division by zero Inside catch block Exception :java.lang.ArithmeticException: / by zero After catch block C:\jdk1.2\bin>
Comp-U-Learn
121
Java Programming I
Multiple Catch Clauses 0RUH WKDQ RQH H[FHSWLRQ FRXOG EH UDLVHG E\ D VLQJOH SLHFH RI FRGH 7R KDQGOH WKLV W\SH RI VLWXDWLRQZHFDQVSHFLI\WZRRUPRUHFDWFKFODXVHVHDFKFDWFKLQJDGLIIHUHQWW\SHRIH[FHSWLRQ :KHQDQH[FHSWLRQLVWKURZQHDFKFDWFKVWDWHPHQWLVLQVSHFWHGLQRUGHUDQGWKHILUVWRQHZKRVH W\SHPDWFKHVWKDWRIWKHH[FHSWLRQH[HFXWHG$IWHURQHFDWFKVWDWHPHQWH[HFXWHVWKHRWKHUVDUH E\SDVVHGDQGH[HFXWLRQFRQWLQXHVDIWHUWKHWU\FDWFKEORFN7KHIROORZLQJH[DPSOHWUDSVWZR GLIIHUHQWH[FHSWLRQW\SHV Example 6.3 class ex63 { public static void main(String args[]) { try{ int a=args.length; System.out.println("a = " +a); int b=42/a; int c[]= {1}; c[42]=99; System.out.println("Test to see the try } catch (ArithmeticException e) { System.out.println("Division by zero " } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index :" + e } System.out.println("After try and catch } }
block
");
+ e);
); block ");
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex63 a = 0 Division by zero java.lang.ArithmeticException: / by zero After try and catch block C:\jdk1.2\bin>java ex63 neem a = 1
:KHQZHXVHPXOWLSOHFDWFKVWDWHPHQWVLWLVLPSRUWDQWWRUHPHPEHUWKDWH[FHSWLRQVXEFODVVHV PXVW FRPH EHIRUH DQ\ RI WKHLU VXSHU FODVVHV 7KLV LV EHFDXVH D FDWFK VWDWHPHQW WKDW XVHV D VXSHUFODVVZLOOFDWFKH[FHSWLRQVRIWKDWW\SHSOXVDQ\RILWVVXEFODVVHV7KXVDVXEFODVVZRXOG QHYHU EH UHDFKHG LI LW FDPH DIWHU LWV VXSHUFODVV )XUWKHU LQ -DYD XQUHDFKDEOH FRGH LV DQ HUURU 7KHIROORZLQJFRGHZLOOLOOXVWUDWHWKLV 122
Comp-U-Learn
Exception Handling and MultiThreading
Example 6.4 class ex64 { public static void main(String args[]) { int d,a; try{ d=0; a=42/d; System.out.println("Test to see the try block "); } catch(Exception e) { System.out.println("General exception raised in catch " +e); } catch (ArithmeticException e) { System.out.println("Division by zero "); System.out.println("Inside catch block "); System.out.println("Exception :"+e); } System.out.println("After catch block "); } }
7KHRXWSXWRIWKHDERYHSURJUDPLVDVIROORZV C:\jdk1.2\bin>javac ex64.java Ex64.java:15: catch not reached. catch (ArithmeticException e) ^ 1 error C:\jdk1.2\bin>
Implicit and Explicit Exceptions $Q\ H[FHSWLRQ GHULYHG IURP (UURU FODVV RU 5XQ7LPH([FHSWLRQ DUH FDOOHG LPSOLFLW H[FHSWLRQV 7KHVH H[FHSWLRQV DUH EH\RQG RXU FRQWURO RU VKRXOG QRW KDYH RFFXUUHG LQ WKH ILUVW SODFH $OO RWKHU H[FHSWLRQV DUH H[SOLFLW H[FHSWLRQV $ PHWKRG PXVW GHFODUH DOO WKH H[SOLFLW H[FHSWLRQV LW WKURZV,IZHRYHUULGHDPHWKRGIURPDSDUHQWFODVVWKHFKLOGFODVVLQKHULWVWKHSDUHQWPHWKRG XQGHUVWDQGDEO\ EXW WKH FKLOG FDQQRW PDQXDOO\ IRUFH DQ H[FHSWLRQ XVLQJ WKURZ ,I WKH SDUHQW FODVVWKURZVQRH[SOLFLWH[FHSWLRQVDWDOOZHVKRXOGIROORZWKHVHVWHSVWRWKURZDQH[FHSWLRQ Comp-U-Learn
123
Java Programming I
)LQGWKHDSSURSULDWHH[FHSWLRQFODVV
00DNHDQREMHFWRIWKDWFODVV
7KURZWKDWREMHFW
Note We can create our Exception classes when the standard exceptions don’t meet our requirements.
Java.lang.Throwable public Throwable()
7KLVFRQVWUXFWVDQHZ7KURZDEOHREMHFWZLWKRXWDQ\REMHFW public Throwable(String message)
7KLV FRQVWUXFWV D QHZ 7KURZDEOH REMHFW ZLWK WKH PHVVDJH JLYHQ ,W FDQ EH XVHG WR SURYLGH LQIRUPDWLRQ IRU GHEXJJLQJ $OO GHULYHG H[FHSWLRQ FODVVHV VXSSRUW ERWK D GHIDXOW FRQVWUXFWRU ZLWKDGHWDLOHGPHVVDJH public String getMessage()
7KLVPHWKRGREWDLQVWKHGHWDLOHGPHVVDJHRIWKH7KURZDEOHREMHFW 7KHWU\VWDWHPHQWFDQEHQHVWHG7KDWLVDWU\VWDWHPHQWFDQEHLQVLGHWKHEORFNRIDQRWKHUWU\ (DFKWLPHDWU\VWDWHPHQWLVHQWHUHGWKHFRQWH[WRIWKDWH[FHSWLRQLVSXVKHGRQWKHVWDFN,IDQ LQQHU WU\ VWDWHPHQW GRHV QRW KDYH D FDWFK KDQGOHU IRU D SDUWLFXODU H[FHSWLRQ WKH VWDFN LV XQZRXQGDQGWKHQH[WWU\VWDWHPHQW·VFDWFKKDQGOHUVDUHLQVSHFWHGIRUDPDWFK7KLVFRQWLQXHV XQWLORQHRIWKHFDWFKVWDWHPHQWVXFFHHGVRUXQWLODOORIWKHQHVWHGWU\VWDWHPHQWVDUHH[KDXVWHG ,IQRFDWFKVWDWHPHQWPDWFKHVWKHQWKH-DYDUXQWLPHV\VWHPKDQGOHVWKHH[FHSWLRQ+HUHLVDQ H[DPSOHWRVKRZWKHQHVWHGWU\VWDWHPHQWV Example 6.5 class ex65 { public static void main(String args[]) { try { int a=args.length; int b=42/a; System.out.println("a = " + a);
124
Comp-U-Learn
Exception Handling and MultiThreading try{ if (a==1) a=a/(a-a); if (a==2) { int c[]={1}; c[42]=99; } } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index out of bounds : " +e); } }catch(ArithmeticException e) { System.out.println("Divide by 0 : " +e); } } }
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex65 Divide by 0 : java.lang.ArithmeticException: / by zero C:\jdk1.2\bin>java ex65 Uma a = 1 Divide by 0 : java.lang.ArithmeticException: / by zero C:\jdk1.2\bin>java ex65 Uma Uma2 a = 2 Array index out of bounds : java.lang.ArrayIndexOutOfBoundsException: 42 C:\jdk1.2\bin>
Throw
:KHQZHZDQWWRWKURZDQH[FHSWLRQH[SOLFLWO\ZHKDYHWRXVHDWKURZVWDWHPHQW7KHJHQHUDO IRUPRIWKURZLVVKRZQKHUH throw ThrowableInstance;
+HUH 7KURZDEOH,QVWDQFH PXVW EH DQ REMHFW RI W\SH 7KURZDEOH RU D VXEFODVV RI 7KURZDEOH 6LPSOHW\SHVVXFKDV LQW RU FKDU DV ZHOO DV QRQWKURZDEOH FODVVHV VXFK DV 6WULQJ DQG REMHFW FDQQRWEHXVHGDVH[FHSWLRQV 7KHUH DUH WZR ZD\V ZH FDQ REWDLQ D 7KURZDEOH REMHFW XVLQJ D SDUDPHWHULQWRDFDWFKFODXVHRUFUHDWLQJRQHZLWKWKHQHZRSHUDWRU 7KHIORZRIH[HFXWLRQVWRSVLPPHGLDWHO\DIWHUWKHWKURZVWDWHPHQW DQ\VXEVHTXHQWVWDWHPHQWV DUHQRWH[HFXWHG7KHQHDUHVWHQFORVLQJWU\EORFNLVLQVSHFWHGWRVHHLILWKDVDFDWFKVWDWHPHQW Comp-U-Learn
125
Java Programming I
WKDW PDWFKHV WKH W\SH RI WKH H[FHSWLRQ ,I LW ILQGV D PDWFK FRQWURO LV WUDQVIHUUHG WR WKDW VWDWHPHQW,IQRWWKHQWKHQH[WHQFORVLQJWU\VWDWHPHQWLVLQVSHFWHGDQGVRRQ,IQRPDWFKLQJLV IRXQGWKHQWKHGHIDXOWH[FHSWLRQKDQGOHUKDOWVWKHSURJUDPDQGSULQWVWKHVWDFNWUDFH 7KHVDPSOHSURJUDPLVJLYHQEHORZ Example 6.6 class ex66 { static void FnA() { try { throw new NullPointerException("demo"); }catch(NullPointerException e) { System.out.println("Caught inside the Function A"); throw e; } } public static void main(String args[]) { try { FnA(); }catch(NullPointerException e) { System.out.println(" Recaught: "+e); } } } The output of the program will be as follows C:\jdk1.2\bin>javac ex66.java C:\jdk1.2\bin>java ex66 Caught inside the Function A Recaught: java.lang.NullPointerException: demo C:\jdk1.2\bin>
Throws
,I D PHWKRG LV FDSDEOH RI FDXVLQJ DQ H[FHSWLRQ WKDW LW GRHV QRW KDQGOH LW PXVW VSHFLI\ WKLV EHKDYLRUVRWKDWFDOOHURIWKHPHWKRGFDQJXDUGKLPVHOIDJDLQVWWKDWH[FHSWLRQ7KLVLVGRQHE\ GHFODULQJ D WKURZV FODXVH LQ WKH PHWKRG·V GHFODUDWLRQ $ WKURZV FODXVH OLVWV WKH W\SHV RI 126
Comp-U-Learn
Exception Handling and MultiThreading
H[FHSWLRQVWKDWDPHWKRGPLJKWWKURZ7KLVLVQHFHVVDU\IRUDOOH[FHSWLRQVH[FHSWWKRVHRIW\SH (UURURU5XQWLPH([FHSWLRQRUDQ\RIWKHLUVXEFODVVHV$OORWKHUH[FHSWLRQVWKDWDPHWKRGFDQ WKURZPXVWEHGHFODUHGLQWKHWKURZVFODXVH,IDUHQRWDFRPSLOHWLPHHUURUZLOOUHVXOW 7KH IROORZLQJ H[DPSOH LOOXVWUDWHV WKLV +HUH WKH SURJUDP ZLOO QRW FRPSLOH EHFDXVH WKH WKURZV FODXVHLVQRWVSHFLILHG Example 6.7 class ex67 { static void demo() { System.out.println("inside the function demo"); throw new IllegalAccessException("demo"); } public static void main(String args[]) { demo(); } }
7KHSURJUDPSURGXFHVDFRPSLODWLRQHUURUOLNHWKLV C:\jdk1.2\bin>javac ex67.java Ex67.java:6: Exception java.lang.IllegalAccessException must be caught, or it must be declared in the throws clause of this method. throw new IllegalAccessException("demo"); ^ 1 error C:\jdk1.2\bin>
7KLVSURJUDPFRXOGEHFRUUHFWHGE\DGGLQJWKHFRGHLQPDLQIXQFWLRQDQGE\DGGLQJWKURZVLQ WKHGHPRIXQFWLRQ class ex67 { static void demo() throws IllegalAccessException { System.out.println("inside the function demo"); throw new IllegalAccessException("demo"); } public static void main(String args[]) { try{ demo(); }catch(IllegalAccessException e) {
Comp-U-Learn
127
Java Programming I System.out.println("Caught" +e); } } }
7KHRXWSXWRIWKHSURJUDPLVDVIROORZV C:\jdk1.2\bin>javac ex67.java C:\jdk1.2\bin>java ex67 inside the function demo Caughtjava.lang.IllegalAccessException: demo C:\jdk1.2\bin
Finally Clause )LQDOO\ FUHDWHV D EORFN RI FRGH WKDW ZLOO EH H[HFXWHG DIWHU D WU\FDWFK EORFN LV FRPSOHWHG DQG EHIRUHWKHFRGHIROORZLQJWKHWU\FDWFKEORFN7KHILQDOO\EORFNZLOOH[HFXWHZKHWKHURUQRWDQ H[HFXWLRQLVWKURZQ,IDQH[HFXWLRQLVWKURZQWKHILQDOO\EORFNZLOOH[HFXWHHYHQLIQRFDWFK VWDWHPHQWPDWFKHVWKHH[FHSWLRQ7KHILQDOO\EORFNZLOOEHH[HFXWHGXQGHUDOOFLUFXPVWDQFHV $FWXDOO\WKHWU\EORFNH[HFXWHVILUVW ♦ If no exception, then finally block executes and then executes the first line after the try block ♦ If an exception occurs, then the catch block executes and then the code in the finally block executes. ,QFDVHWKHUHLVDQH[FHSWLRQEXWWKHUHLVQRPDWFKLQJFDWFKVWDWHPHQWWKHQWKHFRGHH[HFXWLRQ VNLSVUHVWRIWKHFRGHDQGH[HFXWHVWKHILQDOO\EORFN7KLVH[HFXWLRQLVWKURZQEDFNWRWKHFDOOHU RIWKHPHWKRG Guidelines to exceptions
128
8VHH[FHSWLRQVIRUH[FHSWLRQDOFLUFXPVWDQFHVRQO\
$OZD\VSUHIHUWRXVHVLPSOHWHVWVLQSODFHRIH[FHSWLRQKDQGOLQJ
'RQRWKDYHWRRPDQ\WU\FDWFKRSHUDWLRQV
6HSDUDWHQRUPDOSURFHVVLQJIURPHUURUKDQGOLQJ
'RQRWLJQRUHDYRLGH[FHSWLRQVEXWKDQGOHWKHPFRUUHFWO\ Comp-U-Learn
Exception Handling and MultiThreading
Creating Own Exception Subclasses 7KH([FHSWLRQFODVVGRHVQRWGHILQHDQ\PHWKRGVRILWVRZQ,WLQKHULWVWKRVHPHWKRGVSURYLGHG E\ 7KURZDEOH &XVWRPL]HG H[FHSWLRQV DUH QHFHVVDU\ WR KDQGOH DEQRUPDO FRQGLWLRQV RI DSSOLFDWLRQV FUHDWHG E\ WKH XVHU 7KH DGYDQWDJH RI FUHDWLQJ VXFK DQ H[FHSWLRQ FODVV LV WKDW DFFRUGLQJWRVLWXDWLRQVGHILQHGE\WKHXVHUDQH[FHSWLRQFDQEHWKURZQ,WLVDOVRSRVVLEOHWRVHW DQ\ FRQGLWLRQ RU YDOXH WR D YDULDEOH DQG JHQHUDWH XVHUGHILQHG H[FHSWLRQ )RU H[DPSOH LW LV SRVVLEOH WR FKHFN LI WKH LQSXW LV JUHDWHU WKDQ HTXDO WR RU OHVV WKDQ D SUHGHILQHG QXPEHU DQG DFFRUGLQJO\JHQHUDWHH[FHSWLRQV7KHIROORZLQJSURJUDPLOOXVWUDWHVWKLV Example 6.8 class except extends Exception { private int detail; except(int a) { detail=a; } public String toString() { return "My Exception [" + detail + "] "; } } class ex68 { static void compute(int a) throws except { System.out.println("Called compute(" + a + ")"); if(a>10) throw new except(a); System.out.println("Normal exit"); } public static void main(String args[]) { try{ compute(1); compute(20); } catch(except e) { System.out.println("caught " + e); } } }
Comp-U-Learn
129
Java Programming I
7KLVH[DPSOHGHILQHVDVXEFODVVRI([FHSWLRQFDOOHGH[FHSW7KLVVXEFODVVLVTXLWHVLPSOH LWKDV RQO\DFRQVWUXFWRUSOXVDQRYHUORDGHGWR6WULQJ PHWKRGWKDWGLVSOD\VWKHYDOXHRIWKHH[FHSWLRQ 7KH FODVV H[MDYD GHILQHV D PHWKRG QDPHG FRPSXWH WKDW WKURZV DQ H[FHSW REMHFW 7KH H[FHSWLRQLVWKURZQZKHQFRPSXWH ·VLQWHJHUSDUDPHWHULVJUHDWHUWKDQ7KHPDLQPHWKRG VHWVXSDQH[FHSWLRQKDQGOHUIRUH[FHSWWKHQFDOOVWKHFRPSXWH ZLWKDOHJDOYDOXH OHVVWKDQ DQGDQLOOHJDORQHWRVKRZERWKSDWKVWKURXJKWKHFRGH+HUHLVWKHUHVXOW 7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>java ex68 Called compute(1) Normal exit Called compute(20) caught My Exception [20] C:\jdk1.2\bin>
$QRWKHU([DPSOHWRVKRZWKHZRUNLQJRIXVHUFUHDWHGH[FHSWLRQV Example 6.9 class ex69 { static void FnA() { try{ System.out.println("inside function A"); throw new RuntimeException("demo"); }finally{ System.out.println(" Proc A finally method"); } } static void FnB() { try{ System.out.println("inside function B"); return; }finally{ System.out.println(" Proc B finally method"); } } static void FnC() { try{ System.out.println("inside function C"); }finally{ System.out.println(" Proc C finally method");
130
Comp-U-Learn
Exception Handling and MultiThreading } } public static void main(String args[]) { try{ FnA(); }catch(Exception e) { System.out.println("Execution Caught "); } FnB(); FnC(); } }
7KHRXWSXWRIWKHSURJUDP C:\jdk1.2\bin>javac ex69.java C:\jdk1.2\bin>java ex69 inside function A Proc A finally method Execution Caught inside function B Proc B finally method inside function C Proc C finally method C:\jdk1.2\bin>
Quick View of Exceptions and their meanings
Exception ArithmeticException ArrayIndexOutOfBoundsException ArrayStoreException ClassCastException IllegalArgumentException IllegalMonitorStateExceptionIllegal IllegalThreadStateException IndexOutOfBoundsException NegativeArraySizeException
Meaning Arithmetic error such as divide by zero. Array index is out of bounds Assignment to an array element of an incompatible type Invalid cast Illegal argument used to invoke a method. monitor operation, such as waiting on an unlocked thread Requested operation not compatible with current thread state Some type of index is out-of bounds. Array created with a negative size
Comp-U-Learn
131
Java Programming I
Exception NullPointerException NumberFormatException
Meaning Invalid use of a null reference. Invalid conversion of a string to a numeric format
Exception
Meaning
SecurityException ClassNotfoundException CloneNotSupportedException
Attempt to violate security Class not found Attempt to clone an object that does not implement the Cloneable interface Access to a class is denied Attempt to create an object of an abstract class or interface One thread has been interrupted by another thread
IllegalAccessException InstantiationException InterruptedException
MultiThreading Thread
$ WKUHDG FDQ EH GHILQHG DV D VLQJOH VHTXHQWLDO IORZ RI FRQWURO 7KUHDGV DUH DOVR NQRZQ DV H[HFXWLRQFRQWH[WVRUOLJKWZHLJKWSURFHVVHV$SURJUDPLVQRUPDOO\EURNHQLQWRVPDOOFKXQNV FDOOHG WDVNV DQG WDVNV DUH IXUWKHU EURNHQ GRZQ LQWR VPDOOHU FKXQNV FDOOHG WKUHDGV /HW XV FRQVLGHUWKHSURFHVVLQYROYHGIRUSUHSDUDWLRQRIWHD,QRUGHUWRSUHSDUHWHDVRPHVPDOOWDVNV DUHLQYROYHG7KHVHDUH
%RLOLQJWKHWHDOHDYHVLQZDWHU
%RLOLQJPLON
)LOWHULQJWKHIURPWKHWHDOLTXHXUWHDOHDYHV
3RXULQJWHDDGGLQJVXJDUDQGPLONLQDFXS
6WLUULQJWKHFRQWHQWV
(DFKRIWKHDERYHWDVNVLVUHTXLUHGWRSUHSDUHWHDDQGFRXOGEHFRQVLGHUHGDVDWKUHDG6RPHRI WKHWDVNVFRXOGEHSHUIRUPHGVLPXOWDQHRXVO\6RZHFDQVD\WKDWSUHSDULQJWHDLQYROYHVYDULRXV WKUHDGV WR EH H[HFXWHG ,Q FRPSXWHU WHUPLQRORJ\ LI PRUH WKDQ RQH WKUHDG H[HFXWHV VLPXOWDQHRXVO\ WKHQ LW LV FDOOHG PXOWLWKUHDGLQJ $ WKUHDG LV WKH VPDOOHVW XQLW RI FRGH WKDW DQ RSHUDWLQJV\VWHPFDQH[HFXWH7KUHDGVUXQZLWKLQDSURFHVV ,WLVSRVVLEOHWRZRUNLQPRUHWKDQRQHDSSOLFDWLRQVLPXOWDQHRXVO\LQZLQGRZVHQYLURQPHQW,W LVSRVVLEOHWRZRUNLQ0LFURVRIW:RUGGRLQJVRPHIRUPDWWLQJRIWKHWH[WZKLOHDWWKHVDPHWLPH IURP ,QWHUQHW ([SORUHU GRZQORDGLQJ D :HE SDJH 7KDW LV KHUH ZH DUH ZRUNLQJ LQ PRUH WKDQ 132
Comp-U-Learn
Exception Handling and MultiThreading
RQHZLQGRZFRQFXUUHQWO\RULQPRUHWKDQRQHDSSOLFDWLRQ7KLVLVVDLGWREHPXOWLWDVNLQJ/HWV VHHZKDWLVPXOWLWKUHDGLQJ1RZLWLVLPSRUWDQWWRXQGHUVWDQGZKDWLVDSURFHVV 7KHUXQQLQJLQVWDQFHRIDSURJUDPLVFDOOHGDSURFHVV,WLVDSURJUDPLQH[HFXWLRQ1RZWKH V\VWHP UHVRXUFHV DQG WKH &38 WLPH DUH DOORFDWHG WR WKH YDULRXV UXQQLQJ SURFHVVHV :KHQ WKH WLPH VOLFH LV DOORFDWHG WR D SURFHVV WKH YDULRXV WKUHDGV LQ WKH SURFHVV PDNH XVH RI WKH RI WKH DYDLODEOH &38 WLPH ,Q RWKHUV ZRUGV WKH WKUHDGV DUH WKH XOWLPDWH XQLWV WKDW XVH D &38 WLPH 7KRXJKWKH\PDNHXVHRIWKHV\VWHPUHVRXUFHVWKH\DUHQRWDOORWWHGZLWKDQ\7KHWKUHDGVLQD SURFHVV PDNH XVH RI WKH V\VWHP UHVRXUFHV DOORFDWHG WR WKDW SDUWLFXODU SURFHVV 7KH GLIIHUHQFH EHWZHHQDWKUHDGDQGDSURFHVVLVWKDWDWKUHDGFDQQRWH[LVWRQLWVRZQZKHUHDVDSURFHVVFDQ 7KUHDGV DUH ZLWKLQ D SURFHVV 3URFHVV LV DOORFDWHG ZLWK WKH V\VWHP UHVRXUFHV DQG &38 WLPH 7KUHDGV PDNH XVH RI WKHP 7KH HQG XVHU GRHV QRW H[HFXWH D WKUHDG GLUHFWO\ $ SURFHVV FDQ FRQWDLQDVLQJOHWKUHDGRUPRUH3URFHVVWKDWLVPDGHRIDVLQJOHWKUHDGLVFDOOHGVLQJOHWKUHDGHG DSSOLFDWLRQDQGDSURFHVVKDYLQJPRUHLVFDOOHGPXOWLWKUHDGHG$QH[DPSOHRIPXOWLWKUHDGLQJLV WKH DELOLW\RI,QWHUQHW([SORUHUWR GRZQORDG ILOHV GLVSOD\ D :HE3DJHV $OVR WKH FRS\LQJ ILOHV IURPRQHIROGHUWRDQRWKHULVPXOWLWKUHDGHG7KHPDLQDGYDQWDJHRIPXOWLWKUHDGLQJLVWKHVSHHG RIH[HFXWLRQRIWKHSURJUDP /HWXVXQGHUVWDQGWKLVE\DQH[DPSOH$VVXPHWKDWZHKDYHWRSHUIRUPDFDOFXODWLRQOLNH (a+b) – (b*a)
1RZLIZHKDYHPXOWLSOHWKUHDGVWKHQFDOFXODWLQJDEZLOOEHGRQHE\DWKUHDGDQGFDOFXODWLQJ E DZLOO EH GRQH E\ DQRWKHU WKUHDG +HQFH H[HFXWLRQ RI WKLV SURFHVV LV IDVWHU 0XOWLWKUHDGLQJ DOORZVXVWRZULWHHIILFLHQWSURJUDPVWKDWPDNHPD[LPXPXVHRIWKH&38EHFDXVHLGOHWLPHFDQ EHNHSWWRWKHPLQLPXP:KHQDSURJUDPUHTXLUHVXVHULQSXWPXOWLWKUHDGLQJHQDEOHFUHDWLRQRI DVHSDUDWH WKUHDG IRU WKLV WDVN DORQH 7KH PDLQ WKUHDG FDQ FRQWLQXH ZLWK WKH H[HFXWLRQ RI WKH UHVWRIWKHSURJUDP3URJUDPVQRWXVLQJPXOWLWKUHDGLQJZLOOKDYHWRZDLWXQWLOWKHXVHUKDVLQSXW DYDOXHIRUWKHFRQWLQXDWLRQRIWKHSURJUDP 7KH EHQHILW RI -DYD·V PXOWLWKUHDGLQJ LV WKDW RQH WKUHDG WKDW FDQ SDXVH ZLWKRXW VWRSSLQJ RWKHU SDUWV RI WKH SURJUDP )RU H[DPSOH WKH LGOH WLPH FUHDWHG ZKHQ D WKUHDG UHDGV GDWD IURP D QHWZRUNRUZDLWVIRUWKHXVHULQSXWFDQEHXWLOL]HGHOVHZKHUH7KH-DYDUXQWLPHV\VWHPGHSHQGV RQ WKUHDGV IRU PDQ\ WKLQJV DQG DOO RI WKH FODVV OLEUDULHV DUH GHVLJQHG ZLWK PXOWLWKUHDGLQJ LQ PLQG The advantages of using threads are as follows
♦ ♦ ♦ ♦ ♦
Can be created faster Requires less overhead Interprocess communication ids are faster Context switching is faster Uses CPU time optimally. Comp-U-Learn
133
Java Programming I
Note Java assigns a priority to each thread. A higher priority thread does not run faster than a lower priority thread, if it is the only thread running. Instead a thread’s priority is used to decide when to switch from one running thread to the next. This is called a context switch. 7KH7KUHDGFODVVLPSOHPHQWVWKUHDGVLQ-DYD7KH7KUHDGFODVVLVSDUWRIWKHSDFNDJHMDYDODQJ DQG KHOSV WR LPSOHPHQW -DYD WKUHDGV ZKLFK DUH LQGHSHQGHQW 7KHUH DUH WZR ZD\V WR FUHDWH D FODVVWKDWFDQEHPXOWLWKUHDGHG ♦ Create a class that extends the Thread class ♦ Create a class that implements the Runnable interface. 7KHIROORZLQJDUHWKHWKUHDGVLQ7KUHDGFODVV public thread()
&RQVWUXFWVDQHZWKUHDG7KHWKUHDGPXVWKDYHDUXQPHWKRGDQGDVWDUWPHWKRGWRDFWLYDWHWKH UXQPHWKRG public void run()
7KLV PHWKRG ZKLFK PXVW EH RYHUULGGHQ VKRXOG FRQWDLQ WKH FRGH RI WKH WKUHDG 7KH WKUHDG·V ERG\LVLPSOHPHQWHGLQLWVUXQPHWKRG public void start()
6WDUWVWKHWKUHDG7KLVZLOOFDXVHWKHUXQ PHWKRGWREHFDOOHGDQGUHWXUQLPPHGLDWHO\VRWKDW WKHWKUHDGFDQUXQFRQFXUUHQWO\ public static void sleep(long millesecs)
7KH FXUUHQWO\ H[HFXWLQJ WKUHDG ZDLWV VOHHS IRU WKH VSHFLILHG WLPH LQ PLOOLVHFRQGV DQG WKHQ SHUPLWWLQJRWKHUWKUHDGVWRWDNHRYHUFRQWURO public void interrupt()
6HQGVDQLQWHUUXSWUHTXHVWWRDWKUHDG public static boolean interrupted()
5HWXUQVZKHWKHUDWKUHDGKDVEHHQLQWHUUXSWHGRUQRW
134
Comp-U-Learn
Exception Handling and MultiThreading
public static void yield()
7KHFXUUHQWWKUHDG\LHOGVWKHH[HFXWLRQWRWKHQH[WUXQQDEOHWKUHDG getName()
2EWDLQVDWKUHDGQDPH getPriority()
2EWDLQVDWKUHDG·VSULRULW\ isAlive()
'HWHUPLQHVLIDWKUHDGLVVWLOOUXQQLQJ join()
:DLWVIRUDWKUHDGWRWHUPLQDWH resume()
5HVXPHVH[HFXWLRQRIDVXVSHQGHGWKUHDG7KLVLVYDOLGRQO\LIVXVSHQG LVLQLWLDWHG suspend()
6XVSHQGVDWKUHDG public final void stop()
.LOOVDWKUHDG activeCount()
5HWXUQVWKHFXUUHQWQXPEHURIDFWLYHWKUHDGVLQWKLVWKUHDGJURXS currentThread()
5HWXUQVDUHIHUHQFHWRWKHFXUUHQWO\H[HFXWLQJ7KUHDGREMHFWDQGLVDVWDWLFPHWKRG setName(String)
6HWVWKHWKUHDG·VQDPH
Comp-U-Learn
135
Java Programming I
setPriority(int)
6HWVWKHWKUHDGSULRULW\ $QH[DPSOHRIFUHDWLQJWKUHDGXVLQJ7KUHDGFODVVLVVKRZQDVIROORZV Example 6.10 class mythread extends Thread { String name; Thread t; mythread(String s) { t=new Thread(this,s); System.out.println("New thread : " +t); t.start(); } public void run() { try { for(int i=5;i>0;i--) { System.out.println(name + i); Thread.sleep(500); } }catch(InterruptedException e) { } System.out.println(name+ "existing ........"); } } class ex610 { public static void main(String args[]) { mythread m1=new mythread("One"); mythread m2=new mythread("Two"); System.out.println("thread m1 is alive " + m1.t.isAlive()); System.out.println("thread m2 is alive " + m2.t.isAlive()); try{ System.out.println("Waiting ");
136
Comp-U-Learn
Exception Handling and MultiThreading m1.t.join(); m2.t.join(); }catch(InterruptedException e) { } System.out.println("thread m1 is alive " + m1.t.isAlive()); System.out.println("thread m2 is alive " + m2.t.isAlive()); System.out.println("Existing main thread "); } }
2XWSXWRIWKHSURJUDP C:\jdk1.2\bin>java ex610 New thread : Thread[One,5,main] New thread : Thread[Two,5,main] thread m1 is alive true null5 null5 thread m2 is alive true Waiting null4 null4 null3 null3 null2 null2 null1 null1 nullexisting ........ nullexisting ........ thread m1 is alive false thread m2 is alive false Existing main thread
Comp-U-Learn
137
Java Programming I
Thread States
Runnable
Start( ) or run expires
Dead
Not Runnable Start( )
Stop( ) New Thread Stop( )
New Thread
Fig 6.2 :KHQHYHU DQ LQVWDQFH RI WKH 7KUHDG FODVV LV FUHDWHG WKH WKUHDG HQWHUV LQWR WKH QHZ 7KUHDG 6WDWH7KHFRGHWKDWIROORZVLOOXVWUDWHVWKHLQVWDQWLDWLRQRIWKH7KUHDGFODVV Thread nThread=new Thread(this);
7KLV FUHDWHV D QHZ WKUHDG 1RZ QR UHVRXUFHV DUH DOORFDWHG WR WKH WKUHDG ,W LV RQO\ DQ HPSW\ REMHFW$VDUHVXOWRIWKLVRQO\WKHVWDUWDQGVWRSPHWKRGVFDQEHLQYRNHG,IDQDWWHPSWLVPDGH WRLQYRNHRWKHUPHWKRGVRIWKH7KUHDGFODVVWKHQLWZLOOWKURZ,OOHJDO7KUHDG6WDWH([FHSWLRQ Runnable
2QFHWKHWKUHDGUHFHLYHVWKHVWDUWPHWKRGLWHQWHUVLQWRWKHUXQQDEOHVWDWHDQGQRWUXQQLQJVWDWH 7KHWKUHDGPLJKWQRWEHH[HFXWLQJDWWKHUXQQDEOHVWDJH6LQFHDVLQJOHSURFHVVRUFDQQRWH[HFXWH PRUH WKDQ RQH WKUHDG DW RQH WLPH WKHUH LV D ZD\ RI VFKHGXOLQJ WKH SULRULWLHV IRU WKH WKUHDGV 7KLVLVFDOOHG7KUHDGSULRULW\
138
Comp-U-Learn
Exception Handling and MultiThreading
Not Runnable
$WKUHDGLVVDLGWREHLQWKHQRWUXQQDEOHVWDWHLILW ♦ ♦ ♦ ♦
Has been suspended Is sleeping Is waiting Is being blocked by another thread
$WKUHDGFDQEHVXVSHQGHGE\LQYRNLQJWKHVXVSHQGPHWKRGRIWKH7KUHDGFODVVZKHUHE\WKH WKUHDGLVQRWH[HFXWDEOH7RH[HFXWHWKHWKUHDGWKHUHVXPH KDVWREHLQYRNHG7KHVXVSHQG KRZHYHUGRHVQ·WNLOOWKHWKUHDG $WKUHDGLVSXWWRVOHHSZKHQWKHVOHHSPHWKRGLVLQYRNHG7KHWLPHLVJLYHQDVPLOOLVHFRQGVWR WKH VOHHS $ VOHHSLQJ WKUHDG ZLOO HQWHU LQWR WKH UXQQDEOH VWDWH DIWHU WKH VSHFLILHG WLPH KDV HODSVHG8QWLOWKDWWLPHWKUHDGZLOOQRWH[HFXWH7KHVOHHSLQJWKUHDGFDQQRWEHH[HFXWHGXVLQJ WKHUHVXPH $ WKUHDG FDQ EH PDGH WR ZDLW RQ D FRQGLWLRQDO YDULDEOH PDNLQJ LW ZDLW XQWLO WKH FRQGLWLRQ LV VDWLVILHG 7KH WKUHDG LV QRW UXQQDEOH WLOO WKH FRQGLWLRQ EHFRPHV WUXH 7KH FRQGLWLRQ FDQ EH QRWLILHGWRWKHWKUHDGE\LQYRNLQJQRWLI\ Dead
$WKUHDGFDQHLWKHUGLHQDWXUDOO\RULWFDQEHNLOOHG$WKUHDGXQGHUJRHVDQDWXUDOGHDWKZKHQWKH ORRSLQWKHUXQPHWKRGLVFRPSOHWHG$WKUHDGFDQEHNLOOHGE\LQYRNLQJWKHVWRSPHWKRG7KH LV$OLYH PHWKRGFDQEHXVHGWRILQGRXWZKHWKHUDWKUHDGKDVEHHQVWDUWHGRUVWRSSHG
Thread Priority (DFK WKUHDG KDV D SULRULW\ ZKLFK DIIHFWV WKH RUGHU LQ ZKLFK LW LV UXQ 7KUHDGV ZLWK D KLJKHU SULRULW\ VXSHUVHGH WKUHDGV ZLWK D ORZHU SULRULW\ $ WKUHDG LQKHULWV LWV SULRULW\ IURP WKH WKUHDG WKDW FUHDWHG LW 7KH SULRULW\ RI D WKUHDG FDQ EH VHW E\ XVLQJ WKH VHW3ULRULW\ RI WKH 7KUHDG IXQFWLRQ7KHSDUDPHWHUVWRWKLVPHWKRGDUH ♦ MIN_PRIORITY ♦ MAX_PRIORITY ♦ NORM_PRIORITY :KHQPRUHWKDQRQHWKUHDGLVUHDG\IRUH[HFXWLRQ-DYDUXQWLPHV\VWHPFKRRVHVWKHRQHZLWK WKH KLJKHVW SULRULW\ DQG H[HFXWHV LW :KHQ RQH WKUHDG LV EHLQJ H[HFXWHG DQG -DYD HQFRXQWHUV
Comp-U-Learn
139
Java Programming I
DQRWKHUZLWKDKLJKHUSULRULW\WKHQ-DYDSXVKHVWKHFXUUHQWO\H[HFXWLQJWKUHDGDQGWKHRQHZLWK DKLJKHUSULRULW\ZLOOEHH[HFXWHG
Daemon Threads $GDHPRQWKUHDGFDQEHFRQVLGHUHGWREHDWDVNPDQDJHUWKUHDGWKDWVXSSRUWVRWKHUWKUHDGV,WLV LQGHSHQGHQW LQ DQ DSSOLFDWLRQ DQG SURYLGHV VHUYLFHV WR RWKHU REMHFWV LQ WKH VDPH DSSOLFDWLRQ 7KHUXQPHWKRGRIDGDHPRQWKUHDGLVXVXDOO\DQLQILQLWHORRSZKLFKZDLWVIRUDVHUYLFHUHTXHVW 7RVSHFLI\WKDWDWKUHDGLVGDHPRQVHW'DHPRQ PHWKRGLVLQYRNHGZLWKWKHERROHDQSDUDPHWHU WUXH7KHLV'DHPRQ PHWKRGLVXVHGWRFKHFNZKHWKHUDWKUHDGLVD'DHPRQRUQRW 7KH IROORZLQJ SURJUDP LOOXVWUDWHV WKH ZRUNLQJ RI WKUHDGV +HUH WKH WKUHDG LV PDGH WR WLFN FRQWLQXRXVO\LUUHVSHFWLYHRIZKHWKHUWKHDSSOHWLVEHLQJPLQLPL]HGRUPD[LPL]HG Example 6.11 import java.awt.Graphics; import java.util.Date;import java.applet.*; public class time extends Applet implements Runnable { Thread t1; public void start() { if(t1==null) { t1=new Thread(this); t1.start(); } } public void run() { while(t1!=null) { repaint(); try { t1.sleep(1000); } catch(InterruptedException e) { } } } public void paint(Graphics g) { Date d=new Date();
140
Comp-U-Learn
Exception Handling and MultiThreading g.drawString(d.getHours() +":"+d.getMinutes()+":"+d.getSeconds(),5,10); } public void stop() { t1.stop(); t1=null; } }
7KHRXWSXWRIWKHSURJUDPLVDVIROORZV
Fig 6.3 $QRWKHUH[DPSOHWRVKRZWKHZRUNLQJRIWKUHDGVXVLQJDSSOLFDWLRQ Example 6.12 class mythread implements Runnable { Thread t; mythread() { t=new Thread(this," Demo Thread"); System.out.println("child thread : " +t); t.start(); } public void run() { try { for(int i=5;i>0;i--) {
Comp-U-Learn
141
Java Programming I System.out.println("Child Thread : " + i); Thread.sleep(500); } }catch(InterruptedException e) { System.out.println("Child Thread interrupted ."); } System.out.println("Existing child thread "); } } class ex54 { public static void main(String args[]) { new mythread(); try{ for(int i=6;i>0;i--) { System.out.println("Main Thread : " + i); Thread.sleep(1000); } }catch(InterruptedException e) { System.out.println("Main thread Interrupted "); } System.out.println("Existing main thread "); } }
,QVLGHWKHFRQVWUXFWRUP\WKUHDGZHDUHFUHDWLQJDQHZWKUHDGXVLQJWKHVWDWHPHQW T=new Thread(this,”Demo Thread”);
7KLVREMHFWKHUHVSHFLILHVWKDWWKHQHZO\FUHDWHGWKUHDGFUHDWHGZLOOFDOOWKHUXQ PHWKRG1H[W VWDUW LV FDOOHG ZKLFK VWDUWV WKH WKUHDG DQG EHJLQV H[HFXWLQJ WKH UXQ PHWKRG 7KLV FDXVHV WKH FKLOGWKUHDG·VIRUORRSWREHJLQDIWHUFDOOLQJWKHVWDUWPHWKRGP\WKUHDG·VFRQVWUXFWRUUHWXUQVWR PDLQ 7KHPDLQWKUHDGQRZHQWHUVLQWRWKHIRUORRS %RWK WKH WKUHDGV UXQQLQJ VLPXOWDQHRXVO\ VKDULQJ WKH &38 WLPH XQWLO WKH XSSHU ERXQG RI WKH ORRSLVUHDFKHG 7KHRXWSXWRIWKHSURJUDPLV C:\jdk1.2\bin>javac ex54.java C:\jdk1.2\bin>java ex54 child thread : Thread[ Demo Thread,5,main] Main Thread : 6
142
Comp-U-Learn
Exception Handling and MultiThreading Child Thread : 5 Child Thread : 4 Main Thread : 5 Child Thread : 3 Child Thread : 2 Main Thread : 4 Child Thread : 1 Existing child thread Main Thread : 3 Main Thread : 2 Main Thread : 1 Existing main thread C:\jdk1.2\bin>
Summary Exception handling provides a powerful mechanism to control complex programs that have many dynamic run time characteristics. Errors and abnormal situations arising while executing a program needs to be handled. Java provides well-defined methods for exception handling. There are various exception handling classes which are subclasses of Exception. The try, catch ,throw, finally and throws are the keywords involved in exception handling. Multithreading enables the program to make optimum utilization of the available CPU time. It is a feature of the programming environment to make best use of the available resources. Multithreading in Java is offered through Thread class and Runnable interface. The start(), run(), sleep(), stop(), suspend() and resume() are some of the important methods related to threading in Java.
Going Over It Again I. Fill in the Blanks
([FHSWLRQVDUHGHULYHGIURPBBBBBBBBBBBFODVV 0DQXDOO\FUHDWHGH[FHSWLRQVDUHUDLVHGXVLQJBBBBBBBBBBBBBBNH\ZRUG ([FHSWLRQV WKDW DUH WKURZQ RXW RI D PHWKRG PXVW EH VSHFLILHG XVLQJ BBBBBBBBBBBBB FODXVH 7KHDELOLW\WRSHUIRUPPRUHWKDQRQHSURFHVVVLPXOWDQHRXVO\LVFDOOHGBBBBBBBBBBBB BBBBBBBBBBBBBBPHWKRGLVXVHGWRGHWHUPLQHWKHSULRULW\RIDWKUHDG BBBBBBBBBBBBBBBBBBBLVWRNQRZZKHWKHUDWKUHDGKDVEHHQVWDUWHGRUVWRSSHG Comp-U-Learn
143
Java Programming I
II. State True or False
([FHSWLRQKDQGOLQJDOORZV\RXWRIL[HUURUV (UURUFODVVKDQGOHVWKHHUURUVWKDWDUHQRWFDXJKWXQGHUQRUPDOFLUFXPVWDQFHV 'LYLVLRQE\]HURFDXVHV1XOO3RLQWHU([FHSWLRQ 7U\FDQEHXVHGRQDVLQJOHVWDWHPHQWZLWKRXWFXUO\EUDFHV 7KUHDGVFDQH[LVWLQGHSHQGHQWO\ 7KHVXVSHQG NLOOVDWKUHDG III. One line Answers
/LVWWKHVRXUFHVRIHUURUV :KDWLVH[FHSWLRQKDQGOLQJ" :KDWZLOOKDSSHQLIDQH[FHSWLRQWKURZQGRHVQRWKDYHDQKDQGOHU" ([SODLQWKHXVDJHRIILQDOO\EORFN ([SODLQ'DHPRQ7KUHDG :KDWLVLPSOLFLWDQGH[SOLFLWH[FHSWLRQ" :KDWLVDWKUHDG"
144
Comp-U-Learn
Session 7
Java Applets
On Completion of this Session We will be able to understand...
) Java Applet ) Applet in Html ) Basic methods of Applet ) Various Applet classes ) Image class in Applet ) Animation in Applet
In This Session...
Introduction to Applet
Applet vs Application
Applet Architecture
Developing an Applet
Applet in HTML
Basic Methods in Applet
Parameter passing to Applets
Graphics Class
Font Class
Color Class
Images
Animation using Images
Java Applets
Introduction to Applet 7KHPDLQIHDWXUHWKDW-DYDSURYLGHVRYHURWKHUODQJXDJHVLVWKHIDFLOLW\WRZULWHDSSOHWV$SSOHWLV DSURJUDPWKDWFDQEHGRZQORDGHGDQGH[HFXWHGRQDQ\PDFKLQHLQWKHZRUOG7KHDGYDQWDJHV RIIHUHGE\WKHDSSOHWVDUHPXFKPRUHWKDQRQHFDQWKLQNRI$SSOHWVRSHQXSWKHSRVVLELOLW\RI FUHDWLQJDQLPDWLRQRQZHESDJHV:LWKRXWDSSOHWVWKHZHESDJHVDUHMXVWOLNHPDJD]LQHSDJHV ZLWKDSSOHWVWKH\EHFRPHOLNHPRYLHVDQGFRPPXQLFDWHPXFKPRUHHIIHFWLYHO\ ,Q DGGLWLRQ WR WKH DSSOHW LWVHOI WKH ZHE SDJH FDQ FRQWDLQV DOO RWKHU +70/ HOHPHQWV ZH KDYH OHDUQW$SSOHWVDUHMXVWRQHSDUWRIWKHK\SHUWH[WSDJH,WLVDOZD\VZRUWKNHHSLQJLQPLQGWKDW -DYDLVQRWDWRROIRUGHVLJQLQJ+70/SDJHV$FWXDOO\DSSOHWVDUHWKHWRROIRUEULQJLQJWKHPWR OLIH7KLVLVQRWWRVD\WKDWWKH*8,GHVLJQHOHPHQWVLQD-DYDDSSOHWDUHQRWLPSRUWDQWEXWWKH\ PXVWZRUNZLWKWKHXQGHUO\LQJ+70/GHVLJQRIWKHZHESDJH 7KLV VHVVLRQ ILUVW VKRZV KRZ WR FUHDWH D -DYD DSSOHW DQG YLHZ WKHP LQ RXU WHUPLQDO XVLQJ DSSOHWYLHZHU RU DQ\ RWKHU EURZVHUV ZLWK GLIIHUHQW YLVXDO HIIHFWV OLNH IRQWV FRORUV DQG YDULRXV VKDSHV7KHVXFFHHGLQJVHVVLRQVZLOOGLVFXVVKRZWRFRSHZLWKZLQGRZLQJUHTXLUHPHQWVDQGDOO WKHLPSRUWDQWDVSHFWVRI-DYDDSSOHWV
Applet vs Application -DYDDSSOLFDWLRQVDUHVLPSOHVWDQGDORQHSURJUDPVWKDWFDQEHUXQE\WKHMDYDLQWHUSUHWHU:HJHW WKH RXWSXW RI WKH DSSOLFDWLRQ SURJUDPV LQ WKH FRPPDQG OLQH RQO\ %XW MDYD DSSOHWV FDQ UXQ LQVLGHWKH:RUOG:LGH:HEEURZVHUDQGZHJHWRXUDSSOHWRXWSXWLQD*8,IRUPDW$SSOHWVFDQ EHORDGHGRYHUWKHQHWZRUNDQGKDYHPRUHFDSDELOLWLHVWKDQWKHMDYDDSSOLFDWLRQSURJUDPV $SDUWIURPWKDWDSSOHWVKDYHWKHIROORZLQJDGYDQWDJHVWKDWQRWHYHQWKHMDYDDSSOLFDWLRQVKDYH 7KH\DUH ♦ Applets have built-in support for multimedia. ♦ Applets running within a Web browser can easily be embedded in a Web page. ♦ Applets can make use of the GUI based pre-defined packages. ♦ Applet provides a frame, event-handling facility and graphics context. ♦ Applets can invoke public methods of other applets on the same page. (YHQWKRXJKWKHDSSOHWVKDYHWKHDERYHIDFLOLWLHVWKH\KDYHKDVVHFXULW\UHVWULFWLRQVWRSUHYHQW WKHPIURPEHLQJDIIHFWHGE\YLUXVHV-DYDDSSOHWVGRHVQ·WVXSSRUWWKHIROORZLQJDVSHFWVGXHWR VHFXULW\UHVWULFWLRQV Comp-U-Learn
147
Java Programming I
♦ ♦ ♦ ♦
Applets cannot load libraries or define native methods. An applet cannot ordinarily read or write files on the host that is executing it. An applet cannot make network connections except to the host that it came from. An applet cannot read certain system properties.
Applet Architecture :H KDYH DOUHDG\ VHHQ WKDW DQ DSSOHW LV D VLPSOH MDYD FODVV WKDW XOWLPDWHO\ H[WHQGV WKH MDYDDSSOHW$SSOHWFODVV1RWHWKDWWKHDSSOHWSDFNDJHLVQRWSDUWRIWKH$:7FRPSRQHQW7KH DUFKLWHFWXUHVKRZQLQWKHIROORZLQJILJXUHLOOXVWUDWHVWKLV ,QWKHVXFFHHGLQJVHVVLRQVZHZLOOXVHWKH6ZLQJVHWWRLPSOHPHQWDSSOHWV$OORIWKHDSSOHWVZLOO H[WHQGWKH$SSOHWFODVVWKHVXSHUFODVVIRU6ZLQJDSSOHWV$VZHFDQVHHLQWKHIROORZLQJILJXUH $SSOHWLVDQLPPHGLDWHVXEFODVVRIWKHRUGLQDU\$SSOHWFODVV Object
Component
Container
Window
Panel
Frame
Applet
JFrame
JApplet
Fig 7.1.
148
Comp-U-Learn
Java Applets
Developing an Applet ,QWKLVVHFWLRQZHDUHJRLQJWROHDUQDERXWWKHFUHDWLRQRIDVLPSOHDSSOHWSURJUDP7KHFUHDWLRQ RIDQDSSOHWFRQVLVWVRIWKHIROORZLQJIRXUVWHSV ♦ ♦ ♦ ♦
Importing the necessary built-in java packages Defining applet subclasses Applet implementation Passing this Java applet’s .class file into HTML file.
&RQVLGHUWKHIROORZLQJDSSOHWH[DPSOH VD\ VDPSOHMDYD ,WLOOXVWUDWHVWKHGHWDLOVWRFUHDWH DQDSSOHW Example 7.1 import java.awt.*; import java.applet.*; public class sample extends Applet { public void paint(Graphics g) { g.drawString("Java Applet Welcomes You!",100,100); } }
,QWKHDERYHSURJUDPWKHILUVWWZROLQHVDUHXVHGWRLPSRUWVRPHSDFNDJHVDQGFODVVHVZKLFKDUH EHLQJXVHGZLWKLQRXUDSSOHW $VLQDQDSSOLFDWLRQKHUHWRRZHKDYHWRVSHFLI\WKHFODVVGHFODUDWLRQDWWKHEHJLQQLQJ+HUH WKHH[WHQGVNH\ZRUGLVXVHGWRH[WHQGVRPHSUHGHILQHGFODVVHVWRRXUSURJUDP 7KHQZHKDYHWRLPSOHPHQWWKHDSSOHWE\PHDQVRIDSSOHWPHWKRGV,QWKLVSURJUDPWKHSDLQW PHWKRGRIDSSOHWLVXVHGWRSULQWVRPHWH[WLQWKHZLQGRZ7KHGUDZ6WULQJPHWKRGRIWKHFODVV *UDSKLFVLVXVHGIRUSDLQWLQJWKHWH[WLQWKHVFUHHQ )LQDOO\ZHKDYHWRSDVVWKLVVRXUFHILOH VDPSOHFODVV LQWRDQ+70/ILOH)RUWKDWZHKDYHWR FUHDWHDQRWKHU+70/ILOH VD\VDPSOHKWPO ZKLFKVKRXOGFRQWDLQWKHIROORZLQJFRGH
1RZFRPSLOHWKLVVDPSOHMDYDILOHRQWKHFRPPDQGOLQHXVLQJMDYDF7KHQUXQWKLVVDPSOHKWPO ILOHXVLQJDSSOHWYLHZHU7KHIROORZLQJILJXUHVKRZVWKHRXWSXWRIWKLVDSSOHW Comp-U-Learn
149
Java Programming I
Fig 7.2 $IWHUFRPSLOLQJRXUMDYDILOHZHFDQDOVRJHWWKHRXWSXWIRUWKHDERYHSURJUDPE\EURZVLQJWKH VDPSOHKWPO ILOH LQ WKH ,QWHUQHW H[SORUHU 7KH IROORZLQJ ILJXUH VKRZV WKH RXWSXW RI WKH VDPSOHSURJUDPLQWKHLQWHUQHWH[SORUHU
Fig 7.3
Note Look at the applet code. There is no main method. Applets don’t need it. The main method is actually in the browser or the appletviewer, not in the Applet itself.
Applet in HTML %HIRUH-DYDZHXVHG+70/WRGHVFULEHWKHOD\RXWRIDZHESDJH+70/LVDVLPSOHYHKLFOHWR LQGLFDWHHOHPHQWVRIDK\SHUWH[WSDJH7KH+70/SDJHPXVWWHOOWKHEURZVHUZKLFKDSSOHWVWR ORDGDQGZKHUHWRSXWHDFKDSSOHWRQWKHZHESDJH7KH $33/(7!DQG $33/(7!WDJV DUHFDOOHG+70/MDYDWDJV7KHMDYDHQDEOHGEURZVHUVZLOOXQGHUVWDQGWKDWFRGHEHWZHHQWKHVH WDJVDUHWKHMDYDFRGH)RUWKDWZLWKLQWKHVHWDJVZHPXVWSDVVWKHIROORZLQJ
150
Comp-U-Learn
Java Applets
♦ The name of the class files ♦ The location of the class files ♦ How the applet sits on the web page )RUWKHDERYHUHTXLUHPHQWVWKH $33/(7!WDJKDVWKHIROORZLQJDWWULEXWHV:HFDQXVHWKHVH DWWULEXWHVDFFRUGLQJWRRXUUHTXLUHPHQWV <APPLET>
7KLVWDJWKDWLVXQGHUVWRRGE\WKHDSSOHWYLHZHURUDQ\%URZVHU <EMBED>
7KLVWDJWKDWLVXQGHUVWRRGE\WKH1HWVFDSH1DYLJDWRU
Related Documents
Java Book
November 2019 10
Java Book
November 2019 6
Java Turkish Book
December 2019 1
Java Basic Book 2
October 2019 24
Preview Java J2ee Book
November 2019 10