Try and Catch

Try - Make an attempt or effort to do something
Catch - Intercept and Hold

Syntax:

try
{
statement(s);
}

catch (Exception Handler Tag)
{
statement(s);
}


The try and catch  allows you to test a block of errors. Once it encounters a block of errors in the try, it passes it to the tag. A tag is a variable that hold the exception. The statements under the catch are to be executed once the try receives an error (it catches the errors from the try).

Exception Handler is an exception. An exception an error. Famous exceptions are IOException and NumberFormatException.

For an example of a try and catch, refer to the next post.

Creating a GUI of a Simple Calculator



The image above is a simple calculator found in Windows; while the image below is a simplier version of calculator compared to the one above.


And yes, it is created in Java. Try to create your own version of a Java Calculator using the simple operations. The code will be posted in a few days.

PS
Just the GUI. Never mind the functions yet.

Ways to Use Inheritance

There are two ways to use Inheritance in Java.

1. Using the Extend keyword
     As you have learned from the previous lesson, the extend keyword is used in Method Overriding, which is a part of Polymorphism. We use it to refer the different methods and variables in a parent or super class that can be used in the parent of child class. Given the example from the previous post...


class first
{
int number;

void Add()
{
number=number+1;
}

void Subtract()
{
number=number-1;
}
}
class second extends first
{
void Add()
{
number=number*1;
}
void Divide()
{
number=number/1;
}
}
public class MClass
{
public static void main (String args[])
{
first one = new first();
one.Add();
one.Subtract();

second two = new second();
two.Add();
two.Divide()
}
}



2. Constructor Method
     A constructor method is commonly used (beginners) in creating methods in a simple program. The constructor method uses parameters to connect values from the object class to the main class. For example, given a Sample Class and a Main Class...


class Sample
{
void test()
{
System.out.println("Test");
}
}

public class MainClass
{
public static void main (String args[])
{
Sample x = new Sample();
}
}


The output will only display Test.

Inheritance

In Java, the following terms are often used:

  • Super Class - the topmost part of the class
  • Parent Class - the class before the child class
  • Child Class - the last class in the program
To understand fully, here's a sample of a family tree.







Obviously, the child (classes) are the following:

  • Me
  • Brother
  • Sister
  • Cousin; and
  • OTHER Cousin
The Parent Classes are:
  • Mommy and Daddy Smith
  • Uncle and Aunt Trotter
  • Aunt and OTHER A.N
The Super Class are:
  • Grandad and Granny Jones
  • Great Grandad and Great Granny Bloggs
However, Java does not support multiple inheritance. Java can only hold one Super Class, one Parent Class, and one Child Class.

GUI Basics

A GUI is an acronym of Graphical User Interface, and is sometimes pronounced as Gooey. Visual Basic has a very good example of GUI wherein you can draw your objects freely with the use of the mouse. However, in Java, you have to plot it point by point.

The first thing in creating a GUI in Java is to use everything in the swing package and to override swing's JFrame by using the extend keyword.

Our main goal in this lesson is to create a simple GUI of an ATM Machine with two labels and textboxes (Card Number and Pin), two buttons (OK and Cancel) and name it ATM.





Below is the code with explanations...


import javax.swing.*;  //use everything within the swing package
public class CodeGalaxy extends JFrame  //overrides JFrame
{

JTextField txt1 = new JTextField();  //JTextField is equivalent to a textbox
JLabel CardN = new JLabel("Card Number: ");  //JLabel is equivalent to a label

JTextField txt2 = new JTextField();
JLabel PIN = new JLabel("Pin: ");

JButton OKbtn = new JButton("OK");  //JButton is equivalent to a command button
JButton Can = new JButton("Cancel");


public CodeGalaxy()   //constructor method with the same name of your class
{

//shows the output of the Card Number


getContentPane().setLayout(null);   //set to nothing / null 
CardN.setBounds(70,10,90,10); //setBounds defines the boundary of your object
getContentPane().add(CardN);

txt1.setBounds(150,10,150,18);
getContentPane().add(txt1);

//same flow of idea as to the Card Number//

//shows the output of the PIN
PIN.setBounds(70,30,80,10);
getContentPane().add(PIN);

txt2.setBounds(150,30,150,18);
getContentPane().add(txt2);


//shows Ok button
OKbtn.setBounds(230,60,70,30);
getContentPane().add(OKbtn);


//shows Cancel button
Can.setBounds(70,60,90,30);
getContentPane().add(Can);


setTitle("ATM");   //sets the title as ATM
setSize(400,130);  //sets the size
setVisible(true);  //makes our ATM visible

}

public static void main (String args[])
{
CodeGalaxy x = new CodeGalaxy();
}
}



Further explanation:

setBounds syntax:
variable.setBounds(x-axis,y-axis,width,height);

setSize syntax:
setSize(width, height);


public static void main (String args[])
{
Lab3 x = new Lab3();
}
without the public static void main, our program will run invisibly.

JTextField txt1 = new JTextField();
JTextField is a textbox with the variable name txt1


JLabel PIN = new JLabel("Pin: ");
JLabel is a label with the variable name PIN with the caption as Pin:


JButton Can = new JButton("Cancel");
JButton is a command button with the variable name Can with the caption as Cancel

The 'extend' keyword


class first

{
int number;


void Add()
{
number=number+1;
}


void Subtract()
{
number=number-1;
}
}
class second extends first
{
void Add()
{
number=number*1;
}
void Divide()
{
number=number/1;
}
}
public class MClass
{
public static void main (String args[])
{
first one = new first();
one.Add();
one.Subtract();


second two = new second();
two.Add();
two.Divide()
}
}

Given the code above, second extends first where second inherits first's methods and variable. As you can see the variable in class first  and class second is the same, which is number, though number is only declared in class first. Class Second overrides the Add method and added a Divide method.

When class second extends to first, we call second as a subclass of first and first is the superclass of second. In java, two or more classes can inherit from the same parent class but a class can only have one parent.

Method Overriding

Let's start with an example. If Aphrodite Keys is a famous celebrity, her mother, Hera Keys is also a famous celebrity. Whatever the parent is doing is inherited by the child.

In programming, method overriding means that whatever the parent class is doing, it is inherited by the child class. Given the code below:


class CodeGalaxy

{
public void planet()
{
System.out.print("Pluto is not considered a planet");
}
}


class MilyWay extends CodeGalaxy
{
public void planet()
{
System.out.print("How many planets do we have now?");
}
}


public class RunningCode
{
public static void main(String args[])
{
CodeGalaxy output1 = new CodeGalaxy();
CodeGalaxy output2 = new Milkyway();


output1.planet();
output2.planet()
}
}


Class MilkyWay extends CodeGalaxy is better understood as MilkyWay overrides CodeGalaxy.  The output will be:

Pluto is not considered a planet.How many planets do we have now?

For more on Overriding, refer to next post about the extend keyword.

Method Overloading


Whenever a two or more methods have the same name but different behaviors or parameters, it is called method overloading.

A good example of method overloading is a set (or a pair) of people with the same name. A very good example to understand this are social networking sites. Let's say that there are two people with the name Aphrodite Keys on Facebook. The first Aphrodite Keys is a famous celebrity, while the second is just a poser.

Between the two Aphrodite Keys, it is obvious that both have the same name. It is also obvious that both have different personalities and behaviors.  The original Aphrodite Keys posts updates regarding her work and insights of life honestly, while the poser Aphrodite Keys posts different things that may help gain her social network fame.

Given the codes below....

class CodeGalaxy
{
public int sum;

public CodeGalaxy()
{
sum = 0;
}

public void Add(int num1, int num2)
{
sum = num1 + num2;
}

public void Add(int num1, int num2, int num3)
{
sum=int1+num2+num3;
}

public void Add(int num1)
{
sum = num1;
}
}

The code of the main class is the following:

public class UseGalaxy
{
public static void mai (String args[])
{
CodeGalaxy planet = new CodeGalaxy();
planet.Add(2,3);
planet.Add(1,2,3);
planet.Add(100);
}
}

Using the first planet.Add with parameters 2 and 3, the values are passed on the first (public void) Add in your object. The values of the second planet.Add with parameters 1,2 and 3, are passed on the second (public void) Add in your object. The last planet.Add with 1 as its parameter is passed on the last method in your object.

The main idea is: You cannot pass planet.Add(2,3)  to the second method in your object with public void Add(int1, int2, int3) since planet.Add has only two values and the method requires three values. Therefore, in order to use planet.Add(2,3), the values are passed on the first method with public void Add(int1,int2)

Extended Search

Custom Search