ஜாவா நோட்ஸ்

ஜாவா கற்பவர் மற்றும் பயனர்களுக்காக - இந்த நோட்ஸ். ஜாவா என்பது விலாசமான - மிக அதிக பரப்பளவுப் பகுதி. ஜாவாவில் நேர்முகத் தேர்வு, எழுத்துத் தேர்வோ, அல்லது தொலைபேசித் தேர்வோ எழுதுபவர் - ஜாவாவின் அனைத்துப் பகுதிகளையும் ஒருமுறையாவது புரட்டிப் பார்க்க வேண்டியது அவசியமாகிறது. அவர்களின் பயனுக்காக நான் சேமித்து வைத்த ஜாவா நோட்ஸை இங்கு தருகிறேன்.
இது ஆங்காங்கே, அந்தந்த தலைப்புகளுக்கான அம்புக்குறியாகவே பயன்படுத்தவே. அந்த அம்புக்குறிகளைக் கொண்டு, நீங்கள் ஏற்கனேவே கற்றவற்றையோ அல்லது அனுபவத்தில் கண்டவற்றையோ நினைவு படுத்திக் கொள்ளவும்!. அல்லது புதிதான பகுதியாகவோ இருப்பின், ஆர்வம் இருப்பின், கூகிளில் தேடிப்பார்க்கவும். அல்லது மறுமொழியில் விசாரிக்கவும். இயன்றவரை விளக்குகிறேன்.

J2EE Tier ---> Web Tier, Business Tier

J2EE Components ---> Application client, Applets (Client)
Sevlet, JSP (Web)
EJB (Business)

J2EE Container services
• The J2EE security model
• The J2EE transaction model
• JNDI lookup to access naming and directory services.
• The J2EE remote connectivity model.


Web Modules
----------------
WEB-INF/ under the document root contains:
web.xml -> the web application deployment descriptor
Tag library descriptor files
classes
tas
libs

JAXP : Java API for XML Processing:
--------------------------------------------
provides SAX and DOM API,
Also included are XSLT (Extensible Stylesheet Language Transformation) API for transforming to xml or other file formats.


Java Design Patterns :
--> Creational, Structural or Behavioral
-->Class or Object


Common Design Patterns
--------------------------
Observer Pattern
Decorator Pattern : Composition
Factory Pattern
Singleton Pattern
Command Pattern
Facade Pattern
Template Method Pattern
Iterator and Composite Pattern
State Pattern
Proxy Pattern


Model View Controller is a compound pattern consisting of Observer, Strategy and Composite patterns.


Why would you prefer code reuse via composition over inheritance? Both the approaches make use of polymorphism and gives code reuse (in different ways) to achieve the same results but:


Answer:The advantage of class inheritance is that it is done statically at compile-time and is easy to use. The disadvantage of class inheritance is that because it is static, implementation inherited from a parent class cannot be changed at run-time. In object composition, functionality is acquired dynamically at run-time by objects collecting references to other
objects. The advantage of this approach is that implementations can be replaced at run-time. This is possible because objects are accessed only through their interfaces, so one object can be replaced with another just as long as they have the same type.

Another problem with class inheritance is that the subclass becomes dependent on the parent class implementation. This makes it harder to reuse the subclass, especially if part of the inherited implementation is no longer desirable and hence can break encapsulation. Also a change to a superclass can not only ripple down the inheritance hierarchy to subclasses, but can also ripple out to code that uses just the subclasses making the design fragile by tightly couplinthe subclasses with the super class. But it is easier to change the interface/implementation of the composed class.


Encapsulation – refers to keeping all the related members (variables and methods) together in an object. Specifying member variables as private can hide the variables and methods. Objects should hide their inner workings from the outside view. Good encapsulation improves code modularity by preventing objects interacting with each other in an unexpected way, which in turn makes future development and refactoring efforts easy.

Exception throwing:
------------------------
Throw an exception early and catch an exception late but do not sweep an exception under the carpet by catching it and not doing anything with it. This will hide problems and it will be hard to debug and fix.