Introduction to Programming with Java, for Beginners

Introduction to Programmingwith Java, for Beginners Intro OOP with Java Java Program Structure

Object-Oriented Programming Model • Design problems/programs such that they correspond to real world entities • Entity a.k.a Object is something that has real existence • Examples: person, dog, car, student, bank account • Objects: Model the parts of a problem. They have: • Data/State: information about that object • Behaviors: describe how the object behaves • Classes • Describes common features to all objects • Templates for creating objects

Example 1: Student Object • Data: name, address, major, courseList • Behavior: change major, add/drop a course

Example 3: Dog Objects

OOP in Java • A Java program is a collection of objects • A class is an abstract description of objects • Classes contain • Data Fields that hold the data for each object • Data is stored in instancevariables • Methods that describe the actions/behaviors the object can perform • Constructor(s) that tell how to create a new object of this class

Class Structure classClassname { //Data Fields … //Constructor .. //Methods .. } • Classname and Filename should be same • i.e. Classname.java • Start and end of class declaration is indicated by curly braces i.e. { } • Compiler complains if this is missing

Classes describe the data held by each of its objects Also known as instance variables class Dog { String name; int age; ...rest of the class...} Data usually goes first in a class Classes contain Data Definitions

Classes contain Data Definitions (contd..) • Data can also describe the relationship of the object to other objects • Example: a checkingAccount might have • An accountNumber (used as an ID number) • A balance (the internal state of the account) • An owner (some object representing a person)

Classes always contain Constructors • A constructor is a piece of code that “constructs,” or creates, a new object of that class • If you don’t write a constructor, Java defines one for you (behind the scenes) • i.e. defaultconstructor • Usually a constructor is written to initialize an object’s state i.e. data fields • Default constructor initialize object’s state default value for that type. E.g. for type int, the default value is zero

(This part is the constructor) Constructor: Initialize Data Example class Dog { String name; int age; Dog(String Name, int Age) { name = Name; age = Age; } … //rest of the class } • Important: Constructor name is same as ClassName

Dogd2; d2 = new Dog(“Fido”, 5); make a new object make a new object Creating Objects • Declare a variable of appropriate type to hold the object • E.g. For Dog object we a need a variable of type Dog • Use the constructor of Dogto create a Dog instance and store it in the variable • Known as invoking the constructor Dogd1; d1 = new Dog();

Classes contain Methods • A class may contain methods that describe the behavior of objects • Methods contain one or more statements that describe a particular behavior • A block of code, which when used performs certain instructions • Different from control block structures like if, while • Can receive inputs • Can return an output

Examples of Object Behavior • Query Methods: ask an object about its state • What’s your name? Age? Favorite band? • Command Methods: change an object’s state • Withdraw $100 from my bank accountmy bank balance changes

class Dog { ... void bark() { //instructions for barking System.out.println(“Woof”); }} Methods usually go after the data & constructor Statement Example of Method

Making object do something • To make a dog object bark, in Java we write • d1.bark(); • d1 is dog object and we ask a this particular dog to bark, it says “Woof” • Terminology: • Sending message to dog object • Commanding or Asking the dog to something

Input General Method Declaration • return_type methodName(0+ parameters){..} • Method Input • receive 0 or more inputs. E.g. bark() has no inputs • Inputs may be passed so that method can use these values for some purpose • A method specifies its expected inputs via a list of “formal parameters” (type1 name1,type2 name2, …) • void bark(String barkSound){ • System.out.println(barkSound); • }

Output General Method Declaration (contd..) • return_type methodName(0+ parameters){..} • Method Output • A method may output nothing or one thing • If it outputs nothing, then its return_type is void void setDogAge(int dogAge){ age = dogAge; }

General Method Declaration (contd..) • Method Output • If it outputs one thing: Its return_type is non-void • i.e. must be of certain type • It then must have a return statement that returns a value • The value returned must match return type int getDogAge(){ return age; } age is of type “int” and hence return type is int

Calling/Invoking a Method on an Object • Calling/Invoking a method on an Object • Is a programming terminology for asking or making an object to perform some behavior • In general • objectName.methodName(0 + parameters) • In a method call, the number, order, and type of arguments must match the corresponding parameters • Examples: d1.bark(); d1.bark(“Woof grrr”);

Methods can contain other methods • Example: • class Dog { ... void bark() { System.out.println("Woof"); }} • E.g. System.out.println(String s) • String s is the input to the method • Other programmer's wrote printing program and called it class System

Reusing already written methods • Java is famous for reusing already written programs • Benefits: Do not need to reinvent the wheel • Java provides a huge library of useful programs that can be reused • Comes along with the JDK tool kit • Some libraries are part of the language and can be simply used • Some libraries (utilities) need to specified with an import statement • More on this later lectures

Methods may contain temporary data • Data described in a class exists in all objects of that class • Example: Every Dog has its own name and age • A method may contain local temporary data that exists only until the method finishes • E.g: void wakeTheNeighbors( ) {int i = 50; // i is a temporary variable while (i > 0) { bark( ); //using its own class method i = i – 1; } }

Temporary /Local vs. Instance Variables • Temporary/local variables are known • From the point of declaration until the end curly brace of the block in which they are declared • In contrast, instance variables are • Declared outside of any method • Known to all methods in the class in which they are declared

Class Methods in General • Methods consist of statements (or instructions) causes the object to do something • Combination of literals and, operators • Control Structures - e.g. while, if • Temporary variables • Methods from other classes • Methods from its own class

Asking Object about its data directly • It may possible to ask a object about its data without querying the object i.e. calling the method • ObjectName.DataField; >Dog d1 = new Dog(“Fido”,5); >String dogName = d1.name; >System.out.println(dogName); Fido • But this depends on accessibility of the data • More on this in slide 28

Putting it all together • When you want to create standalone Java application program one of the classes should contain the main method • Method main is a special method, not part of any object, that is executed in order to get things started such as: • Creating Objects • Ask objects to do something or interact with another object

Main Method public static void main(String[ ] args) {Dog fido = new Dog("Fido", 5); // creates a Dog fido.bark(); fido.setAge(6); } • Method main is of return type void • Will explain the keyword public (on slide 28) • Learn about static andString [] args in later lectures

OOP Recap • Class: a template for creating objects • An object is an instance of a class • Example: • One Dog class • Multiple Dog objects • Lord of the Rings Simulation • One Human class, multiple Human objects • One Elf class, multiple Elf objects • One Orc class, multiple Orc objects

A Counter class example

Complete Counter class public class Counter { private int count; public Counter () { count = 0; } public int currentCount () { return count; } public void incrementCount () { count = count + 1; } public void reset () { count = 0; } } Data field (instance variable) constructor methods query command ? Counter class declaration

Counter Object Behaviors • Counter c= new Counter(); • If you want to increment count value of object c • c.incrementCount(); • If you want see the count value of object c • c.currentCount(); • If you want to reset count value of object c • c.reset();

Accessibility Level • Data fields/instance variables of class and class itself can also have accessibility_level • Examples: public void incrementCount(){ .. }, private count ; • public:makes the method/data fieldaccessible from outside the class • Private:not accessible outside the class • In default case: accessible if within same directory • Accessibility_level appears before • the return type of method • the type of variable

public class Counter { private int count; public Counter () { count = 0; } public int getCount () { return count; } public void incrementCount () { count = count + 1; } public void reset () { count = 0; } public static void main(String[ ] args) { Counter c = new Counter(); int whatIsCount = 0; c.incrementCount(); c.incrementCount(); whatIsCount = c.currentCount(); System.out.println(whatIsCount); c.reset(); whatIsCount = c.currentCount(); System.out.println(whatIsCount); } } // ends the class Complete Counter Program

File File File Class Variables Statements Constructors Variables File Statements Methods Variables General Java Program • A program consists of one or more classes • Typically, each class is in a separate java file

Writing and Running Programs in OOP • When you write a program • You are writing classes and all the things that go into classes • Your program typically contains commands to create objects and make them do something • When you run a program • It creates objects, and those objects interact with one another and do whatever they do to cause something to happen

Advantages of OOP • OOP is conducive to good design and efficient redesign • Most changes affect only a few classes

Introduction to Programming with Java, for Beginners