java java java java java-unit-ii-batu-.pptx

BT-COE404
Object-Oriented Programming using Java
UNIT-II
Introduction to Classes, Objects, Methods and Strings: Introduction,
Declaring a Class with a Method and Instantiating an Object of a Class,
Declaring a Method with a Parameter, Instance Variables, set Methods
and get Methods, Primitive Types vs. Reference Types, Initializing
Objects with Constructors Floating-Point Numbers and Type double.

• Reference Book:
1.Paul Deitel and Harvey Detail, Java: How to Program, Pearson's
Publication, 9th Edition, 2012. -Chapter -3

Introduction to Classes, Objects, Methods and Strings
• Performing a task in a program requires a method.
• The method describes the mechanisms that actually perform its tasks.
• The method hides from its user the complex tasks that it performs, just as the accelerator pedal
of a car hides from the driver the complex mechanisms of making the car go faster.
• In Java, we begin by creating a program unit called a class to house a method, just as a car’s
engineering drawings house the design of an accelerator pedal.
• In a class, you provide one or more methods that are designed to perform the class’s tasks.
• For example, a class that represents a bank account might contain one method to deposit
money to an account, another to withdraw money from an account and a third to inquire what
the current balance is.
• we’ve used the car analogy to introduce classes, objects and methods. In addition to a car’s
capabilities, car also has many attributes, such as its color, the number of doors, the amount of
gas in its tank, its current speed and its total miles driven.
• Attributes are specified by the class’s instance variables.

Declaring a Class with a Method and Instantiating an
Object of a Class
• Class GradeBook (declared in file GradeBook.java) will be used to display a
message on the screen.
Class GradeBook
• The GradeBook class declaration (Fig. 3.1) contains a displayMessage method
(lines 7–10) that displays a message on the screen. Line 9 of the class
performs the work of displaying the message.
• Variable myGradeBook is initialized with the result of the class instance
creation expression new GradeBook(). Keyword new creates a new object of
the class specified to the right of the keyword (i.e., GradeBook).
• The keyword public is an access modifier.

• The method declaration begins with keyword public to indicate that the
method is “available to the public”—that is, it can be called from outside the
class declaration’s body by methods of other classes.
• Keyword void indicates that this method will perform a task but will not
return (i.e., give back) any information to its calling method when it completes
its task.
Class GradeBookTest
• The GradeBookTest class declaration (Fig. 3.2) contains the main method that
will control application’s execution.
Compiling an Application with Multiple Classes
• You must compile the classes in Fig. 3.1 and Fig. 3.2 before you can execute the
application. First, change to the directory that contains the application’s
source-code files. Next, type the command
javac GradeBook.java GradeBookTest.java

• to compile both classes at once. If the directory containing the application
includes only this application’s files, you can compile all the classes in the
directory with the command.
javac *.java
• The asterisk (*) in *.java indicates that all files in the current directory that
end with the file name extension “.java” should be compiled.

Declaring a Method with a Parameter
• a method can require one or more parameters that represent additional
information it needs to perform its task.
• A method call supplies values—called arguments—for each of the
method’s parameters. For example, the method System.out.println
requires an argument that specifies the data to output in a command
window.
• Similarly, to make a deposit into a bank account, a deposit method
specifies a parameter that represents the deposit amount. When the
deposit method is called, an argument value representing the deposit
amount is assigned to the method’s parameter. The method then makes a
deposit of that amount.

• Our next example declares class GradeBook (Fig. 3.4) with a displayMessage
method that displays the course name as part of the welcome message.
• The new displayMessage method requires a parameter that represents the
course name to output.
• Line 12 creates a Scanner named input for reading the course name from the
user. Line 15 creates an object of class GradeBook and assigns it to variable
myGradeBook. Line 18 prompts the user to enter a course name. Line 19 reads
the name from the user and assigns it to the nameOfCourse variable, using
Scanner method nextLine to perform the input. The user types the course
name and presses Enter to submit the course name to the program.
• The variable nameOfCourse in parentheses is the argument that is passed to
method displayMessage so that the method can perform its task. The value of
variable nameOfCourse in main beco.mes the value of method
displayMessage’s parameter courseName.

More on Arguments and Parameters
• When you declare a method, you must specify whether the method requires
data to perform its task. To do so, you place additional information in the
method’s parameter list, which is located in the parentheses that follow the
method name.
• A method can specify multiple parameters by separating each parameter
from the next with a comma .The number of arguments in a method call
must match the number of parameters in the parameter list of the called
method’s declaration.
• argument types in the method call must be “consistent with” the types of the
corresponding parameters in the method’s declaration.

Instance Variables, set Methods and get Methods
• Variables declared in the body of a particular method are known as local
variables and can be used only in that method. When that method terminates,
the values of its local variables are lost.
• Attributes are represented as variables in a class declaration. Such variables
are called fields and are declared inside a class declaration but outside the
bodies of the class’s method declarations.
• When each object of a class maintains its own copy of an attribute, the field
that represents the attribute is also known as an instance variable—each
object (instance) of the class has a separate instance of the variable in
memory.
• The example in this section demonstrates a GradeBook class that contains a
courseName instance variable to represent a particular GradeBook object’s
course name.

GradeBook Class with an Instance Variable, a set Method and a get Method
• class GradeBook (Fig. 3.7) maintains the course name as an instance variable
so that it can be used or modified at any time during an application’s
execution. The class contains three methods—setCourseName, get-
CourseName and displayMessage.

set and get Methods
• Classes often provide public methods to allow clients of the class to set (i.e., assign
values to) or get (i.e., obtain the values of) private instance variables.
• Every instance (i.e.,object) of class GradeBook contains one copy of each instance
variable. For example, if there are two GradeBook objects, each object has its own
copy of courseName (one per object). A benefit of making courseName an instance
variable is that all the methods of the class (in this case, GradeBook) can
manipulate any instance variables that appear in the class (in this case,
courseName).
Access Modifiers public and private
• Most instance variable declarations are preceded with the keyword private (as in
line 7). Like public, keyword private is an access modifier. Variables or methods
declared with access modifier private are accessible only to methods of the class in
which they are declared. Thus, variable courseName can be used only in methods
setCourseName, get- CourseName and displayMessage of (every object of) class
GradeBook.

Primitive Types vs. Reference Types
• Data types in Java are divided into two categories—primitive types and reference
types (sometimes called nonprimitive types).
• The primitive types are boolean, byte, char, short, int, long, float and double. All
nonprimitive types are reference types, so classes, which specify the types of objects,
are reference types.
• A primitive-type variable can store exactly one value of its declared type at a time.
• For example, an int variable can store one whole number (such as 7) at a time. When
another value is assigned to that variable, its initial value is replaced.
• Primitive-type instance variables are initialized by default—variables of types byte,
char, short, int, long, float and double are initialized to 0, and variables of type
boolean are initialized to false.
• You can specify your own initial values for primitive-type variables.
• local variables are not initialized by default.

• Programs use variables of reference types (normally called references) to store the locations of
objects in the computer’s memory. Such a variable is said to refer to an object in the program.
Objects that are referenced may each contain many instance variables and methods. Line 14 of
Fig. 3.8 creates an object of class GradeBook, and the variable myGradeBook contains a reference
to that GradeBook object.
• Reference-type instance variables are initialized by default to the value null.
• reference to an object is required to invoke (i.e., call) the object’s methods.
• primitive-type variables do not refer to objects, so such variables cannot be used to invoke
methods.

Initializing Objects with Constructors
• Each class you declare can provide a constructor that can be used to initialize an object of a
class when the object is created.
• Java requires a constructor call for every object that is created.
• Keyword new calls the class’s constructor to perform the initialization.
• The constructor call is indicated by the class name followed by parentheses—the
constructor must have the same name as the class.
• By default, the compiler provides a default constructor with no parameters in any class that
does not explicitly include a constructor.
• Lines 9–12 declare the constructor for class GradeBook. A constructor must have the same name
as its class.
• Line 9 indicates that class GradeBook’s constructor has a String parameter called name. The
name passed to the constructor is assigned to instance variable courseName in line 11 of the
constructor’s body.

Floating-Point Numbers and Type double
• class Account represents the account balance as a floating-point number (i.e.,
a number with a decimal point, such as 7.33, 0.0975 or 1000.12345).
• Java provides two primitive types for storing floating point numbers in
memory—float and double.
• The primary difference between them is that double variables can store
numbers with larger magnitude and finer detail (i.e., more digits to the right
of the decimal point—also known as the number’s precision) than float
variables.

Floating-Point Number Precision and Memory
Requirements
• Variables of type float represent single-precision floating-point numbers
and have seven significant digits. Variables of type double represent
double-precision floating-point numbers. These require twice as much
memory as float variables and provide 15 significant digits .
Account Class with an Instance Variable of Type double
• Application (Figs. 3.13–3.14) contains a class named Account (Fig. 3.13)
that maintains the balance of a bank account. A typical bank services
many accounts, each with its own balance, so line 7 declares an instance
variable named balance of type double. Variable balance is an instance
variable because it is declared in the body of the class but outside the
class’s method declarations (lines 10–16, 19–22 and 25–28). Every instance
(i.e., object) of class Account contains its own copy of balance.

• The format specifier %f is used to output values of type float
or double. The .2 between % and f represents the number of
decimal places (2) that should be output to the right of the
decimal point in the floating-point number—also known as
the number’s precision.
•Any floating-point value output with %.2f will be rounded to
the hundredths position—for example, 123.457 would be
rounded to 123.46, and 27.333 would be rounded to 27.33.

java java java java java-unit-ii-batu-.pptx

More Related Content

Similar to java java java java java-unit-ii-batu-.pptx

More from ssuser7b9bda1

Recently uploaded

java java java java java-unit-ii-batu-.pptx