Your SlideShare is downloading. ×
Java session 3
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Java session 3

152
views

Published on

Java basics

Java basics

Published in: Education, Technology

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
152
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
5
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Java Session-3
  • 2. Static variables and Methods ❖ ❖ Variables and methods marked as static belongs to class, rather than any particular instance. One copy is shared across all class instances. ➢ ❖ ❖ ❖ ❖ ● Ex : https://gist.github.com/rajeevprasanna/8754235 A static method can’t access a nonstatic(instance) variable, because there is not instance. ex : https://gist.github.com/rajeevprasanna/8754328 Static=class, nonstatic=instance. Access static method or variable by dot operator on className. Static methods can’t be overridden. ex : https://gist.github.com/rajeevprasanna/8754437 Static or initialization block: Initialization blocks run when the class is first loaded (a static initialization block) or when an instance is created. ex : https://gist.github.com/rajeevprasanna/8756880
  • 3. Data types and primitives Data Types : Primitive types are special data types built into the language; they are not objects created from a class Literal : A Literal is the source code representation of a fixed value; literals are represented directly in your code without requiring computation boolean result = true; boolean - is data type true - is literal Refer : http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
  • 4. Float and Double ➔ ➔ ➔ A float is a 32 bit IEEE 754 floating point. A double is a 64 bit IEEE 754 floating point. You shouldn't ever compare floats or doubles for equality; because, you can't really guarantee that the number you assign to the float or double is exact. Ex : https://gist.github.com/rajeevprasanna/8754840
  • 5. Character literals ● ● Char literal is represented by a single character in single quotes It stores the 16-bit Unicode integer value of the character in question ■ char a = 'a'; ■ char letterN = 'u004E'; // The letter 'N' in unicode representation ■ char a = 0x892; // hexadecimal literal ■ char b = 982; // int literal ■ char c = (char)70000; // The cast is required; 70000 is out of char range ■ char d = (char) -98; // Ridiculous, but legal ■ char e = -29; //Error : Possible loss of precision; needs a cast ■ char f = 70000 //Error : Possible loss of precision; needs a cast ● Use an escape code if you want to represent a character that can't be typed in as a literal, including the characters for line feed, newline, horizontal tab, backspace, and single quotes. ■ char c = '"'; // A double quote ■ ● char d = 'n'; // A newline If given character is out of range, it is displayed as ?. Refer table here ○ Ex : https://gist.github.com/rajeevprasanna/8755247
  • 6. Assignment operators ● ● Result of an expression involving anything int-sized or smaller is always an int Multiply an int and a short and you'll get an int. Divide a short by a byte and you'll get...an int. ex : https://gist.github.com/rajeevprasanna/8755470 ● ● ● Assigning Floating-Point Numbers : In order to assign a floating-point literal to a float variable, you must either cast the value or append an f to the end of the literal(compiler treat as double if no casting is there). ○ float f = (float) 32.3 ○ float g = 32.3f ○ float h = 32.3F byte a = 128; // Error : byte can only hold up to 127(Assigning a Literal That Is Too Large for the Variable) Array instance variable initialization : Array elements are always, always, always given default values, regardless of where the array itself is declared or instantiated.
  • 7. Passing variables into methods ❖ ❖ ❖ Passing primitive variables Passing reference variables Does java use Pass-By-Value ? ➢ ❖ ❖ Java is actually pass-by-value for all variables running within a single VM. Pass-by-value means pass-by-variable-value. And that means, pass-by-copy-of- the-variable! ➢ ex : https://gist.github.com/rajeevprasanna/8755774 Shadowing instance/static primitive variables. ➢ ex: https://gist.github.com/rajeevprasanna/8755805 Shadow instance reference variables. ➢ ex : https://gist.github.com/rajeevprasanna/8755845
  • 8. Arrays ❖ ❖ ❖ ❖ Declaring arrays ➢ int[] key;//preferred, int key []; (primitive array declaration) ➢ Thread[] threads; //Declaring array of object references. Array object is created on the heap. You must specify the size of the array at creation time. The size of the array is the number of elements the array will hold. One dimensional array : ➢ int[] testScores; // Declares the array of ints testScores = new int[4]; ❖ ❖ ❖ ➢ int[] testScores = new int[4];//Initialize at the time of declaration. ➢ int[] carList = new int[]; // Will not compile; needs a size Multi dimensional array : ➢ Multidimensional arrays, remember, are simply arrays of arrays. ➢ So a two- dimensional array of type int is really an object of type int array (int []), with each element in that array holding a reference to another int array. ➢ int[][] myArray = new int[3][]; //valid Array initialization: https://gist.github.com/rajeevprasanna/8756729 Array index starts from 0 to arrayLength-1.
  • 9. Wrapper class The wrapper classes in the Java API serve two primary purposes: ● ● ● ● To provide a mechanism to "wrap" primitive values in an object so that the primitives can be included in activities reserved for objects, like being added to Collections, or returned from a method with an object return value. To provide an assortment of utility functions for primitives. Most of these functions are related to various conversions: converting primitives to and from String objects, and converting primitives and String objects to and from different bases (or radix), such as binary, octal, and hexadecimal. Wrapper objects are immutable. Once they have been given a value, that value cannot be changed. Methods : valueOf, xxxValue, toXxxString,
  • 10. Overloading ● ● ● ● Widening. ex : https://gist.github.com/rajeevprasanna/8757265 Autoboxing Var-args When overloading, compiler will choose widening over boxing. ○ Widening beats boxing ○ Widening beats var-args ○ Boxing beats var-args ○ ● ex : https://gist.github.com/rajeevprasanna/8757252 Widening reference variables. ex: https://gist.github.com/rajeevprasanna/8757479
  • 11. Equality operator ❖ ❖ ❖ ❖ == equals (also known as "equal to") != not equals (also known as "not equal to") Equal operation on primitives, references and enums. ➢ ex: https://gist.github.com/rajeevprasanna/8757682 instanceof Comparison: ➢ ❖ The instanceof operator is used for object reference variables only, and you can use it to check whether an object is of a particular type. ➢ By type, we mean class or interface type—in other words, if the object referred to by the variable on the left side of the operator passes the IS-A test for the class or interface type on the right side ■ ex: https://gist.github.com/rajeevprasanna/8757785 ➢ You can't use the instanceof operator to test across two different class hierarchies. ■ ex: https://gist.github.com/rajeevprasanna/8757802 Remember that arrays are objects, even if the array is an array of primitives ➢ int [] nums = new int[3]; if (nums instanceof Object) { } // result is true

×