Introduction to Programming with 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 Entity that has a real existence Bookie (One who accepts and pays off bets, as on a horserace) Example

Example 1: Student Object Problem – Registration system Student - Model Data: name, address, major, courseList Behavior: change major, add/drop a course

Example 3: Dog Objects

OOP in Java A class is an abstract description of objects 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 instance variables 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 class Classname { //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 contain Data Definitions 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 (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. default constructor 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

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 (This part is the constructor)

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 Dog to create a Dog instance and store it in the variable Known as invoking the constructor Dog d1; d1 = new Dog(); Dog d2; d2 = new Dog(“Fido”, 5); make a new object make a new object

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

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

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

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, …) Input Example: void setAge(int dogAge){ age = dogAge; } void bark(String barkSound){ System.out.println(barkSound); }

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; } Output

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 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; } } Making the dog object d1 wake up the neighbors d1.wakeUpTheNeighbors();

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 Method main is of return type void 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 and String [] 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 As class: reset method() is query or command? 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 field accessible 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

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

General Java Program A program consists of one or more classes File Class Variables Constructors Variables Statements Methods 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