1. CS 5JA Introduction to Java note... You must use your umail email when you submit homework. In fact every time you email me or any of the TAs you should use your umail account. From now on, all late assignments are due by Tuesday at 11am. This is because I will discuss the previous week’s homework in class. Grades from the homeworks are will be posted on the course website. The link will be on the original homework page, indexed by your secret code (which you should all have gotten by now.) If anyone doesn’t see their grade, or gets an erroneous grade, see me as soon as possible so we can resolve the situation.

2. CS 5JA Introduction to Java On Thursday... Last class we talked about a few different things: We looked at the while loop and the for loop which allow you to loop (or iterate) over a chunk of code. We talked about how the loops check to see if particular conditional evaluates to true to decide if it should keep looping. We talked about the break statements to exit a loop abruptly; and we talked about the continue statement which brings you back to the top of the loop without evaluating any lines beneath it. We talked about how to join together logical operations to simplify conditionals. And finally, we took a close look at two classes that we used to model an ATM machine and a couple of bank accounts.

3. CS 5JA Introduction to Java Today... The classes Account.java and AtmMachine.java are the basis of your homework, and some people asked me to talk about the concept of classes and object some more. Then we’re going to look at one last control statement, the switch statement. This is the last concept that you will need to absorb for the midterm exam, which will take place during class next Tuesday. Then we will look at a super basic graphics function that we can get by extending the JPanel class and overriding its paintComponent method.. And then we’ll talk a bit more about methods, and talk about the scope of a variable.

4. CS 5JA Introduction to Java A Class - Summary What is a class? a) It groups together some pieces of data. b) It contains specific instructions you can use to interact with that data The data are called instance variables. The instructions are called methods. In general, you want to use classes to model some aspect of the system you are trying to model. So you need to ask yourself: what parts of the system can be separated out? This is usually a natural process. Humans automatically see things in terms of usable objects. Moreover, humans think in terms of classes of objects.

5. CS 5JA Introduction to Java A Class - Summary For instance, if you want look at a bicycle, you will notice that it is made up of different parts: wheels, handle bars, a seat, pedals, and a frame that holds it together. So you might say a bike is composed of other objects. Also you can recognize that there are lots of different types of bicycles, but that they are share similarities. The similarities are: a) that they are all made out of the same basic objects, and b) that they are all used for the same function. Moreover, the basic object themselves are made out of more basic objects, and you can recognize that there are lots of different versions of those basic objects, in fact, you might say that there are a “class” of objects with a certain function, made up of certain things. For instance, there are tons of different bike cranks out there. But all cranks have pedals attached to them, and they all spin, etc. They all have a similar shape. They are all made of smaller parts: nuts, bolts, metal, etc. And they all have the same function. So if you were programming a bicycle, you might naturally break it into different classes

6. CS 5JA Introduction to Java A Class - Summary So if you were programming a bicycle, you might naturally break it into different classes. You might have a top-level Bike class. What data would be important to describe the bike? What instructions would need to exist for you to use the bike?

7. CS 5JA Introduction to Java A Class - Summary So if you were programming a bicycle, you might naturally break it into different classes. You might have a top-level Bike class. What data would be important to describe the bike? What instructions would need to exist for you to use the bike? data: smaller objects it is composed of (wheels, frame, handlebars, etc) ; owner of bike; price; brand; type (mountain bike, road bike, bmx); maximum speed, etc instructions: mountBike; rideBike; ringBell; doWheelie; whatever... And what data and instructions would be appropriate in defining a bike wheel?

8. CS 5JA Introduction to Java A Class - Summary And what data and instructions would be appropriate in defining a bike wheel? data: composed out of spokes, rims, tubes; maximum air pressure; name; brand; resistance to glass and nails; radius of wheel; etc methods: fillWithAir; deflate; applyBrakes; etc. Note that all the objects have certain things in common: they all share certain types of data and certain methods to interact with the data. But the specific way in which that that data is defined, and the specific things that happen when you interact with the data is what makes your object unique.

9. CS 5JA Introduction to Java A Class - Summary You can also model things which are inherently abstract. For example, in our homework, we have a class called “Account” stored in a file called “Account.java”. Now an account isn’t generally a physical thing (unless it’s a piggy bank), but it still has certain properties and methods of interacting with it that define it as an account. What data is fundamental to an account? What data is important to an account? What actions are needed to manipulate this data? In other words, what is the least amount of definition needed to define an account, both in terms of data and in terms of instructions?

10. CS 5JA Introduction to Java A Class - Summary Data: the balance; the type of account; the bank the account is for; the branch it was opened in; the date it was first created; a history of all transactions; the limit on how much a person an take out per day; the number of bonus points/miles you get each time you add money; the amount of interest you get; the amount that gets deducted if you have less than a certain amount, etc, etc... Methods: check balance; add bonus points; store transaction information; save branch information; accrue interest; alert bank manager of suspicious activity; restrict withdrawals; increase/decrease balance, etc, etc...

11. CS 5JA Introduction to Java Objects - Summary Once you have defined a class, you need to instantiate it in order to use it. The instantiation makes it a unique, real “thing”. It’s the difference between saying: A bicycle has wheels, and can go a certain speed, and has a certain size, a certain color and saying: I have a Trek 900 Hybrid-style bike with a 22” frame, colored blue, with low-end Shimano brakes... All classes have a default constructor. You define your own constructor when you want to automatically initialize your data. For example, in the Account class that your homework is based on, the constructor requires an initial account type and an initial balance. This is because we defined the constructor with the following signature: public Account(String accountType, double startingAmount) When you instantiate the Account class you need to provide the constructor with this data. The signature is like a contract. If you break the contract, your program will not compile. Just like if you break the law, you will go to jail.

12. CS 5JA Introduction to Java Objects - Summary You instantiate an object using the new keyword. Since our constructor has a signature asking for a String and then a double, we must instantiate our object of type Account with this data, in this order: String type = “checking”; double balance = 500.0; Account checkingAccount = new Account(type, balance); Now we have created (or instantiated) an object named checkingAccount of type Account. This account’s instance variables are initialized in its constructor so that checkingAccount’s “balance” equals 500.0 and “type” equals “checking”. These variables are the arguments or parameters you pass to the constructor. Now we are able to manipulate the data using the methods we defined for the Account class.

13. CS 5JA Introduction to Java Objects - Summary Just as the constructor we made has a signature, the methods we define also have a signature. To use these methods, you are required to adhere to the letter of the law! Here’s a method from Account.java: public void setBalance(double amount) { balance = amount; } This method lets you update the balance to a new value. If you want to instruct the object to update its balance, you are required to pass in a double. If you pass in nothing, or any other type of data then you will get an error! Remember, balance is an instance variable (which we initialized in the constructor). The variable amount is a local variable which is defined only during the life of the instruction. Once the code is done with the method (ie, all the lines within the squiggly brackets) we throw the variable amount into the garbage. Here we assign whatever is in the local variable amount to our instance variable balance. The variable balance will not be thrown away.

14. CS 5JA Introduction to Java Objects - Summary Here’s another method from Account.java: public double getBalance() { return balance; } This method lets you retrieve the balance. If you want to instruct the object to retrieve its balance to you, then you are required to pass in nothing. If you pass anything at all then you will get an error. That is your end of the bargain. The object’s end of the bargain is defined in the second keyword of the method signature. Here that keyword is double. The object will return some data to you, and that data will a decimal number. You can see that no instance variables are altered. The only thing that happens is that you now have a bucket containing the value of the instance variable balance. And you can do whatever you want with it. For example AtmMachine prints it to the screen when you select the “check balance” from the menu.

15. CS 5JA Introduction to Java Summary To summarize, a class has : instance variables, methods, a constructor. You instantiate an object with the new keyword and by passing in the parameters required by the constructor’s signature. You invoke the methods of your object using the dot notation and passing in the parameters required by the method’s signature. Account myAccount = new Account(“new account", 1000.0); myAccount.setBalance(myAccount.getBalance()-5.0);

16. CS 5JA Introduction to Java questions???

17. CS 5JA Introduction to Java Switch A switch statement is similar to an if statement. It simplifies certain types of selections. It selects a code block based on a simple conditional. switch(scanner.nextInt()) { case 1: System.out.println(“how much to withdraw?”); withdrawMoney(scanner.nextDouble()); break; case 2: System.out.println(“how much to deposit?”); depositMoney(scanner.nextDouble()); break; case 3: checkBalance(); break; default: System.out.println(“This is not a valid option!”); }

18. CS 5JA Introduction to Java Switch vs If..else int choice = scanner.nextInt(); if (choice == 1) { System.out.println(“how much to withdraw?”); withdrawMoney(scanner.nextDouble()); } else if (choice == 2) { System.out.println(“how much to deposit?”); depositMoney(scanner.nextDouble()); } else if (choice == 3) { checkBalance(); } else { System.out.println(“This is not a valid option!”); }

19. CS 5JA Introduction to Java Switch The most important thing to remember about the switch statement is that you need to remember the break statement at the end of each case or the code will continue on to the next case! (In some instances, this is exactly what you want). int val = 1; switch(val) { case 1: System.out.println(“I am here!”); case 2: System.out.println(“Oops! I am here too!”); break; default: break; } Although the switch statement is not as prevalent as the if...else statement, it does simplify certain code and you will run across it often.

20. CS 5JA Introduction to Java Switch The conditional is always simple. It is always a comparison of an int variable to a number. double decimal = 1.5; switch(decimal) {} //Error! boolean truth = true; switch(truth) {} //Error! The case statements are shortcuts for the comparison of the int variable after the switch keyword to an int constant. That is an actual number and NOT a variable. int valA = 1, valB = 2; switch(valA) { case valB: //ERROR!!!...

21. CS 5JA Introduction to Java Static? If you add the static keyword to an instance variable or a method, that means that you can access that method/variable without instantiating the object. “Static” here means “unchanging”. That is, there is only one copy of this method/variable for ALL objects of this class. Basically, unless you have a reason to do this, it is best that you do not use the static keyword. When we introduce some of the Java libraries (for example the Math package) I’ll explain why you might use it. The major issue that some of you have run into with the static methods is that you get errors when you try to access any method that is non-static!

22. CS 5JA Introduction to Java Static? For instance, the main method is always static. When your program starts, NO objects are instantiated, but we still need to start somewhere! But you can’t do anything complicated until you instantiate an object. Instance variables do not exist, because there is no instance of anything yet! On the other hand, the other way around works fine: regular, non-static methods can access static instance variables. Static variables exist even if the object isn’t created yet... But this can be confusing... see code... (code example: http://cs.ucsb.edu/~cs5ja/examples/StaticExample.java) So, use your main method to instantiate objects, and don’t try to access instance variables until you actually have created an object to work with!

23. CS 5JA Introduction to Java More about methods... You can have more than one method with the exact same name. But they might have different signatures. For instance, in the Account class we have a method called setType. The signature for setType is: public void setType(String accountType) But we could also add another method also called setType but that has a different signature: public void setType(String accountType, long timestamp) In this version you pass in a timestamp because you decide that you want to record when the account type was edited.

24. CS 5JA Introduction to Java More about methods... For all practical purposes, according to the compiler these are totally different methods! The only thing that is the same is the name, and that is only to help you organize your code. Practically, the methods should be very similar, otherwise your method names won’t make very much sense. Say you also wanted to keep track of the type of person using the account (say we want to know if the user is a student versus a professional, etc). The compiler would get confused however if you made these two methods: public void setType(String accountType) public void setType(String typeOfPerson) Even though the variables have different names, they have the same signature, so the compiler spits out an error.

25. CS 5JA Introduction to Java More about methods... A method’s signature has a few different parts. 1) accessibility: public, private, protected 2) return data type: the object/primitive data it returns (Account, int, String, Scanner, etc) 3) method name 4) the data types that are passed in (ie the paramaters or arguments) The combination of 3 and 4 must be unique.

26. CS 5JA Introduction to Java More about methods... What is the difference between public and private? a public method means that the method can be accessed and invoked from outside of the object. For example, our AtmMachine invoked the checkBalance method inside the checkingAccount object. This would not have worked if the method was only privately accessible method. A method is private if you want to insure that no one else can access the method except the object itself.

27. CS 5JA Introduction to Java More about methods... For example, we might want to make sure that only certain methods are available to the outside world. We might do this for security reasons, or to make things simpler for other classes. public boolean isUserReallyACriminal(String name, long socialSecurity) { boolean isCriminal = checkSecretData(socialSecurity); if (isCriminal) { alertPolice() return true; } return false; } private boolean checkSecretData(long socialSecurity) { //do secret stuff... }

28. CS 5JA Introduction to Java More about methods... Thinking about what methods (and instance variables) that you want to make publicly available is thinking about how you want other classes to “interface” with you class. There are thousands of classes in the java library. We might want to use their functionality to make something happen, but we don’t really care how it happens. For example, in the Scanner class we use the publicly available method “nextInt()” which reads an int from the command line for us. But we don’t care how it does it. Obviously there is all sorts of complicated code that talks to the operating system, etc. But it is hidden from us. The “interface” is the set of publicly available methods that let us focus on the useful things it does, rather than the complicated ways it does it. A real-world example is a car. You interface with the car by putting the key in the ignition. You don’t care at all about how it ignites a spark, which starts the engine, which fires up the pistons, etc. If you had to think about that every time you started a car, it might take a while for you to get anywhere. Those complicated methods are private. They are off-limits except to experts– in this case auto-mechanics.

29. CS 5JA Introduction to Java More about methods... Let’s go back to methods again: I said that a signature is unique based on its name and the data types of its arguments. Would the compiler accept these? public void method1() public String method1() private String method1() public String method1() private int method1(boolean fact) private int method1(boolean aDifferentFact) private int method1(boolean fact) private int method1(boolean fact, boolean aDifferentFact)

30. CS 5JA Introduction to Java Multiple Constructors Now the same thing applies to the constructor, except that the signature doesn’t include a return type. public Account(String accountType, int initialBalance) { type = accountType; balance = initialBalance; } public Account(String accountType) { type = accountType; balance = 0; }

31. CS 5JA Introduction to Java Multiple Constructors But this doesn’t work... public Account(int initialBalance) { balance = initialBalance; } public Account(int initialBonusPoints) { bonusPoints = boinusPoints }

32. CS 5JA Introduction to Java Scope Every variable has a certain lifetime. When that lifetime is over, it gets thrown into the trash. In all but a few strange cases, Java is smart enough to figure out when data is no longer needed. It handles it own garbage collection. However, a programmer can make some errors if they don’t realize that a variable isn’t around anymore. Also, programmers can make errors if they try to use a variable that isn’t initialized yet. The range of a variable’s lifetime is called its scope. And there are a few things to be aware of. Usually the compiler will tell you if there is a problem, but in certain cases it can’t.

33. CS 5JA Introduction to Java Scope The scope of an instance variable is anywhere in the entire object. Unless it is shadowed by a local variable. int x = 5; public void method1() { int y = 10; System.out.println(“ x = “ + x); } public void method2() { int x = 10; System.out.println(“ x = “ + x); } The x in method2 is a completely different variable– it just happens to have the same name. method2() does not overwrite the instance variable. At the end of method2, our local variable (with the name x) is no longer alive, and gets thrown in the garbage. Any references to x in other methods will again refer to the instance variable. The local variable x inside of method2 is said to shadow the instance variable.

34. CS 5JA Introduction to Java Scope The scope of a local variable is from the point it was defined until the end of that code block. public void method() { int x = 5; //lots of code... } Since x was created and initialized at the first line of the method, anything that follows can use or change x.

35. CS 5JA Introduction to Java Scope What will happen here? public void method() { int x; if (x == 5) { System.out.println(“x = 5!!!”); }

36. CS 5JA Introduction to Java Scope What will happen here? public void method() { int x; if (x == 5) { System.out.println(“x = 5!!!”); } A variable needs to defined and initialized before it is used. In this case, the variable is in scope, but since nothing has been assigned to it, the compiler prints an error.

37. CS 5JA Introduction to Java Scope What will happen here? public void method() { for (int i = 1; i <= 5; i++) { int x = 5; System.out.println(“looping through ” + i + “ of “ + x); } System.out.println(“We have successfully looped through “ + x + loops”); }

38. CS 5JA Introduction to Java Scope What will happen here? public void method() { for (int i = 1; i <= 5; i++) { int x = 5; System.out.println(“looping through ” + i + “ of “ + x); } System.out.println(“We have successfully looped through “ + x + loops”); } x was defined within a code block. Thus, it dies at the end of the code block. In this case the block is the for loop. Thus outside the for loop we no longer can refer to x. In fact, this code is creating and destroying x in every iteration of the loop.

39. CS 5JA Introduction to Java Scope What will happen here? int x = 10; //instance variable public void method() { for (int i = 1; i <= 5; i++) { int x = 5; System.out.println(“looping through ” + i + “ of “ + x); } System.out.println(“We have successfully looped through “ + x + loops”); }

40. CS 5JA Introduction to Java Scope What will happen here? int x = 10; //instance variable public void method() { int x = 5; for (int i = 1; i <= 5; i++) { System.out.println(“looping through ” + i + “ of “ + x); } System.out.println(“We have successfully looped through “ + x + loops”); }

41. CS 5JA Introduction to Java Graphics http://java.sun.com/javase/6/docs/api/java/awt/Graphics.html One of the powerful things about Java is that there is a large library of code that already exists. Not only can you use it, but you can extend the library with your own custom code. We’ll talk more about his in detail in a later class, but I just want to give you enough to use the built in user- interface widgets (called “Swing”) so that you can make some simple 2D graphics. The basic “widget” in Java is called a “JFrame” (J for java...). A frame is the square object that contains an application. It usually has a title bar, a button for minimizing and closing the application, and a panel that contains the content of the application. This panel is called a JPanel (J for java...). You can create your own JPanel and do anything you want to it. For our next homework assignment we’re going to learn how to make digital art.

42. CS 5JA Introduction to Java Graphics The JPanel contains lots of built-in methods to handle all sorts of things, like recognizing mouse focus, knowing how to minimize itself, knowing when to be behind another application, etc. So we can utilize all of this functionality, but customize it for our purposes. Here’s how we do it: public class MyArtwork extends JPanel The JPanel object has a built-in method called paintComponent which describes how to draw itself. By default it just draws a big gray square. You can override this method and tell your JPanel to draw itself in a more interesting way.

43. CS 5JA Introduction to Java Graphics //overriding! public void paintComponent(Graphics artist) { //dip paintbrush into new color artist.setColor(Color.BLACK); //paint a rectangle artist.fillRect(30, 30, 100, 100); } Each JPanel has a built-in palette and a built-in artist. The artist is prized for his graphics abilities, so he is of data type “Graphics”. Here we name him “artist”. In this method, we are telling the artist inside JPanel to paint the screen. In the first line we are telling artist to change colors. In the second line we are telling him to draw a rectangle.

44. CS 5JA Introduction to Java Graphics You can set the color using built-in colors, or by defining your own color using its RGB values. Let’s make a new color and tell the artist to use it: Color newColor = new Color( 255, 0, 0 ); //Red Green Blue artist.setColor(newColor); The range of the canvas is defined by pixel values. You can think of a graph, except the origin (0, 0) is in the top-left corner, and the y value is reversed. The y-value increases as you go down. The x-value increases as you go toward the right. Code example...

45. CS 5JA Introduction to Java Why do variables change names? You can see that eventually the word “checking” is assigned to the instance variable type. But to get there we make 3 other variables! (myAccount, accountType, and typeOfAccount) String type; public Account(String accountType) { setType(accountType); } public void setType(String typeOfAccount) { type = typeOfAccount; } And we called the constructor from AtmMachine like this: String myAccount = “checking”; new Account(myAccount);