// Stick.java
//Chapter 8 OBP material crammed into here.

import java.awt.*;

//class encapsulates (wraps together) data (attributes) and methods (behaviors)

//public so is usable by any other class.  
//class can be either public or blank (meaning package level access).

//If no extends, then implicitly extends Object.
public class Stick {

    //fields: static (class variable) or non-static (instance variable)

    //static field is per class.  one copy shared by all objects
    private static int sticks=0;       //number of instantiated Sticks 

    public  static final int STICK_MAX_LENGTH=200;   //sort of global constant



    //fields are the hidden implementation.  Per object.
    private int length;
    private int width;
    private Point start;
    private double angle;
    //typically, fields are private and methods are public.
    //Within the class, any field or method can be accessed by name.  

    private final int INCREMENT = 5;   //unmodifiable instance variable


    //overloaded constructors to ensure objects start in consistent state 
    //i.e. are initialized correctly.
    //no return type.  name is same as class.  normally are public.
    //automatically called when object is instantiated/created with new.
    //can not be explicitly called by other methods.

    //constructor with no args:
    public Stick() {
	//use of this to invoke another constructor:
	this( 100, 10, new Point(0,0), 90 ); //calls constructor of these args
	//can only be first statement of a constructor
    }

    public Stick( int l, int w, Point s, double ang ) {
	length = l;
	width = w;
	start = s;
	angle = ang;
	sticks++;
    }

    //C++: copy constructor
    public Stick( Stick otherStick ) {
	//object can access private members of another object of same class
	this( otherStick.length, otherStick.width, otherStick.start, 
	      otherStick.angle );
	//warning.  both sticks now share the same Point object. (shallow copy) 
	//if one changes it, that effects the other
    }


    //an "accessor" method.  "getter"
    public int getLength() {
	return length;
    }

    //a "mutator" method.   "setter"
    public void setLength( int newLength ) {
	//some kind of validity check done to ensure object stays correct
	if (newLength>0 && newLength<Stick.STICK_MAX_LENGTH )
	    //convention that statics are accessed with class name
	    length = newLength;
	else
	    //complain somehow...
	    ;
    }

 
    
    //static method can be called even if no objects exist.
    //can only access static members, since non-static members don't exist.
    public static int getStickCount() {    
	return Stick.sticks;        //doesn't have to have classname qualifier
    }
    //static method can be called thru class name or thru any object:
    //Stick.getStickCount()     or    s1.getStickCount()   (first is preferred)


    //Stick object draws itself
    public void draw( Graphics g ) {
	g.drawLine( start.x, start.y, start.x+length, start.y+length);
	//need to add width and angle and do fillPolygon...

	int num;    //local variable can not be public/private, static
	//can have same name as field (shouldn't): shadows the field:
	int length;
	length = 1234;   
	this.length = 1234;   //to access a shadowed field
	this.width = 23;     //OK but unnecessary. same as width=23;

    }

    //private method is only accessible by the class.
    //can not be called from code in any other class.
    //typically some kind of auxiliary/utility/helper method.
    private void calculatePosition() {
	//do some calculation for internal purposes....
    }
}