A class in Java contains class variables, instance variables, class methods and instance methods. We will work with instances first.

public class MyClass { //note no extends (assumes Object) int i; // can also do: int i = 0; public MyClass() { // NO void in constructors!!! why? i = 10; } public void Add_to_i (int j) { i = i + j; } }

The MyClass contains an instance variable i and two methods, MyClass which is a constructor for the class, and Add_to_i(int j).

Methods can be called by other classes(if public) or within the same class. One specific type of method is a constructor and

• is always named the same name as the class name
• doesn't have a return type
• gets called automatically with new messages
• automatically sends constructor to super() (can override by sending specific constructor message - super(x,y))
• the this Object is implicitly returned; a constructor should not use a return to explicitly return a value

When you declare a class in Java, you may declare one or more optional constructors that perform initialization when you instantiate an object of the class name.

public class MyClass { int i; int j; public MyClass() { i = 10; j = 20; } public MyClass(int first, int second) { i = first; j = second; } }

In this way, Java allows "overloading" of methods. Note this is not the same as overloading of functions in C, C++. The first step is looking at the object instance, then the method is always determined and performed based (1) on this object instance (2) on how many arguments were passed (3) on the type of arguments.

String str = new String() ; MyClass myClass = new MyClass(); MyClass myClass2 = new MyClass(3,4);

MyClass mc, test; mc = new MyClass(); test = new MyClass (6,9);

After the new object mc is instantiated, the value of i will be equal to 10. You may refer to the instance variable i with the object name:

mc.i++ ; // increments the mc instance variable i

mc.Add_to_i (10) ;

public class Name { String first, last ; public Name() { first = last = "" ; } public Name(String f, String l) { first = f; last = l; } } Name n = new Name(); Name o = new Name("T", "P");

n = o; //what does it do to what was in n?

Even with this access to the handle, in general, classes won't know about other classes variables since instance variables should be private to classes (encapsulation).

One can make variables public but one should do so only for variables (and methods) that form part of the public API of the class.

If you are inside a method being defined in Name then it knows the variables of Name (even the private ones).

private String name;
The private keyword makes sure that no outside agency can access the instances fields except through the methods of our class.

myObject.variable.state;

Now, this is interesting. One should be able to assign values to these variables:

myObject.variable.state = true;

Methods

A handy pair of methods is:myObject.getclass().getName()
Another handy tool is the instanceof predicate

Programming style:

If you really want to have data encapsulation and data hidding, then you probably want your variables to be private.

But, if variables are private, then how can you do techniques to access information?

One clean methodology is to always program accessors and converting (or mutating) methods (in LISP we had GetValue and PutValue). Most pure object-oriented languages make you provide such accessor methods.

Thus a user can only access the Instance Variables through the methods - and cannot do things like mc.i++

Java does not support destructors (as in C++) since it provides a means of automatically reaping objects that go out of scope, but it does provide a method that the automatic garbage collector will call:

// Close the stream when this object is collected void finalize() { close () ; }

This tells the garbage collector to do it but it does not actually do it until the garbage collector gets it.

You can always call the finalize method yourself, but calling it does not force the object to be garbage collected...only removing all references to an object will cause it to be marked for deletion.

When the last thread dies, the program stops. What does exit do? Kills whatever threads are present. Garbage collector is a thread.

Forced finalization and gc
(System.runFinalization() (calls finalize on all objects waiting to be g.c.), System.gc())

Subclassing (inheritence)

Java allows only single inheritence.

Subclassing allows us to create a new object defined in terms of some existing object.

// Sample HelloWorld applet // import java.awt.Graphics; // not the same as #include. No linking import java.applet.Applet; // just identifying where the class is public class HelloWorld extends Applet { public void paint (Graphics g){ g.drawString("Hello world!", 25, 25); } }

The keyword extends denotes subclassing. HelloWorld is a subclass of Applet.

Since the class Applet is contained in the package java.applet we need to import java.applet.Applet; so that we have access to the class

Public - we will get to permissions in classes in a bit ...

• Instance Variables and default values
• Class Variables and values
• Instance Methods
• Class Methods

The Methods can be totally new, can wrap-around parent's methods, or can override parent's methods

Class Variables and Methods

class FamilyMember { static String surname = "Gabet"; String name; int age; ... }

Note: to get or change the value of a class variable, you can use either the instance or name of the class on the left of the dot.

super and this

this refers to the "current" instance (like self in Smalltalk)
super is the parent of the "current" class

public class MyClass { int i; public MyClass() { i = 10; } // A constructor that sets the value of i public MyClass (int value){ this.i = value; // or, i = value } public void Add_to_i (int j) { i = i + j; } }

Here this.i refers to the int i in the class MyClass

default: if don't say who gets message, it is this.whatevermessage

If you need to call the parent method within a class that has overridden that method, you can refer to the parent method with the super keyword:

public class MyNewClass extends MyClass { public void Add_to_i (int j) { i = i + (j / 2); super.Add_to_i (j); } }

In the following code fragment, the value of i would be set to 10 by the constructor, then set to 15 and finally to 25 by the parent (MyClass) Add_to_i method:

MyNewClass mnc; mnc = new MyNewClass(); mnc.Add_to_i (10);

class A { int i; } class B extends A { int i; void foo(int i) { // scope example i = 3; //method variable this.i = 4; //this class instance variable super.i = 5; } //super's instance variable }

B myB = new B(); myB.foo(10);

Permissions, ClassTypes, Inheritence, Interfaces, Packages

Permissions (or Protections) depends on point of view :-) :

for methods and variables

Typical order:

• public - any and all classes can access
  (for classes, one usually starts out with this until know why to protect)
  • public void AnyOneCanAccess() {}
• private - accessible only to those within the class they are defined. They are not available to subclasses.
  • private String CreditCardNumber;
• protected - all classes in package and subclasses of the class inside and outside package.
• "friendly" - no specific declaration. I.e., the default
  Also known as "package" since it allows access to any objects inside the same package.
  • void MyPackageMethod() {}

Another example about who can access what (class vs instance variables and methods):

class Document extends File { private static int version = 10; public static void SetVersion (int v) { version = v; } }

Document d1, d2, d3: d1 = new Document(); d2 = new Document(); d3 = new Document(); Document.SetVersion(5); // calling by class; can we do this? d3.SetVersion(5); // calling by instance; can we do this?

Note:

If you declare a method static, it prevents the method from accessing any variables of the class which are not also declared static (i.e., class methods cannot change instance variables):

class Document extends File { private static int version = 10; int number_of_chapters; public static void SetVersion (int v) { version = v; } static void add_a_chapter () { number_of_chapters++; // won't work (CM, IV) } static void modify_rev (int i) { version++; // will work (CM, CV) } }

Class Types:

abstract

An abstract class must have at least one abstract method. An abstract class cannot be instantiated, and must be subclassed

final

A final class is declared as the last class of any subclass chain. (efficiency) Classes declared final may not be subclassed. The Math class is a final class

public

Can be accessed by other classes, either directly or subclassing. The class must be imported to be used by other packages, otherwise it is only available within the package where it is declared

synchronized

This class modifier declares that the methods defined in the class are all synchronized.

final

A final method cannot be overriden, a final variable may never have its variable set

native

native is a modifier for methods. It indicates that the method is implemented elsewhere in C, or in some other platform-dependent fashion

transient

indicates a field that is notpart of an object's persistant state and thus will not be serialized with the object

synchronized

This class modifier declares that the methods defined in the class are all synchronized.

volatile

applied to variable fields. Specifies that the filed is used by synchronized threads and that the compiler should not attempt to perform optimizations with it.