Week 3 Object-oriented programming JOptionPane Random Graphics.

Week 3 Object-oriented programming JOptionPane Random Graphics

Why Java One of things that make Java a handy language for digital problem solving is its rich set of built-in libraries To name just a few of the thousands that are available – Libraries for input manipulation – Libraries for representing information as lists and dictionaries – Libraries to provide access and manipulation of files and folders on your computer and on the Internet – Libraries for creating windows, colors, images, labels,... – Libraries for generating random numbers

Objects Java treats objects different than numbers and boolean values Numbers and boolean values just exist – you can enter them as literals and get other values using arithmetic and logical operators Objects have to be created The creation of an object has two parts – Get the memory to store the object – Configure the memory to represent the desired object – Programmers typically use the term construct instead of configure

For example We have been using Scanner for a while now. A typical Scanner definition is Scanner keyboard = new Scanner( System.in ); The new in the statement is a Java keyword and operator – A new operation causes Java to get memory for storing a new object – Java can tell how much memory is needed by the identifier following keyword new. The identifier is the type of object to be created

For example We have been using Scanner’s for a while now. A typical Scanner definition is Scanner keyboard = new Scanner( System.in ); For our example Java gets enough memory to represent a Scanner The values in the parentheses following the object type are generally called arguments or parameters The arguments tell Java how to construct the new object. In our example the argument System.in specifies the input source for the new Scanner (the keyboard of the computer running the program)

For example We have been using Scanner’s for a while now. A typical Scanner definition is Scanner keyboard = new Scanner( System.in ); The value of the expression new Scanner( System.in ) is the location (address in memory) where a newly constructed Scanner object is stored. The location value produced by the expression is then used to initialize variable keyboard

For example We have been using Scanner’s for a while now. A typical Scanner definition is Scanner keyboard = new Scanner( System.in ); The value of the expression new Scanner( System.in ) is the location (address in memory) where a newly constructed Scanner object is stored. The location value produced by the expression is then used to initialize variable keyboard Understanding the above is subtle and crucial to realize While the value of a numeric variable is a number, the value of an object variable is not an object but a pointer where to find an object

For example Let’s expand our example to also define and int variable n and a boolean variable b int n = 1112; Scanner keyboard = new Scanner( System.in ); The correct picture of memory boxes for the two variables is below. It shows that the value of variable keyboard is not a Scanner but a pointer where to find a Scanner n1112 keyboard

JOptionPane Class JOptionPane supports the creation of popup windows The class provides many methods that will create and do popups for you The popup we will often find useful is one that includes a picture in its popup JOptionPane was not part of the original version of Java JOptionPane is an add-on that can be gotten by including the following import statement at the start of your program import javax.swing.*;

URLImagePopUp The program will display a popup of a requested CS 1112 class member

URLImagePopUp The program begins with several import statements worth noting import javax.swing.*; import java.net.*; import java.io.*; import java.util.*;

URLImagePopUp import statements The program begins with several import statements worth noting import javax.swing.*; // gets JOptionPane import java.net.*; import java.io.*; import java.util.*;

URLImagePopUp import statements The program begins with several import statements worth noting import javax.swing.*; // gets JOptionPane import java.net.*; // gets URL import java.io.*; import java.util.*;

URLImagePopUp import statements The program begins with several import statements worth noting import javax.swing.*; // gets JOptionPane import java.net.*; // gets URL import java.io.*; // gets IOException import java.util.*;

URLImagePopUp import statements The program begins with several import statements worth noting import javax.swing.*; // gets JOptionPane import java.net.*; // gets URL import java.io.*; // gets IOException import java.util.*; // gets Scanner

URLImagePopUp constants The program defines two constants // base web folder public static final String CS1112_PEOPLE_URL = "http://www.cs.virginia.edu/cs1112/people/"; // photo filename public static final String JPG_NAME = "selfie.jpg";

URLImagePopUp constants The program defines two constants // base web folder public static final String CS1112_PEOPLE_URL = "http://www.cs.virginia.edu/cs1112/people/"; // photo filename public static final String JPG_NAME = "selfie.jpg"; CS1112_PEOPLE_URL names the web folder for current CS 1112 class members. The folder has a subfolder for each class member

URLImagePopUp constants The program defines two constants // base web folder public static final String CS1112_PEOPLE_URL = "http://www.cs.virginia.edu/cs1112/people/"; // photo filename public static final String JPG_NAME = "selfie.jpg"; CS1112_PEOPLE_URL names the web folder for current CS 1112 class members. The folder has a subfolder for each class member JPG_NAME names the web file given to the uploaded class member pictures

URLImagePopUp constants The program defines two constants // base web folder public static final String CS1112_PEOPLE_URL = "http://www.cs.virginia.edu/cs1112/people/"; // photo filename public static final String JPG_NAME = "selfie.jpg"; The constants when coupled with one of our ID’s specifies a web location; the below string is web location of my uploaded picture CS1112_PEOPLE_URL + "jpc" + "/" + JPG_NAME

URLImagePopUp constants The program defines two constants // base web folder public static final String CS1112_PEOPLE_URL = "http://www.cs.virginia.edu/cs1112/people/"; // photo filename public static final String JPG_NAME = "selfie.jpg"; The constants when coupled with one of our ID’s specifies a web location; the below string is web location of my uploaded picture CS1112_PEOPLE_URL + "jpc" + "/" + JPG_NAME http://www.cs.virginia.edu/cs1112/people/jpc/selfie.jpg

URLImagePopUp throws IOException The method main() definition starts differently than in previous programs public static void main( String[] args ) throws IOException { The phrase throws IOException has been added

URLImagePopUp throws IOException The method main() definition starts differently than in previous programs public static void main( String[] args ) throws IOException { The phrase throws IOException has been added The throws IOException is necessary because of what the code is going to attempt – get access to something out on the web – a class selfie

URLImagePopUp throws IOException The method main() definition starts differently than in previous programs public static void main( String[] args ) throws IOException { The phrase throws IOException has been added The throws IOException is necessary because of what the code is going to attempt – get access to something out on the web – a class selfie If the user mistypes the ID then the web location the program attempts to access does not exist

URLImagePopUp throws IOException The method main() definition starts differently than in previous programs public static void main( String[] args ) throws IOException { The phrase throws IOException has been added The throws IOException is necessary because of what the code is going to attempt – get access to something out on the web – a class selfie If the user mistypes the ID then the web location the program attempts to access does not exist An errant access attempt generates an input error condition or in Java parlance throws an IOException

URLImagePopUp throws IOException The method main() definition starts differently than in previous programs public static void main( String[] args ) throws IOException { The phrase throws IOException has been added The throws IOException is necessary because of what the code is going to attempt – get access to something out on the web – a class selfie If the user mistypes the ID then the web location the program attempts to access does not exist An errant access attempt generates an input error condition or in Java parlance throws an IOException Programs that can have input errors need to tell Java of the possibility

URLImagePopUp input processing The beginning of the body of method main() is something you are now use to – get some input from the program user Scanner stdin = new Scanner( System.in ); System.out.print( "Email id for person of interest: " ); String id = stdin.next();

URLImagePopUp input processing The beginning of the body of method main() is something you are now use to – get some input from the program user Scanner stdin = new Scanner( System.in ); System.out.print( "Email id for person of interest: " ); String id = stdin.next(); A Scanner stdin that gets its input from the keyboard is gotten

URLImagePopUp input processing The beginning of the body of method main() is something you are now use to – get some input from the program user Scanner stdin = new Scanner( System.in ); System.out.print( "Email id for person of interest: " ); String id = stdin.next(); A Scanner stdin that gets its input from the keyboard is gotten A prompt is printed that tells the user what to enter

URLImagePopUp input processing The beginning of the body of method main() is something you are now use to – get some input from the program user Scanner stdin = new Scanner( System.in ); System.out.print( "Email id for person of interest: " ); String id = stdin.next(); A Scanner stdin that gets its input from the keyboard is gotten A prompt is printed that tells the user what to enter The input is read and assigned to String variable id

URLImagePopUp input processing The beginning of the body of method main() is something you are now use to – get some input from the program user Scanner stdin = new Scanner( System.in ); System.out.print( "Email id for person of interest: " ); String id = stdin.next(); A Scanner stdin that gets its input from the keyboard is gotten A prompt is printed that tells the user what to enter The input is read and assigned to String variable id – In case you do not remember the Scanner method next() processes (reads and returns) the next nonblank entry the user enters

URLImagePopUp input processing The beginning of the body of method main() is something you are now use to – get some input from the program user Scanner stdin = new Scanner( System.in ); System.out.print( "Email id for person of interest: " ); String id = stdin.next(); If the user enters mst3k then the memory boxes look like below (Remember both stdin and id are object variables) keyboard id "mst3k"

URLImagePopUp popup description The program then defines three variables String msg = "Aren't I cute?"; String banner = "Hello from " + id; String location = CS1112_PEOPLE_URL + id + "/" + JPG_NAME; The first two msg and banner will be directly used in making the popup – they are respectively the popup message and title bar text

URLImagePopUp popup description The program then defines three variables String msg = "Aren't I cute?"; String banner = "Hello from " + id; String location = CS1112_PEOPLE_URL + id + "/" + JPG_NAME; The first two msg and banner will be directly used in making the popup – they are respectively the popup message and title bar text The last variable location specifies the Internet location for the selfie of interest

URLImagePopUp popup description The program uses the location variable in creating a URL object URL photoURL = new URL( page ); URL is Java’s representation for something on the web. URL is an abbreviation for Uniform Resource Locator Everything on the web has to have a unique web location

URLImagePopUp popup description The program uses the location variable in creating a URL object. URL photoURL = new URL( page ); URL is Java’s representation for something on the web. URL is an abbreviation for Uniform Resource Locator Everything on the web has to have a unique web location Just as a Scanner construction need to indicate an input source, the constructing of a URL needs a web source location

URLImagePopUp popup description The program uses the location variable in creating a URL object. URL photoURL = new URL( page ); URL is Java’s representation for something on the web. URL is an abbreviation for Uniform Resource Locator Everything on the web has to have a unique web location Just as a Scanner construction need to indicate an input source, the constructing of a URL needs a web source location If it turns out that page does not represent a valid web source, when the program attempts to access the illegal location, Java terminates the program and indicates an IOException has occurred

URLImagePopUp popup description The program uses the URL as the input source in constructing an ImageIcon ImageIcon image = new ImageIcon( photoURL ); ImageIcon is Java’s basic representation for an image In constructing a new ImageIcon we need to specify where to get the pixels that make up the image A web location is a valid input source for an ImageIcon

URLImagePopUp popup description At this point we have all of the elements necessary for making a popup – the message to be displayed, the text for the title bar, and the image for the popup String msg = "Aren't I cute?"; String banner = "Hello from " + id;... ImageIcon image = new ImageIcon( photoURL );

URLImagePopUp popup description JOptionPane can create many kinds of popups – information messages, warnings, selections,... Our interest is an information message popup JOptionPane provides a bunch of constants for indicating the possible popup types – to indicate an interest in an information popup use JOptionPane.INFORMATION_MESSAGE

URLImagePopUp popup generation The JOptionPane method showMessageDialog() will display a popup The appearance of the popup is specified through the arguments passed to the method The method expects values for the following and in the indicated order 1.Where should the popup be displayed in the window 2.What is the message of the popup 3.What is the title text of the popup 4.What kind of popup should it be 5.What image should be displayed as part of the popup

URLImagePopUp popup generation Our popup command for URLImagePopup is the following JOptionPane.showMessageDialog ( null // what window to center on msg, // what is the popup message banner, // what is the popup title JOptionPane.INFORMATION_MESSAGE, // what type of message image ); // what is the popup image }

URLImagePopUp popup generation Our popup command for URLImagePopup is the following JOptionPane.showMessageDialog ( null // what window to center on msg, // what is the popup message banner, // what is the popup title JOptionPane.INFORMATION_MESSAGE, // what type of message image ); // what is the popup image } null is a Java keyword and that indicates the lack of an object.

URLImagePopUp popup generation Our popup command for URLImagePopup is the following JOptionPane.showMessageDialog ( null // what window to center on msg, // what is the popup message banner, // what is the popup title JOptionPane.INFORMATION_MESSAGE, // what type of message image ); // what is the popup image } null is a Java keyword and that indicates the lack of an object. When null is the first parameter to a showMessageDialog() it means rather than centering on a particular window, the popup is centered on the middle of the screen

Random numbers Random numbers are used in lots of software Two examples that always come to my mind are electronic games and stock trading software – In games they are used so players do not experience the same situation each time they play – In stock trading analysis they are used to model changing financial markets

Random numbers Java class Random provides the means to create a random number generator The library is available when importing java.util.*

Random numbers Java class Random provides the means to create a random number generator The library is available when importing java.util.* By default the construction of Random generator produces a different sequence of numbers every time

Random numbers Java class Random provides the means to create a random number generator The library is available when importing java.util.* By default the construction of Random generator produces a different sequence of numbers every time Some of the capabilities of a Random generator are producing random integers, logical values, and decimal values from the interval (0, 1])

Random numbers Java class Random provides the means to create a random number generator The library is available when importing java.util.* By default the construction of Random generator produces a different sequence of numbers every time it is used. Some of the capabilities of a Random generator are producing random integers, logical values, and decimal values from the interval (0, 1]) – CS 1112 tends to only use examples involving random integers

Random numbers Program RandomNumbers creates and uses a default Random generator to produce five random int values – Multiple runs of the program display different integer sequences

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); The initialization expression for the Random variable dice is new Random( ) The expression gets memory for the generator and performs default construction. Default occurs when there are no arguments in the ( ) in a new expression

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); A default-constructed Random generator will produce a different random number sequence then other default-constructed Random generators The ability to be different provides the variability we want

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); I typically call my Random generator variable dice because the throwing of dice is a random sequence

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); A Random generator has a method nextInt() that takes no parameters

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); A Random generator has a method nextInt() that takes no parameters When a Random generator such as dice gets the message nextInt() it produces a random int value; i.e., a value as small as -2147483648 and as large as 2147483647

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); A Random generator has a method nextInt() that takes no parameters When a Random generator such as dice gets the message nextInt() it produces a random int value; i.e., a value as small as -2147483648 and as large as 2147483647; i.e., in the interval (- 2147483648, 2147483647]

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); Below are the numbers outputted from one program run 832098310 -1708435978 -2132655842 -2101213972 808269398

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); Below are the (different) numbers outputted from another program run -1139735074 4555273 -2079226278 681790015 -651527058

RandomNumbers The important statements in program RandomNumbers are Random dice = new Random( ); int a = dice.nextInt(); int b = dice.nextInt(); int c = dice.nextInt(); int d = dice.nextInt(); int e = dice.nextInt(); Below are the (again different) numbers outputted from yet another program run 605338243 515810532 -238143103 2087856151 -1102462255

Random numbers Program RandomNumbersBaseN also creates and uses a default Random generator to produce five random int values. Its random values are all numbers in the interval 0 … n-1 (the value of n is gotten from the program user) Multiple runs of the program display different integer sequences

Random numbers Program RandomNumbersBaseN also creates and uses a default Random generator to produce five random int values. Its random values are all numbers in the interval 0 … n-1 (the value of n is gotten from the program user) Multiple runs of the program display different integer sequences Its ability to tailor the values will prove to be very important

Random numbers Program RandomNumbersBaseN also creates and uses a default Random generator to produce five random int values. Its random values are all numbers in the interval 0 … n-1 (the value of n is gotten from the program user) Multiple runs of the program display different integer sequences Its ability to tailor the values will prove to be very important By the way the interval 0 … n-1 is written mathematically as (0, n]. The leading ( indicates includes, the trailing ] indicates excludes

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); The program gets a value n from the keyboard. That value is used an argument to a nextInt() method expecting an int argument

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); The program gets a value n from the keyboard. That value is repeatedly used an argument to a nextInt() expecting an int argument

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); This nextInt() expecting an int argument uses the value of its argument to limit the interval from the random numbers are generated

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); The argument value specifies a base. The generated random numbers are limited to integers from that numeric base

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); For argument n, the numbers are limited to base n – If n is 2 then binary numbers are generated; i.e., 0 or 1

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); For argument n, the numbers are limited to base n – If n is 10 then binary numbers are generated; i.e., 0, 1, 2... 9

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); For argument n, the numbers are limited to base n – If n is 256 then binary numbers are generated; i.e., 0, 1, 2... 255

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); For argument n, the numbers are limited to base n – In general the numbers come from the interval 0... n-1; i.e., (0, n]

RandomNumbersBaseN The important statements in program RandomNumbersBaseN are int n = keyboard.nextInt(); Random dice = new Random( ); int a = dice.nextInt( n ); int b = dice.nextInt( n ); int c = dice.nextInt( n ); int d = dice.nextInt( n ); int e = dice.nextInt( n ); Program runs where the user supplied 2 for n produced random numbers 0 0 1 0 0 0 1 1 0 0 0 1 0 1 0

Graphics rendering Besides being able to produce popup windows, Java provides support for producing regular windows with all sorts of window elements JFrame is the Java representation for a general purpose window When we need windows I will provide the code to set up the window, you will be in charge of the fun part – producing the content of the window

Window setup Our basic Java instructions for setting up a window are JFrame window = new JFrame( "Rendering" ); window.setSize( WIDTH, HEIGHT ); window.setAlwaysOnTop( true ); window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

Window setup Our basic Java instructions for setting up a window are JFrame window = new JFrame( "Rendering" ); window.setSize( WIDTH, HEIGHT ); window.setAlwaysOnTop( true ); window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); The first instruction constructs a new JFrame whose title bar has the text Rendering

Window setup Our basic Java instructions for setting up a window are JFrame window = new JFrame( "Rendering" ); window.setSize( WIDTH, HEIGHT ); window.setAlwaysOnTop( true ); window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); The second instruction sets the size of the window. Here WIDTH and HEIGHT are constants defined at the beginning of the program

Window setup Our basic Java instructions for setting up a window are JFrame window = new JFrame( "Rendering" ); window.setSize( WIDTH, HEIGHT ); window.setAlwaysOnTop( true ); window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); JFrame provides methods for controlling the behavior of a window. The third instruction causes your computer to always keep this window on top of your other windows I include this instruction because if the window does not popup to the top you will probably suspect your code is broken as you do not see the window

Window setup Our basic Java instructions for setting up a window are JFrame window = new JFrame( "Rendering" ); window.setSize( WIDTH, HEIGHT ); window.setAlwaysOnTop( true ); window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); The fourth instruction tells Java to end your program when the window disappears – something I think is what you would expect

Content pane Once we have a window we are going to want to be able to interact with its content pane The content pane is the part below the title bar People in CS 1112 are using many different types of computers and operating systems with many personalizations. The instructions coming up allow everybody to generate and consistently see what they put on to the content pane in a similar manner to others in the class I view the instructions as setting up a canvas to be the content pane of your window I will always supply these statements to any graphical program you are to build

Content pane setup Our instructions for setting up the content pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true );

Content pane setup Our instructions for setting up the content pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true ); The BufferedImage supplies a drawing surface that for our image

Content pane setup Our instructions for setting up the content pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true ); The BufferedImage supplies a drawing surface that for our image The ImageIcon takes that surface and makes into a canvas

Content pane setup Our instructions for setting up the content pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true ); The BufferedImage supplies a drawing surface that for our image The ImageIcon takes that surface and makes into a canvas The JLabel mounts the canvas in a way that it is now suitable as a content pane

Content pane setup Our instructions for setting up the content pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true ); Method setContentPane() does what you would expect it to do – it tells its window to set its content pane to be the graphical object argument being passed to the method

Content pane setup Our instructions for setting up the canvas pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true ); Method pack() tells the window to set its size to match the dimensions of the content pane

Content pane setup Our instructions for setting up the canvas pane are BufferedImage surface = new BufferedImage( WIDTH, HEIGHT, RGB ); ImageIcon canvas = new ImageIcon( surface ); JLabel pane = new JLabel( canvas ); window.setContentPane( pane ); window.pack(); window.setVisible( true ); The setVisible() instruction causes the window to be made visible – by default windows are invisible. They start off that way so the window can be assembled before it is viewed

Graphics rendering Now that the content pane is set up, we are ready to paint (render) an image onto it Everything paintable in Java has a method getGraphics() The getGraphics() method returns an object type Graphics. A Graphics object has a rich set of instructions for making images Our call names the Graphics object artist Graphics artist = surface.getGraphics();

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT );

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT ); Graphics method setColor() takes a Color as its argument Until another setColor() occurs all rendering commands will use that color in accomplishing their tasks

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT ); Graphics method fillRect() paints a filled in rectangle onto the image. The method expects four arguments

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT ); Graphics method fillRect() paints a filled in rectangle onto the image. The method expects four arguments. In order they are 1.The x-location where to start painting 2.The y-location where to start painting 3.The width of the rectangle to be painted 4.The height of the rectangle to be painted

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT ); In graphics the origin of an image is its upper left hand color. So the x-location and y-location arguments tell the fillRect() method how far over and how far down to start the rendering

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT ); The width and height arguments tell the fillRect() method how far to the right and how far down to paint is filled in rectangle

Painting the background Our program next sets the entire canvas to our chosen background color artist.setColor( BACKGROUND_COLOR ); artist.fillRect( 0, 0, WIDTH, HEIGHT ); So all together the arguments cause a filled-in rectangle to be painted that covers the entire surface

drawRect() Using the currently set color, method drawRect() draws on its image the outline of a box specified by its four arguments. The first two arguments give the location for the drawing. The second two arguments give the width and height of the rectangle to be drawn Using green, the below example draws at (40, 80) the outline of a 50 x 75 rectangle int x1 = 40; int y1 = 80; int w1 = 50 int h1 = 75; artist.setColor( Color.GREEN ); artist.drawRect( x1, y1, w1, h1 );

fillRect() The program again uses method fillRect() to paint at (100, 20) a filled-in 100 x 25 orange rectangle int x2 = 100; int y2 = 20; int w2 = 100; int h2 = 25; artist.setColor( Color.ORANGE ); artist.fillRect( x2, y2, w2, h2 );

drawOval() Using the currently set color, method drawOval() draws on its image the outline of an oval fitting the box specified by its four arguments. The first two arguments give the location for the drawing. The second two arguments specify the width and height of the rectangle in which to draw the oval Using magenta, the below example draws at (120, 65) the outline of the oval fitting a 150 x 90 rectangle int x3 = 120; int y3 = 65; int w3 = 150; int h3 = 90; artist.setColor( Color.MAGENTA ); artist.drawOval( x3, y3, w3, h3 );

fillOval() Using the currently set color, method fillOval() paints on its image the filled-oval fitting the box specified by its four arguments. The first two arguments give the location for the painting. The second two arguments specify the width and height of the rectangle in which to fit the oval Using blue, the below example paints at (300, 25) the filled-in oval fitting a 50 x 75 rectangle int x4 = 300; int y4 = 25; int w4 = 50; int h4 = 75; artist.setColor( Color.BLUE ); artist.fillOval( x4, y4, w4, h4 );

drawString() Using the currently set color and font, method drawString() draws a string on its image using its three arguments. The first argument gives the string to be rendered. The second two arguments give the location for the drawing Using cyan, the below example draws at (300, 155) the string "We are the best!" int x5 = 300; int y5 = 155; String s5 = "We are the best!"; artist.setColor( Color.CYAN ); artist.drawString( s5, x5, y5 );

drawLine() Using the currently set color, method drawLine() draws on its image the line specified by its four arguments. The first two arguments give the starting location of the line. The second two arguments give ending location of the line Using white, the below example draws a line from (300, 165) to (400, 165) int x6 = 300; int y6 = 165; int x7= 400; int y7 = 165; artist.setColor( Color.WHITE ); artist.drawLine( x6, y6, x7, y7);

drawPolygon() Using the currently set color, method drawPolygon() draws on its image the outline of the closed polygon specified by its three arguments. The first two arguments give respectively the x- coordinates and y-coordinates from which to get the polygon vertex locations. The last argument specifies the number of vertices Using yellow, the below example draws 6-sided polyon int[] x8 = { 350, 400, 425, 425, 400, 375 }; int[] y8 = { 20, 60, 100, 160, 125, 90 }; int n8 = 6; artist.setColor( Color.YELLOW); artist.drawPolygon( x8, y8, n8 );

fillPolygon() Using the currently set color, method fillPolygon() paints on its image the closed filled-in polygon specified by its three arguments. The first two arguments give respectively the x- coordinates and y-coordinates from which to get the polygon vertex locations. The last argument specifies the number of vertices Using pink, the below example paints a filled-in 4-sided polygon int[] x9 = { 175, 240, 190, 150 }; int[] y9 = { 80, 110, 130, 120 }; int n9 = 4; artist.setColor( Color.PINK ); artist.drawPolygon( x8, y8, n8 );

Week 3 Object-oriented programming JOptionPane Random Graphics.

Similar presentations

Presentation on theme: "Week 3 Object-oriented programming JOptionPane Random Graphics."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Week 3 Object-oriented programming JOptionPane Random Graphics.

Similar presentations

Presentation on theme: "Week 3 Object-oriented programming JOptionPane Random Graphics."— Presentation transcript:

Similar presentations

About project

Feedback