variables methods and_objects_lecture_2

In Java there are three kinds of variables.

The difference has to do with scope.

Java Basics

The Three Are:

Class Variables

Instance Variables

Local Variables

Java Basics

The Three Are:

Class Variables--declared with ‘static’

Instance Variables--declared outside of any method

Local Variables--declared inside of a method

Java Basics

Local Variables

When you declare a variable inside a method, it is a local variable.

It lives only as long as the method lives.

We say it has ‘method scope’.

Java Basics

public class ShowLocalVariables{ public void aMethod() {

int x = 0; StringBuffer d = new StringBuffer( “myBuffer”); }

‘x’ and ‘d’ are declared within the method. Since they are declared within the method, they have ‘method scope’ and they live only as long as the method is alive.

int x = 0; StringBuffer d = new StringBuffer( “myBuffer”); }

Notice that I have not included an ‘access modifier’ such as public, private or protected. Why? Because all local variables are automatically private.

In fact, it is a syntax error to include an access modifier on a local variable and the compiler will complain loudly.

int x = 0; StringBuffer d = new StringBuffer( “myBuffer” ); }

Also notice that I have initialized the primitive variable ‘x’ to zero, and I have instantiated the object variable ‘d’. A local variable must always be manually set to an initial value.

Instance Variables

When you declare a variable outside any method, it is an instance variable.

It lives only as long as the instance of this class lives.

We say it has ‘instance scope’.

Java Basics

Instance Variables

An instance variable will be automatically initialized.

Primitive numeric variables will automatically be initialized to zero.

Object variables will be automatically initialized to null.

Strings will be set to spaces.

Java Basics

Instance Variables

Take close notice of the word ‘instance’.

When you have an instance variable, each instance of the class gets its own set of the instance variables in a class.

Java Basics

public class InstanceVariables{ private int x; private StringBuffer d;

public void aMethod() {

d = new StringBuffer( “myBuffer” ); }

Notice I have declared ‘x’ and ‘d’ outside of any method.

Even though I’m instantiating ‘d’ in a method, it will live and hold its value beyond this method’s life.

public class InstanceVariables{ private int x; private StringBuffer d; public InstanceVariables( int p, StringBuffer w ) {

x = p; d = w; }

public String toString() { String out = “x=“ + x + “,d=“ d.toString();

return out; }}

In a moment we will make an instance of this class, but first a question:

this.x = p; this.d = w; }

public String toString() { String out = “x=“ + x + “,d=“ d.toString();

return out; }} Is it legal to use the ‘this’ reference above?

this.x = p; this.d = w; }

public String toString() { String out = “x=“ + x + “,d=“ + d.toString();

return out; }}

Yes! This line says: “Take the value of ‘p’ and assign it to the instance variable ‘x’ in thisthis instance.”

public class Tester{ public Tester() { InstanceVariables v; v = new InstanceVariables( 5, “hello” ); System.out.println( v.toString() ); }

public static void main( String[] args ) { Tester t = new Tester(); }}

Let’s follow the sequence of execution here.

x=5,d=hello

public class Tester{ public Tester() { InstanceVariables a, b, c; a = new InstanceVariables( 5, “hello” );

b = new InstanceVariables( 6, “howdy” );c = new InstanceVariables( 7, “hi” );

System.out.println( a.toString() );System.out.println( b.toString() );System.out.println( c.toString() );

public static void main( String[] args ) { Tester t = new Tester(); }}

Now, we will create multiple instances. The key point? Each instance of the class has its own copyown copy of those variables.

x=5,d=hellox=6,d=howdyx=7,d=hi

Class Variables

static

A ‘class variable’ is declared with the keyword ‘static’.

‘static’ variables belong to the class, not to any one instance of the class.

When you declare a variable as static, then all instances of the class shareshare one copy of that variable.

Java Basics

static

As soon as the class is loaded--and before you have even instantiated an instance of the class (with the new keyword), you can access a static variable.

This fact governs static variables and their behavior.

Java Basics

static

Say you had a class called SavingsAccount, which held the information for a single person’s account.

Our bank has a million instances of this class to serve our million customers.

Java Basics

static

If--by mistake--this class contained an instanceinstance variable called ‘interestRate’, then--every time the interest rate changed-- you’d have to go out and update a million instances with the new interest rate.

But, if you made the variable static, then all instances share one copy. Change it once and you’ve updated it for everybody.

Java Basics

static

statics are snobs. They only associate with their own kind.

If you have a static variable, then it can only be accessed by a method that has been declared as static.

Java Basics

static

That makes sense.

Since a static variable can exist even when there isn’t an instance of the class, then a static method would exist even when there isn’t an instance.

Java Basics

static

To access a static variable, you need a static method.

A static method can only call anotheranother static method--because that’s the only kind of method that’s sure to be present, even if we don’t have an instance of the class.

Java Basics

public class SnobbyStatics{ static double interest;

public static double getInterest() {

return interest; }

public static void setInterest( double inter ) {

interest = inter; }

return interest; }

this.interest = inter; }

For a static, is the ‘this’ keyword legal?

The ‘this’ keyword means ‘this instancethis instance’ and therefore it doesn’t fit.

return interest; }

interest = inter;anotherStaticMethod();

public static void anotherStaticMethod() { System.out.println( “I’m ecstatic!” ); }

Does this make sense? Can you call a static method from within another static method?

return interest; }

interest = inter; }

public double nonStaticMethodCallStaticMethod() {

return getInterest(); }

Is this legal? Having a non-static method calling a static method?

return interest; }

public double nonStaticMethodCallStaticMethod() {

return getInterest(); }}

Let’s understand why this is okay. Before we can call a non-static method, we would need to have an instance of the class instantiated. At that point, will the static methods be available?

Therefore, it is legal to call a static method from a non-static method.

return interest; }

interest = inter + aNonStaticMethod(); }

public double aNonStaticMethod() {

return 0.0; }

Is this legal? Having a static method calling a non-static method?

You can call a static method without an instance and the non-static method might not be there.

static variable … used in a static method?

static variable … used in a NON-static method?

Non static variable … used in a static method?

static method … called by another static method?

static method … called by a Non static method?

Non static method … called by a static method?

static variable … used in a static method? Of course

static variable … used in a NON-static method? NO

Non static variable … used in a static method? NO

static method … called by another static method? YES

static method … called by a Non static method? YES

Non static method … called by a static method? NO

static

statics are snobs. They only associate with their own kind. If you have a static variable, then it can only be accessed by a method that has been declared as static.

That makes sense. Since a static can exist even when there isn’t an instance of the class, then a static method would exist even when there isn’t an instance.

Java Basics

Java Methods

Pass by Value

In Java, when you call a method, a copy of the argument is always passed.

Because it passes a copy, the original can never be changed.

Ah! But don’t let that fool you.

Java Methods, Pass by Value

When you’re dealing with a primitive variable, that is literally true.

Java makes a duplicate of the original variable and makes an exact copy of the contents of the variable.

public class PassByValueMysteries{ private int x = 59;

public PassByValueMysteries() {

System.out.println( “Before x=“ + x );tryToChangeMyArgument( x );

System.out.println( “After x=“ + x ); }

public void tryToChangeMyArgument( int q ) { q++; }

public static void main( String[] args ) { PassByValueMysteries m = new PassByValueMysteries(); }}

q 59q 60

Before x=59After x=59

public class PassByValueMysteries{ private StringBuffer x;

public PassByValueMysteries() {

x = new StringBuffer( “before” );System.out.println( “Before x=“ + x.toString() );canChangeMyArgument( x );

System.out.println( “After x=“ + x.toString() ); }

public void canChangeMyArgument( StringBuffer q ) { q.append( “ after” ); }

public static void main( String[] args ) { PassByValueMysteries m = new PassByValueMysteries(); }}

q 1221231314

Before x=beforeAfter x=before after

1221231314

before

X 12212313141221231314

before after

So, you see the principle is consistent.

The twist is this: a reference contains a a different kind of datadifferent kind of data--the address of the object. So, if we send the address of the original object (as the data contained in the variable we’re sending) then we can change the original.

What Really Happens When You Instantiate

An Object

Next, I will show you a simple class, and I want you to tell me what the sequence is

What Really Happens When You Instantiate An Object

public class Test{ public Test() { Bbb b = new Bbb(); }

public static void main(String[] args) { Test t = new Test(); }}

public class Object{ public Object() { System.out.println( “Object Const” ); }}

public class Aaa{ public Aaa() {

System.out.println( “Aaa Const” ); }}

public class Bbb extends Aaa{ public Bbb() {

System.out.println( “Bbb Const” ); }}

Test mainTest constObject ConstAaa ConstBbb Const

Questions?

Requests for future topics?

variables methods and_objects_lecture_2

tom hunterpublic class

instance variable x

new instancevariables

tom hunterthe

object variable d

tom hunterstaticas

class shareshare

theprimitive variable

Business

introduction to instrumental variables methods

instrumental variables and panel data methods in economics...

variables cont. psych 231: research methods in psychology

class variables and methods

quantitative methods combining continuous and categorical...

object-oriented programming: static methods &...

methods to control extraneous variables

generating random variables - simulating methods

applications of graded methods to cluster variables in...

comp 110 static variables and methods

6.092: introduction to java lecture 1: types, variables...

4. naming identifiers - naming variables, methods, classes,...

object-oriented programming: static methods & variables

research methods steps in psychological research...

instrumental variables: problems methods of economic...

methods csc 171 fall 2004 lecture 3. methods variables...

research methods (variables & hypothesis)

large margin methods for structured and interdependent...

chapter 8 relationships among variables research methods in...

aula01-03_03_16 (1) methods 2 complex variables