java programs are built from classes. there is nothing else, but classes

Java programs are built from classes.

Java programs are built from classes.

There is nothing else, but classes.

A class contains members:


a) data (variables)


a) data (variables)

b) procedures (methods)

Members could be static or not static.

End of story.

Let’s see some examples now.

class One {

}

Draw this:

class One {

}

One

Draw this: Don’t forget the blueprint (even though it’s empty).

class Two { int u; double q;}

Draw this:


Two

Draw this: Notice that the blueprint is no longer empty:


Two

u

q



Two

u

q


u and q are called instance variables

class Student {

}

Draw this:

class Student {

}

Student

Draw this:

Easy. Student or One – same difference.

class Student { int age; }

Now draw this:

class Student { int age; }

Now draw this:

Student

age

class Z { int m; double n; }

Draw this:

class Z { int m; double n; }

Draw this:

Z

m

n

class M { int m; static double n; }

Draw this:


Draw this:

M

mn


Draw this:

M

m

n

class M { int m; double n; }

Draw this:

M

m

n


Draw this:

M

mn

class Q { int v; double z; public static void main(String[ ] args) {

} }

Draw this:


} }

Draw this:

For this the picture is bigger:


} }

Draw this:

For this the picture is bigger:

Qv

zmain

args

class E { int v; double z; public static void main(String[ ] args) { int q; q = 3; } }

Draw this:


Draw this:

Same as above, only main is no longer empty:


Draw this:


Ev

z


Draw this:


Ev

zmain

args


Draw this:


Ev

zmain

argsint q;


Draw this:


Ev

zmain

argsint q;

q is a local variable.


Draw this:


Ev

zmain

argsint q;

q is a local variable. It is local to main.


Draw this:


Ev

zmain

argsint q;

q = 3;


Draw this:


Ev

zmain

argsint q;

q = 3;

3

class Student { int age; double gpa; public static void main(String[ ] args) { int q = 21; String n = “John”; } }

Draw this:


Draw this:

Student

age

gpamain

args


Draw this:

Student

age

gpamain

argsq


Draw this:

Student

age

gpamain

argsq 21


Draw this:

Student

age

gpamain

argsq 21

n


Draw this:

Student

age

gpamain

argsq 21

n

java.lang.String

“John”


Draw this:

Student

age

gpamain

argsq 21

n

java.lang.String

“John”

String is a reference type.

Types in Java:

Types in Java:

a) primitive

Types in Java:

a) primitive (int, double, boolean, char)

Types in Java:


b) reference types

Types in Java:


b) reference types (classes)

Types in Java:


int x;

Types in Java:


int x;

int y;

Types in Java:


int x;

int y;

x = 5;

Types in Java:


int x;

int y;

x = 5;

5

Types in Java:


int x;

int y;

x = 5;

5

y = x;

Types in Java:


int x;

int y;

x = 5;

5

y = x;

5

Types in Java:


int x;

int y;

x = 5;

5

y = x;

5

x = x + 2;

Types in Java:


int x;

int y;

x = 5;

5

y = x;

5

x = 5 + 2;

Types in Java:


int x;

int y;

x = 5;

7

y = x;

5

x = x + 2;

Types in Java:


int x;

int y;

x = 5;

7

y = x;

5

x = x + 2;

But this doesn’t change y.

Types in Java:


int x;

int y;

x = 5;

7

y = x;

5

x = x + 2;


And that’s because y is a copy of x.

Types in Java:


int x;

int y;

x = 5;

7

y = x;

5

x = x + 2;



Things don’t work the same with reference types.

Types in Java:


int x;

int y;

x = 5;

7

y = x;

5

x = x + 2;



But the above is true of primitive types:

int (long, short, byte)double (float)charboolean

Types in Java:


b) reference types

Types in Java:


b) reference types

Penguin x;

Types in Java:


b) reference types

Penguin x;

x = new Penguin();

Types in Java:


b) reference types

Penguin x;

x = new Penguin();

Penguin y;

Types in Java:


b) reference types

Penguin x;

x = new Penguin();

Penguin y;

y = x;

Types in Java:


b) reference types

Penguin x;

x = new Penguin();

Penguin y;

y = x;

x.turnLeft();

Types in Java:


b) reference types

Penguin x;

x = new Penguin();

Penguin y;

y = x;

x.turnLeft();

But that also changes the value of y.

Types in Java:


b) reference types

Penguin x;

x = new Penguin();

Penguin y;

y = x;

x.turnLeft();

But that also changes the value of y.

The Penguin object is only one, and shared.

Types in Java:


b) reference types

Types in Java:



Types in Java:



A value of primitive type fits in a location of that type.

Types in Java:




A value of reference type (an object) doesn’t.

Types in Java:




A value of reference type (an object) doesn’t.

For objects, a reference to them is kept in the variable.

Let’s continue with the examples.

class J { int x; public static void main(String[ ] args) { J z = new J(); int x = 5; z.x = 5; } }

Draw this:


Draw this:

main

args

x

J


Draw this:

main

args

x

J

z


Draw this:

main

args

x

J

z

x0


Draw this:

main

args

x

J

z

x

x

0


Draw this:

main

args

x

J

z

x

x 5

0


Draw this:

main

args

x

J

z

x

x 5

5

Draw this:

Draw this:

class Student { int age; double gpa; public static void main(String[ ] args) { int q; String n; Student s; s = new Student(); } }

Draw this:


What kind of variables are age and gpa?

Draw this:


Yes, they are instance variables.

Draw this:


What kind of variables are q, n, and s?

Draw this:


Exactly, they are local variables.

Draw this:


They’re local to main.

Draw this:


Now let’s draw!

Draw this:


Student

age

gpa

main

argsq

Draw this:


Student

age

gpa

main

argsq

n

Draw this:


Student

age

gpa

main

argsq

n

s

Draw this:


Student

age

gpa

main

argsq

n

s

age

gpa 0

0

Draw this:


Student

age

gpa

main

argsq

n

s

age

gpa 0

0

Notice that q and n have no values in them.

Draw this:


Student

age

gpa

main

argsq

n

s

age

gpa 0

0

Notice that q and n have no values in them.Unlike instance or class variables, local variablesneed to be initialized explicitly by the programmer.

Draw this:


Student

age

gpa

main

argsq

n

s

age

gpa 0

0

Instance and class variables have default values.

Draw this:


Student

age

gpa

main

argsq

n

s

age

gpa 0

0

Instance and class variables have default values.It’s not hard to guess the default values.

Draw this:

class Student { int age = 20; double gpa; public static void main(String[ ] args) { Student s = new Student(); Student q = new Student(); q.age = 19; s.age = 21; q.age = 3 + q.age; } }

Draw this:


Student

age

gpa

main

args

Draw this:


Student

age

gpa

main

argss

age

gpa 0

20

Draw this:


Student

age

gpa

main

argss

q

age

gpa 0

20age

gpa 0

20

Draw this:


Student

age

gpa

main

argss

q

age

gpa 0

19age

gpa 0

20

Draw this:


Student

age

gpa

main

argss

q

age

gpa 0

19age

gpa 0

21

Draw this:

class Student { int age = 20; double gpa; public static void main(String[ ] args) { Student s = new Student(); Student q = new Student(); q.age = 19; s.age = 21; q.age = 3 + 19; } }

Student

age

gpa

main

argss

q

age

gpa 0

19age

gpa 0

21

Draw this:

class Student { int age = 20; double gpa; public static void main(String[ ] args) { Student s = new Student(); Student q = new Student(); q.age = 19; s.age = 21; q.age = 22; } }

Student

age

gpa

main

argss

q

age

gpa 0

19age

gpa 0

21

Draw this:


Student

age

gpa

main

argss

q

age

gpa 0

22age

gpa 0

21

Now write this (in Java): Create two accounts, for Doug and Adrian.

Now write this (in Java): Create two accounts, for Doug and Adrian. Initial balance for both accounts is 10.

Now write this (in Java): Create two accounts, for Doug and Adrian. Initial balance for both accounts is 10. Then Doug’s account doubles, Adrian’s decreases by 3 dollars, and Doug’s account has one more dollar deposited into it.

Let me try it. How about this?

class Account { double balance = 10; public static void main(String[ ] args) { Account doug, adrian; doug = new Account(); adrian = new Account(); doug.balance = doug.balance * 2; adrian.balance -= 3; doug.balance++; } }

Let me try it. How about this?


Create two accounts, for Doug and Adrian. Initial balance for both accounts is 10. Then Doug’s account doubles, Adrian’s decreases by 3 dollars, and Doug’s account has one more dollar deposited into it.


Account

balance


Looks good.


Looks good. Thank you.

Draw this:

Draw this:

class BankAccount { double balance = 25; public static void main(String[ ] args) { BankAccount doug = new BankAccount(); BankAccount adrian = new BankAccount(); doug.balance = doug.balance * 2; adrian.balance -= 3; doug.balance++; } }

Draw this:

class BankAccount { double balance = 25; public static void main(String[ ] args) { BankAccount doug = new BankAccount(); BankAccount adrian = new BankAccount(); doug.balance = doug.balance * 2; adrian.balance -= 3; doug.balance++; } }

Too easy, almost the same thing...

Draw this:

class Account { double balance = 20; void deposit(int n) { this.balance += n; } }

Draw this:


Draw this:

Account

this.balance

n

deposit

this.balance += n;


Draw this:

Account

this.balance

n

deposit

+this.balance += n;


Draw this: balance is an instance variable.

Account

this.balance

n

deposit

+this.balance += n;


Draw this: balance is an instance variable. It belongs to the object.

Account

this.balance

n

deposit

+this.balance += n;


Draw this: deposit is an instance method.It belongs to the object and describes an update on its instance variables (state).

Account

this.balance

n

deposit

+this.balance += n;


Draw this: n is not a local variable in deposit.

Account

this.balance

n

deposit

+this.balance += n;


Draw this: It is called a parameter of the method deposit.It is a way of naming the method’s inputs.It is a way to refer to the ingredients of the recipe.

Account

this.balance

n

deposit

+this.balance += n;


Draw this: The keyword this allows an object to refer to itself.

Account

this.balance

n

deposit

+this.balance += n;

Draw this:

Account

this.balance

n

deposit

+this.balance += n;

class Account { double balance = 20; void deposit(int n) { this.balance += n; } public static void main(String[ ] args) { Account m = new Account(); Account q = new Account(); m.deposit(10); q.deposit(3); }}

Draw this: Account

this.balance

n

deposit

+this.balance += n;


mainargs

Draw this: Account


+

this.balance

n

deposit

+this.balance += n;

mainargs

m

20

Draw this: Account


+

this.balance

n

deposit

+this.balance += n;

mainargs

m

+

q

2020

Draw this: Account


+

this.balance

n

deposit

+this.balance += n;

mainargs

m

+

q

202010

Draw this: Account


+

this.balance

n

deposit

+this.balance += n;

mainargs

m

+

q

3020

Draw this: Account


+

this.balance

n

deposit

+this.balance += n;

mainargs

m

+

q

30203

Draw this: Account


+

this.balance

n

deposit

+this.balance += n;

mainargs

m

+

q

3023

Draw this:

class Account { double balance; Account(double x) { } public static void main(String[ ] args) { Account m = new Account(10); Account q = new Account(3); m.balance = 10 + m.balance; }}

Draw this:


This is a constructor.

Draw this:


It’s like an initialization procedure.

Draw this:


It’s attached to the blueprint

Draw this:


It’s attached to the blueprint (not instances)

Draw this:


It’s attached to the blueprint (not instances)This one is empty.

Draw this:


Account

this.balance

x

Account

mainargs

Draw this:


Account

this.balance

x

Account

mainargs

m

10

0balance

Draw this:


Account

this.balance

x

Account

mainargs

m

0balance

Draw this:


Account

this.balance

x

Account

mainargs

m

0balance

q

0balance


Draw this: Account

this.balance

x

Account

mainargs

m

0balance

q

0balance

10 + m.balance


Draw this: Account

this.balance

x

Account

mainargs

m

0balance

q

0balance

10 + 0


Draw this: Account

this.balance

x

Account

mainargs

m

0balance

q

0balance

10


Draw this: Account

this.balance

x

Account

mainargs

m

10balance

q

0balance

class X { int x;}

Draw this:

X

x

How easy.

class X { int x;}

Draw this:

class A { int x; A (int initialValue) { this.x = initialValue; } /* do this when you first create the object but don’t make it part of the generated instance */}

Draw this:


Draw this: That’s called a constructor.

A

x

initialValue

A


Draw this: Notice the name of the constructor.

A

x

initialValue

A


Draw this: Notice the name of the constructor.It’s the name of the class.

A

x

initialValue

A


Draw this: Notice the name of the constructor.It’s the name of the class. A constructor looks like a method (procedure).

A

x

initialValue

A


Draw this: Notice the name of the constructor.It’s the name of the class. A constructor looks like a method (procedure).But doesn’t have a return type.

A

x

initialValue

A


Draw this: Here’s how the constructor works:

A

x

initialValue

A


Draw this: Here’s how the constructor works:

A

x

initialValue

A

this.x = initialValue;


Draw this: When the constructor is invoked, a value is passed

(as an argument)to the constructor.

A

x

initialValue

A



Draw this: The constructor then starts executing.

A

x

initialValue

A



Draw this: The constructor then starts executing.The value is taken from the argument,

A

x

initialValue

A



Draw this: The constructor then starts executing.The value is taken from the argument,

into the instance variable.

A

x

initialValue

A



Draw this: Thus the instance variable will have beeninitialized with what is in initialValue.

A

x

initialValue

A


initialValue;

Speaking of this, can I show you an example?

Sure, go ahead.

Sure, go ahead. Here it is:

class Speakers { public static void main(String[ ] args) { Speaker a = new Speaker(“Larry”); Speaker b = new Speaker(“Michael”); Speaker c = new Speaker(“Toni”); a.talk(); b.talk(); c.talk(); } }

class Speaker { String speaker; Speaker(String name) { speaker = name; } void talk() { System.out.println(this.speaker + “ is very happy.”); }}

This writer is very happy. Here it is:

class Speakers { public static void main(String[ ] args) { Speaker a = new Speaker(“Larry”); Speaker b = new Speaker(“Michael”); Speaker c = new Speaker(“Toni”); a.talk(); b.talk(); c.talk(); } }

class Speaker { String speaker; Speaker(String name) { speaker = name; } void talk() { System.out.println(this.speaker + “ is very happy.”); }}

This writer is very happy. Ha, ha. Draw this:

class Student { String name; Student(String w) { this.name = w; }}

class Tuesday { public static void main(String[ ] args) { Student q = new Student(“Larry”); Student u = new Student(“John”); Student s = new Student(“Adrian”); } }

That’s funny. Ha, ha. Draw this:



That’s funny. Yes.



We should always try to refer to instance variables through the instance they belong to.

That’s funny. Yes.

We should always try to refer to instance variables through the instance they belong to.This way we would also be able to keep them separate from local variables

and parameters (or arguments).



Draw this:

class Checking { double balance; Checking(double x) { this.balance = x; } void deposit(double y) { this.balance = this.balance + y; }}

Draw this:

class Tea { double bird; void book(double watch) { this.bird = watch – this.bird; } Tea (double snake) { this.bird = snake * 2; }}

Draw this:


instance variable


Draw this:

instance method


Draw this:

formal parameter


Draw this:

formal parameter(like a local variable only initialized when invoked)


Draw this:

constructor

Draw this:


Draw this:

class Hat { public static void main(String[ ] args) { Tea m = new Tea(-2); Tea n = new Tea(42);

m.book(92); n.bird = m.bird + n.bird;

n.book(25); n.book(25); } }

Draw this:



n.book(25); n.book(25); } }


Where Tea is the class seen before.

Draw this:



n.book(25); n.book(25); } }


Where Tea is the class seen before.

(Soliloquy p. 133) We should also use BlueJ to examine this example thoroughly.

Last example:

class X { int q; }

class Play { public static void main(String[ ] args) { X u = new X(); X p = new X(); u.q = 3; p.q = u.q + p.q; u.q = u.q + p.q; } }

Last example:

class X { int q; }

class Play { public static void main(String[ ] args) { X u = new X(); X p = new X(); u.q = 3; p.q = u.q + p.q; u.q = u.q + p.q; } }

This should be easy, by now.

So what types do we have in Lab Eight (for example)?


Point


PointCircle


PointCircleRectangle


PointCircleRectangle

We should also discuss Robot (to understand Penguin).

Thank you.

java programs are built from classes. there is nothing else, but classes

Documents