• java -classpath gFolder/Game.jar civilization.java: In such command, -classpath will override (replace) CLASSPATH environment variable.
• java -classpath gFolder/Game.jar civilization.java: if both gFolder and current directory contain Game.jar then the jar file under gFolder will be used.
• If you want java compiler to recognize your jar file, either you have to mention the location of the jar file in javac command using -classpath switch or you have to add the jar file in the CLASSPATH environment variable. Mentionable – you need to add the file, adding upto the directory will not work.
• Garbage collection: can Java program run out of memory? yes.
• Can objects be garbage collected even if it has a valid reference? yes. when no live thread has access to the object.
• Can Objects created within inner classes be eligible for garbage collection.? yes.
• Do garbage collector deletes objects from the stack? No. As objects reside in heaps not in the stack.
• If an object’s finalize method runs to completion will it always be garbage collected? No. The finalize method may create some other references.
• Arrays.equals(Object[] a1, Object[] a2) : Returns true if the two specified arrays of Objects are equal to one another
• The results of Binary search on an unsorted array are undefined
• Alpha go(int i) is a valid method declaration with a generic return type. class Alpha{}

From: http://sitestree.com/?p=4891
Categories:Java Short Notes, SCJP
Tags:
Post Data:2010-06-26 02:46:16

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• For the package

  package com.sun2;public enum Seasons {SUMMER, FALL, WINTER, SPRING}      

  Valid import statements are:

  import com.sun2.Seasons; // the class import static com.sun2.Seasons.*; //all enum valuesimport static com.sun2.Seasons.FALL; //only one enum value

• An interface can extend many interfaces
• Interfaces can have variables, overrides and overloads
• An enum can have methods and can override those methods for a specific enum constant
• var-args can be used to pass arrays, var args can be of 0 or more lengths
• A var-args argument must be a method’s last argument
• An override cannot change the return type. Override can use covariant as a return type
• Overloading does not depend on the return type
• From J2se 5.0, a method in a subclass may return an object whose type is a subclass of the type returned by the method with the same signature in the superclass
• When a subclass constructor does not explicitly invoke a superclass constructor, the no-argument constructor of the superclass is automatically called from the subclass constructor. If the super class does not have a no-argument constructor, a compile-time error is displayed
• When subclasses override superclass methods, these superclass methods can be accesses using the super keyword (from subclass methods)
• From java 1.5, enums can be used in a switch
• To enable asserts in java program use -ea switch.
• assert has two forms: assert Expression1 ;, assert Expression1 : Expression2 ;. In the first form only AssertionErorr is displayed, in the second form you can add additional message(Expression2) to the AssertionError. Assert when finds its arguments to be false, it throws AssertionError
• Good places to use assertions: Internal Invariants, Control-Flow Invariants, Preconditions, Postconditions, and Class Invariants
• bad use of assertions: argument checking in public methods, to do any work that your application requires for correct operation
• Assertions should be free of side effects: evaluating the expression should not affect any state that is visible after the evaluation is complete
• An overriding method does not need to throw the overridden method’s exception
• Nesting try/catches are ok and normal flow rules apply in case of nesting.
• Accessing uninitialized instance/class wrapper variables (Integer, Short) will cause NullPointerException
• NumberFormatException extends IllegalArgumentException
• JVM when calling a method, to make data types compatible, will widen the parameters before boxing.
• java.io.Console class: Only a single instance exists for a given JVM, All of the methods that read user input are synchronized
• Among File, FileReader, BufferedReader only BufferedReader has a readLine method
• A class’s superclasses don’t have to implement Serializable in order to be serialized
• if a superclass doesn’t implement Serializable then it’s constructor will run during deserialization.
• A transient variable’s state is lost during serialization
• A volatile variable’s state is not lost during serialization
• If Dog has-a Collar, then Collar must implement java.io.Serializable in order to serialize an instance of Dog.
• If Dog extends Animal and Animal implements java.io.Serializable but Dog does NOT implement java.io.Serializable, you can serialize an instance of Dog.
• Serialization rules: # Rule #1: The object to be persisted must implement the Serializable interface or inherit that implementation from its object hierarchy,# Rule #2: The object to be persisted must mark all nonserializable fields transient
• To make thread instance unserializable: transient private Thread animator;
• java.lang.Object does not implement Serializable. AWT and Swing GUI components, strings, and arrays — are serializable
• Serialization Details
• NumberFormat, Calendar, and DateFormat are abstract. Use the getInstance method to get instances.
• For java.util.Scanner, the default separator is a blank NOT a comma
• Multiple threads can be created using the same Runnable object, but a given thread can be started only once
• Two invocations of synchronized methods on the same object to interleave – is not possible. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object. When a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.
• In object oriented design, low coupling is more desirable than high coupling. High cohesion is more desirable than low cohesion. Coupling: class interdependence. Cohesion: Class activities should be well focused.
• Polymorphism does NOT apply to static methods
• Polymorphic calls and co-variant returns can be mixed
• no modifier (package private) is weaker than protected. The order is: public, protected, package private, private
• Kind of’ translates to extends, ‘contract’ translates to implements, and ‘composed’ translates to a has-a implementation.
• TreeMap: headMap() method returns keys that are less than the argument, and tailMap() returns keys that are greater than(>=) the argument.

From: http://sitestree.com/?p=4888
Categories:Java Short Notes, SCJP
Tags:
Post Data:2011-10-20 04:13:02

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• A class’s superclasses don’t have to implement Serializable in order to be serialized
• if a superclass doesn’t implement Serializable then it’s constructor will run during deserialization
• A transient variable’s state is lost during serialization, but a volatile variable’s state is not lost
• Java:Volatile variable
• Transient Variable
• NumberFormat, Calendar, DateFormat are abstract classes. Use the getInstance method to get NumberFormat instances.
• The + quantifier in a regular expression indicates 1 or more occurrences, * indicates 0 or more, [] just one character in the group, () indicates a whole group match.
• The default separator in Scanner class is a blank NOT a comma
• Multiple threads can be created using the same Runnable object, but a given thread can be started only once.
• Thread.yield(): Causes the currently executing thread object to temporarily pause and allow other threads to execute.
• Thread.join(): Waits for this thread to die.
• Wait(), Notify(), NotifyAll() methods
• Low coupling: classes know the least possible about each other, is preferable over tight coupling.
• High cohesion: Each class has well focused responsibilities. Is preferable over low cohesion.
• Polymorphism does NOT apply to static methods.
• Instance variable cannot be referenced from static method

From: http://sitestree.com/?p=4883
Categories:Java Short Notes, SCJP
Tags:
Post Data:2011-09-04 06:32:26

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• Java High Level Concurrency Objects
• constructors cannot be synchronized
• Liveness of multi-threaded applications
• Immutable Objects
• An application may have one or more processes. A process may have one or more threads.
• Two ways to create threads
• Thread.sleep(4000); To pause a thread. The time like 4000 ms is really dependent on the os and not precise
• Thread Interrupts
• Thread Join
• Regular Expression
• Regular expression – meta characters: ([{^-$|]})?*+.
• Character Classes for Regular Expressions
• Pattern Class
• Matcher Class
• System.getenv(): get environment variables in a hashmap.
• System.getProperty(“path.separator”); System.setProperties : read and write system properties.
• How to use Properties to keep application properties
• Access SecurityManager: SecurityManager appsm = System.getSecurityManager();

From: http://sitestree.com/?p=4879
Categories:Java Short Notes, SCJP
Tags:
Post Data:2009-04-19 03:15:05

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• ByteStream is the basic I/O stream. Handles data as a stream of bytes. Does operation with byte unit and uses 8 bit. FileInputStream, FileOutputStream – can be used to copy files as byte by byte.
• Character Streams: FileReader and FileWriter are character streams. They treat file data as 16 bit unicode charater streams.
• InputStreamReader, OutputStreamWriter are also character streams. May be used in socket data reading.
• Line-Oriented I/O: BufferedReader and PrintWriter
• Buffered Streams: BufferedInputStream and BufferedOutputStream create buffered byte streams, while BufferedReader and BufferedWriter create buffered character streams
• You can set autoflush() of buffered streams or call manually flush() method.
• The scanner API breaks input into individual tokens. The formatting API assembles data into nicely formatted, human-readable form.
• Scanner:

  Scanner scanner = new Scanner(new BufferedReader(new FileReader("test.txt")));            while (s.hasNext()) {                System.out.println(s.next());            }

• To create formatted output streams, instantiate PrintWriter not PrintStream
• Check: System.out.format(“The square root of %d is %f.%n”, i, r);
• System.out and System.err are PrintStream objects. PrintStream is really a byte stream but uses some mechanism to emulate character stream.
• InputStreamReader cin = new InputStreamReader(System.in); System.in is a byte stream. InputStreamReader is used to emulate a character stream.
• System.console provides character streams to handle console read/write operations. Provides readPassword method to read password from the console
• Data Streams: Support I/O operations of primitive data types. DataInputStream and DataOutputStream.
• Check:

  out = new DataOutputStream(new            BufferedOutputStream(new FileOutputStream(dataFile)));out.writeDouble(prices);out.writeInt(units);out.writeUTF(descs);

• DataStreams detects an end-of-file condition by catching EOFException
• Correct type to represent currency values: java.math.BigDecimal – an object type
• Object Streams: ObjectInputStream and ObjectOutputStream. Use writeObject and readObject to write and read objects respectively.
• A stream can contain only one copy of an object but many references to it when required.
• File Objects: File I/O
• Random access file:

  new RandomAccessFile("test.txt", "r");new RandomAccessFile("test.txt", "rw");RandomAccessFile methods:    * int skipBytes(int)     * void seek(long)      * long getFilePointer() 

• The new java.nio.* package provides supports to handle file i/o for high performance applications.

From: http://sitestree.com/?p=4878
Categories:Java Short Notes, SCJP
Tags:
Post Data:2012-10-24 02:25:07

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• How to use generics to avoid runtime errors.
• More Generics
• Class casting in Java: How to avoid runtime exception – ClassCastException: overloading, overriding, variable and method hiding
• Java HotSpot virtual machine
• What Java Technology can do?
• Offers from Java Technology
• Java:Common Problems (and Their Solutions)
• Benefits of OOP: Modularity, Information-hiding, Code re-use, Pluggability and debugging ease
• Object oriented concepts in Java
• Variable Naming Conventions in Java
• Java Primitive Data Types
• Java : Arrays: System.arraycopy method
• Java Operators: Carefully look about precedence
• continue and break statements in Java
• Annotations in Java
• Passing Parameters, System.out.printf, Shadowing Variables
• The Garbage Collector
• You can use interface names as return types. The object returned must implement the specified interface.
• when a class name is used as a return type, the returned object must be either a subclass of, or the exact class of, the return type
• Controlling Access to Members of a Class
• Java initializing variables: initialize at declarations, Static Initialization Blocks, private static method to initialize, Initializer blocks for instance variables, A final method for initialization
• Nested Classes
• enum in Java: enums implicitly extend java.lang.Enum. An enum cannot extend anything else. Enums can have methods like classes
• if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface
• Interfaces provide an alternative to multiple inheritance
• Java Interfaces
• Rewriting Interfaces
• Covariant return type: An overriding method can return a subtype of the type returned by the overridden method
• The access modifier for an overriding method can allow more, but not less, access than the overridden method
• Hiding fields makes code difficult to read
• java.lang.Object as a super class
• final methods can not be overridden, final classes can not be sub-classed, methods called from constructors should generally be declared final (otherwise, a different implementation of the method in subclasses may create unwanted results)
• Interfaces can not have static or final methods
• System.out.format(…..) and String.format() can be used as alternatives to System.out.println()
• Using Number class vs. primitive data types
• String, StringBuilder, StringBuffer: StringBuilder has capacity(), reverse() methods that String does not have. StringBuffer = StringBuilder but StringBuffer is thread-safe i.e. synchronized. String, and StringBuilder can be converted to each other
• Three kinds of exceptions
• Chained Exceptions: Stack Trace: Logging

From: http://sitestree.com/?p=4876
Categories:Java Short Notes, SCJP
Tags:
Post Data:2008-03-19 18:31:53

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• An enum may NOT be declared in a method
• An enum can be imported
• If the JVM has a choice, it will select a method without varargs before selecting a method with varargs
• When enums are equal, both .equals and == always return true
• The headMap() method returns the portion of the map whose keys are less than the key sent to it
• The asList() method of Arrays creates a fixed-size list that is backed by the array, so no additions are possible.
• A static initialization block is a normal block of code enclosed in braces, { }, and preceded by the static keyword. Used to initialize class variables
• All enums implicitly extend java.lang.Enum.
• A class can extend only one other class, an interface can extend any number of interfaces
• An interface might also contain constant definitions.
• An abstract class that implements an interface may not implement all interface methods

From: http://sitestree.com/?p=4872
Categories:Java Short Notes, SCJP
Tags:
Post Data:2012-12-07 07:48:57

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

Interface

• An interface is a reference type, similar to a class
• Interfaces can contain only constants, method signatures, and nested types
• No method is implemented
• Interfaces cannot be instantiated
• They can only be implemented by classes or extended by other interfaces
• Interfaces are not part of the class hierarchy
• A class can implement multiple interfaces

From: http://sitestree.com/?p=4867
Categories:Java Short Notes, SCJP
Tags:
Post Data:2010-01-20 15:33:28

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

class declarations

• Start with modifiers such as public, private followed by class keyword
• The class name, with the initial letter capitalized
• The name of the class’s parent (superclass), preceded by the keyword extends (if any). A class can only extend (subclass) one parent.
• list of interfaces implemented by the class, preceded by the keyword implements (if any). A class can implement more than one interface
• The class body, surrounded by braces, {}.
• Class member variable declarations
  • Requires three components, in order:
  • Zero or more modifiers, such as public or private
  • The field’s type
  • The field’s name.

Abstract Classes

• A class declared with abstract keyword is an abstract class. It may or may not include abstract methods
• Abstract classes cannot be instantiated
• Abstract classes can be subclassed
• Class containing abstract methods, must be declared to be abstract
• Abstract methods are methods declared without implementation (braces)
• The subclass of an abstract class must provide implementations of all the abstract methods otherwise the subclass itself needs to be declared as abstract.
• An abstract class may have static and final fields and methods. Interfaces can not
• If an abstract class contains only abstract method declarations with no implementations, it should better be declared as an interface
• It’s a good design to declare a common abstract class with common methods with implementations for several very related classes (will extend the abstract class)
• An abstract class can implement an interface but are not bound to implement all interface methods

Nested Classes

• Classes declared under another class are called nested classes
• Two types: Static Nested: declared with static keyword, Inner Nested: declared with no static keyword
• inner classes have access to other members of the outer class including private members
• Static nested classes do not have access to other members of the outer class
• Static nested classes are accessed using the outer class name such as: OuterClass.StaticNestedClass
• To use inner classes, the outer class must be instantiated first. Then, inner object can be created as follows: OuterClass.InnerClass innerObject = outerObject.new InnerClass();
• Local inner classes: Declared within the body of a method
• Anonymous inner classes: Declared within the body of a method without naming it
• Inner classes may have similar access modifiers like other outer class members
• Why use nested classes:
  • For logically grouping classes that are only used in one place
  • It increases encapsulation.
  • May lead to more readable and maintainable code

From: http://sitestree.com/?p=4866
Categories:Java Short Notes, SCJP
Tags:
Post Data:2012-09-13 21:25:27

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

Flow Control and ExceptionsFlow control statements

• Conditional: if, if-else and switch-case
• Looping: for, while, do-while
• Exception handling: try-catch-finally, throw
• Ad hoc flow control: break, continue with or without labels

switch statement
         switch(expression){ 
        case ConstantExpression: statement(s); 
        case ConstantExpression: statement(s);
        .
        .
        .
        default: statement(s);
      }

• expression: must be char, byte, short, or int, or a compile-time error occurs
• long primitive can be used if type casted to int
• Object reference cannot be used as expression
• Every case expression must be unique
• break statement may be used at the end of a case statement, to discontinue execution.
• There can be at most only one default statement.
• The order of case statements and default can be anything.

break and continue

• A break statement transfers the control out of an enclosing statement. break used within a loop breaks the execution of the current loop. In case of nested loops, the break statement passes the control to the immediate outer loop.
• A continue statement breaks the current iteration and moves to next iteration.
• break and continue with labels.
  • Labels specify the target (statement) for continue and break
  • continue with label does not jump to the labeled statement but instead jumps to the end of the labeled loop.
  • Same label identifiers can be reused multiple times as long as they are not nested.
  • Label names do not conflict with the same named identifier(variable, method or class name).

Checked and Unchecked Exceptions

Checked Exceptions

• Checked Exceptions are checked by the compiler to see if these exceptions are properly caught or specified. If not, the code will fail to compile
• Checked exception forces client program to deal with the scenario in which an exception may be thrown
• Checked exceptions must be either declared or caught at compile time

Unchecked Exceptions

• Unchecked exceptions are RuntimeException and all of its subclasses.
• Class java.lang.Error and its subclasses also are unchecked.
• Unchecked Exceptions are not checked by the compiler.
• Runtime exceptions do not need to be caught or declared.

From: http://sitestree.com/?p=4864
Categories:Java Short Notes, SCJP
Tags:
Post Data:2008-08-25 00:56:33

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada