{\fonttbl\f0\fswiss\fcharset0 Helvetica;\f1\fswiss\fcharset0 ArialMT;\f2\fnil\fcharset0 Menlo-Regular;

\f3\froman\fcharset0 Times-Roman;}

{\colortbl;\red255\green255\blue255;\red66\green72\blue77;\red255\green255\blue255;\red0\green0\blue0;

\red0\green0\blue0;\red26\green28\blue40;\red36\green149\blue255;\red66\green72\blue77;}

{\*\expandedcolortbl;;\cssrgb\c32549\c35294\c37647;\cssrgb\c100000\c100000\c100000;\cssrgb\c0\c0\c0\c59361;

\cssrgb\c0\c0\c0;\cssrgb\c13333\c14902\c20784;\cssrgb\c16078\c65882\c100000;\cssrgb\c32549\c35294\c37647;}

{\*\listtable{\list\listtemplateid1\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{disc\}}{\leveltext\leveltemplateid1\'01\uc0\u8226 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid1}}

\b0 \

Java is:\

1. High-level\

2. Object-oriented\

3. Platform independent\

4. High performance\

5. Multithreaded\

6. Portable\

programming language & platform (it provides own JRE and API)\

\b0 \

C++\

1. Platform dependent\

2. Mainly used for system programming\

3. Design goal: Designed for systems and application programming\

4. Supports goto\

5. Supports multiple inheritance\

6. Supports operator overloading\

7. Supports pointers\

8. C++ is compiled to machine code (uses compiler only)\

9. Supports both call by value and call by reference\

10. Supports structures and unions\

11. Does not have built in support for threads\

1. Relies on third party libraries\

12. Does not support documentation comments\

13.

\b0 keyword is supported that gives the flexibility to whether override a function or not\

14. Doesn\'92t support unsigned right shift operator >>>\

15. Independent inheritance trees get created (no root that connects all the trees)\

16. Object aware language\

Java\

1. Platform independent (byte code can run on any platform that supports JVM)\

2. Mainly used for application programming\

1. Window applications\

2. Web-based applications\

3. Enterprise applications\

4. Mobile applications\

3. Design goal: Initially designed for printing systems but later extended to support network computing\

1. Goals:\

1. Easy to use\

2. Accessible to broader audience\

4. Java doesn\'92t support goto\

5. No multiple inheritance through class (but can be achieved using interface)\

6. Does not support operator overloading\

7. Internal support for pointer (no explicit pointer programs allowed in Java)\

8. Users compiler and interpreter\

1. Source code is compiled to byte code during compilation time\

2. Bytecode is executed by interpreter at runtime to produce output\

1. Compiles to native code if necessary\

9. Call by value only (no call by reference)\

10. No support for structures and unions\

11. built-in thread support\

12. Supports documentation comments /** \'85 */\

13. No

\b0 keyword support\

1. All non-static methods can be overridden by default (non-static methods are virtual by default)\

14. Supports unsigned right-shift operator >>>\

1. Fills zeros at top of negative numbers or positive numbers\

15. Only single inheritance tree is supported\

1. All classes are child of

\b0 class (which is root of the inheritance tree)\

16. Object oriented language\

1. Except primitive types, everything else is an object \

\b0 \

1. \ul Simple\ulnone : \

1. Easy to learn\

2. Syntax is similar to that of C++\

2. \ul Object-oriented:\ulnone \

1. Code can be a combination of different type of objects that encapsulates data and behaviour and exchange messages with each other\

3. \ul Portable:\ulnone \

1. write-once-run-anywhere approach\

1. Java program can be converted to bytecode which can be run on any machine that supports JVM\

4. \ul Platform independent:\ulnone \

1. Java comes with it\'92s own platform (JVM) on which code is executed (It is OS independent for execution)\

5. \ul Secured:\ulnone \

1. Doesn\'92t use explicit pointers\

2. Bytecode makes it secure\

3. Exception handling also makes it secure\

6. \ul Robust:\ulnone \

1. Java uses memory management\

1. Automatic garbage collection\

2. Exception handling\

7. \ul Architecture Neutral:\ulnone \

1. Java does not depend on the architecture\

1. Size of data types is fixed (unlike in C or C++ where int can be 32 bit or 64 bit based on the architecture)\

8. \ul Interpreted:\ulnone \

1. Java uses JIT compiler and interpreter to interpret initially and compile if necessary (based on whether code is re-used multiple times)\

9. \ul High Performance:\ulnone \

1. Java is faster than other traditional interpreted languages\

1. Java bytecode is close to native code\

2. bytecode gets compiled to native code over time based on certain heuristics\

10. \ul Multithreaded:\ulnone \

1. Multiple threads can be used to run in parallel out of the box\

1. Multiple threads do not require additional memory (they share common memory area)\

2. Use cases:\

1. Multimedia\

2. Web applications\

11. \ul Distributed:\ulnone \

1. Java facilitates users to construct distributed applications\

1. RMI\

2. EJB\

12. \ul Dynamic:\ulnone \

1. Dynamic loading of classes\

1. Classes are loaded on demand\

2. Supports functions from native langurs - C or C++\

\b0 \

1. It is a virtual machine that runs java program\

2. It is a runtime engine that calls main method\

3. JVM is a specification which interprets bytecode and converts it to machine code to execute on the machine\

\b0 \

1. JVM\

1. Java Virtual Machine\

2. It is abstract machine the provides runtime environment in which Java bytecode can run\

3. The specification of JVM is maintained by Oracle\

4. Implementations of JVM specification is provided by Oracle and other companies\

5. Implementation of JVM is called JRE\

6. JVM is platform dependent\

2. JRE (JVM + Libraries)\

1. Java Runtime Environment\

2. It is the implementation of JVM\

3. It provides runtime environment for a Java application\

4. Content\

1. Libraries\

2. Files used by JVM at runtime\

3. JDK (JRE + Dev tools)\

1. Java Development Kit\

2. It is software development environment\

1. Provides tools for Java application development\

3. JDK implements any of the following:\

1. Standard Edition Java Platform\

2. Enterprise Edition Java Platform\

3. Micro Edition Java Platform\

\b0 \

1. Types:\

1.

\b0 \

1. Per-class structures\

1. Runtime constant pool\

2. Field\

3. Method data\

4. Code for methods\

2.

\b0 \

1. Runtime data area in which memory is allocated to the objects\

3.

\b0 \

1. Stores frames\

1. Holds local variables, partial results\

2. Used for method invocation and return\

3. Each thread has a private JVM stack\

1. It is created at the same time as the thread\

4. New frame is created each time a method is invoked\

5. Frame is destroyed when its method invocation completes\

4.

\b0 PC (program counter) contains address of Java virtual machine instruction currently being executed\

5.

\b0 Supports all native methods used in the application (conventional stack of \'93c stack\'94 for instance)\

\b0 \

1. Just-In-Time (JIT) Compiler\

1. It is used to improve performance\

2. JIT compiles part of code that is used many times using higher levels of optimisation and to native code (which may be stored in the code cache)\

3. Compilation: Translation of JVM instruction set to CPU instruction set\

\b0 \

1. It is hardware or software environment in which a piece of software is executed\

2. Two types:\

1. Software-based - Java provides this type\

2. Hardware based\

\b0 \

1. Java platform is provided on top of hardware platform\

2. Java platform is software based\

\b0 \

1. Java compiler converts source code into bytecode\

1. Bytecode - it is an intermediate language between source code and machine code\

2. Bytecode is not platform specific (OS + Hardware) and can be run on any computer\

\b0 \

1. It is a subsystem of JVM that loads class files\

1. If we need to run a Java program, it is first loaded by the class loader\

2. Types of class loader\

1.

\b0 \

1. First class-loader\

2. It is a super class of

\b0 \

3. It loads

\b0 file

\b0 - contains all classes of Java Standard Edition (JSE)\

1.

\b0 classes

\b0 2.

\b0 classes

\b0 3.

\b0 classes\

\b0 4.

\b0 classes\

5.

\b0 classes\

6. \'85

\b0 2.

\b0 \

1. Child class loader of Bootstrap\

2. Parent class loader of

\b0

\b0 \

3. Loads jar files located inside

\b0 directory\

\

cldrdata.jar\

dnsns.jar\

access.jar\

jfxrt.jar\

localedata.jar\

meta-index\

nashorn.jar\

sunec.jar\

sunjce_provider.jar\

sunpkcs11.jar\

zipfs.jar \

\b0 3.

\b0 \

1. Child classloader of Extension\

2. Loads class files from classpath\

1. CLASSPATH - set to current directory by default\

1. Can be changed using:\

1. -cp \

2. -classpath\

\b0 \

1. Yes\

class A \{ // no public modifier\

public static void main(String[] args) \{\

System.out.println(\'93Alhamdulillah!\'94);\

\}\

\}\

\b0 \

1. No\

\b0 \

1. Empty\

\b0 \

1. Order of the specifiers does not matter\

\

\b0 \

1. primitives - not initialized to any default value\

1. Any usage will throw a compilation error\

2. Object references - not initialised to any default value\

1. Any usage will throw a compilation error\

\b0 \

1.

\b0 : class, method or variable can be accessed by any class or method\

2.

\b0 : accessed by class of same package, subclass of this class (same or different package), same class\

3. default: accessed within package - if no qualifier is given\

4.

\b0 : class, method or variable can be accessed within the class only\

\b0 \

1. They are shared among all objects of the class\

2. It is part of the class (not part of the object)\

3. static variables\

1. Created in class area\

1. Objects don\'92t have to be created to access them\

4. Example: class simulating collection of students in college\

1. college name can be static\

\b0 \

1. To avoid name clashes\

2. Access control (using access modifiers)\

1. Hidden classes can be used by the package\

3. Makes it easy to locate classes using fully qualified names\

\b0 \

\

class Test \{\

public static void main (String args[]) \{\

System.out.println(10 + 20 + \'93Javatpoint\'94);\

System.out.println(\'93Javatpoint\'94 + 10 + 20);\

\}\

\}\

> 30Javatpoint\

> Javatpoint1020\

1. First - 10 & 20 are treated as numbers\

2. Second - 10 and 20 are converted to strings\

\b0 \

class Test \{\

public static void main(String args[]) \{\

System.out.println(10 * 20 + \'93Javatpoint\'94);\

System.out.println(\'93Javatpoint\'94 + 10 * 20);\

\}\

\}\

> 200Javatpoint\

> Javatpoint200\

1. precedence of * is higher than addition hence it will be evaluated first\

\b0 \

class Test \{\

public static void main(String args[]) \{\

for (int i = 0; 0; i++) \{\

System.out.println(\'93Hello Javatpoint\'94);\

\}\

\}\

\}\

1. Compilation error (condition in for loop is not boolean)\

OOPs Concepts:\

\b0 \

1. Programming paradigm that is based on objects\

1. Objects contain data and methods defined in class to which the object belongs\

2. pros:\

1. Modularity\

2. Re-usability\

3. Objects interact with each other to form the entire program\

4. Features:\

1. Follows bottom-up approach in program design (?)\

2. Encapsulates and abstracts and hides the complexity from user and show only functionality\

5. Examples:\

1. C++\

2. Simula\

3. Smalltalk\

4. Python\

5. C#\

6. \'85\

\b0 \

1. Object is a runtime entity that can contain state and behaviour and is an instance of a class\

1. state - contained in instance variables\

2. methods - contain behaviour\

2. new - keyword can be used for creation of object\

\b0 \

1. Object oriented programming language:\

1. Supports all concepts of OOPs\

2. Doesn\'92t have in-built objects\

3. Example: Java, C#, Smalltalk, \'85\

2. Object based programming language:\

1. Might support only a subset of the concept of OOPs\

2. Has in-built objects - JavaScript: Window object\

3. Example: JavaScript, VBScript, \'85\

\b0 \

1. null\

Constructor\

\b0 \

1. A special method that is invoked during instantiation of an object\

1. overloaded constructors can be used to initialise state of an object\

2.

\b0 - calls default constructor by default\

3. It must not have explicit return type\

4. It\'92s name should be the same as the class name\

\b0 \

1. Two types\

1. default constructor\

1. Does not accept any value\

2. Implicitly added if there is no constructors are defined\

2. parameterised constructor\

1. Initialises instance variables with given values\

\b0 \

1. Added by compiler when no constructors are defined\

2. Default constructor calls superclass\'92s no argument constructor\

\b0 \

1. No\

1. It is just called during instantiation\

\b0 \

1. No - because it does not belong to the object\

\b0 \

1. No - it cannot be overridden => it cannot be modified => declaring it as

\b0 makes no sense\

\b0 \

1. Yes - By changing the number and type of arguments\

\b0 \

1. There is no copy constructor in Java but one can copy values from one object to another like copy constructor in C++\

2. Ways to copy:\

1. Using constructor\

2. Assigning values of one object to another\

3.

\b0 method of

\b0 class\

class Test \{\

int x, y;\

\}\

class Test2 implements Cloneable \{\

int a;\

int b;\

Test c = new Test();\

\

public Object clone() throws CloneNotSupportedException \{\

return super.clone();\

\}\

\}\

\b0 \

1. Constructor\

1. Used to initialise state of an object\

2. Must not have a return type\

3. Invoked implicitly\

4. Default constructor is provided if we don\'92t explicitly provide a constructor\

5. Name must be same as that of the class\

2. Method\

1. Used to expose behaviour of an object\

2. Must have a return type (void or others)\

3. Invoked explicitly\

4. Method is provided by the user (or library like Lombok)\

5. Name may or may not be the same as that of the class\

\b0 \

public class Test \{\

Test(int a, int b) \{\

System.out.println(\'93a = \'93 + a + \'93 b = \'93 + b);\

\}\

Test(int a, float b) \{\

System.out.println(\'93a = \'93 + a + \'93 b = \'93 + b);\

\}\

public static void main(String args[]) \{\

byte a = 10;\

byte b = 15;\

Test test = new Test(a, b);\

\}\

\}\

a = 10 b = 15\

1. byte gets promoted to int\

\b0 \

class Test \{\

int i;\

\}\

public class Main \{\

public static void main(String[] args) \{\

Test test = new Test();\

System.out.println(test.i);\

\}\

\}\

0 - initialized to default value when object is created (because default constructor is invoked which does not set any values)\

\b0 \

class Test \{\

int test_a, test_b;\

Test (int a, int b) \{\

test_a = a;\

test_b = b;\

\}\

public static void main(String args[]) \{\

Test test = new Test();\

System.out.println(test.test_a + \'93 \'93 + test.test_b);\

\}\

\}\

1. Compiler error - No args constructor is not provided by the compiler when parameterised constructor(s) is/are defined by the user\

1. Fix: no args constructor must be explicitly defined for the class\

\b0 \

1. Class variable that can be referenced without an object\

2. Memory is allocated only once in the class area when the class is loaded\

\b0 \

1. It a method that belongs to the class and doesn\'92t need an object to invoke it\

2. It can access and change values of a static variable\

\b0 \

1. Cannot use non-static variables or call non-static methods directly\

2.

\b0 and

\b0 cannot be used (because they are non-static)\

\b0 \

1. It is convention used for JVM design\

1. No new object needs to be created to invoke main\

2. It is called

\b0 \

3. No default constructor or any constructor is invoked\

\b0 \

\b0 \'a0Overriding in Java simply means that the particular method would be \

called based on the run time type of the object and not on the compile time type of it \

(which is the case with overriden static methods)\

\b0 \'a0Parent class methods that are static are not part of a child class (although \

they are accessible), so there is no question of overriding it. Even if you add \

another static method in a subclass, identical to the one in its parent class, this \

subclass static method is unique and distinct from the static method in its parent \

class.

\f0\fs24 \cf0 \cb1 \kerning1\expnd0\expndtw0 \

\b0 \

1. It is used to initialise static data members \

2. It is executed before the main method (at the time of classloading)\

class A2 \{\

static \{\

System.out.println(\'93static block is invoked\'94);\

\}\

public static void main(String[] args) \{\

System.out.println(\'93Hello man\'94);\

\}\

\}\

\b0 \

1. Yes (but throws an error saying - there is not main method in class)\

1. Use static block\

\b0 \

1. Throws error saying: main method is not declared as

\b0 \

\b0 \

1. static (class) method\

1. method declared as

\b0 2. They don\'92t need objects to call\

3. non-static members cannot be accessed in static method (static context)\

2. instance method\

1. method declared without

\b0 keyword (that is not a constructor)\

2. Object is required to call an instance method\

3. static and non-static members can be accessed in instance methods\

\b0 \

1. constructors are not explicitly invoked but only when object is created hence no sense making it static\

1. Compiler error is thrown\

\b0 \

1. Compiler throws an error: Illegal combination of modifiers abstract and static\

1. If we make a method static, it belongs to the class and it can be called directly (without overriding which is not allowed for static methods). But the method does not have any body and hence calling it is useless.\

\b0 \

1. Yes. Only class name can be used to access static variables and methods and hence does not required extending the class to access them.\

\b0 \

1.

\b0 is a reference variable that refers to the current object\

1. It can be used to refer to instance variables and methods\

2. It can be passed as argument into methods or constructors\

3. It can be returned\

\b0 \

1.

\b0 can be used to refer to current class instance variable\

2.

\b0 can be used to invoke current class method (implicitly)\

3.

\b0 calls current class constructor\

4.

\b0 can be passed as an argument in a method call\

5.

\b0 can be passed as an argument in constructor call\

6.

\b0 can be used to return the current class instance from method\

\b0 \

1.

\b0 is a final variable (cannot be re-assigned any other reference)\

1. It points only to the current class instance and cannot be changed\

\b0 \

1. Yes\

1. object reference can be used to refer to static members (not recommended)\

\b0 \

public class Employee \{\

int id, age;\

String name, address;\

public Employee (int id) \{\

this.id = id;\

\}\

public Employee (int id, int age) \{\

this(id);\

this.age = age;\

\}\

public Employee(int id, int age, String name, String address) \{\

this(id, age);\

this.name = name;\

this.address = address;\

\}\

public String toString() \{\

return \'93id: \'94 + id + \'93, age: \'93 + age + \'93, name: \'93 + name + \'93, address: \'93 + address;\

\}\

public static void main(String[] args) \{\

Employee employee = new Employee(3, 45, \'93Folk\'94, \'93Drive\'94);\

System.out.println(employee);\

\}\

\}\

\b0 \

1.

\b0 and current class object refer to the same object but\

1.

\b0 is final and cannot be changed (but non final class object reference can be re-assigned)\

2.

\b0 is allowed to be used in synchronised block\

synchronised (this) \{\

// critical section\

\}\

\b0 \

1. It is a mechanism that allows a class to obtain state and/or behaviour of another class (re-usability)\

1. Also allows overriding only behaviour that is different\

2. New classes can be built upon existing classes\

2. It is

\b0 relationship (parent-child)\

3. 5 types of inheritance in Java\

1. single-level\

2. multi-level\

3. multiple (not supported in Java)\

4. hierarchical (one class inherited by multiple sub-classes)\

5. hybrid (combo of single and multiple inheritance)\

\b0 \

1. Code re-usability - derived classes do not need to re-define common methods in the base class\

2. Runtime polymorphism - achieved using inheritance\

3. Inheritance can be used to provide data hiding mechanism - certain private variables do not have to be given access\

\b0 \

1.

\b0 \

\b0 \

1. https://stackoverflow.com/questions/2515477/why-is-there-no-multiple-inheritance-in-java-but-implementing-multiple-interfac#:~:text=Java%20does%20not%20support%20multiple,explicitly%20or%20not%20at%20all.\

1. Two classes may defined different ways of doing the same thing and subclass can\'92t choose which one to pick\

2. Keeps the language simple (avoids diamond problem)\

3. The feature is rarely used (not worth having this feature at the cost of simplicity)\

4. Can be achieved using other safer mechanisms if need be (without sacrificing simplicity)\

\b0 \

1. It is relationship between two classes\

1. aggregate class: contains reference to a class it owns\

1.

\b0 relationship\

2. Example:

\b0 has a field called

\b0 where\

1.

\b0 contains Address-line-1, City, State, pin-code\

\b0 \

1. Composition: Holding reference of a class within another class\

1. If the containing class object cannot exist without the container class object (Special case of aggregation)\

1. Class contains Students\

1. Student cannot exist without a Class\

\b0 \

1. Aggregation - represents weak relationship (bike with mirror)\

2. Composition - represents strong relationship (bike with engine)\

\b0 \

1. To improve security\

1. Pointers are unsafe\

1. Can lead to memory leaks\

2. Can lead to memory corruption\

3. Can lead to access of invalid memory locations\

1. Un-initialized or out of bounds memory access\

2. No direct access to memory and it is managed by JVM\

3. Not safe to expose memory through pointers on the internet (potential leak of information)\

2. Java uses reference model (but it has address to the actual object)\

1. Indirection is required for GC to work\

1. If GC does heap compaction, then certain objects are moved around in memory and the references are updated internally\

\b0 \

1. It has the reference to immediate parent class object of an object\

1. Uses:\

1. Accessing variables of super-class object\

/* Base class vehicle */\

class Vehicle \{\

int maxSpeed = 120;\

\}\

/* sub class Car extending vehicle */\

class Car extends Vehicle \{\

int maxSpeed = 180;\

void display() \{\

/* print maxSpeed of base class (vehicle) */\

System.out.println(\'93Maximum Speed: \'93 + super.maxSpeed);\

\}\

\}\

/* Driver program to test */\

class Test \{\

public static void main(String[] args) \{\

Car small = new Car();\

small.display();\

\}\

\}\

2. Accessing methods of super-class object\

/* Base class Person */\

class Person \{\

void message() \{\

System.out.println(\'93This is person class\'94);\

\}\

\}\

/* Subclass Student */\

class Student extends Person \{\

void message() \{\

System.out.println(\'93This is student class\'94);\

\}\

// Note that display() is only in student class\

void display() \{\

// will invoke or call current class message() method\

message();\

// will invoke or call parent class message() method\

super.message();\

\}\

\}\

/* Driver program to test */\

class Test \{\

public static void main(String[] args) \{\

Student s = new Student();\

// calling display() of Student\

s.display();\

\}\

\}\

3. Accessing constructors of superclass (both non-parametric and parametric)\

/* superclass Person */\

class Person \{\

Person() \{\

System.out.println(\'93Person class Constructor\'94);\

\}\

\}\

/* subclass Student extending the Person class */\

class Student extends Person \{\

Student() \{\

// invoke or call parent class constructor\

super();\

System.out.println(\'93Student class Constructor\'94);\

\}\

\}\

/* Driver program to test */\

class Test \{\

public static void main(String[] args) \{\

Student s = new Student();\