The document provides an introduction to basic Java programming concepts including inputs and outputs, variables, and data types. It discusses how to take input using the Scanner class and output using System.out. It defines variables as containers that hold values and explains variable declaration, initialization, and naming conventions. The different types of variables like local, instance, and static variables are also described. Finally, the document covers Java data types like primitive types (int, float, etc.), their ranges and sizes, and type conversion and casting between types. It includes examples and lab problems to practice these concepts.

1. Basic Java Programming
Sasidhara Marrapu

2. Introduction to Java Programming
– Environment Setup
 Java Inputs and OutPuts?
 Java Variables
 Java Data Types
 Lab Problem
 Home Work

3. Taking Input Using Scanner:
• The java.util.Scanner class is a simple text scanner which
can parse primitive types and strings using regular
expressions
• A Scanner breaks its input into tokens using a delimiter
pattern, which by default matches whitespace.
• A scanning operation may block waiting for input

4. OutPut Using System.out:

5. Variables:
A variable is a container/place which holds value for you,
during the life of a Java program.
Every variable is assigned a data type which designates the
type and quantity of value it can hold.
To use a variable in a program
 Variable Declaration
 Variable Initialization

6. Variables:
Variable Declaration:
int x,y,count;
float pi;
double d;
char a;
Variable Initialization:
pi =3.14f;
d = 20.22d;
a = ’v’;

7. Variables Naming:
Variable names are case-sensitive. A variable's name can be
any legal identifier
Subsequent characters may be letters, digits, dollar signs,
or underscore characters. Conventions (and common
sense) apply to this rule as well.
If the name you choose consists of only one word, spell
that word in all lowercase letters. If it consists of more than
one word, capitalize the first letter of each subsequent
word..

8. Types of Variables:
 Local Variables :
 Local Variables are a variable that are declared inside the body of a
method/block.
 Instance Variables
 Instance variables are declared in a class, but outside a method, constructor or
any block.
 Referenced by more than one method, constructor or block
 They tied with Object
 Static Variables
 Class variables also known as static variables are declared with the static
keyword in a class, but outside a method, constructor or a block.
 They tied with class.
 Parameters or Arguments:

9. Variables Initialization and default
values:

10. Lab : Variables
• CommentsSlashes.java
• VariableExample.java
• Test your skills – VariableExample2.java
As we saw above, we used the ‘/’ to work out the quotient of var1
by 2. Given that ‘+’ would perform addition, ‘-‘ subtraction and ‘*’
multiplication, write out a program which performs all the named
operations by using two integer values which are hard coded into
the program. Hints:
• You need only two variables of type integer
• Make one variable larger and divisible by the other
• You can perform the required calculations directly in the print statements,
remember to enclose the operation within brackets, e.g. (var1-var2)
• Use all three types of comments
• VariableScope.java

11. Data Type:
• Data type specifies the size and type of values that can be stored in
an identifier.
Two Data Types:
• Primitive Data Types
• Reference or Object Type

12. Data Types:

13. Data Types:
Name Range Storage Size
byte –27 (-128) to 27–1 (127) 8-bit signed
short –215 (-32768) to 215–1 (32767) 16-bit signed
int –231 (-2147483648) to 231–1 (2147483647) 32-bit signed
long –263 to 263–1 64-bit signed
(i.e., -9223372036854775808
to 9223372036854775807)
float Negative range: 32-bit IEEE 754
-3.4028235E+38 to -1.4E-45
Positive range:
1.4E-45 to 3.4028235E+38
double Negative range: 64-bit IEEE 754
-1.7976931348623157E+308 to
-4.9E-324
Positive range:
4.9E-324 to 1.7976931348623157E+308

14. Type Conversion and Casting:
• A variable of one type can receive the
value of another type. Here there are 2
cases
Automatic Conversion (Auto Boxing):
Smaller capacity  Bigger Capacity Variable
Type Casting:
Variable of larger capacity  Smaller
capacity

15. long
64 bit
int
32 bit
l
i
int i;
i = (int)l;
l = (long)i;
Moving Between Buckets
"Casting"
long l;
l = i;
long
64 bit
int
32 bit
l
i
Widening
Narrowing

16. Acceptable Implicit Casts
char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Illegal
b = l;
l = f;
c = s;
OK
l = b;
i = c;
f = l

17. char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Automatic Promotion with Arithmetic
Illegal Casts
s = s + b;
s = s + s;
OK
s = (short)(s + b);
s = (short)(s + s);
Arithmetic is never done
in 8 or 16 bit containers.

18. char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Arithmetic Promotion with Mixed
Primitives
Illegal Casts
i = i + l;
f = f + d;
l = l + f;
OK
i = (int)(i + l);
d = (double)(f + d);
l = (long)(l + f);
Arithmetic is done
in the "widest" type.

19. Implicit Casts in Method Calls
char
16 bit
double
64 bit
float
32 bit
long
64 bit
int
32 bit
short
16 bit
byte
8 bit
Illegal
i = st.indexOf(f);
OK
i = st.indexOf(c);
i = st.indexOf(b);
For: String st; and,
public int indexOf(int ch);

20. Lab : Variables
• Examples
• TypeCasting
• DataTypes

21. Home Work