Monday, March 2, 2015

Age checker

Tim and I made a java program that checks to see if you're 18 years old or older.

import javax.swing.JOptionPane;
import java.util.Calendar;
import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class home {
public static void main(String[] args) {
int day = 0;
int month = 0;
int year = 0;
boolean workingstr = false;
while (workingstr == false) {
String inputValue = JOptionPane.showInputDialog("Please type in your birthday (mm/dd/yy)");
workingstr=true;
try {
day = Integer.parseInt(inputValue.substring(4,5));
month = Integer.parseInt(inputValue.substring(0,2));
year = Integer.parseInt("19"+inputValue.substring(inputValue.length()-2,inputValue.length()));
} catch (NumberFormatException e) {
workingstr=false;
} catch (StringIndexOutOfBoundsException e) {  
workingstr=false; //This section of the program will repeat if any errors are thrown trying to convert the
}                                      //input string to integers.
}
DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
Calendar cd = Calendar.getInstance();
int todayDay = Integer.parseInt(dateFormat.format(cd.getTime()).substring(0,2));
int todayMonth = Integer.parseInt(dateFormat.format(cd.getTime()).substring(4,5));
int todayYear = Integer.parseInt(dateFormat.format(cd.getTime()).substring(6,10));

if (day<=todayDay) {
month++;
}
if (month<=todayMonth){
year++;
}
if (year+18<=todayYear) {
System.out.println("You're good.");
} else {
System.out.println("Nope! You're underage.");
}
}
}

Friday, February 13, 2015

Chapter 5

For a while, I've been working on a little project called "Infinite Mario Bros". Looks pretty good so far.
Some of Chapter 5's content was actually surprisingly informative and helpful.
Consider this bit of code-
I made this before I discovered that there were two formats for for loops;
for (int i=0; i < Main.mainPanel.Enemies.size(); i++) { Main.mainPanel.enemies.get(i) }
for (Enemy test : Main.mainPanel.enemies) { test }

Using the new for loop, my code is easier to modify and looks much cleaner overall, because instead of typing "Main.mainPanel.enemies.get(i)" each time, i can just type "test".







And if you're wondering what this code does, it goes through a list of enemies, checks if they're overlapping with Mario, and if he's falling, change their state. In other words...
Goomba goes squish.

Tuesday, February 3, 2015

Chapter 4

In Chapter 4 of Headfirst Java, I learned about Instance and Local variables, and how they act. Instance variables are declared as part of the class and have default values, but Local variables are defined within a method and have no initial value. For example...

public class Dog{
    public int size;
    public void printSize() {
        System.out.print(size);
    }
}

Calling the printSize() method on this Dog class will return 0, since the default value of ints are 0. However, you can't do this...

public class Dog{
    public void printSize() {
        int size;
        System.out.print(size);
    }
}

This code won't compile because the size variabe is Local and has no default value.

I also learned that there are two different ways to compare variables, as I discovered in the cat simulator program. The == operator  compares variables on a binary level, meaning the variables have to be exactly the same values and be in the same "heap", whereas you can use .equals() to compare similar objects from different heaps (such as strings with the same characters).

Friday, January 30, 2015

Cat Simulator 2015

I worked together with my friend Tim to make a 'cat simulator' of sorts in Java. After naming your virtual cat, you can use text commands to pet it, give it things to play with / eat, or watch it interact with things you've given it. Here's an example run of the program:

You got a new pet cat! What do you want to name him?
Tom
You named him Tom.
What do you want to do?
(pet, give, watch, exit)
give
What item is it?
paper ball
Is it edible?
no
Tom plays idly with the paper ball.
(pet, give, watch, exit)
give
What item is it?
catnip
Is it edible?
yes
Tom stares at the catnip.
(pet, give, watch, exit)
watch
Tom eats the catnip. Viciously.
(pet, give, watch, exit)
watch
Tom meows.
(pet, give, watch, exit)
pet
You pet Tom and he purrs softly.
(pet, give, watch, exit)
pet
You pet Tom the wrong way, and he scratches you!
(pet, give, watch, exit)

The program is split into three .java files and three separate classes; a main class, a cat class, and an Object class. The main class handles command inputs and stores objects, the cat class decides what it wants to do with with the objects it's given, and the Object class stores information about each object.

The project code can be viewed in this Eclipse project.

Wednesday, January 28, 2015

Chapter 3

In experimenting with the Dog program example, I learned that Java reads all the class definitions (variables, constructors, methods, etc.) before executing public static void main (String[] args). This means you can have the main program inside a class, and that the program will start with one copy of that particular class. This makes me wonder if you could refer to itself in an array.

class Dog {
   public String name = "Ben";
   public static void main (String[] args) {
      Dog[] myDogs = new Dog[2];
      myDogs[0] = new Dog("Bob");
      myDogs[1] = this;
      int x = 0;
      while (x < myDogs.length) {
         System.out.println(myDogs[x].name); // Would this print "Bob" and then "Ben"?
      }
   }
   public Dog(String newnname) {
      this.name = newname;
   }
}

     

Tuesday, January 20, 2015

Chapter 2

In the second chapter of Headfirst java, I learned about subclasses and superclasses, and how subclasses can override superclass methods. For example, if we have a superclass called Shape, we can have subclasses Square and Triangle. The subclasses can have their own unique variables and classes, while preserving any of Shape's methods assuming they haven't been overridden.

Tuesday, January 13, 2015

Chapter 1 findings

In the first chapter of Headfirst Java, the two biggest things I learned about are casts and declaring arrays. Casts allow you to change numbers from one data type to another, such as from Float to Int.
Example:

float x = 32.25f;
if ((int) x == 32) {
     System.out.println("This will print because 32.25 rounds to 32.")
}
if (x==32) {
     System.out.println("This won't print because x is still 32.25.")
}

Arrays in Java are created somewhat differently than other languages- You have to tell the code you want an array after the primitive type. This means the array will only accept one type of data (String, integer, etc).

String[] animals = {"cats", "dogs", "pigs"}
int[] numbers = {1, 30, 25, 22.5} // This will throw an error, since 22.5 is a float in an integer array.