Core Java Career Essentials
Focusing on Java platform, language, classes, objects, OO concepts & principles, data structures, algorithms, and pattern matching essentials
By Arulkumaran Kumaraswamipillai Sivayini Arulkumaran
Core Java Career Essentials Focusing on platform, language, classes, objects, collections, and logic essentials Copy Right 2011
The authors have made every effort in the preparation of this book to ensure the accuracy of the information. However, information in this book is sold without warranty either expressed or implied. The authors will not be held liable for any damages caused or alleged to be caused either directly or indirectly by this book.
Please e-mail feedback & corrections (technical, grammatical and/or spelling) to [email protected]
More Java/JEE career resources are availabale at http://www.lulu.com/java-success
First Edition : April 2011
Thanks to the reviewers: Ankit Garg, Devaka Cooray, Roberto Perillo, Rod Good, and Sean Clynes.
2
Table of Contents Getting Started ….........................................................................................5 How can this book help you?...........................................................................................6 Why is this a PERFECT companion?..............................................................................8 What are the technical key areas?....................................................................................9
Platform Essentials....................................................................................15 Why use Java? ...........................................................................................................16 Java platform basics – JDK, JRE, JVM, etc..................................................................21 Setting up and running Java...........................................................................................30 How are your classes loaded?........................................................................................34 Compile-time versus runtime........................................................................................39
Knowing your way around Java................................................................51 Judging Experience .......................................................................................................52 Gauging Your Experience with UNIX ..........................................................................88 Exposure to tools, technologies, and frameworks.......................................................103 Documenting your Java applications...........................................................................115 Ensuring code quality. ................................................................................................122
Language Essentials..................................................................................133 Valid identifiers and reserved keywords......................................................................135 Choosing the right data types......................................................................................144 Widening versus narrowing conversions.....................................................................150 Understanding the operator precedence.......................................................................159 Thinking in binary and bitwise operations .................................................................162 Initializing your data correctly.....................................................................................176 Constants and static imports........................................................................................182 Modifiers and where are they applicable? ..................................................................186 Methods and constructors............................................................................................196 Stack versus Heap........................................................................................................209 Java is pass-by-value....................................................................................................211 Recursive functions.....................................................................................................214 Class, instance, and local variables..............................................................................217
Classes and Interfaces Essentials.............................................................225 Working with classes and interfaces ...........................................................................226 Subclassing, overriding, and hiding (aka shadowing) ................................................227 Designing your classes and interfaces.........................................................................233 Working with abstract classes and interfaces..............................................................247 3
Inheritance versus composition...................................................................................260 Applying the design principles....................................................................................268 Designing an application or a system..........................................................................281 Class invariant and design by contract .......................................................................285 Working with inner classes..........................................................................................290 Packaging your classes to avoid conflicts...................................................................300
Objects Essentials......................................................................................305 Working with Objects..................................................................................................306 Cloning Objects...........................................................................................................312 Casting Objects............................................................................................................314 Immutable Objects.......................................................................................................318 Working with Enumerations........................................................................................326 Understanding “” versus equals( )...........................................................................332 Working with the String class......................................................................................338 Type safety with Generics............................................................................................346 Serializing your objects...............................................................................................364 Garbage Collection......................................................................................................372
Logic and Data structures Essentials......................................................383 Java Flow Control........................................................................................................384 Java Data structures.....................................................................................................390 Sorting Elements..........................................................................................................422 Algorithms...................................................................................................................427 Logic Processing..........................................................................................................449 Exception handling......................................................................................................471
Matching patterns with regular expressions..........................................487 Matching patterns with Regular Expressions..............................................................488
Job Interview Tips.....................................................................................520 Interviews are not technical contests...........................................................................521 Don't wait to be asked ….............................................................................................523 Think out loud and brainstorm with the interviewers ….............................................524 Sometimes knowing something is better than knowing nothing …............................526 Interviewers place a lot of value in 'I don't know' over inventing answers ... ..........526 An interview is a two way street ….............................................................................527 Open-ended questions are your opportunity …..........................................................528 Books can impart knowledge, but cannot give you the much needed experience …..528
Glossary & Index......................................................................................530
4
Section-1: Getting Started …... • • •
How can this book help you? Why is this a PERFECT companion? What are the technical key areas?
So you have a java interview coming up in a few days or you want to impress your peers and superiors with your technical strengths during code review sessions, team meetings, and stand-ups, and concerned about how to make a good impression? you don't need to worry if you are familiar with the fundamentals. Most Java interviews and technical challenges you face at work are structured around the fundamentals and how well you communicate those fundamentals. So regularly brushing up on these fundamentals really pays off. Your analytical, problem solving, and coding skills will also be under scrutiny along with your ability to get the job done with the right tools. If your fundamentals are clear and know what tools to use, you can tackle any questions, and find solutions to any problems and challenges you face. Even if you don't have the exact answer for a problem, you will know how to go about solving them with a little research if you have a solid grounding in the fundamentals covered in this book. A little preparation can make a huge difference to your career success. Preparation can help you communicate your thoughts more clearly with examples and illustrations. Preparation can make a good and lasting impression on those who talk with you during your interviews and team meetings. This impression will be partly influenced by how prepared you are and how knowledgeable you are about your industry and the challenges it faces. It will also be influenced by your appearance, attitude, enthusiasm, and confidence. Good preparation breeds confidence and it shows in the interviews and team meetings. So prepare well in advance if you just begun to see yourself in your dream company or would like to go places in your chosen field.
5
Getting Started …...
How can this book help you? This unique “questions and answers approach” with tagged technical key areas, diagrams, code snippets, and examples can help you excel in your chosen Java based profession. This is more than just an interview preparation guide. Let's look at ways in which we believe this book can benefit a reader. •
Helps you brush up or be aware of the basics in software development that you must know. Preparing for the most common interview questions will increase your chances. If you fail to answer these basic questions, your chances of succeeding in interviews will be very slim. In fact, 40% - 60% of the professionals irrespective of their level of experience fail to make an impression in one or more of the following most common areas.  Coding: You may have to write some simple code, with correct syntax and logic in Java. You might be asked to explain and critique on snippets of code. You might be asked to demonstrate both recursive and iterative approaches to a given problem. You will be assessed on your ability to think about the exceptional cases, exit conditions, and algorithms.  OO design: You will be asked to define basic OO concepts and principles, and come up with the classes and interfaces to model a simple problem. A good weeder question would be to judge your ability to decide when to use attributes, inheritance, and composition. You might be asked to critique a system or platform you had worked on. A good OO design question can also test your coding skills and domain knowledge.  Language fundamentals and best practices: You must have a solid grasp of the language fundamentals. You might be asked what parts of Java you don't like and why? You must know about the common pitfalls, anti-patterns, and how to avoid them. You must know the differences between abstract classes and interfaces, how the garbage collection works?, etc and relevant best practices.  Data structures: You must demonstrate basic knowledge of the most common data structures. Most candidates know about arrays, sets, lists, and maps but fail to mention trees and graphs. You will be quizzed on real life examples of where to use a particular data structure and big-O performance
6
(e.g. linear, logarithmic, exponential, etc) of various operations like find, insert, and delete. It is also worth knowing the basic sorting and searching algorithms.  Bits, bytes, and data types: You must demonstrate how good you are technically. You must know the logical operations like AND, OR, NOT, and XOR and where to use them in real life examples for things like setting or testing for a specific bit. Using the wrong data types in your program can bring the whole application down. You must also know the difference between signed and unsigned data types and narrowing versus widening conversions.  Right tools to use: Knowing the right tools will make you more productive without having to reinvent the wheel, and get the job done more effectively and on time. These tools can vary from harnessing the power of Unix scripts with regular expressions or embedded groovy scripts to tools like Wireshark to sniff the packets. The prospective employers generally determine if you “know it”, “knowledgeable enough to learn it on the job” or “have no clue at all”. You surely don't want to be in the category of “have no clue at all”. •
Helps you refresh your memory or learn answers to the technical questions that are frequently asked in interviews. This can build up your confidence and it really shows in interviews. Software development field is very vast and competitive, and it pays to jog your memory even if you are an experienced professional.
•
All the other applicants may have much the same degrees, certifications, skills, and experience. But those who are in the know how can make it all come alive and seem real by selling their practical and technical competencies with illustrations, examples, and enthusiasm. If you don't relate your qualifications, skills, experience, and abilities to demonstrated results, most employers will tend to think that you have a great deal of raw potential – but limited immediate usefulness.
•
Helps you think aloud for some of the more difficult to tackle scenario based and open-ended questions where the interviewers will be more interested in evaluating your thought process and approach than expecting a detailed solution or answer.
7
Getting Started …... •
Helps you progress in your career a lot quicker by enabling you to pro-actively learn and apply the core technical key areas that will otherwise take years to fully under­ stand if you rely on your experience alone. Some mistakes are too expensive to learn on the job.
This book complements our previously published book in 2005, entitled “Java/J2EE Job Interview Companion”, which was well received, and the purpose of this book is to keep up with the recent developments, cover more on coding, open-ended, and scenario based interview Q&A, and to incorporate some of the constructive criticisms from the readers and reviewers. The “Java/J2EE Job Interview Companion” gives an overview of many topics from Java to J2EE, XML to UML, and frameworks to emerging technologies. The “Core Java Career Essentials” as the name implies, focuses solely on the essentials in more depth. The ensuing career essentials series will cover the topics not covered here. “Knowledge is knowing what to do, skill is knowing how to do, virtue is getting it done. ” – Norman Vincent Peale
Why is this a PERFECT companion? The primary objective is to make your learning or brushing up a PERFECT experience, which stands for Practical, Enjoyable, Rewarding, Focused, Examples driven, Concise, and Thought-provoking.
8
•
Practical: What is the point in learning bitwise operators without knowing where to apply and when to use them? This book is full of practical examples, workable code, best practices, and potential pitfalls.
•
Enjoyable: Nothing is more enjoyable as a developer than cutting quality and workable code. That is why there are 100+ executable code samples as opposed to just code snippets. Feel free to experiment with the code samples.
•
Rewarding: The basics described here with examples and sample code can bring success in job interviews, technical tests, code reviews, and performance appraisals by learning to sell yourself more effectively.
•
Focused: Our last book entitled “Java/J2EE Job Interview Companion” was providing a bird's eye view of a vast range of technologies and frameworks. While this approach was well received and provided a road map for job interviews, it lacked some level of details. This book is focused on more details to extend its usefulness beyond just interviews by covering a limited number of topics in more depth.
•
Examples driven: Prospective employers are not just looking for professionals with just academic qualifications. They are looking for professionals with experience. You cannot drive a car with just theoretical knowledge. Software development is no different. So use these examples to code, code, and more code.
•
Concise: Who wants to read pages after pages about a single topic. There is always Google to perform additional research on a as needed basis.
•
Thought-provoking: The questions and answers approach gives a different perspective to learning and brushing up. It will get you thinking and asking the right questions when you are working on a project. Asking the right questions and spotting the potential pitfalls can present you in a better light for potential promo­ tions and pay rises.
What are the technical key areas? Writing a quality software is a very complex process. It must not only meet all the functional requirements to satisfy the business needs, but also should be robust, maintainable, testable, and flexible enough to adapt to growing and changing business needs. It must also address non-functional aspects like, • • •
Adequate logging, auditing, and alarms to provide better problem diagnostics and customer support. Security, data integrity, data retention, fail over and disaster recovery strategies. Being up 24x7, performance metrics, and adherence to SLAs (Service Level Agree­ ments) like response times, timeouts, etc. Service assurance can help improve customer trust and experience in the system.
If you just take technical design alone, there are many pros and cons for each approach 9
Getting Started …... along with likely trade-offs to be made in your design decisions. Understanding the key areas will help you not only write quality software, but also excel in your chosen career. How do you excel in your career by understanding the key areas you may ask? Firstly, in your regular job, •
You can earn the appreciation of your superiors and peers by pro-actively and retro­ actively solving everyday problems by understanding the key areas. For example, you can resolve problems relating to performance, memory, concurrency, language fundamentals, etc. Some of the subtle issues can be hard to understand, reproduce and solve without the adequate technical skills, and it really pays to have the exper­ ience and good understanding of the basics in these key areas.
•
Understanding some of the nuances and best practices can help you write less errorprone and more robust code. Writing maintainable, supportable, readable, and testable code will not go unnoticed in code reviews and can also earn you the much needed recognition. You can also come up with intelligent questions or suggestions in team/stand-up meetings and group discussions. You can pro-actively identify potential issues not only in your own code or design, but also in others' code and design to become a great contributor.
•
You can build up a reputation as a “go to person” by complementing your technical skills in these key areas with soft-skills and personal attributes to mentor others and get things done.
Secondly, in your job interviews,
10
•
You can impress your interviewers by highlighting your past achievements in these key areas. For example, you can make use of open-ended questions like “Tell me about your self ?” or “Why do you like software development?” to highlight your strengths and accomplishments.
•
Many software projects face performance bottlenecks, design inefficiencies, concur ­ rency issues, inadequate software development processes, etc. Hence the prospective employers will make sure that they hire the right candidate by asking questions relating to these key areas. Even if they don't cover any particular key area you are good at like performance tuning or concurrency management, you can bring it up yourself by asking intelligent questions like “What are the challenges faced by your
current software? and do you face any performance issues or customer complaints that are hard to reproduce? ”. •
Better candidates will control the interview in a nicer way as they understand it is a two way process. They will quickly understand what the prospective interviewer is looking for and reflect back on their past experience to relate how they went about resolving problems and adding value.
Let's look at the key areas relating to software development. Please be aware that not all key areas are covered in this book. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.
Language Fundamentals LF Specification Fundamentals SF Design Concepts DC Design Patterns DP Performance Considerations PC Memory Considerations MC Transaction Management TM Concurrency Considerations CC SCalability SC Exception Handling EH Best Practices BP Software Development Processes SP SEcurity SE COding for readability, maintainability, supportability, extendability, and testability CO 15. Quality of Service QS 16. Platform Fundamentals PF Most of the questions are tagged with relevant technical key area(s) shown above. Some questions are also tagged with question type and/or its popularity as shown below: • • • • •
Open-Ended Question OEQ Scenario Based Question SBQ COding Question COQ IMpossible Question IMQ Frequently Asked Question FAQ 11
Getting Started …... Speaking the same language as your prospective employers from both technical and business perspective will help you establish a level of comfort with them. Discuss things in simple terms so that anyone can understand. It is okay if you struggle a little and then figure it out with minor hints or prompting from the interviewers. It is natural to be a bit rusty as the technologies are pretty vast these days. But it is not a good sign to be completely clueless or badly confused, especially with the core fundamentals. These career companions and career essentials will boost your knowledge and confidence to succeed in your career. Take the initiative to grasp a potential employer's problems, challenges, and require­ ments to marry them with your past experience and accomplishments. This is more important than just having the necessary experience or understanding in the technical key areas. The ensuing sections will elaborate on this.
12
Important: •
Sample code in this book is making use of static methods and other approaches in many places for illustration purpose and to keep things simple. This should not be construed as a best practice.
•
A commercial standard code will make use of unit tests using either JUnit or TestNG instead of public static main(String[ ] args) methods for testing and most of the methods except a fewer utility methods will be non-static. You will hardly see main methods required except for initial bootstrapping of applications that are run stand-alone. It will also be making use of Object Oriented principles, Dependency Injection, Law of Demeter principle, Don't Repeat Yourself (DRY) principle, etc to make the code more reusable, testable, maintainable and readable.
•
The System.out.println(....) statements should be replaced with a logging framework like log4j. For example, private static final Log logger = LogFactory.getLog(MyClass.class); logger.info(“logging text goes here …................. ”);
•
Comments are over used to explain concepts, and real code should not be cluttered with comments. The classes, methods, and variables should have meaningful names and the code should be self-explanatory.
13
Getting Started …...
14
Section-2:
Platform Essentials • • • • •
Why use Java? Java platform basics – JDK, JRE, JVM, etc. Setting up and running Java How are your classes loaded? Compile-time vs runtime
This section is mainly for a beginner level, but I am very surprised to see even some intermediate to senior level developers lack good understanding of these platform essentials. This section is a must read for a beginner level. The intermediate and senior level candidates are highly recommended to brush up on the following frequently asked questions, Q1, Q2, Q3, Q7, Q8, Q9, Q10, Q17, Q18, Q19, Q20, Q21, Q22, Q24 and Q25. Even if you have limited experience, it is better to have an idea as to how to go about getting it done than to have no idea at all. This will differentiate yourself from others who have similar experience as you. Good Java interview questions are designed in a way to analyze if you are capable of applying the basics of a programming language.
15
Platform Essentials
Q&As 1-18 are skipped
Q19 What tips would you give to someone who is experiencing a class loading or “Class Not Found” exception? OEQ A19 “Class Not Found” exceptions could be quite tricky to troubleshoot. Firstly, determine the jar file that should contain the class file: $ find . -name '*.jar' -print -exec jar -tf '{}' ; grep -E 'jar$ String.class' Secondly, check the version of the jar in the manifest file MANIFEST.MF, access rights (e.g. read-only) of the jar file, and any jar corruption by trying to unjar it with 'jar -xvf ...'. If the class is dynamically loaded, check if you have spelled the class name correctly. Thirdly, check if the application is running under the right JDK? JAVA_HOME environment property
Check the
$ echo $JAVA_HOME Finally, you’ll need to have a good understanding of your application server’s classloader hierarchy. 16
•
Is the missing class packaged with the application (e.g., under WEB-INF/lib) and being loaded by one of the parent class-loaders? Most application servers utilize a class-loader hierarchy where WAR file’s class-loader is a child of EAR class-loader which in turn is a child of the system (JVM) class-loader. Parent class-loaders can’t go down to request a class loaded from a child class-loader. The problem occurs if some jars were moved to a shared library but they still depend on classes packaged with the application.
•
Running different versions of the same jar loaded by the different class loaders can cause this issue.
17
Platform Essentials
Compile-time versus runtime Learn to think in terms of compile-time versus runtime to solve issues quickly and identify better solutions to a given problem. Each approach has its pros and cons.
Q20 Explain compile-time versus runtime? PF FAQ A20 Compile-time (i.e. static) is when a program text (e.g. MyProgram.java) is being read in, analyzed, and translated into byte code version (e.g. MyProgram.class) that can be run on the JVM. At compile-time you can get syntactic errors like leaving out a closing bracket or a semicolon, type safety errors like assigning a type long to type int without an explicit casting, etc. Runtime (i.e. dynamic) is when the generated byte code is executed within the JVM. At runtime you get semantic errors like trying to examine the 4 th element of a list that has only 3 elements (e.g. ArrayIndexOutOfBoundsException), null reference errors (e.g. NullPointerException), attempting to cast an object to a subclass of which it is not an instance (e.g. ClassCastException), etc. Q21 Does this happen during compile-time, runtime, or both? PF LF FAQ A21 Method overloading: Skipped.... Method overriding: Skipped.... Generics (aka type checking): Skipped.... Annotations: Skipped.... Exceptions: Skipped.... Aspect Oriented Programming (AOP): Skipped.... Q22 Can you differentiate compile-time inheritance and runtime inheritance with examples and specify which Java supports? PF LF FAQ A22 Skipped.... Q23 Are marker or tag interfaces obsolete with the advent of annotations (i.e. runtime annotations)? LF A23 Skipped.... 18
Q24 What is the difference between line A & line B in the following code snippet? PC
COQ
public class ConstantFolding { static final int number1 = 5; static final int number2 = 6; static int number3 = 5; static int number4= 6; public static void main(String[ ] args) { int product1 = number1 * number2; int product2 = number3 * number4; }
//line A //line B
} A24 Skipped.... Q25 What is a Java debugger? What are the different ways to debug your code? PF A25 Skipped....
19
Platform Essentials
Section-3: Knowing your way around Java • • • •
Judging your exposure to Java through open-ended questions. Gauging your exposure to Unix operating systems as most production systems are Unix based. Understanding your experience in regards to proper documentation. Obtaining a feel for your awareness and attitude towards software quality
This section is mainly for intermediate to senior level. If you are a beginner, skim through this section, and come back to it after reading the other sections. This section is mainly used to judge your experience. So where possible give practical examples by reflecting back on your past experience using the SAR (Situation-Action-Result) technique. The answers provided here are hints only. As an experienced professional, your experience and views may differ. Experienced professionals know what works and what doesn't. They know what tools to use to simplify a task at hand. Good developers are opinionated based on their past experience. They can handle scenario based questions. They may pause a while to reflect back on their experience, but won't be stumped by the open ended questions. Reflecting back on your past experience and a little preparation prior to your interviews and meetings will really boost your performance. This is a brush up section that will not only help you sell yourself more effectively, but also will help you reflect back on your past experience and refresh your memory. This section will add value only if you perform well relating to sections 4 – 7 on fundamentals. This section will also provide valuable insights into getting your job done more effectively, and making yourself heard in team meetings by contributing suggestions or raising opinions. This does not mean that you will have to be inflexible. Most importantly, the good developers get things done by complimenting their technical skills with good soft-skills and right attitude.
20
Judging Experience As explained earlier, open ended questions give you a great opportunity to prove your caliber and usefulness to the organization in a well-rounded manner. You have no control over what questions get asked in interviews, but you have control over what messages, skills, exper­ ience, and personal attributes you want to nicely get across to your prospective employers or interviewers without bragging, being too critical, or coming across inflexible. The openended questions give you the chance to make an impression. A very common open-ended question is – tell me about yourself ? OEQ Q1 Can you list some of the Java features you used recently? LF A1 [Hint] JDK 5.0 (external version 5.0 and internal version 1.5.0) is a major feature release that largely centered on enhancing ease-of-development. Features: •
•
•
•
•
•
•
Generics: provides compile-time type safety to operate on objects of various types and collections frameworks. It eliminates the tedious labor of casting. (JSR-14) Enhanced for loop: eliminates the monotonous labor and error-proneness of iterators and index variables when iterating over collections and arrays. (JSR201) Autoboxing and auto-unboxing: eliminates the routine work of manual conversion between primitive data types such as int, long, etc and wrapper object types such as Integer, Long, etc. (JSR-201) Type safe enums: are flexible object oriented enumerated type facility that allows type safety without the verbosity and error-proneness of the “type safe enum pattern” that existed prior to JDK 5.0. (JSR-201) Varargs: eliminates the need of manually wrapping up argument list into an array when invoking methods that accept variable-length argument lists. (JSR201) Static import: eliminates the need to qualify static members with class names without the shortcomings of the “constant interface” anti-pattern existed prior to JDK 5.0. (JSR-201) Annotations: let you avoid boilerplate code under many circumstances by enabling tools to generate it from annotations in the source code. This leads to “attribute oriented” (aka declarative) programming. This eliminates the need to maintain “side files” that must be kept up to date with changes in source files. 21
Knowing your way around Java Instead the information can be maintained in a source file itself. This is also Java's answer to the XDoclet framework used prior to JDK 5.0 (JSR-175). Annotations allow you to add runtime metadata to classes, fields, and methods. Everything that can be done with marker or tag interfaces in earlier versions of Java can now be done with annotations at runtime using reflection. Libraries: •
• •
The Collections framework has been enhanced with support for generics, enhanced for loop, and autoboxing. Three new interfaces named Queue, Block­ ingQueue, and ConcurrentMap have been added. More efficient copy-on-write “List” and “Set” implementations have also been added. The Java API for XML Processing (JAXP) has been included in the JDK so it doesn't need to be downloaded separately. (JSR-206) The concurrency utility package java.util.concurrent was included as part of the standard edition 5.0, which previously had to be downloaded separately. This package provides a scalable, thread-safe, and high-performance building blocks for developing concurrent applications.
JDK 6.0 (external version 6.0 and internal version 1.6.0) release is centered on being Web Services friendly, mixing of Java with other scripting languages, and general enhancements to existing libraries. •
•
22
One of the most significant features of this release is support for the Java API for XML Web Services (JAX-WS), version 2.0. JAX-WS 2.0 includes Java Architecture for XML Binding (JAXB) 2.0 and SOAP with Attachments API for Java (SAAJ) 1.3. So Java SE 6.0 is SOA (Service Oriented Architecture) friendly, and Apache Axis framework is no longer required. Java SE 6.0 also includes a new framework and developer APIs to allow mixing of Java technology with scripting languages such as PHP, Python, JavaScript, and Ruby. This is very useful for prototyping, experimentation of an algorithm or function, and one off or ad hoc tasks like transforming a text file into a needed format, looking for a specific item in large log files, getting a subset of data from a database and packing it as a text file, etc. All of the above tasks can be done in a language like Java, but it can be faster and easier to do them in a scripting language like PERL, Ruby, or Python. BP It is a best practice to always use the right or best tool for the right job without just being overly passionate about Java alone.
•
•
•
Full JDBC 4.0 (Java Data Base Connectivity) implementation providing improved XML support for Databases. A free to use Java Database based on Apache Derby is included since JDK SE 5.0 download. Improved desktop APIs including newly incorporated “SwingWorker” utility to help with multi-threading in GUI applications and much needed “JTable” sorting and filtering capabilities. You also have access to new things such as desktop applications through what used to be called the JDesktop Integration Components (JDIC). You can now have the ability to add applications to the system tray. The GUI performance is snappier and integrates well with the native platforms. Improved monitoring and management through out of the box on demand support tools and inclusion of Java heap analysis tool (Jhat) for forensic explorations of those core dumps.
Q&As 2 to 4 are skipped Q5 Can you list the Java SE features you like to be added in the future? LF A5 [Hint] Closures: are useful for implementing abstractions that involve behavior. A closure is a named or anonymous subroutine. It looks like Java 7 will have closures. Closures can make your life as a developer much easier. Not sure of the actual syntax for Closures at this stage, but it could be something like: For example, to run a function in a thread pool, myThreadPool.submit(#( ) { for (int i = 1; i < 1000; i++) performTask(i) }); #( ) {...} --> is a function (i.e. an anonymous function) #( ) --> empty paranthesis indicate that the function has no arguments. Currently (up to Java 6), custom sorting of objects in a list requires an implementation of a Comparator interface. Closure could simplify this as follows to sort strings in a list by its length in an ascending order as shown here: Collections.sort( listStrings, #(String str1, String str2) str1.length( ) - str2.length( ));
23
Knowing your way around Java JavaScript is widely used in web development, and in JavaScript a closure is created every time you create a function within a function. When using a closure, you will have access to all the variables in the enclosing (i.e. the parent) function. var calculate = function(x) { var const = 2; return function(y) { return x + y + const; // has visibility to parent variable 'const' }; } var plus5 = calculate(5); alert(plus5(3)); alert(plus5(7)); alert(plus5(10));
//plus5 is now a closure //returns 10 i.e. x=5, y=3, const=2 //returns 14 i.e x=5, y=7, const=2 //returns 17 i.e x=5, y=10, const=2
Closures are first class objects in groovy, and in many ways it resembles anonymous inner classes in Java. The above functionality can be implemented in groovy as shown below: def calculate = {x,y -> x + y + 2} //closure def plus5 = { calculate.call(5,it)} //'it' is like 'this' in java. Here stands for //values passed in to plus5 call like 3, 7 or 10 println plus5.call(3) println plus5.call(7) println plus5.call(10)
//prints 10 //prints 14 //prints 17
Mixins: Java does not support multiple-inheritance, but it is possible to have the concept of 'mixins inheritance', which are 'partial classes' that you can bolt onto your class, giving you something very much like multiple inheritance. The concept of 'mixins inheritances' are great when you want to refactor common functionality from two classes having different super classes. Currently Java does not have 'mixins' like Ruby does. In many languages including Java, you cannot say, class FileTreeNode extends File mixin TreeNode {….} to give you access to all the operations provided by the File class to work with files and the TreeNode class to arrange files and perform binary searches at the same time. 24
You can achieve mixins in Java with the help of, • •
Aspect Oriented Programing (AOP) language like AspectJ. AOP compliments OO. Using interfaces and annotations (or reflection, CGLIB, etc) to mix at build time using annotations to generate the mixin code as demonstrated below. public interface TreeNode { TreeNode search(String toSearch); // ….other methods } public class TreeNodeImpl implements TreeNode { public TreeNode search(String toSearch) {…. } // ….other methods } @compose ( type = TreeNode.class, field = “tree”, implClass= “TreeNodeImpl.class” @parentClass (name = “java.io.File”) public FileTreeNode extends FileTreeNodeGenerated implements TreeNode { //... } The @compose and @parentClass annotations will generate the class FileTreeNode­ Generated at build time as shown below, which is extended and used by the FileTreeNode class. /** * Generated class that achieves reuse of the File class through * inheritance and the TreeNode class through composition. More * interfaces can be composed if required. */ public class FileTreeNodeGenerated extends File { private TreeNode tree; //composition public FileTreeNodeGenerated(....){ this.tree = new TreeNodeImpl(...); } 25
Knowing your way around Java public TreeNode search(String toSearch) { tree.search(toSearch); }
//use TreeNode
//... other methods } Note: The above example is shown only to demonstrate mixins, and this may not be the ideal solution to a given problem. You could also fake mixins in Java with the inner classes, but it would be ideal to have true mixins that are easier to use out of the box. Java Module System: JAR files are hard to distribute, hard to version, and hard to reference in general. Existing JAR format can lead to classpath and class loading problems when: •
a developer or deployer of a Java application has accidentally made two different versions of a library available to the system.
•
two different libraries (or a library and the application) require different versions of the same third library. If both versions of the third library use the same class names, there is no way to load both versions of the third library with the same classloader.
•
classes loaded by different class loaders may interact in complex ways not fully understood by a developer, leading to inexplicable errors or bugs.
The Java Module System (JSR 277) was initiated to address some of the issues caused by the JAR files. The Java Module System defines a distribution format and a repos­ itory for collections of Java code and related resources. It also defines the discovery, loading, and integrity mechanisms at runtime. It looks like Java 7 will have the Java Module System. Until then the OSGi can handle all of these nicely. The OSGi (Open Services Gateway initiative), which is also known as the dynamic module system for Java, defines an architecture for modular application development. The OSGi imple­ mentations such as Apache Felix, Equinox, and Knoplerfish allow you to break your 26
application into multiple modules, and thus allow you to better manage the cross dependencies between those modules Add some of the frequently used third party libraries like “Apache commons collections”, “Apache commons lang”, and more intuitive and easy to use libraries like “Joda-Time” to the Java core API (Joda-Time may become part of Java SE 7.0). You may also think of some of the features in other languages that you liked and keen to have those features added to Java if not already present in Java. For example, multi-line string literal in both Scala and Groovy as shown below is more readable and does not require special escape characters as in Java. String multiLine = '' Line 1 Line 2 'no escape' Line 3''; The syntax in Java is less readable, String multiLine = 'Line 1' + 'Line 2 'escape' + 'Line 3'; The Java POJOs (Plain Old Java Objects) verbose and less readable with all the getter and setter methods. Groovy comes to the rescue. Groovy makes POGOs (Plain Old Groovy Objects) less verbose and more readable by creating the getters/setters during byte code generation. In a POGO, if you have an access modifier, it will be treated as a property and if you don't specify an access modifier it will be a normal field. The following code shows Groovy and Java code working together by using the -j compiler switch to enable the joint compilation. The less verbose POGO in Groovy is as shown below: public class Person { String name String lastName private int id
//property //property //a normal field 27
Knowing your way around Java String toString( ) { return 'I am ${name} ${lastName}.' } } The invoking code in Java is as shown below public class Organization { public static void main( String args[ ] ) { Person person = new Person( ); . person.setName( 'Peter' ); person.setLastName( 'Smith' ); System.out.println( person.toString( ) ); } } Finally, you may prefer fixing or improving the existing limitations and gotchas in Java before adding any new features as it could make things worse. Most of these pitfalls are brought about by the effort to maintain the backward compatibility. Note: Being able to compare strengths and weaknesses of Java with other programming and scripting languages will demonstrate some of the recognizable qualities of good programmers. Good programmers get excited chatting about techno­ logies, and are passionate about diversifying on the technology stack. So learn different technologies, frameworks, and tools, and be opinionated about which are better for various scenarios. Q&As 6 to 11 are skipped
Gauging Your Experience with UNIX Most production systems are run in a Unix environment. The Unix environment is very robust, and offers powerful tools to automate tasks. You might be asked a scenario based question as shown below: Q. How would you go about replacing a piece of a text or a phrase from 20,000+ web 28
templates residing on a Unix file system? SBQ Even some candidates with 5+ years of experience will be tempted to spend a day or two to write 200+ lines of code to achieve the above requirement, when it can be achieved in 5 minutes with a simple Unix command. Some of the Unix commands like grep, find, awk, sed, etc along with the power of regular expressions can make you more productive. Q12 Can you list some of the “UNIX” commands Java developers use very frequently? PF A12 Find command: allows a Unix user to process a set of files and/or directories in a file sub tree. Examples, •
Recursively delete .svn directories: Subversion is a widely used open-source revision control application. Every copy of source code received from subversion repository has .svn folders, which store metadata. However, if you want to use or distribute source code, these .svn folders are often not necessary. When creating a new subversion project (or folder) based on an existing subversion project, it is imperative that the .svn folders are deleted before checking in the copied and subsequently modified project. Otherwise you run the risk of corrupting the original subversion project with the newly copied and modified project. rm -rf `find . -type d -name .svn`
•
Search for a file with a specific name in a set of files in the current (i.e. “ .”) directory. find . -name 'rc.conf' -print
•
Search for “*.java” files that are using “java.util.concurrent” classes. find . -type f -name '*.java' -exec grep 'java.util.concurrent' {} ; -print find . -type f -name '*.java' xargs -n1 grep 'java.util.concurrent'
•
Searching for old files. Finding files that are 7 days old or finding a file that has not been accessed for 30 days more, and files that are larger than 100k: 29
Knowing your way around Java find . -mtime 7 -print find . -type f -atime +30 -print find . -type f -size +100k -ls The grep and egrep commands are very handy for tearing through text files and finding exactly what you want very quickly. •
Search the log files to see if a particular user logged in. cat /var/log/server.log grep 'login.jsp' grep 'userid'
•
List all the log files that have a particular search text. grep -l 'Missing Characteristic Value' *.log*
•
You can use regular expression patterns to search. grep -e '^import.*util.regex' *.java
•
Find all occurrences of util.* packages except the util.regex package. grep -e '^import.*util' *.java grep -v 'regex'
Tip: The Java LinkageError is tricky to resolve and it indicates that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class. Since plethora of third party jar files are used in commercial applications, it is not uncommon to get an error like, java.lang.LinkageError: Class javax/xml/namespace/QNAme violates loader constraints This means the class javax.xml.namespace.QName is loaded by two or more different class loaders, and the versions are not compatible. For example, one might be under WEB-INF/lib, another might be loaded through an EJB or from a server lib folder. The “find” and “grep” Unix command can come to the rescue to identify the offending jars as shown below:
30
$ find . -name '*.jar' -print -exec jar tvf {} ; grep -E 'jar$ javax/xml/namespace/QName.class' Remaining discussions are skipped ... Q13 Can you give some examples of where you used “sed” and “awk” utilities? PF A13 Q14 Can you answer the following Unix questions? PF Q. Can you explain the following Unix command? $ date ; ps -ef awk '{print $1}' sed -e '1d' sort uniq wc -l >> activity.log A. Skipped.... Q. How will you list the top 5 largest files or directories? A. Skipped.... Q. How will you find out the disk free space? A. Skipped.... More Q&A Skipped.... Q15 Can you brief on a shell script that you had worked on? OEQ A15 Skipped....
Exposure to tools, technologies, and frameworks Using the right tools, technologies, and frameworks for the right job can not only make developers more productive, but also can significantly increase the robustness and quality of the applications built. There are so many free online resources to master the tools if you know what tools to use and when to use them. Tools will not only help you become more productive, but also enable you to impress your superiors and peers by delivering your work on time without compromising on the quality. 31
Knowing your way around Java Q16 Can you name some tools, technologies, or frameworks you had to use in Java for source code generation, byte code manipulation, or assembling code at runtime? PF A16 Skipped.... Q17 What tools do you generally need to get your job done? OEQ FAQ A17 Skipped.... Q18 What other languages have you used? LF A18 Skipped.... Q19 How would you go about......? questions like • • • • • •
How would you go about performance tuning an application? How would you go about identifying memory leaks or thread safety issues in an application? How would you go about gathering requirements, designing, and documenting your applications? How would you go about identifying and fixing any potential transactional issues in your application? How would you go about determining the security requirements for your application? How would you go about describing the software development process you are familiar with?
A19 These questions have been addressed in the “Java/J2EE Job Interview Companion (400+ Q&A)”.
Documenting your Java applications Good documentation is vital to any software project. As your documentation will be reviewed by your superiors and peers, a good documentation will also make a good impression and can surely help you progress in your career or get your contracts extended. Q20 What are the different types of documents you refer to while designing or coding your system? DC OEQ FAQ A20 Skipped.... 32
Q21 In your experience, why is it important to have relevant APIs handy while coding? LF COQ A21 Skipped.... Q22 What do you expect to see in a high level or detailed technical specification document? DC OEQ A22 Skipped.... Q23 What do you expect to see in a high level or detailed business requirements document? OEQ A23 Skipped.... Q24 What tips do you give to someone who wants to write a technical documentation? A24 Skipped....
Ensuring code quality. As a software engineer, you should ensure how your users will a have quality experience with the system you build. You must learn not only to think from a technology perspective, but also from a user experience and business objective perspective. No point in building something with a bleeding edge technology, if it does not add real value to your business and their users. QOS
Q25 Do you use test driven development? Why / Why not? COQ SP A25 [Hint:] Yes. •
Gives you a better understanding of what you're going to write. Gets you to clearly think what the inputs are and what the output is. Helps you separate the concerns by getting you to think about the single responsibility principle (SRP).
•
Enforces a better test coverage. This gives you the confidence to refactor your code in the future, since you have a good coverage.
33
Knowing your way around Java •
You won't waste time writing features you don't need.
Q26 What tips do you give someone who is writing the unit testing? COQ SP A26 Skipped.... Q27 How will you ensure quality of your design and code? COQ BP DC DP A27 Skipped.... Q28 Can you list some of the key aspects you keep in mind while coding to ensure quality & robustness? COQ BP DC DP A28 Skipped.... Q29 What are mock objects and when do you use them? COQ A29 Skipped.... Q30 What development methodologies are you comfortable with? SP A30 Skipped.... 'In theory there is no difference between theory and practice. In practice there is.' – YogiBerra
34
Section-4:
Language Essentials • • • • • • • • • • • • •
Valid identifiers and reserved keywords Choosing the right data types Widening versus narrowing conversions Understanding the operator precedence Thinking in binary and bitwise operations Initializing your data correctly Packaging your classes to avoid conflicts Constants and static imports Modifiers and where are they applicable? Methods and constructors Recursive functions It is always pass-by-value in Java Class, instance, and local variables
This section is mainly for beginner to intermediate level. It also contains useful information for senior level candidates, and worth having a quick browse through, especially if you are required to sit for a basic Java technical test. Even among experienced profes­ sionals, there are a breed of developers who know how to get things done by using various frameworks, tools, and googling without fully understanding the fundamentals. Under­ standing the core Java fundamentals are essential not only from the point of view of passing the technical tests used for screening potential candidates and to perform well in technical job interviews, but also from the point of view of showing off your technical capabilities within limits to your peers and superiors during code review sessions, team meetings, and situations where you were able to resolve an intermittent, critical, or obscure problem more quickly than others as you understand the nitty-gritty details. It's important to let others know about the good things you are accomplishing. Don't think that by just working hard that you'll get noticed. You need to let people know, 35
Language Essentials especially your leaders like to know these things because they can't know everything that is going on, so speak up when required to. A little preparation prior to a code review session or an important team meeting that was going to discuss “a class loading issue” can make a huge difference in making an impact. All you have to do is refresh your memory on the basics.
36
Valid identifiers and reserved keywords Q1
What are identifiers in Java? What does the following code do? Can you talk us through the code highlighting some of the key language and design features? COQ LF BP package chapter2.com; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; public final class ValidIdentifiers { private enum Validity { Valid, InvalidIdentifierStart, InvalidIdentierPart, ReservedKeyWord, ReservedLiteral }; private static final String[ ] RESERVED_KEYWORDS = { 'abstract', 'continue', 'for', 'new', 'switch', 'assert', 'default', 'if', 'package', 'synchronized', 'boolean', 'do', 'goto', 'private', 'this', 'break', 'double', 'implements', 'protected', 'throw', 'byte', 'else', 'import', 'public', 'throws', 'case', 'enum', 'instanceof', 'return', 'transient', 'catch', 'extends', 'int', 'short', 'try', 'char', 'final', 'interface', 'static', 'void', 'class', 'finally', 'long', 'strictfp', 'volatile', 'const', 'float', 'native', 'super', 'while' }; private static final String[ ] RESERVED_LITERALS = {'true', 'false', 'null'}; private static Set KEYWORDS = new HashSet( (int)(RESERVED_KEYWORDS.length/0.75)); private static Set LITERALS = new HashSet( (int)(RESERVED_LITERALS.length/0.75)); 37
Language Essentials static { List list = Arrays.asList(RESERVED_KEYWORDS); KEYWORDS = new HashSet(list); List listLit = Arrays.asList(RESERVED_LITERALS); LITERALS = new HashSet(listLit); } public static final Validity valid(String input) { if (input.length( ) 0 !Character.isJavaIdentifierStart(input.charAt(0))) { return Validity.InvalidIdentifierStart; } for (int i = 1; i < input.length( ); i++) { if (!Character.isJavaIdentifierPart(input.charAt(i))) { return Validity.InvalidIdentierPart; } } if (KEYWORDS.contains(input)) { return Validity.ReservedKeyWord; } if (LITERALS.contains(input)) { return Validity.ReservedLiteral; } return Validity.Valid; } } A1
Identifiers are names you give to your variables, constants, classes, interfaces and methods. The above code verifies if a given input is a valid identifier, complying with the following rules: •
38
The first character of an identifier must be a letter, an underscore(_), or a currency sign(e.g. $).
• • •
The rest of the characters in the identifier can be a letter, underscore, currency sign, or digit. Note that spaces are NOT allowed in identifiers. Identifiers are case-sensitive. This means that age and Age are considered as different identifiers. Identifiers cannot match any of Java's reserved words like for, int, etc or literals like null, true, and false..
Note: true, false, and null might seem like keywords, but they are actually literals; you cannot use them as identifiers in your programs. Note: const and goto are reserved, but not currently used. enum was added in Java 5. strictfp allows you to have more predictable control over floating-point arithmetic. Q. Can you talk us through the code highlighting some of the key language and design features? A. • Use of enums and generics indicates that this code must be using JDK version 1.5 or greater. •
LF Private access modifiers are used where required to encapsulate the internal details.
•
LF The class is marked final so that it cannot be extended.
•
DC It follows the “code to interface” design principle. For example, the Set, List, etc shown below are interfaces. private static Set KEYWORDS = new HashSet( (int)(RESERVED_KEYWORDS.length/0.75)); //... List list = Arrays.asList(RESERVED_KEYWORDS);
•
BP Making use of the Java API methods where possible. For example, the methods shown below from the Character and Arrays classes, simplify your code. So don't memorize the Java API, but keep it handy and constantly refer to it.
39
Language Essentials Character.isJavaIdentifierStart(input.charAt(0)) Character.isJavaIdentifierPart(input.charAt(i)) List list = Arrays.asList(RESERVED_KEYWORDS); •
BP If a size of a collection is known in advance, it is a best practice to set its initial size appropriately to prevent any resizing. Implementing the code as shown below would not quite work. private static Set KEYWORDS = new HashSet( RESERVED_KEYWORDS.length); The internal threshold for HashSets and HashMaps are calculated as (int) (capacity * loadFactor). The default loadFactor is 0.75. This means the HashSet will resize after 75% of its capacity has been reached. The resizing and rehashing of the set can be prevented as follows, private static Set KEYWORDS = new HashSet( (int)(RESERVED_KEYWORDS.length/0.75));
•
BP: BP Checking for null and empty string as a precondition in the beginning of the valid(String input) method. if (input null input.length( ) 0 ...) The above code snippet is a slight deviation of the fail fast principle, which states that check and report any possible failures as soon as possible. Testing your code for failure points will lead to better, safer, and more reliable code.
Q. Do you have any recommendations to further improve the code? OEQ A. Yes. •
The Apache commons library class StringUtils can be introduced here. The method isEmpty (String input) can be used to check for both null and empty string. This library does have other useful methods that can be used elsewhere in the application code to enforce the fail fast principle. StringUtils.isEmpty(input)
40
•
The RESERVED_KEYWORDS and RESERVED_LITERALS constants may be loaded from a configuration file. This will ensure that if new keywords or literals are added to Java in the future, it will require only a configuration change.
Note: Even though the above recommendations are debatable depending on various other factors, it is better to know the possible options to demonstrate your experience than to have no ideas at all. Q2
Which of these are legal Identifiers? LF a) b) c) d) e) f) g) h) i) j) k)
$Ident1 _Ident1 -Ident1 2Ident1 private private1 null Ident-1 Ident$1 u00A3Ident1 u00A5Ident1
A2
Skipped....
Q3
Which of the following are keywords in Java? LF a) b) c) d) e) f) g) h) i) j) k)
friend NULL implement synchronized throws implements synchronize volatile transient native interface 41
Language Essentials l) m) n) o) p) q) r) s) A3
TRUE new true strictfp instanceof then throw this
The keywords are: d, e, f, h, i, j, m, o, p, r, s. Note: true is a reserved literal not a reserved keyword. Also, take care with the spelling. implements ending with an 's' is a keyword, but implement is not. synchronized ending with 'ed' is a keyword, but synchronize is not. Unlike other languages, then is not a keyword. You only have if and else in Java. Both throw and throws are keywords.
Q4 A4
Why is it a best practice to adhere to naming conventions and what are they? BP Skipped....
Choosing the right data types Some simple mistakes like having an integer overflow can bring an application down and cost companies in thousands. Q5
How would you go about choosing the right data types for your application? What are wrapper classes, and why do you need them? LF BP FAQ
A5
Skipped....
Q6
When working with floating-point data types, what are some of the key considera­ tions? LF BP COQ FAQ
A6
Skipped....
Widening versus narrowing conversions 42
Q7 A7 Q8 A8
What is your understanding of widening versus narrowing conversions of primitive data types? Can you explain explicit and implicit casting? LF COQ FAQ Skipped.... What are the dangers of explicit casting? LF COQ FAQ Not knowing the MIN and MAX values can result in unexpected results due to loss of data during narrowing. package chapter2.com; public class DataTypes2 { /** * Trap #1 Be careful when casting explicitly. * * Not knowing the correct range (i.e Min and Max) can cause * unexpected results as illustrated */ public static void main(String[ ] args) { int iWithinByteRange = 125; int iOutsideByteRangeMax = 129; int iOutsideByteRangeMin = -129; byte bGood = (byte) iWithinByteRange; System.out.println('bOkay=' + bGood);
// 125 – good
byte bBad = (byte) iOutsideByteRangeMax; System.out.println('Trap #1 - bBad=' + bBad);
// -127 – bad
byte bBadAgain = (byte) iOutsideByteRangeMin; System.out.println('Trap #1 - bBadAgain=' + bBad); // -127 – bad } } Q9
Can you explain why the code snippet under (a) gives a compile-time error and code snippet under (b) compiles and runs with an output of 20? COQ LF a)
43
Language Essentials byte b = 10; b = b + 10;
// line 1 // line 2
b) byte b = 10; b+=10; A9
//line 1 //line 2
Skipped....
Q10 What is wrong with the following code, and how will you fix it? LF COQ package chapter2.com; public class IntegerMaxValue { public int addFive(int input) { if (input + 5 > Integer.MAX_VALUE) { throw new IllegalArgumentException('Invalid input: ' + input); } return input + 5; } public static void main(String[ ] args) { IntegerMaxValue imv = new IntegerMaxValue( ); System.out.println('value = ' + imv.addFive(5)); } } A10 Skipped....
Understanding the operator precedence Q11 What do you understand by operator precedence in Java? LF A11 Skipped....
44
Q12 Do you think the following code will throw a compile-time exception? If yes, how will you fix it? LF float myVal = (float)3.0/2.0; A12 Yes. It is cast first and then divided as casting operator has precedence over division operator as per the precedence table. So the above code is equivalent to float myVal = 3.0f/2.0; // float divided by double returns a double //as per the binary numeric promotion principle To fix it, you need to get the division operator to evaluate prior to casting. You can achieve this by introducing a parenthesis around the division as parenthesis has higher precedence (in fact highest) than casting as per the precedence table. float myVal = (float)(3.0/2.0);
// double divided by double returns a // double and it is then explicitly // cast to float to return a float value.
. Q13 What is the output of the following code snippet? LF COQ package chapter2.com; public class PrePostOperators { public static void main(String[ ] args) { int x = 5; int y = ++x; int z = y++;
// line 1 // line 2 // line 3
System.out.println('x=' + x + ', y=' + y + ', z=' + z); } } A13 Skipped.... Q14 What is the output of the following code snippet? LF package chapter2.com; 45
Language Essentials public class NaN { public static void main(String[ ] args) { System.out.println('Output=' + 2.0/0.0); //floating-point division by zero System.out.println('Output=' + -2.0/0.0); //floating-point division by zero System.out.println('Output=' + 2 /0); //integer division by zero } } A14 Skipped.... Q15 What will be the output of following operations? LF int i = 10 / 3; int r = 10 % 3; A15 Skipped.... •
Thinking in binary and bitwise operations Even though there is rarely a time bitwise operations seem directly necessary, the standard library uses bitwise operations indirectly for efficient processing. For example, the StringBuf­ fer.reverse( ), Integer.toString( ), BigDecimal and BigInteger classes to name a few. There are number of practical examples listed where bitwise operations are very handy. Some interviewers prefer asking questions on this topic or including it in the written test to determine how technical you are. If pressed for time, either scan through or skip this topic. Q16 Can you convert the decimal value of 127 to binary, octal, and hexadecimal values? LF A16 Binary: Bit number Binary has 2 possible values 0 (off) and 1(on). Expanded Bits that need to be on (i.e. 1) 46
8
7
6
5
4
3
2
1
7
6
5
4
3
2
1
2
2
2
2
2
2
2
20
128
64
32
16
8
4
2
1
0
1
1
1
1
1
1
1
to add up to 127 are 64 + 32 + 16 + 8 + 4 + 2 + 1 = 127. Hence the binary value is 0111 1111. Octal: Binary value for 127 is
0
1
1
2
Octal has 8 possible values 0, 1, 2, 3, 4, 5, 6, 7
1
1
1
1
1
8
1
0
8
8
Represent the octal values in binary
21
20
22
21
20
22
21
20
Expanded, and the bits that are “turned on” (i.e. 1's) highlighted. Shaded values add up to the octal values shown below.
2
1
4
2
1
4
2
1
Octal representation of 127.
1
7
7
The octal value is 0177. (First zero denotes octal representation ). You can verify your result by converting this back to decimal as follows: 1 x 82 + 7 x 81 + 7 x 80 = 64 + 56 + 7 = 127. Hexadecimal: Binary value for 127 is
0
1
Hexadecimal has 16 possible values from 0 to 15 denoted by 0,1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F (i.e. A is 10, B is 11 … and F is 15)
1
1
1
1
161
1
1
160
Represent the hexadecimal 23 values in binary
22
21
20
23
22
21
20
Expanded, and the bits that are “turned on” (i.e. 1's) highlighted. Shaded values
4
2
1
8
4
2
1
8
47
Language Essentials add up to the hexadecimal values shown below. Hexadecimal representation of 127.
7
F
The hexadecimal value is 0x7F. (0x denotes hexadecimal). You can verify your result by converting this back to decimal as follows: 7 x 161 + 15 x 160 = 112 + 15 = 127. Q. How will you convert 0x7F back to binary? LF Hexadecimal value 7
F
Value
15
Shaded values add up to the value above
7 8
4
2
1
8
4
2
1
23
22
21
20
23
22
21
20
0
1
1
1
1
1
1
1
The binary value for 0x7F is 0111 111. Here is a sample Java program. package chapter2.com; public class Binary1 { public static void main(String[ ] args) { Byte bOctal = 0177; Byte bHexaDecimal = 0x7F;
// decimal value 127 // decimal value 127
System.out.println('decimal value of bOctal = ' + bOctal.intValue( )); System.out.println('decimal value of bHexaDecimal = ' + bHexaDecimal.intValue( )); System.out.println('binary value of bOctal = ' + Integer.toBinaryString(bOctal)); System.out.println('binary value of bHexaDecimal =' 48
//127 // 127 //1111111
+ Integer.toBinaryString(bHexaDecimal));
//1111111
} } Q17 How do you represent negative numbers in Java? What is the negative binary value for the number 37? LF A17 Skipped.... Q18 What are the common bitwise operations? LF A18 Skipped.... Q19 Can you list some practical applications where the bitwise operations can be applied? LF COQ A19 Skipped....
Initializing your data correctly Q20 What would happen when the following code is compiled and run? LF COQ package chapter2.com; public class VariableInitialization2 { public static void main(String[ ] args) { int x = 10, y; if (x < 10) { y = 1; } if (x >= 10) { y = 2; } System.out.println('y is ' + y); } } A20 Skipped.... 49
Language Essentials Q21 Can you tell me what is the use of a static block in a class with an example? Is it a good practice to use static blocks? LF BP COQ A21 Skipped.... Q22 How will you provide a member variable named dueDate with an initial default value set to first day of the following month? LF COQ A22 Skipped.... Q23 Is there anything wrong with the following code snippet? COQ package chapter2.com; public class VariableInitialization3 { private static final String CONSTANT_VALUE = null;
// line A
static { // … load values based on some condition or .properties file. CONSTANT_VALUE = 'loaded'; // line B } } A23 Yes. Compile-time error at line B. CONSTANT_VALUE = 'loaded'; indicating that the final field VariableInitialization3.CONSTANT_VALUE cannot be assigned. Q. How will you fix it? A. Remove the initial null assignment in line A. Final variables can only be assigned once. private static final String CONSTANT_VALUE;
Constants and static imports 50
// fixed
Q25 What is a constant interface anti-pattern? How will you avoid it? DP A25 Skipped....
Modifiers and where are they applicable? Q26 Why use modifiers? Why can't you declare a class as both abstract and final? FAQ A26 Skipped....
LF
Q27 What are the valid access modifiers? LF FAQ A27 Public, protected, package-private (i.e. no modifier), and private. Q28 Discuss the significance of the modifiers used in the following class? LF COQ package chapter2.com; final class MyConsts { private MyConsts( ){ }; static final double TRIANGLE_AREA_PREFIX = 1.0/2.0; static final double SPHERE_VOLUME_PREFIX = 4.0/3.0; } A28 Skipped.... Q29 If you want to extend the java.lang.String class, what methods will you override in your extending class? LF A29 Skipped.... Q30 Are 'volatile' and 'const' valid modifiers in Java? LF FAQ A30 Skipped.... Q31 How would you go about determining what access levels to use in your code? FAQ
BP
51
Language Essentials A31 Skipped.... Q32 If you were to give some tips on modifiers, what would they be? LF A32 Skipped....
Methods and constructors Q33 What is the difference between constructors and other regular methods? What happens if you do not provide a constructor? Can you call one constructor from another? Are constructors inherited? How do you call a super class's constructor? LF FAQ A33 Skipped.... Q34 Where and how can you use a private constructor? A34 Skipped....
LF DP FAQ
Q35 What are static factory methods? Can you give examples from the Java API? What design patterns does it use? Can you describe the benefits of static factory methods and usefulness of private constructors? LF DP FAQ A35 Skipped.... Q35 … Q49 are skipped …..................
52
53
Language Essentials
Section-5:
Classes and Interfaces Essentials • • • • • • • • •
Working with classes and interfaces subclassing, overriding, and hiding Designing your classes and interfaces Working with abstract classes and interfaces Inheritance versus composition Applying the design principles Class invariant and design by contract Working with inner classes Packaging your classes to avoid conflicts
This section is for all. If you asked me to pick a section that is most popular with the interviewers, this is it. If you don't perform well in this section, your success rate in inter­ views will be very low. Good interviewers will be getting you to analyze or code for a particular scenario. They will be observing your decisions with interfaces and classes, and question your decisions to ascertain your technical skills, analytical skills, and communication skills. You can't memorize your answers. This section requires some level of experience to fully understand. It has enough examples for beginners to get some level of familiarization. Be ready to be asked about some tricky questions around the topics discussed in this section. Java interview questions are meant to analyze your technical bent of mind. You have to tell the way you are going to solve a particular problem with Java or any other programming language of your choice. So the key is to ask the right questions and then apply what you had learned. Keep practicing the examples provided here, and experiment with them until you get a good grasp.
54
Working with classes and interfaces Object oriented (i.e. OO) concepts are an important building for creating good services. They provide a common vocabulary to talk about the architecture. Without good under­ standing of the OO concepts, you could easily implement a procedural programming using classes. All you have to do is create a bunch of classes with nothing but data with getter and setter methods, and some other Handler or Processor classes to handle the logic with if/else and instanceof constructs sprayed all over the place. It is important to understand that objects need to not only take care of themselves with data and behavior, but also have to interact with each other. Q1 Which class declaration is correct if A and B are classes and C and D are interfaces? LF a.) class Z extends A implements C, D{} b.) class Z extends A,B implements D {} c.) class Z extends C implements A,B {} d.) class Z extends C,D implements B {} A1
a. class Z extends A implements C, D{} A class is a template. A class can extend only a single class (i.e. single inheritance. Java does not support multiple implementation inheritance), but can implement multiple interfaces to achieve multiple interface inheritance. An interface can also extend more than one other interfaces. interface E extends C,D { //.... }
Q2 What is a class? What are the valid modifiers of a top level class? LF A2 A class is a template for multiple objects with similar features. In another words, A class defines responsibilities (i.e. characteristics and behaviors) that are common to every object. Modifiers: A top level class can either be public or package-private (i.e. no access modifier) scoped. It can be final concrete, abstract, or non-final concrete (i.e. no final or abstract modifiers). public class A { … }
// non-final concrete class 55
Classes and Interfaces Essentials class A { … } public abstract class A { … } public final class A { … }
// non-final concrete class // abstract class // final concrete class
Subclassing, overriding, and hiding (aka shadowing) Q3 What is a subclass? LF A3 A subclass is a class that extends a class. A subclass inherits all of the public and protected members of its parent class, no matter what package the subclass is in. If the subclass is in the same package as its parent, it also inherits the package-private (i.e. no access modifier) scoped members of the parent. Q4 What can you do in a subclass? LF FAQ A4 You can supplement, override, inherit, and hide/shadow your superclass members. Supplement: • You can declare new fields in the subclass that are not in the superclass. • You can declare new methods in the subclass that are not in the superclass. • You can write a subclass constructor that invokes the constructor of the superclass, either implicitly or by explicitly using the keyword “super(...)”. Override: • You can write a new instance method in the subclass that has the same signature as the one in the superclass, thus overriding it. The ability to override methods allows you to take advantage of runtime polymorphism. Inherit: • You can inherit commonly used state and behavior in the super class. One of the benefits of implementation inheritance is to minimize the amount of duplicate code in an application by reusing code from the superclass. Since Java does not support multiple implementation inheritance, it becomes a card that can be played only once, and thus it should be used with caution. Shadow/hide: • You can declare a field in the subclass with the same name as the one in the superclass, thus hiding it (not recommended). 56
•
You can write a new static method in the subclass that has the same signature as the one in the superclass, thus hiding it (not recommended).
Q5 What is the output of the following code snippet? Give your reasons and recommend­ ations? COQ package subclass1; public abstract class Animal { String name = 'animal'; public String getName( ){ return this.name; } } package subclass1; public class Cat extends Animal { String name = 'cat'; public String getName( ){ return this.name; } } package subclass1; public class Example { public static void main(String[ ] args) { Animal animal = new Cat( ); Cat cat = new Cat( ); System.out.println(animal.name); System.out.println(cat.name); System.out.println(((Cat)animal).name); 57
Classes and Interfaces Essentials System.out.println(((Animal)cat).name); System.out.println(animal.getName( )); System.out.println(cat.getName( )); } } A5
Skipped....
Q6 What happens when a parent class and a child class each have a static method with the same signature? LF A6 Skipped....
Designing your classes and interfaces You need to have a good understanding of the OO concepts, design principles, and certain amount of common sense to design a quality system. Any one can recite the definition of the OO concepts and design principles, but only a few can come up with good class designs for a given problem. It is important to understand when to use an attribute versus a subclass, and when to use a composition or aggregation as opposed to inheritance. For example, if a Dog is a class extending an abstract class Animal, how would you design a Dog with a mole? As a subclass or as an attribute? If you have a class Animal, how would you define its body parts? As a subclass of animal or composition? [Hint: define mole as an attribute like special­ Marks, and define the body parts as a composition]. A mole won't make a Dog to be more specialized. A dog with a mole does not have a more specialized behavior compared to dogs without a mole. The body parts of a dog don't have an “is a” relationship with the Dog. You can't say that a leg “is a” dog. You will have to say a dog has legs. This is a “ has a” relationship denoting a composition or aggregation. There are more to it, and you will have a better understanding after going through the following Q&As with lots of examples. Q7 How do you know that your classes are badly designed? DC OEQ A7 • If your application is fragile – when making a change, unexpected parts of the application can break. • If your application is rigid – it is hard to change one part of the application without affecting too many other parts. • If your application is immobile – it is hard to reuse the code in another 58
application because it cannot be separated. Overly complex design is as bad as no design at all. Get the granularity of your classes and objects right without overly complicating them. Don't apply too many patterns and principles to a simple problem. Apply them only when they are adequate. Don't anticipate changes in requirements ahead of time. Preparing for future changes can easily lead to overly complex designs. Focus on writing code that is not only easy to understand, but also flexible enough so that it is easy to change if the requirements change. Q8 Can you explain if the following classes are badly designed? OEQ SBQ The following snippets design the classes & interfaces for the following scenario. Bob, and Jane work for a restaurant. Bob works as manager and a waiter. Jane works as a waitress. A waiter's behavior is to take customer orders and a manager's behavior is to manage employees. package badrestaurant; public interface Person {} package badrestaurant; public interface Manager extends Person { public void managePeople( ); } package badrestaurant; public interface Waiter extends Person { public void takeOrders( ); } package badrestaurant; public class Bob implements Manager, Waiter { @Override public void managePeople( ) { 59
Classes and Interfaces Essentials //implementation goes here } @Override public void takeOrders( ) { //implementation goes here } } package badrestaurant; public class Jane implements Waiter { @Override public List takeOrders( ) { //implementation goes here } } The Restaurant class uses the above classes as shown below. package badrestaurant; public class Restaurant { public static void main(String[ ] args) { Bob bob = new Bob( ); bob.managePeople( ); bob.takeOrders( ); Jane jane = new Jane( ); jane.takeOrders( ); } } A8
Skipped....
Q9 What do you achieve through good class and interface design? DC OEQ 60
A9
Skipped....
Q10 What are the principles of class design used in regards to OOD? DC A10 Skipped.... Questions 11 … 26 are skipped....
Applying the design principles Q27 How will you improve on the following code snippets with appropriate design principles? DC COQ SBQ package principle_srp1; import java.sql.Connection; import java.sql.SQLException; import org.apache.commons.lang.StringUtils; public class Animal { private Integer id; private String name; private Connection con = null; //getters and setters for above attributes go here.. public boolean validate( ) { return id != null && id > 0 && StringUtils.isNotBlank(name); } public void saveAnimal( ) throws SQLException { //save Animal to database using SQL //goes here ... } public Animal readAnimal( ) throws SQLException { //read Animal from database using SQL 61
Classes and Interfaces Essentials //... Animal animal = null; //... return animal; } } A27 The above class represents 3 different responsibilities. • • •
Uniquely identifies an animal with id and name. Interacts with the database to save and read an animal. Validates the animal details.
Hence, the above class violates the Single Responsibility Principle (SRP), which states that a class should have only one reason to change. This principle is based on cohesion. Cohesion is a measure of how strongly a class focuses on its responsibil­ ities. It is of the following two types: •
High cohesion: This means that a class is designed to carry on a specific and precise task. Using high cohesion, methods are easier to understand, as they perform a single task.
•
Low cohesion: This means that a class is designed to carry on various tasks. Using low cohesion, methods are difficult to understand and maintain.
Hence the above code suffers from low cohesion. The above code can be improved as shown below. The Animal class is re-factored to have only a single responsibility of uniquely identifying an animal. package principle_srp1a; public class Animal { private Integer id; private String name; public Integer getId( ) { return id; 62
} public void setId(Integer id) { this.id = id; } public String getName( ) { return name; } public void setName(String name) { this.name = name; } } The responsibility of interacting with the database is shifted to a data access object (i.e. DAO) class. The data access object class takes an animal object or any of its attributes as input. package principle_srp1a; public interface AnimalDao { public void saveAnimal(Animal animal); public Animal readAnimal(Integer id); } package principle_srp1a; import java.sql.Connection; public class AnimalDaoImpl implements AnimalDao { private Connection con = null; // getters and setters for above attributes // go here.. @Override public void saveAnimal(Animal animal) { // save Animal to database using SQL // goes here ... } 63
Classes and Interfaces Essentials @Override public Animal readAnimal(Integer id) { // read Animal from database using SQL // goes here ... Animal animal = null; // ... return animal; } } Finally, the responsibility of validating an animal is re-factored to a separate class that takes an animal object as input. package principle_srp1a; public interface Validator { public boolean validate(Animal animal); } package principle_srp1a; import org.apache.commons.lang.StringUtils; public class AnimalValidator implements Validator { @Override public boolean validate(Animal animal) { return animal.getId( ) != null && animal.getId( ) > 0 && StringUtils.isNotBlank(animal.getName( )); } } You now have 3 classes that have clear separation of concerns. The Animal class has been decoupled from database concern and validation concern. The above code is also well encapsulated and highly cohesive. The challenge with SRP is getting the granularity of a responsibility right. One of the most common complaints about SRP is object explosion. This is a valid complaint, 64
but when things are broken down by concern as shown above, it is far easier to consider the concern in isolation and come up with a better design for that single concern. The art of design is all about striking a good balance by asking the right questions and not blindly following a principle. Q28 Is there anything wrong with the following code snippet? DC COQ SBQ package principle_ocp1; public interface Animal { //methods are left out for brevity } package principle_ocp1; public class Cat implements Animal { //methods are left out for brevity } package principle_ocp1; public class Spider implements Animal { //methods are left out for brevity } package principle_ocp1; public class Ostritch implements Animal { //methods are left out for brevity } package principle_ocp1; import java.util.List; public class AnimalLegsCounter { public int count(List animals) { int count = 0; 65
Classes and Interfaces Essentials for (Animal animal : animals) { if (animal instanceof Cat) { count += 4; } else if (animal instanceof Spider) { count += 8; } else if (animal instanceof Ostritch) { count += 2; } } return count; } } package principle_ocp1; import java.util.ArrayList; import java.util.List; public class Example { public static void main(String[ ] args) { List list = new ArrayList( ); Animal animal = new Cat( ); list.add(animal); animal = new Spider( ); list.add(animal); animal = new Ostritch( ); list.add(animal); int count = new AnimalLegsCounter( ).count(list); System.out.println('Total count for ' + list.size( ) + ' animals = ' + count); } } A28 Skipped.... Questions 29 to 40 are skipped
66
Section-6: Objects Essentials • • • • • • • • • •
Working with objects Cloning objects Casting objects Immutable objects Working with enumerations Understanding “” versus equals( ) Working with the String class Type safety with generics Serializing your objects Garbage collecting your objects
An object (or instance) is an executable copy of a class. In the last section, you looked at the object oriented concepts, design principles, working with classes, and inter­ faces. It is a must to have a good understanding in working with the objects. You will be performing various operations like creating, cloning, casting, comparing, modifying, serial­ izing, and garbage collecting your objects. The general preparation for a Java job interview can be summed up in four steps: research, predict questions, prepare answers and practice. The step 2 to predict questions is often not an easy task, but you can always prepare for most common interview questions relating to OO concepts, classes, interfaces, working with objects, and language funda­ mentals. Still more than 50% of the candidates don't answer these questions right. If you can demonstrate that your fundamentals are solid by answering these questions with examples and illustrations, you will stand a good chance of succeeding. This will be valued a lot more than happening to know or having experience with a sought-after framework the very moment. In other words, if you don't get these fundamental questions right, knowing the sought-after frameworks is not going to do you any good.
67
Objects Essentials
Working with Objects The java.lang.Object class is the ultimate super class of all objects. If a class does not explicitly extend a class, then the compiler assumes it extends java.lang.Object. Questions & Answers 1 … 34 are skipped.
Type safety with Generics Generics are a big step forward for Java, making it more readable and robust. Having said that, there are a number of limitations and can be tricky to use it correctly in your code. Remembering some of the rules will help you better understand generics. Q34 Why use generics? LF A34 Generics was introduced in JDK 5.0, and allows you to abstract over types. Without generics, you could put any object into a collection. This can encourage developers to write programs that are harder to read and maintain. For example, List list = new ArrayList( ); list.add(new Integer( )); list.add(“A String”); list.add(new Mango( )); Since you can add any object, you would also not only have to use “instanceof ” operator, but also have to explicitly cast any objects returned from this list. package generics; import java.util.ArrayList; import java.util.List; public class WithoutGenerics { public static void main(String[ ] args) { //Bad practice to add any object List list = new ArrayList( ); list.add(new Integer(5)); //index 0 list.add('A String'); //index 1 list.add(new Float(3.0)); //index 2 68
//too many unsightly casts & instanceof constructs Integer i = (Integer)list.get(0); String s1 = null; Object o1 = list.get(1); if(o1 instanceof String){ s1 = (String)o1; } //if you use the wrong cast, you can get a ClassCastException at runtime String s2 = (String)list.get(2); //index 2 is a Float, not a String . } } Now with generics, your code becomes more robust and readable. Rule 1: The type safety is checked during compile-time. package generics; import java.util.ArrayList; import java.util.List; public class WithGenerics { public static void main(String[ ] args) { //can only add Integers List list1 = new ArrayList( ); list1.add(new Integer(5)); //can only add Strings List list2 = new ArrayList( ); list2.add('A String'); //can only add Floats List list3 = new ArrayList( ); list3.add(new Float(3.0)); //compile error if you try to add a wrong type 69
Objects Essentials //list1.add('NOT ALLOWED');
//list1 contains Integers NOT String
//no casting is needed Integer i = list1.get(0); String s1 = list2.get(0); Float f1 = list3.get(0); } } The for-each loop that was added in JDK 1.5 works well with generics. for(String aString : list2){ System.out.println(aString); } Q35 What do you understand by the term “type erasure” with regards to generics? LF FAQ A35 Rule 1: Java generics differ from C++ templates. Java generics (at least until JDK 7), generate only one compiled version of a generic class or method regardless of the number of types used. During compile-time, all the parametrized type information within the angle brackets are erased and the compiled class file will look similar to code written prior to JDK 5.0. In other words, Java does not support runtime generics. Q. Why was it done this way? A. This was done this way to achieve backward compatibility. package generics; import java.util.HashMap; import java.util.Map; public class TypeErasure { public static void main(String[ ] args) { Map map = new HashMap( ); map.put('Key1',new Integer(1)); Integer val1 = map.get('Key1'); //casting is not required System.out.println(val1); } 70
} If you run the compiled class file (i.e. TypeErasure.class) with the help of a Java decom­ piler discussed under platform essentials, you will get the following source code. package generics; import java.util.HashMap; import java.util.Map; public class TypeErasure { public static void main(String[ ] args) { Map map = new HashMap( ); map.put('Key1', new Integer(1)); Integer val1 = (Integer)map.get('Key1'); System.out.println(val1); } } As you can see, all the angle brackets have disappeared, and casting has been added. Q36 What does the following code fragment print? LF COQ List list1 = new ArrayList( ); List list2 = new ArrayList( ); System.out.println(list1.getClass( ) list2.getClass( )); A36 Skipped.... Q37 What are the differences among LF FAQ – raw or plain old collection type e.g. Collection – Collection of unknown e.g. Collection – Collection of type object e.g. Collection A37 Skipped.... 71
Objects Essentials Q&As 38 to 61 are skipped.
72
Section-7:
Logic and Data structures Essentials • • • •
Java Flow Control Java Data structures and algorithms Logic Processing Exception handling
The data structures and logic processing are prevalently used in programming. It is important to have a basic understanding of the most common data structures like arrays, lists, sets, maps, trees, and graphs, and the basics of the “big-O” algorithmic complexity analysis. You should know why a particular data structure or an algorithm needs to be used for a given usage pattern. You should know the abstract data types such as List, Stack, or Set and the corresponding concrete implementations like ArrayList, HashSet, HashMap, etc. It is also imperative to understand the performance versus memory tradeoffs between two different concrete implementations of an abstract data structure. The data structures can be traversed iteratively(e.g. arrays, lists, sets) or recursively (e.g. tree). Various sorting, partitioning, and searching algorithms can be applied to various data structures. Most data structures internally use an array or a list to provide a more specialized functionality. Thread-safety and immutability are other two considerations in using different data structures. The following are some common questions answered in this section. “If Java did not have a Map or Set implementation, how would you go about implementing your own?” “What are the common data structures, and where would you use them?”
73
Logic and Data structures Essentials
Java Flow Control Q1 A1
Why would you prefer a short circuit “&&, ” operators over logical “& , ” operators? LF COQ Firstly, NullPointerException is by far the most common runtime exception. If you use a logical operator, you can get a NullPointerException. This can be avoided easily by using a short circuit operator as shown below. There are other ways to check for null, but short circuit && operator can simplify your code by not having to declare separate if clauses. if((obj != null) & obj.equals(newObj)) { ….
// can cause a NullPointerException // obj.equals(newObj) is executed // even if obj != null returns false.
} Short-circuiting means that an operator only evaluates as far as it has to, not as far as it can. If the variable 'obj' is null, it won't even try to evaluate the 'obj.equals(newObj)’ clause as shown below. This protects the potential NullPointerException. if((obj != null) && obj.equals(newObj)) { // cannot get a NullPointerException ... // because obj.equals(newObj) is // executed only if obj != null returns true } PC Secondly, short-circuit “&&” and “ ” operators can improve performance in certain situations. For example: //the CPU intensive method in bold is executed only if number is > 7 if((number