Scribd Logo
Upload

Welcome to Scribd!

  • 48 views

    Seminar 1

    Uploaded by

    Ajay Tendulkar
    The document defines and provides examples of local variables, instance variables, static variables, type casting, and debugging in Java. Local variables are defined within methods and only exist within that scope, while instance variables are declared in a class and each object has its own copy. Static variables can be accessed without an object using the class name and are shared among all instances. Type casting involves converting between compatible data types, either automatically during widening casts or manually during narrowing casts. Debugging allows running a program step-by-step and examining variables at breakpoints.

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd

    Seminar 1

    Uploaded by

    Ajay Tendulkar
    48 views3 pages
    The document defines and provides examples of local variables, instance variables, static variables, type casting, and debugging in Java. Local variables are defined within methods and only exist within that scope, while instance variables are declared in a class and each object has its own copy. Static variables can be accessed without an object using the class name and are shared among all instances. Type casting involves converting between compatible data types, either automatically during widening casts or manually during narrowing casts. Debugging allows running a program step-by-step and examining variables at breakpoints.

    Original Title

    seminar 1

    Copyright

    © © All Rights Reserved

    Available Formats

    TXT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document defines and provides examples of local variables, instance variables, static variables, type casting, and debugging in Java. Local variables are defined within methods and only exist within that scope, while instance variables are declared in a class and each object has its own copy. Static variables can be accessed without an object using the class name and are shared among all instances. Type casting involves converting between compatible data types, either automatically during widening casts or manually during narrowing casts. Debugging allows running a program step-by-step and examining variables at breakpoints.

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd
    Download as txt, pdf, or txt
    48 views3 pages

    Seminar 1

    Uploaded by

    Ajay Tendulkar
    The document defines and provides examples of local variables, instance variables, static variables, type casting, and debugging in Java. Local variables are defined within methods and only exist within that scope, while instance variables are declared in a class and each object has its own copy. Static variables can be accessed without an object using the class name and are shared among all instances. Type casting involves converting between compatible data types, either automatically during widening casts or manually during narrowing casts. Debugging allows running a program step-by-step and examining variables at breakpoints.

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd
    Download as txt, pdf, or txt
    of 3

    Local variable: A variable defined with in a method.

    -->The scope of the variables exists only with in a method.

    EX:public class StudentDetails {


    public void StudentAge()
    {
    // local variable age
    int age = 0;
    age = age + 5;
    System.out.println("Student age is : " + age);
    }

    public static void main(String args[])


    {
    StudentDetails obj = new StudentDetails();
    obj.StudentAge();
    }
    }
    -->the variable age is a local variable to the function StudentAge().

    Instance Variables: Instance variables are non-static variables and are declared in
    a class and outside any method.
    --> these variables are created when an object of the class is created and
    destroyed when the object is destroyed.

    Ex:import java.io.*;
    class Marks {
    // These variables are instance variables.
    // These variables are in a class
    // and are not inside any function
    int engMarks;
    int mathsMarks;
    int phyMarks;
    }

    class MarksDemo {
    public static void main(String args[])
    {
    // first object
    Marks obj1 = new Marks();
    obj1.engMarks = 50;
    obj1.mathsMarks = 80;
    obj1.phyMarks = 90;

    // second object
    Marks obj2 = new Marks();
    obj2.engMarks = 80;
    obj2.mathsMarks = 60;
    obj2.phyMarks = 85;

    // displaying marks for first object


    System.out.println("Marks for first object:");
    System.out.println(obj1.engMarks);
    System.out.println(obj1.mathsMarks);
    System.out.println(obj1.phyMarks);

    // displaying marks for second object


    System.out.println("Marks for second object:");
    System.out.println(obj2.engMarks);
    System.out.println(obj2.mathsMarks);
    System.out.println(obj2.phyMarks);
    }
    }
    -->the variables engMarks , mathsMarks , phyMarks are instance variables.
    -->we have multiple objects as in the above program, each object will have its own
    copies of instance variables.

    Static variable: static variables are declared using the static keyword within a
    class outside any method.
    -->need not create an object of that class.
    -->To access static variables-->class_name.variable_name;

    EX:import java.io.*;
    class Emp {

    // static variable salary


    public static double salary;
    public static String name = "Harsh";
    }

    public class EmpDemo {


    public static void main(String args[])
    {

    // accessing static variable without object


    Emp.salary = 1000;
    System.out.println(Emp.name + "'s average salary:"
    + Emp.salary);
    }
    }

    Type Casting:is a method or process that converts a data type into another data
    type in both ways manually and automatically.
    -->The automatic conversion is done by the compiler and manual conversion performed
    by the programmer.

    There are two types of type casting:

    Widening Type Casting:


    -->Converting a lower data type into a higher one is called widening type casting.
    -->Both data types must be compatible with each other.
    -->byte -> short -> char -> int -> long -> float -> double.

    EX:public class WideningTypeCastingExample


    {
    public static void main(String[] args)
    {
    int x = 7;
    //automatically converts the integer type into long type
    long y = x;
    //automatically converts the long type into float type
    float z = y;
    System.out.println("Before conversion, int value "+x);
    System.out.println("After conversion, long value "+y);
    System.out.println("After conversion, float value "+z);
    }
    }

    Narrowing Type Casting:


    -->Converting a higher data type into a lower one is called narrowing type casting.
    -->It is done manually by the programmer.
    -->double -> float -> long -> int -> char -> short -> byte

    EX:public class NarrowingTypeCastingExample


    {
    public static void main(String args[])
    {
    double d = 166.66;
    //converting double data type into long data type
    long l = (long)d;
    //converting long data type into int data type
    int i = (int)l;
    System.out.println("Before conversion: "+d);
    //fractional part lost
    System.out.println("After conversion into long type: "+l);
    //fractional part lost
    System.out.println("After conversion into int type: "+i);
    }
    }

    Debugging:
    -->it allows you to run a program interactively while watching the source code and
    the variables during the execution.
    -->A breakpoint in the source code specifies where the execution of the program
    should stop during debugging.

    You might also like