Added and Updated

Author: Liebmann5

Diff for: Actor.java

@@ -0,0 +1,56 @@
+import java.awt.Graphics;
+
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!?????????????????????????????????????????????
+//IDEA:I believe the purpose of an interface is a way for multiple
+//objects(DP & {?Sprite or Game}?) in a code to invoke an interface(Actor)
+//for the purpose of identifying them as a new object that will allow them
+//to use a common code that they both require! {for the means of having less
+//code in your program} I think this package has only 2 objects that need
+//to be manipulated which is ?DP and Sprite?; the other objects can be/are
+//these objects already(?because they are subclasses?). Both objects have
+//different draw() and step() which is why Actor requires both common
+//objects to have and implement them. Identifying both of them as a common
+//object(Actor) allows them to use Drawing, which uses that common object as
+//a "type" in the class so the only object type to be used in parameters or
+//ArrayLists is that very common object type(Actor)!!!!!! ??Drawing has it's
+//own step method which then calls step() again BUT, ?I think it invokes the
+//step method that each object provided in Actor... so because dp is an Actor
+//type/object it doesn't use recursion it actually ?knows that the objects(dp)
+//is an interface? so it invokes the step method in Actor which then invokes
+//the proper objects step()? If this is true then ya BUT why is recursion not
+//the immediate ?thing to do?????? {Go through the section again and see how
+//dp.step() is used throughout because I think it changes!!!!} DRAWING is the
+//common code and ?it is what makes a blank Canvas for every class and allows
+//them to manipulate multiple objects(becasue of ArrayList) from each of the
+//2 main objects!!????
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!?????????????????????????????????????????????
+//??With this idea in mind; WHY did he make us put the DP main method in
+//Drawing? rather than us invoking Drawing from DP??
+//IDEA:I think it was just a weird situation translate() & other methods
+//required a extends Canvas(which I'm pretty sure he explains as how to deal
+//with an object that needs 2 superclasses) so... ????????????????????
+//public class Actor
+public interface Actor
+{
+	//(51)BOOK:Define a new superclass, which we call Actor, that
+	//provides the two methods needed by Drawing:
+	//???Drawing doesn't need any methods so how the heck would I
+	//know what to provide?????????????????
+	/*public void draw(Graphics g)
+	{
+		//do nothing
+	}*/
+	//??Why can't I put a breakpoint here to see when this method
+	//is implemented or invoked??????????????????????????????????
+	void draw(Graphics g);
+	
+	/*public void step()
+	{
+		//do nothing
+	}*/
+	void step();
+	
+	//Seems as though the 2nd one works here but not the 1st!!??
+	//Polygon p1 = new DrawablePolygon();
+	Actor a2 = new DrawablePolygon();
+}

Diff for: ArrayPractice.java

@@ -0,0 +1,139 @@
+/*
+ * Chapter 7.3
+ */
+import java.util.Arrays;
+import java.util.Random;
+
+public class ArrayPractice
+{
+	public static void main(String[] args)
+	{
+		int[] array = {1,2,3,4};
+		printArray(array);
+		
+		int[] g = printArrayReverse(array);
+		System.out.println(Arrays.toString(g));
+		
+		//Random nums = new Random(30);
+		int[] scores = randomNumbers(30);
+		System.out.println(Arrays.toString(scores));
+		//int a = scores(scores, 90, 100);
+		//System.out.println(a);
+		
+		int[] range = new int[10];
+		for(int i = 0; i < range.length; i++)
+		{
+			if(i == 0)
+				range[i] = inRange(scores, i, i+10);
+			else if (i == 9)
+				range[i] = inRange(scores, i*10, i*10+11);
+			else
+				range[i] = inRange(scores, i*10, i*10+10);
+		}
+		System.out.println(Arrays.toString(range));
+		
+		/*How do the above more efficiently
+		int[] counts = new int[100];
+		for(int i = 0; i < scores.length; i++)
+		{
+			int index = scores[i];
+			counts[index]++;
+		}
+		System.out.println(Arrays.toString(counts));*/
+		
+		//try to efficiently go through the scores array
+		//and organize it by grades
+		int[] counts = new int[10];
+		for(int i = 0; i < scores.length; i++)
+		{
+			int index = 0;
+			if (scores[i] == 100)
+				counts[counts.length-1]++;
+			else
+			{
+				//Int Division(/) doesn't include decimals
+				//and always rounds the decimals down
+				index = ((scores[i] % 100)/10);
+				counts[index]++;
+			}
+		}
+		System.out.println(Arrays.toString(counts));
+		
+		//Enhanced for Loop
+		int[] countsMore = new int[101];
+		for (int score : scores)
+			countsMore[score]++;
+		System.out.println(Arrays.toString(countsMore));
+		
+		int[] countAgain = new int[10];
+		for(int assign : scores)
+		{
+			//assign replaces writing scores[i]
+			if (assign == 100)
+				countAgain[countAgain.length-1]++;
+			else
+				countAgain[((assign%100)/10)]++;
+		}
+		System.out.println(Arrays.toString(countAgain));
+	}
+	
+	public static String printArray(int[] a)
+	{
+		System.out.print("{");
+		for(int i = 0; i < a.length; i++)
+		{
+			if(i == 0)
+				System.out.print(a[0]);
+			else
+				System.out.print(", " + a[i]);
+			//For a[4] why does an OutOfBounds err not occur?
+			//Also why is there not another comma after 4?
+			//YOUR DUMB! Do it!
+		}
+		System.out.println("}");
+		return "}";
+		//Why does it not return }?
+		//RETURN prints nothing
+	}
+	
+	//To copy an array from one to another you do it this way
+	//int[] c = Arrays.copyOf(b, b.length); does it too
+	public static int[] printArrayReverse(int[] b)
+	{
+		int[] c = new int[b.length];
+		//int j = 0;
+		for(int i = b.length-1; i >= 0; i--)
+		{
+			for (int j = 0; j <= b.length-c.length; j++)
+			{
+				c[j] = b[i];
+			System.out.print(c[j]);
+			//break;
+			//j++;
+			}
+		}
+		//System.out.println();
+		System.out.println(Arrays.toString(c));
+		return c;
+	}
+	
+	public static int[] randomNumbers(int size)
+	{
+		Random numbers = new Random();
+		int[] rando = new int[size];
+		for(int i = 0;i < rando.length; i++)
+			rando[i] = numbers.nextInt(101);
+		return rando;
+	}
+	
+	public static int inRange(int[] scores, int low, int high)
+	{
+		int count = 0;
+		for(int i = 0; i < scores.length; i++)
+		{
+			if(scores[i] < high && scores[i] >= low)
+				count++;
+		}
+		return count;
+	}
+}

Diff for: Automaton.java

@@ -0,0 +1,115 @@
+/*
+ * Chapter 16.2
+ */
+import javax.swing.JFrame;
+
+//??????(10)WHY A SUPERCLASS if it only does so little???????????????
+//IDEA:I believe it's to show how refactoring and abstract works!!! We
+//wanted to remove repeated code by refactoring it. Then in order for
+//our repeated code to work it required the mainloop() to be present
+//and by adding this, it needed a method(update) from each class so we
+//used abstract to access the update() from each class. ?IN ORDER to
+//abstract something from another class(subclass) we ?need to make the
+//superclass abstract? so I think it was easier to show and implement
+//it here in this way!!?????
+//??If yes then why not abstract the mainloop???? I feel like adding it
+//here is only for organization because I think it would be faster to
+//leave them where they are as is and here it's just more computations
+//and also at putting more at risk??????????????
+//???Why not just inherit because this way for this problem seems dumb!??
+public abstract class Automaton
+{
+	/*
+	 * BOOK:There are a few problems with the current design
+	 * 
+	 * 1. The grid attribute is private, making it inaccessible in Conway 
+	 * 	  and Langton. We could make it public, but then other (unrelated)
+	 *    classes would have access to it as well.
+	 *    
+	 * 2. The Automaton class has no constructors, and even if it did, there
+	 *    would be no reason to create an instance of this class.
+	 *    
+	 * 3. The Automaton class does not provide an implementation of update.
+	 *    In order to work properly, subclasses need to provide one.
+	 *    
+	 * Java provides language features to solve these problems:
+	 * 
+	 * 1. We can make the grid attribute protected, which means it's accessible
+	 *    to subclasses but not other classes.
+	 *    
+	 * 2. We can make the class abstract, which means it cannot be instantiated.
+	 * 	  If you attempt to create an object for an abstract class, you will get
+	 *    a compiler error.
+	 *    
+	 * 3. We can declare update as an abstract method, meaning that it must be
+	 *    overridden in subclasses. If the subclass does not override an abstract
+	 *    method, you will get a compiler error.
+	 */
+	//??#2.1 To have/be an instance do you need a constructor??????????
+	//??#1.1&1.2 By making it public other classes would have access to it too
+	//but our solution is to just allow only subclasses access SOOOOO..... what's
+	//stopping someone from just extending this super as well and boom now it's a
+	//subclass of this class? OR just make a subclass to the subclass????????????
+	//??#2.1 (Question still stands) Why is there no reason to create an instance
+	//for this class!? If it's not an instance then what is it????? What is the
+	//purpose or benefit of creating an instance and not?????????
+	//??#2.2 Abstract classes can't be instantiated(make a new instance); again
+	//what is the purpose or benefit in doing this????????
+	//??#3.2 Why do the methods in the subclasses need to be overridden?? To me
+	//overridden means that a method is written multiple times so override is
+	//used to make a particular method the priority, but here we define the
+	//object, we wish to access with, this; meaning that we know which object
+	//is currently in use so we will find each update() in that objects class??
+	//???After adding update() I was wondering that if only 1 class had update,
+	//because it was a necessity for it, that if this would still be 
+	//necessary/needed? ALSO what if each class has update but different return
+	//values for it then what?????????
+	
+	
+	//BOOK:Automaton declares grid as an instance variable, so 
+	//every Automaton "has a" GridCanvas
+	//???define the HAS-A here??? The variable grid has a value
+	//that is = to a reference(?or instance?) that is from GridCanvas
+	//private GridCanvas grid;
+	protected GridCanvas grid;
+	
+	//BOOK:The declaration specifies the name, arguments, and return type. But
+	//it does not provide an implementation, because it is an abstract method.
+	//Any class that extends Automaton must provide an implementation of update;
+	//the declaration here allows the compiler to check.
+	//??How does the compiler check??? Aside from that, does the compiler check
+	//if a method like this exists; without the abstract, and if so run the code.
+	//(Read the Aside part like, What does the compiler check for?)
+	public abstract void update();
+	
+	//????(11)Why a method and not a constructor???? I know it's
+	//supposed to be a super but doesn't that only further my point??
+	//BOOK:rate="frame rate", the # of time steps to show per second
+	public void run(String title, int rate)
+	{
+		JFrame frame = new JFrame(title);
+		//???Why JFrame.EXIT and not frame????
+		//frame is a variable here and not there???
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		frame.setResizable(false);
+		frame.add(this.grid);
+		frame.pack();
+		frame.setVisible(true);
+		this.mainloop(rate);
+	}
+	
+	private void mainloop(int rate)
+	{
+		while(true)
+		{
+			this.update();
+			grid.repaint();
+			
+			try {
+				Thread.sleep(1000 / rate);
+			} catch(InterruptedException e) {
+				//do nada
+			}
+		}
+	}
+}

Diff for: BlinkingPolygon.java

@@ -0,0 +1,46 @@
+import java.awt.*;
+
+//??????????????????????????????????????????????????????????????????????????
+//??How and when is this class called or invoked since we never explicitly
+//invoke or refer to it anywhere?? We only go as far down as RP so how, why,
+//and when is this reached?????????????????
+//??I also never saw this occur in the debug!!!!!!????????????
+public class BlinkingPolygon extends RegularPolygon
+{
+	public boolean visible;
+	public int count;
+	
+	//??My program won't work without a constructor but in DP the
+	//book said that if I don't make one when I extend a class that
+	//the compiler will make one for me??? Obviously this is false?
+	public BlinkingPolygon(int nsides, int radius, Color c)
+	{
+		super(nsides, radius, c);
+		//"initializes" visible and count
+		visible = true;
+		count = 0;
+	}
+	
+	//??Still don't know what this does but why not use a different/
+	//already made draw?????????????????????????????????????????????
+	public void draw(Graphics g)
+	{
+		if(visible)
+			super.draw(g);
+		//^Since super invokes draw in RP yet RP does not provide a
+		//draw method, it goes to DP
+		//??Does super always just work up the "extends" chain?????
+	}
+	
+	public void step()
+	{
+		count++;
+		if(count == 10)
+		{
+			//??Don't understand the purpose of this??  Why??
+			visible = !visible;
+			//??Don't understand why is would reset count????
+			count = 0;
+		}
+	}
+}