Midterm 1

Characteristics of Java

• Simple, object oriented,robust, secure, architecture neutral and portable, high proformance,interpreted dynamic, distributed.
• write once, run everywhere

how java works

• To compile, use javac XXX.java.
• To run, use java XXX .
• Not every program has a main method.
• You compile the program into bytecode.
• The bytecode is interpreted by Java virtual machine.

Comments

• // : single line
• /* ....... */ : multiple lines.
• /** ...... */ : multiple lines, can be used to generate documementation.
• You should know the difference between them and how to use them.

main

• public static void main(String[] args)
• It is the entry point of an application.
• Not every class has this method. If you has this method in the class, you can run the program by java ClassName .
• You can overload the main method. But it is not the entry point of the application.
• This method is a class method, with argument of type String[]. The return tpye is void. It is no different from other methods.
• Since args is a String array. You can use
  • args.length to access the length of args.
  • You can use args[0], args[1]... to access the elements in the array
  • If you try to access a non-existent args[i] (i.e. i >= args.length ) an error will occur during runtime.

• you can run the program by java ClassName string0 string1 ..
• String[] args = {string0, string1 , ... } is created
• args pass to main(String[] args) and the method body is executed
• if no argument is given, args is not null but args.length is 0.
• arguments are seperated by space
• if you want to have an arguemnt with space in between, use quotation. e.g. java ClassName "Charles Li".

System.out.println(String s)

• Use System.out.println(string) to print out a string and then go to next line.
• Use System.out.print(String) to print out a string without going to a new line at the end.
• System.out.println(....) can print out int, float,... as well.

class

• Objects has states(members) and behavior(methods)
• Everything in java is a class.
• The filename must be the classname.java

Identifies

1. An identify is a squence of letters , digits, dollar sign $, underscore _.
2. It cannot begin with a digit.
3. It cannot be any reserved keywords like , public, class, void ....
4. Actually it can be in other language (other than English) if you use unicode.
5. They are case senstive . i.e. myName is different from MyName.

Primitive type

• Primitive types are byte, short, int, long, float, double, char, boolean.
• You don't have to memorize the size of the primitive. But you should know that they are platform independent. And long is more precise than int, double is more precise than float etc etc.
• You can define more than more than one variable of the same primitive on the same line, eg.

   int a, b, c

int

• If you don't initiate the value for an integer, it is 0
• You dont't need to understand the octal number and hexadecimal number. They won't appear in the midterm

float and double

• Different ways to declare double are

   double a = 3.14, b = 3, c = 2.713e10, d = 34.665e5d;
   

• Ways to declare float are very similar to double. You have to add f at the end of the number.

  float a = 3.14f, b= 34.665e5f;
  

• If you don't initate the values, they are 0.
• float a = 3.14 causes an compiling error because 3.14 is a double by defalt

long

• The way to declare it is long x = 58819394L; .
• more precious then int

char

• char represents a character.
• example char a = 'a';

boolean

• example

  boolean a = true;
  boolean b = false;
  

Arithemetic

• You should know how to do arithemetic on primitive type.
• The arithmetic operators are very similar to C++.
• When the operands are of 2 different types, the more precious type will be returned.
  example : when a integer add to a float, the result is a float.
  

Flow control

• Refer to my notes on flow control for more detail
• you should know how to use if, else, while, do-while, for, switch .

Array

• To declare an array use ClassName[] arrayName
• To allocate an array with given size, use arrayName = new ClassName[size].
• You should initiate the elements of the array, otherwise they all are null.
• A quick way to initalize array is :
  Example

   
  int[] array1 = {1,2,3,4,5};
  String[] array2 = {"this", "is" , "review" , "notes"}
  

• use array.length to get the size of the array.
• Try to understand arrays of array from my handout

String

• initiate String by String s = "Hi";
• You can add 2 strings together by +
• You should not memorize all the methods in the String class. But you should understand the methods. Documentation will be provided.

class and inheritance

• how to use constructor.
• how to use new.
• how to use private, protected and public and their meaning.
• understand the difference between static variables and non-static variables.
• how to use this and super.
• understand overriding and overloading
• understand 3 ways to use final.
• understand subclass and superclass and how to extends classes.
• understand what is abstract class.
• understand how Java pass information in a method. Java pass the arguments by value.

Midterm 2

Import

• Understand the meaning of import
• Import by wild character , example import java.awt.*.
• Import by full name, example import javax.swing.JFrame.
• Import statements are not necessary. Example
  javax.swing.JFrame f = new javax.swing.JFrame("title").

Graphics

• know how to extend JFrame and override paint(Graphics g) method
• understand Font class and Color class, how to set/get font and color
• how to use drawLine, drawRect, fillRect, drawOval, fillOval, drawString methods

JFrame

• getContentPane()
• how to set layout
• constructors
• setSize, setVisible, setLocation....

Layout

• 3 layouts: BorderLayout, FlowLayout, GridLayout
• the effect of different layout (how they look?)
• understand all the constructors
• What do new GridLayout(0, 5), new GridLayout(5,0) mean?
• add(component), remove(index), add(component, index)

JPanel

• use as an intermediate container for creating complicated Swing applications
• JPanel(), JPanel(layout)

JLabel, JButton, JTextField

• constructors
• getText, setText
• setBackground
• know how to set text position, icons, etc etc
• getActionCommand, setActionCommand

Interface

• know how to create an interface
• all member methods in an interface are public abstract
• all member variables in an interface are public static final
• know how to implement an interface

ActionListener

• public class XXX implements ActionListener {
      .............
      ............
      public void actionPerformed(ActionEvent e) {
          // your codes
      }
  }
  

• Anonymous class:

  button.addActionListener(new ActionListener() {
          public void actionPerformed(ActionEvent e) {
              // your codes
          }
      });
  

• familiar with them and know how to change form one form to another

ActionEvent

e.getSource()

• returns Component
• may need to downcast it, example:
  

  JButton button = (JButton)e.getSource();
  

• can be used to distinguish sources of the event, example
  

  public void actionPerformed(ActionEvent e) {
      if(e.getSource() == button1) {
           // do something
       } else if( e.getSource() == button2) {
          // do something
      } ......
        .....
  }
  

e.getActionCommand()

• returns the actionCommand(as a String) of the source
• e.g. button.setActionCommand(String s) set the action command of the button to s. If you don't set it, the default value is the text on the button.
• can be used to distinguish sources of the event, example
  

  public void actionPerformed(ActionEvent e) {
       String action = e.getActionCommand();
       if(action.equals(string1)) {
          // do something
       } else if (action.equals(string2)) {
           // do something
      } .....
        .....
  

After midterm 2

Exception

• There are 2 types of exception: RuntimeException, Checked exception
• RuntimeExceptions are classes that extends RuntimeException.
• You have to "take care" of checked exception. There will be compiler error if you don't do that.
  2 ways of taking care of exceptions

  someMethod(......)  throws SomeException {
     // your code
  }
  

  or

  try {
      // some codes
  } catch (ExceptionX ex) {
       // some codes
  } catch (ExceptionY ex) {
      // some codes
  }
  .....
  

• It is optional to "take care" of the RuntimeException.
• NullPointerException, ArraryIndexOutOfBoundsException, ArithmeticException, NumberFormatException are all RuntimeExceptions. Understand when will these exceptions occur.
• FileNotFoundException, IOException are checked exceptions. You should know when these exceptions occur.
• You should understand the flow of the program with exception: example

  try {
     line1
     line2
     line3
     ......
     line10
  } catch (ExceptionX ex) {
     lineX
     ......
  } catch (ExceptionY ex) {
     lineY
     .......
     
  } finally {
      ......
  } 
  line101
  line102
  
  

  If the first exception occurs at line3, then the program will find out which exception matches the exceptin thrown by line 3. The codes in the catch block will be executed. After that, the codes in finally block will be executed. And then line 101.......
  Please modify the following program to understand the concept

  public class ExceptionTest {
      public static void main(String[] args) {
          try {
              System.out.println("line 1");
              String[] s = new String[10];
              
              System.out.println("line 2");
              s[0] = "Hi";
          
              System.out.println("line 3");
              System.out.println(s[11]);
          
              System.out.println("line 4");
              System.out.println(s[1].toUpperCase());
          
              System.out.println("line 5");
              System.out.println(10/0);
         } catch (ArrayIndexOutOfBoundsException ex) {
             System.out.println("line X");
         } catch (NullPointerException ex) {
             System.out.println("line Y");
         } catch (ArithmeticException ex) {
             System.out.println("line Z");
         } finally {
             System.out.println("line finally");
         }
         System.out.println("Start all over");
      }
  }
  

• Lazy way of taking care the exceptions

  public static void main(String[] args) throws Exception {
     // your codes
  }
  

  or

  public static void main(String[] args)  {
       try {
            // your codes
           
        } catch (Exception ex) {
           // catch all exception because all exception class are subclass of Exception
        }
  }
  

IO

Input

• InputStream
  • FileInputStream in = new FileInputStream(filename)
  • int read()

    int ch = -1;
    while((ch = in.read())!= -1) {
        // do something
    }
    

• BufferedReader:
  • BufferedReader in = new BufferedReader(new FileReader(filename));: create a BufferedReader from a file.
  • new BufferedReader(new InputStreamReader(System.in));: create a BufferedReader from user input
  • String readLine:

    String line = null;
    while((line = in.readLine())!=null) {
       // do something
    }
    

Output

• FileOutputStream
  • FileOutputStream out = new FileOutputStream(filename);
  • out.write(int ch)
• PrintStream
  • PrintStream out = new PrintStream(new FileOutputStream(filename));
  • out.print(...), out.println(....)
  • System.out is a PrintStream

• Most of the methods throw IOException or FileNotFoundException
• don't forget to close the stream by close()
• understand other read, write methods.

File

• understand all the constructors and methods
• create a File object doesn't mean the file is created!
• read the API. Try my sample exam.

Split

• String[] split(String exp) splits a String by exp. Example String s = "123ab456abXXX", then s.split("ab") returns {"123", "456", "XXX"}

Object

• equals (vs ==) and how to write equals method.
• toString (System.out.println(obj))
• instanceof: obj instanceof aClassName returns true if obj is of type aClassName. Returns false otherwise.
• every class extends Object

Type Wrapper class

• how to "convert" one type to another, example

  Double x = new Double(1.23);
  double = x.doubleValue();
  

• useful methods, eg. Double.parseDouble() or Double.MAX_VALUE
• There are lot of useful methods in Character class. Example, Character.isUpperCase(char ch), Character.isLetter(char ch)
• Why do we need them?

Math

• understand how to use Math class. Example Math.sqrt(5) is used to calculate the square root of 5.
• Math.random() generates a random double between 0 and 0.99999999. To generate an integer random number from 0 to max-1, use (int)(max*Math.random()).

Vector/LinkedList

• understand all the constructors and API
• add(Object obj), get(int index), set(int index, Object obj, size(), remove(int index), remove(Object obj)
• boolean contains(Object obj),int indexOf(Object obj) : these methods use equals method to test equality
• Type casting: (String)vector.get(5) get method returns Object.
• primitive type: vector.add(new Integer(101)); you can' t add primitive type to a vector. instead, you have to use type wrapper class.
• get primitive type: ((Integer)vector.get(2)).intValue() returns int