we have already seen one type of class definition defining the class that contains your program

Transcription

1 Java development: 1. I'm using Visual Studio Microsoft product (not free) 2. Java developer's kit (JDK) text-based compilers and Java runtime for compiling and executing Java programs integrated development environment Class definition / Creating your own classes. we have already seen one type of class definition defining the class that contains your program public class MyProgram public static void main(string[] args)... when you declare your own classes (with their own methods), the syntax is similar. A class generally contains three things: methods: procedures attached to the class for manipulating data stored in the class. e.g., String objects of type String can be manipulated using String methods, like charat(), length() fields: variables attached to the class that contain data (e.g., in String, this is just the string). constructors: a special kind of method which initializes objects of the class type when you declare your own class, you can allow/restrict access to the methods, constructors, and data fields, as you wish.

2 By controlling access (e.g., data fields are almost never public), you are specifying the interface to your class (e.g., because data fields are almost never public, one must go through methods in order to access or change the data fields) in other words you are specifying the API. Class definition syntax fields declared like variables in a method. In addition to type and name (as in a method), we need to specify access. //e.g. An integer named x, with public access public int x; // public means that the variable x is available outside of the class //e.g., a double named y, with private access private double y; // not available outside of the class can only be accessed by // methods and constructors inside the class two other access specifiers: protected, (blank) these two mean something in between public and private from now on we will only use public and private Method definition syntax we previously wrote our own method called main -- a special method that is the entry point for every java program other methods have similar syntax to main example:

3 // access specifier, then return type, then name, then parameters public void mymethod(int i) System.out.println(i); public int myothermethod() return 5; the parameters (e.g., int i in mymethod) are variables that are available to the method parameters are passed into the method from the outside. The return value is the result of the method passed to the outside from the method. It is legal to make a method private; in this case, the method can only be accessed by other methods in the same class. It cannot be accessed from the outside. Methods provide the best way to access and manipulate private fields of the class.

4 Example: private int i = 5; public int MyMethod(int j) int k; k = i + j; // can access the private class member i return k; Some more comments on return types: if nothing needs to be returned, the return type should be void unless the return type is void, the method MUST use the return statement. return ends the method and returns to whatever called the method. Example public int MyMethod() System.out.println( Before return ); // this will be printed return 8; // after this line, the method ends System.out.println( After return ); // this will never be printed // inaccessible code Constructor definition syntax

5 like methods, constructors have access to the private fields of the class. Constructors are somewhat like methods they have access specifiers and take parameters a bit different: no return value, not even void, and they always have the same name as the class (this is how java knows that they are constructors) the constructor is executed whenever an object of the class is created (i.e., with the new command). Example: private int y; // access specifier and the name of the class NO RETURN // TYPE optional parameters public MyClass() y = 0; it is okay to provide more than one constructor as long as they take different parameters in that case, the constructor will be called according to the parameters that are given with the new command Extending the example:

6 private int y; public MyClass() y = 0; public MyClass(int j y = j; in this example, executing MyClass m = new MyClass(); calls the first constructor (with no parameters) whereas executing MyClass m = new MyClass(6); calls the second constructor (with an int parameter). Is it legal not to provide a constructor? Usually yes. Every object has a default constructor that takes no parameters, and this default constructor is executed whenever a constructor is not specified. Class Design when writing a class, we should be mindful of how another programmer would use it Best practice: firstly write the public interface (i.e., the API). Afterward, fill in the details.

7 Example: a class to handle a bank account. Class must handle all functions we normally associate with bank accounts, i.e., deposit (add money to the balance) withdraw (subtract money from the balance) balance inquiry (returning the value of the balance)...? can start an account with zero dollars by default, or you can make an initial deposit which is the initial balance of the account. the first thing we will do is to write the public interface of the class consists of all the PUBLIC methods, constructors, and fields in the class. (Don't think about anything private for now.) example. public class BankAccount // no public fields // constructors: a default constructor starting at zero dollars public BankAccount() //constructor: starting with an initial balance public BankAccount(double initdeposit) //method: deposit, add the given amount to the balance public void deposit(double amount) //method: withdraw, subtract the given amount from the balance public void withdraw(double amount)

8 //method: get balance, return the current value of the balance public double getbalance() we see from the public interface the value of good object-oriented design by forcing all changes to the balance to go through the methods we specify (deposit() and withdraw()), we can prevent spurious changes to the balance. To review the elements of class design: 1. Consider the requirements of the class. 2. Specify the public interface (public constructors / methods / fields) 3. Fill in the details given the public interface (decide on private aspects of the class). More advanced class concepts the keyword this -- refers to the current object within the object. outside objects of the class type, we refer to methods or fields within the class by (object name).(method name) for methods or (object name).(field name) for fields. Example. public int x; public void MyMethod()

9 System.out.println(x);... in a main method: MyClass m = new MyClass; m.= 5; // the dot notation for referring to the field x in object m the dot notation is usually not necessary within the class, as it is implicit which field x is. Sometimes it is necessary to invoke the dot notation within the class. Example: private int x; public MyClass(int x) x = x; //??? whenever you need to refer to the current object within the class, use this we can say: private int x; public MyClass(int x)

10 this.x = x; // this.x is the private field, x is the parameter can also use this notation with methods, etc. this is optional, but sometimes helps with readability Another example: private int x; public void mymethod() int x; x = 5; // variable x this.x = 0; // private field x System.out.println(x); // would print 5, not 0. Another use of the this keyword: if you say this(), calls the appropriate constructor of the current class. -- very useful when you have multiple constructors. (See example MultiConstructor.java) The static keyword remember the declaration public static void main... we know what everything means except static normally methods and fields are attached to objects e.g., a class MyClass with field x and method mymethod() first have to declare an object of type MyClass in order to access the field or method

11 MyClass m = new MyClass(); m.x = 5; // accessing field through the object x m.mymethod(); // accessing method through the object x with static, the method or field declared static is attached to the class, not to a particular object of the type of the class. Normal field ( instance field ) -- one per object e.g., MyClass m = new MyClass(); MyClass n = new MyClass(); // m.x and n.x are DIFFERENT variables Static field one for the class, i.e., one for ALL objects example public int x; public static int y;... MyClass m = new MyClass(); MyClass n = new MyClass(); // m.x and n.x are DIFFERENT // m.y and n.y are THE SAME // y exists with the class so y exists even if there are no objects // of type MyClass // legal to say m.y, n.y, MyClass.y

12 Static fields and static methods can be used even if no objects of the class type have been created. For that reason, private static fields must be initialized on the line where they are created (they exist before any constructor is executed) if you think back to the main method, this makes sense... we did not create any new objects to use main static methods cannot access normal fields obvious because static method can exist before any objects are created, so before any fields are created. There exists a particular kind of class that is composed entirely of static fields and methods called a utility class -- only exists to provide certain functions and constants (e.g., for math) Since it usually makes no sense to create an object of a utility class type, utility classes usually have default constructors with access specifier private -- illegal to create an object of utility class type. Example: public class MyUtility public static double pi = ; public static double addtwonumbers(double a, double b) return a+b; private MyUtility() // illegal to create an object of class // MyUtility Mutable versus immutable objects

13 consider the following class private int x; public MyClass(int in_x) x = in_x; public int getvalue() return x; after the class is created, there is no way to change the value of x (because there is no public method to do so). A class whose fields cannot be changed after creation is called an immutable class Any class without this property is called a mutable class. Copying objects Value versus reference In the example, CopyMain, we wanted for d to be a copy of c. In other words, changing d should not change c. But that's not what happened: changing d actually did change c. In java, all object variables are references (this is like a pointer in C or a similar language).

14 The variable c is actually pointing to the space in memory where an object is stored. Saying d = c; means that d now points to the SAME space in memory. How do we create a copy of an object in java? -- we must do so explicitly. That is, we must create a new object and load it with all the features of the original. Methods: 1. d = c; // WRONG d is a pointer to c, they are the same object. 2. d = a.clone(); // some (but not all) objects contain a clone //method. 3. d = new MyClass(c); // copy constructor most preferable