Java Classes and Objects
Object Oriented Terms
Abstraction
Before abstraction: Porche, Pinto, Semi, Motorcycle After abstraction: Vehicle
Encapsulation
All vehicles have: number of wheels, color, start(), accelerate(), decelerate(), turnOff()
Object Oriented Terms
Inheritance Polymorphism
Method Overloading
start(Key key) start (Screwdriver s, Hammer, h) The list of input variables must be unique for each overloaded method
Method Overriding
For vehicle: start() { engineStatus = ON } For bicycle: start() { throw new DoesNotStartEx()}
Access Specifiers/Modifiers
Private, Protected, Public, (none) Accessed By this class only All Package Inherited? No
Private Public <none>
Protected this class only
Yes
Yes Yes
Returning values from Methods
If your method returns something, use
return <variable>;
If your method returns nothing (void), you can use return alone.
return; Note: only use this when you want to exit the method early. No need to put it at the end!
Constructors
No return type If a class does not have a constructor defined, the compiler automatically adds a default constructor with no input values. Constructors are NOT inherited!
If you wish to inherit a constructor, you must write out the signature and call the parents constructor using the super keyword
Variable Scope
{} define the scope of a variable When using catch, for, and while, remember that items declared within the catch, for, or while are only in scope within the following {}
{
Try { //ex out of scope} Catch (Exception ex) {// ex in scope} Finally { // ex out of scope }
//ex out of scope }
The Stack and the Heap
The stack is an orderly storage of data that is currently in scope The heap is an disorderly storage of data that may or may not be in scope Primitive data types exit on the stack Objects exist in the heap, but if they are in scope, pointer(s) to them exist in the stack
The stack
Once popped from the stack, the variables are out of scope
Garbage Collection
Cleans the heap Done sporadically by JRE after an object is out of the scope of the stack finalize() method of an object is called before the memory occupied by that object is released System.gc() makes a request that garbage collection take place, but there is no guarantee that it will happen Setting reference variables to null marks the associated object for garbage collection
Passing Data To Methods
If you call a method with a primitive variable, a copy of it is made on the stack, so changing it in the method has no effect on your copy. If you call a method with an object, you pass a reference, so any modifications to the object are done to the same data used by your pointer.
The return of return
In addition to modifying classes that are passed into a method, you can return a reference to an item created in the method with the return statement When calling the method you can:
Use the return value: Dog dog = Kennel.getDog() Use it directly: Kennel.getDog().speak(); Disregard it: Kennel.getDog()
Building your own packages
Normally, your projects will include more than a single class. Therefore, it is best to organize them in packages Create a folder hierarchy that makes sense with classes in each folder The package keyword is used on the first line (above import statements!) of each class to define its package structure to be used in import statements package com.mypackage;
-classpath parameter
When compiling and running classes that use other classes, the compiler and JRE need to know the location of the binaries of the classes in your import clauses.
javac -classpath . MyClass.java java -classpath . MyClass
When using multiple packages, you must do it from the root root by package Javac classpath mypackage/* *.java Java classpath mypackage/* ClsName
http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/classpath.html
