Java Tutorial

Wednesday, April 8, 2015

Example 13

Chapter 13

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public abstract class GeometricObject {
private String color = "white";
private boolean filled;
private java.util.Date dateCreated;

/** Construct a default geometric object */
protected GeometricObject() {
dateCreated = new java.util.Date();
}

/** Construct a geometric object with color and filled value */
protected GeometricObject(String color, boolean filled) {
dateCreated = new java.util.Date();
this.color = color;
this.filled = filled;
}

/** Return color */
public String getColor() {
return color;
}

/** Set a new color */
public void setColor(String color) {
this.color = color;
}

/** Return filled. Since filled is boolean,
* the get method is named isFilled */
public boolean isFilled() {
return filled;
}

/** Set a new filled */
public void setFilled(boolean filled) {
this.filled = filled;
}

/** Get dateCreated */
public java.util.Date getDateCreated() {
return dateCreated;
}

@Override
public String toString() {
return "created on " + dateCreated + "\ncolor: " + color +
" and filled: " + filled;
}

/** Abstract method getArea */
public abstract double getArea();

/** Abstract method getPerimeter */
public abstract double getPerimeter();
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class Circle extends GeometricObject {
private double radius;

public Circle() {
}

public Circle(double radius) {
this.radius = radius;
}

/** Return radius */
public double getRadius() {
return radius;
}

/** Set a new radius */
public void setRadius(double radius) {
this.radius = radius;
}

@Override /** Return area */
public double getArea() {
return radius * radius * Math.PI;
}

/** Return diameter */
public double getDiameter() {
return 2 * radius;
}

@Override /** Return perimeter */
public double getPerimeter() {
return 2 * radius * Math.PI;
}

/* Print the circle info */
public void printCircle() {
System.out.println("The circle is created " + getDateCreated() +
" and the radius is " + radius);
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class Rectangle extends GeometricObject {
private double width;
private double height;

public Rectangle() {
}

public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}

/** Return width */
public double getWidth() {
return width;
}

/** Set a new width */
public void setWidth(double width) {
this.width = width;
}

/** Return height */
public double getHeight() {
return height;
}

/** Set a new height */
public void setHeight(double height) {
this.height = height;
}

@Override /** Return area */
public double getArea() {
return width * height;
}

@Override /** Return perimeter */
public double getPerimeter() {
return 2 * (width + height);
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestGeometricObject {
/** Main method */
public static void main(String[] args) {
// Declare and initialize two geometric objects
GeometricObject geoObject1 = new Circle(5);
GeometricObject geoObject2 = new Rectangle(5, 3);

System.out.println("The two objects have the same area? " +
equalArea(geoObject1, geoObject2));

// Display circle
displayGeometricObject(geoObject1);

// Display rectangle
displayGeometricObject(geoObject2);
}

/** A method for comparing the areas of two geometric objects */
public static boolean equalArea(GeometricObject object1,
GeometricObject object2) {
return object1.getArea() == object2.getArea();
}

/** A method for displaying a geometric object */
public static void displayGeometricObject(GeometricObject object) {
System.out.println();
System.out.println("The area is " + object.getArea());
System.out.println("The perimeter is " + object.getPerimeter());
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.ArrayList;
import java.math.*;

public class LargestNumbers {
public static void main(String[] args) {
ArrayList<Number> list = new ArrayList<>();
list.add(45); // Add an integer
list.add(3445.53); // Add a double
// Add a BigInteger
list.add(new BigInteger("3432323234344343101"));
// Add a BigDecimal
list.add(new BigDecimal("2.0909090989091343433344343"));

System.out.println("The largest number is " +
getLargestNumber(list));
}

public static Number getLargestNumber(ArrayList<Number> list) {
if (list == null || list.size() == 0)
return null;

Number number = list.get(0);
for (int i = 1; i < list.size(); i++)
if (number.doubleValue() < list.get(i).doubleValue())
number = list.get(i);

return number;
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.*;

public class TestCalendar {
public static void main(String[] args) {
// Construct a Gregorian calendar for the current date and time
Calendar calendar = new GregorianCalendar();
System.out.println("Current time is " + new Date());
System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
System.out.println("DATE: " + calendar.get(Calendar.DATE));
System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
System.out.println("HOUR_OF_DAY: " +
calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
System.out.println("DAY_OF_WEEK: " +
calendar.get(Calendar.DAY_OF_WEEK));
System.out.println("DAY_OF_MONTH: " +
calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("DAY_OF_YEAR: " +
calendar.get(Calendar.DAY_OF_YEAR));
System.out.println("WEEK_OF_MONTH: " +
calendar.get(Calendar.WEEK_OF_MONTH));
System.out.println("WEEK_OF_YEAR: " +
calendar.get(Calendar.WEEK_OF_YEAR));
System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));

// Construct a calendar for September 11, 2001
Calendar calendar1 = new GregorianCalendar(2001, 8, 11);
String[] dayNameOfWeek = {"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"};
System.out.println("September 11, 2001 is a " +
dayNameOfWeek[calendar1.get(Calendar.DAY_OF_WEEK) - 1]);
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestEdible {
public static void main(String[] args) {
Object[] objects = {new Tiger(), new Chicken(), new Apple()};
for (int i = 0; i < objects.length; i++) {
if (objects[i] instanceof Edible)
System.out.println(((Edible)objects[i]).howToEat());

if (objects[i] instanceof Animal) {
System.out.println(((Animal)objects[i]).sound());
}
}
}
}

abstract class Animal {
/** Return animal sound */
public abstract String sound();
}

class Chicken extends Animal implements Edible {
@Override
public String howToEat() {
return "Chicken: Fry it";
}

@Override
public String sound() {
return "Chicken: cock-a-doodle-doo";
}
}

class Tiger extends Animal {
@Override
public String sound() {
return "Tiger: RROOAARR";
}
}

abstract class Fruit implements Edible {
// Data fields, constructors, and methods omitted here
}

class Apple extends Fruit {
@Override
public String howToEat() {
return "Apple: Make apple cider";
}
}

class Orange extends Fruit {
@Override
public String howToEat() {
return "Orange: Make orange juice";
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.math.*;

public class SortComparableObjects {
public static void main(String[] args) {
String[] cities = {"Savannah", "Boston", "Atlanta", "Tampa"};
java.util.Arrays.sort(cities);
for (String city: cities)
System.out.print(city + " ");
System.out.println();

BigInteger[] hugeNumbers = {new BigInteger("2323231092923992"),
new BigInteger("432232323239292"),
new BigInteger("54623239292")};
java.util.Arrays.sort(hugeNumbers);
for (BigInteger number: hugeNumbers)
System.out.print(number + " ");
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class ComparableRectangle extends Rectangle
implements Comparable<ComparableRectangle> {
/** Construct a ComparableRectangle with specified properties */
public ComparableRectangle(double width, double height) {
super(width, height);
}

@Override // Implement the compareTo method defined in Comparable
public int compareTo(ComparableRectangle o) {
if (getArea() > o.getArea())
return 1;
else if (getArea() < o.getArea())
return -1;
else
return 0;
}

@Override // Implement the toString method in GeometricObject
public String toString() {
return "Width: " + getWidth() + " Height: " + getHeight() +
" Area: " + getArea();
}
}

//----------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class SortRectangles {
public static void main(String[] args) {
ComparableRectangle[] rectangles = {
new ComparableRectangle(3.4, 5.4),
new ComparableRectangle(13.24, 55.4),
new ComparableRectangle(7.4, 35.4),
new ComparableRectangle(1.4, 25.4)};
java.util.Arrays.sort(rectangles);
for (Rectangle rectangle: rectangles) {
System.out.print(rectangle + " ");
System.out.println();
}
}
}

//---------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class House implements Cloneable, Comparable<House> {
private int id;
private double area;
private java.util.Date whenBuilt;

public House(int id, double area) {
this.id = id;
this.area = area;
whenBuilt = new java.util.Date();
}

public int getId() {
return id;
}

public double getArea() {
return area;
}

public java.util.Date getWhenBuilt() {
return whenBuilt;
}

@Override /** Override the protected clone method defined in
the Object class, and strengthen its accessibility */
public Object clone() {
try {
return super.clone();
}
catch (CloneNotSupportedException ex) {
return null;
}
}

@Override // Implement the compareTo method defined in Comparable
public int compareTo(House o) {
if (area > o.area)
return 1;
else if (area < o.area)
return -1;
else
return 0;
}
}

//-----------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestRationalClass {
/** Main method */
public static void main(String[] args) {
// Create and initialize two rational numbers r1 and r2.
Rational r1 = new Rational(4, 2);
Rational r2 = new Rational(2, 3);

// Display results
System.out.println(r1 + " + " + r2 + " = " + r1.add(r2));
System.out.println(r1 + " - " + r2 + " = " + r1.subtract(r2));
System.out.println(r1 + " * " + r2 + " = " + r1.multiply(r2));
System.out.println(r1 + " / " + r2 + " = " + r1.divide(r2));
System.out.println(r2 + " is " + r2.doubleValue());
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class Rational extends Number implements Comparable<Rational> {
// Data fields for numerator and denominator
private long numerator = 0;
private long denominator = 1;

/** Construct a rational with default properties */
public Rational() {
this(0, 1);
}

/** Construct a rational with specified numerator and denominator */
public Rational(long numerator, long denominator) {
long gcd = gcd(numerator, denominator);
this.numerator = ((denominator > 0) ? 1 : -1) * numerator / gcd;
this.denominator = Math.abs(denominator) / gcd;
}

/** Find GCD of two numbers */
private static long gcd(long n, long d) {
long n1 = Math.abs(n);
long n2 = Math.abs(d);
int gcd = 1;

for (int k = 1; k <= n1 && k <= n2; k++) {
if (n1 % k == 0 && n2 % k == 0)
gcd = k;
}

return gcd;
}

/** Return numerator */
public long getNumerator() {
return numerator;
}

/** Return denominator */
public long getDenominator() {
return denominator;
}

/** Add a rational number to this rational */
public Rational add(Rational secondRational) {
long n = numerator * secondRational.getDenominator() +
denominator * secondRational.getNumerator();
long d = denominator * secondRational.getDenominator();
return new Rational(n, d);
}

/** Subtract a rational number from this rational */
public Rational subtract(Rational secondRational) {
long n = numerator * secondRational.getDenominator()
- denominator * secondRational.getNumerator();
long d = denominator * secondRational.getDenominator();
return new Rational(n, d);
}

/** Multiply a rational number to this rational */
public Rational multiply(Rational secondRational) {
long n = numerator * secondRational.getNumerator();
long d = denominator * secondRational.getDenominator();
return new Rational(n, d);
}

/** Divide a rational number from this rational */
public Rational divide(Rational secondRational) {
long n = numerator * secondRational.getDenominator();
long d = denominator * secondRational.numerator;
return new Rational(n, d);
}

@Override
public String toString() {
if (denominator == 1)
return numerator + "";
else
return numerator + "/" + denominator;
}

@Override // Override the equals method in the Object class
public boolean equals(Object other) {
if ((this.subtract((Rational)(other))).getNumerator() == 0)
return true;
else
return false;
}

@Override // Implement the abstract intValue method in Number
public int intValue() {
return (int)doubleValue();
}

@Override // Implement the abstract floatValue method in Number
public float floatValue() {
return (float)doubleValue();
}

@Override // Implement the doubleValue method in Number
public double doubleValue() {
return numerator * 1.0 / denominator;
}

@Override // Implement the abstract longValue method in Number
public long longValue() {
return (long)doubleValue();
}

@Override // Implement the compareTo method in Comparable
public int compareTo(Rational o) {
if (this.subtract(o).getNumerator() > 0)
return 1;
else if (this.subtract(o).getNumerator() < 0)
return -1;
else
return 0;
}
}

//--------------

Example 12

Chapter 12

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class Quotient {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);

// Prompt the user to enter two integers
System.out.print("Enter two integers: ");
int number1 = input.nextInt();
int number2 = input.nextInt();

System.out.println(number1 + " / " + number2 + " is " +
(number1 / number2));
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class QuotientWithIf {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);

// Prompt the user to enter two integers
System.out.print("Enter two integers: ");
int number1 = input.nextInt();
int number2 = input.nextInt();

if (number2 != 0)
System.out.println(number1 + " / " + number2 + " is " +
(number1 / number2));
else
System.out.println("Divisor cannot be zero ");
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class QuotientWithMethod {
public static int quotient(int number1, int number2) {
if (number2 == 0) {
System.out.println("Divisor cannot be zero");
System.exit(1);
}

return number1 / number2;
}

public static void main(String[] args) {
Scanner input = new Scanner(System.in);

// Prompt the user to enter two integers
System.out.print("Enter two integers: ");
int number1 = input.nextInt();
int number2 = input.nextInt();

int result = quotient(number1, number2);
System.out.println(number1 + " / " + number2 + " is "
+ result);
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class QuotientWithException {
public static int quotient(int number1, int number2) {
if (number2 == 0)
throw new ArithmeticException("Divisor cannot be zero");

return number1 / number2;
}

public static void main(String[] args) {
Scanner input = new Scanner(System.in);

// Prompt the user to enter two integers
System.out.print("Enter two integers: ");
int number1 = input.nextInt();
int number2 = input.nextInt();

try {
int result = quotient(number1, number2);
System.out.println(number1 + " / " + number2 + " is "
+ result);
}
catch (ArithmeticException ex) {
System.out.println("Exception: an integer " +
"cannot be divided by zero ");
}

System.out.println("Execution continues ...");
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.*;

public class InputMismatchExceptionDemo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
boolean continueInput = true;

do {
try {
System.out.print("Enter an integer: ");
int number = input.nextInt();

// Display the result
System.out.println(
"The number entered is " + number);

continueInput = false;
}
catch (InputMismatchException ex) {
System.out.println("Try again. (" +
"Incorrect input: an integer is required)");
input.nextLine(); // discard input
}
} while (continueInput);
}
}

//----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestException {
public static void main(String[] args) {
try {
System.out.println(sum(new int[] {1, 2, 3, 4, 5}));
}
catch (Exception ex) {
ex.printStackTrace();
System.out.println("\n" + ex.getMessage());
System.out.println("\n" + ex.toString());

System.out.println("\nTrace Info Obtained from getStackTrace");
StackTraceElement[] traceElements = ex.getStackTrace();
for (int i = 0; i < traceElements.length; i++) {
System.out.print("method " + traceElements[i].getMethodName());
System.out.print("(" + traceElements[i].getClassName() + ":");
System.out.println(traceElements[i].getLineNumber() + ")");
}
}
}

private static int sum(int[] list) {
int result = 0;
for (int i = 0; i <= list.length; i++)
result += list[i];
return result;
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class CircleWithException {
/** The radius of the circle */
private double radius;

/** The number of the objects created */
private static int numberOfObjects = 0;

/** Construct a circle with radius 1 */
public CircleWithException() {
this(1.0);
}

/** Construct a circle with a specified radius */
public CircleWithException(double newRadius) {
setRadius(newRadius);
numberOfObjects++;
}

/** Return radius */
public double getRadius() {
return radius;
}

/** Set a new radius */
public void setRadius(double newRadius)
throws IllegalArgumentException {
if (newRadius >= 0)
radius = newRadius;
else
throw new IllegalArgumentException(
"Radius cannot be negative");
}

/** Return numberOfObjects */
public static int getNumberOfObjects() {
return numberOfObjects;
}

/** Return the area of this circle */
public double findArea() {
return radius * radius * 3.14159;
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestCircleWithException {
public static void main(String[] args) {
try {
CircleWithException c1 = new CircleWithException(5);
CircleWithException c2 = new CircleWithException(-5);
CircleWithException c3 = new CircleWithException(0);
}
catch (IllegalArgumentException ex) {
System.out.println(ex);
}

System.out.println("Number of objects created: " +
CircleWithException.getNumberOfObjects());
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class ChainedExceptionDemo {
public static void main(String[] args) {
try {
method1();
}
catch (Exception ex) {
ex.printStackTrace();
}
}

public static void method1() throws Exception {
try {
method2();
}
catch (Exception ex) {
throw new Exception("New info from method1", ex);
}
}

public static void method2() throws Exception {
throw new Exception("New info from method2");
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class InvalidRadiusException extends Exception {
private double radius;

/** Construct an exception */
public InvalidRadiusException(double radius) {
super("Invalid radius " + radius);
this.radius = radius;
}

/** Return the radius */
public double getRadius() {
return radius;
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestCircleWithCustomException {
public static void main(String[] args) {
try {
new CircleWithCustomException(5);
new CircleWithCustomException(-5);
new CircleWithCustomException(0);
}
catch (InvalidRadiusException ex) {
System.out.println(ex);
}

System.out.println("Number of objects created: " +
CircleWithCustomException.getNumberOfObjects());
}
}

class CircleWithCustomException {
/** The radius of the circle */
private double radius;

/** The number of the objects created */
private static int numberOfObjects = 0;

/** Construct a circle with radius 1 */
public CircleWithCustomException() throws InvalidRadiusException {
this(1.0);
}

/** Construct a circle with a specified radius */
public CircleWithCustomException(double newRadius)
throws InvalidRadiusException {
setRadius(newRadius);
numberOfObjects++;
}

/** Return radius */
public double getRadius() {
return radius;
}

/** Set a new radius */
public void setRadius(double newRadius)
throws InvalidRadiusException {
if (newRadius >= 0)
radius = newRadius;
else
throw new InvalidRadiusException(newRadius);
}

/** Return numberOfObjects */
public static int getNumberOfObjects() {
return numberOfObjects;
}

/** Return the area of this circle */
public double findArea() {
return radius * radius * 3.14159;
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestFileClass {
public static void main(String[] args) {
java.io.File file = new java.io.File("image/us.gif");
System.out.println("Does it exist? " + file.exists());
System.out.println("The file has " + file.length() + " bytes");
System.out.println("Can it be read? " + file.canRead());
System.out.println("Can it be written? " + file.canWrite());
System.out.println("Is it a directory? " + file.isDirectory());
System.out.println("Is it a file? " + file.isFile());
System.out.println("Is it absolute? " + file.isAbsolute());
System.out.println("Is it hidden? " + file.isHidden());
System.out.println("Absolute path is " +
file.getAbsolutePath());
System.out.println("Last modified on " +
new java.util.Date(file.lastModified()));
}
}

//----------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class WriteData {
public static void main(String[] args) throws Exception {
java.io.File file = new java.io.File("scores.txt");
if (file.exists()) {
System.out.println("File already exists");
System.exit(0);
}

// Create a file
java.io.PrintWriter output = new java.io.PrintWriter(file);

// Write formatted output to the file
output.print("John T Smith ");
output.println(90);
output.print("Eric K Jones ");
output.println(85);

// Close the file
output.close();
}
}

//---------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class WriteDataWithAutoClose {
public static void main(String[] args) throws Exception {
java.io.File file = new java.io.File("scores.txt");
if (file.exists()) {
System.out.println("File already exists");
System.exit(0);
}

try (
// Create a file
java.io.PrintWriter output = new java.io.PrintWriter(file);
) {
// Write formatted output to the file
output.print("John T Smith ");
output.println(90);
output.print("Eric K Jones ");
output.println(85);
}
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class ReadData {
public static void main(String[] args) throws Exception {
// Create a File instance
java.io.File file = new java.io.File("scores.txt");

// Create a Scanner for the file
Scanner input = new Scanner(file);

// Read data from a file
while (input.hasNext()) {
String firstName = input.next();
String mi = input.next();
String lastName = input.next();
int score = input.nextInt();
System.out.println(
firstName + " " + mi + " " + lastName + " " + score);
}

// Close the file
input.close();
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;
import java.util.*;

public class ReplaceText {
public static void main(String[] args) throws Exception {
// Check command line parameter usage
if (args.length != 4) {
System.out.println(
"Usage: java ReplaceText sourceFile targetFile oldStr newStr");
System.exit(1);
}

// Check if source file exists
File sourceFile = new File(args[0]);
if (!sourceFile.exists()) {
System.out.println("Source file " + args[0] + " does not exist");
System.exit(2);
}

// Check if target file exists
File targetFile = new File(args[1]);
if (targetFile.exists()) {
System.out.println("Target file " + args[1] + " already exists");
System.exit(3);
}

try (
// Create input and output files
Scanner input = new Scanner(sourceFile);
PrintWriter output = new PrintWriter(targetFile);
) {
while (input.hasNext()) {
String s1 = input.nextLine();
String s2 = s1.replaceAll(args[2], args[3]);
output.println(s2);
}
}
}
}

//-----------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class ReadFileFromURL {
public static void main(String[] args) {
System.out.print("Enter a URL: ");
String URLString = new Scanner(System.in).next();

try {
java.net.URL url = new java.net.URL(URLString);
int count = 0;
Scanner input = new Scanner(url.openStream());
while (input.hasNext()) {
String line = input.nextLine();
count += line.length();
}

System.out.println("The file size is " + count + " characters");
}
catch (java.net.MalformedURLException ex) {
System.out.println("Invalid URL");
}
catch (java.io.IOException ex) {
System.out.println("IO Errors");
}
}
}

//---------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;
import java.util.ArrayList;

public class WebCrawler {
public static void main(String[] args) {
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("Enter a URL: ");
String url = input.nextLine();
crawler(url); // Traverse the Web from the a starting url
}

public static void crawler(String startingURL) {
ArrayList<String> listOfPendingURLs = new ArrayList<>();
ArrayList<String> listOfTraversedURLs = new ArrayList<>();

listOfPendingURLs.add(startingURL);
while (!listOfPendingURLs.isEmpty() &&
listOfTraversedURLs.size() <= 100) {
String urlString = listOfPendingURLs.remove(0);
if (!listOfTraversedURLs.contains(urlString)) {
listOfTraversedURLs.add(urlString);
System.out.println("Craw " + urlString);

for (String s: getSubURLs(urlString)) {
if (!listOfTraversedURLs.contains(s))
listOfPendingURLs.add(s);
}
}
}
}

public static ArrayList<String> getSubURLs(String urlString) {
ArrayList<String> list = new ArrayList<>();

try {
java.net.URL url = new java.net.URL(urlString);
Scanner input = new Scanner(url.openStream());
int current = 0;
while (input.hasNext()) {
String line = input.nextLine();
current = line.indexOf("http:", current);
while (current > 0) {
int endIndex = line.indexOf("\"", current);
if (endIndex > 0) { // Ensure that a correct URL is found
list.add(line.substring(current, endIndex));
current = line.indexOf("http:", endIndex);
}
else
current = -1;
}
}
}
catch (Exception ex) {
System.out.println("Error: " + ex.getMessage());
}

return list;
}
}

//-------------

Example 11

Chapter 11

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class SimpleGeometricObject {
private String color = "white";
private boolean filled;
private java.util.Date dateCreated;

/** Construct a default geometric object */
public SimpleGeometricObject() {
dateCreated = new java.util.Date();
}

/** Construct a geometric object with the specified color
* and filled value */
public SimpleGeometricObject(String color, boolean filled) {
dateCreated = new java.util.Date();
this.color = color;
this.filled = filled;
}

/** Return color */
public String getColor() {
return color;
}

/** Set a new color */
public void setColor(String color) {
this.color = color;
}

/** Return filled. Since filled is boolean,
its get method is named isFilled */
public boolean isFilled() {
return filled;
}

/** Set a new filled */
public void setFilled(boolean filled) {
this.filled = filled;
}

/** Get dateCreated */
public java.util.Date getDateCreated() {
return dateCreated;
}

/** Return a string representation of this object */
public String toString() {
return "created on " + dateCreated + "\ncolor: " + color +
" and filled: " + filled;
}
}

//----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class CircleFromSimpleGeometricObject
extends SimpleGeometricObject {
private double radius;

public CircleFromSimpleGeometricObject() {
}

public CircleFromSimpleGeometricObject(double radius) {
this.radius = radius;
}

public CircleFromSimpleGeometricObject(double radius,
String color, boolean filled) {
this.radius = radius;
setColor(color);
setFilled(filled);
}

/** Return radius */
public double getRadius() {
return radius;
}

/** Set a new radius */
public void setRadius(double radius) {
this.radius = radius;
}

/** Return area */
public double getArea() {
return radius * radius * Math.PI;
}

/** Return diameter */
public double getDiameter() {
return 2 * radius;
}

/** Return perimeter */
public double getPerimeter() {
return 2 * radius * Math.PI;
}

/* Print the circle info */
public void printCircle() {
System.out.println("The circle is created " + getDateCreated() +
" and the radius is " + radius);
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class RectangleFromSimpleGeometricObject
extends SimpleGeometricObject {
private double width;
private double height;

public RectangleFromSimpleGeometricObject() {
}

public RectangleFromSimpleGeometricObject(
double width, double height) {
this.width = width;
this.height = height;
}

public RectangleFromSimpleGeometricObject(
double width, double height, String color, boolean filled) {
this.width = width;
this.height = height;
setColor(color);
setFilled(filled);
}

/** Return width */
public double getWidth() {
return width;
}

/** Set a new width */
public void setWidth(double width) {
this.width = width;
}

/** Return height */
public double getHeight() {
return height;
}

/** Set a new height */
public void setHeight(double height) {
this.height = height;
}

/** Return area */
public double getArea() {
return width * height;
}

/** Return perimeter */
public double getPerimeter() {
return 2 * (width + height);
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestCircleRectangle {
public static void main(String[] args) {
CircleFromSimpleGeometricObject circle =
new CircleFromSimpleGeometricObject(1);
System.out.println("A circle " + circle.toString());
System.out.println("The color is " + circle.getColor());
System.out.println("The radius is " + circle.getRadius());
System.out.println("The area is " + circle.getArea());
System.out.println("The diameter is " + circle.getDiameter());

RectangleFromSimpleGeometricObject rectangle =
new RectangleFromSimpleGeometricObject(2, 4);
System.out.println("\nA rectangle " + rectangle.toString());
System.out.println("The area is " + rectangle.getArea());
System.out.println("The perimeter is " +
rectangle.getPerimeter());
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class PolymorphismDemo {
/** Main method */
public static void main(String[] args) {
// Display circle and rectangle properties
displayObject(new CircleFromSimpleGeometricObject
(1, "red", false));
displayObject(new RectangleFromSimpleGeometricObject
(1, 1, "black", true));
}

/** Display geometric object properties */
public static void displayObject(SimpleGeometricObject object) {
System.out.println("Created on " + object.getDateCreated() +
". Color is " + object.getColor());
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class DynamicBindingDemo {
public static void main(String[] args) {
m(new GraduateStudent());
m(new Student());
m(new Person());
m(new Object());
}

public static void m(Object x) {
System.out.println(x.toString());
}
}

class GraduateStudent extends Student {
}

class Student extends Person {
@Override
public String toString() {
return "Student";
}
}

class Person extends Object {
@Override
public String toString() {
return "Person";
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class CastingDemo {
/** Main method */
public static void main(String[] args) {
// Create and initialize two objects
Object object1 = new CircleFromSimpleGeometricObject(1);
Object object2 = new RectangleFromSimpleGeometricObject(1, 1);

// Display circle and rectangle
displayObject(object1);
displayObject(object2);
}

/** A method for displaying an object */
public static void displayObject(Object object) {
if (object instanceof CircleFromSimpleGeometricObject) {
System.out.println("The circle area is " +
((CircleFromSimpleGeometricObject)object).getArea());
System.out.println("The circle diameter is " +
((CircleFromSimpleGeometricObject)object).getDiameter());
}
else if (object instanceof
RectangleFromSimpleGeometricObject) {
System.out.println("The rectangle area is " +
((RectangleFromSimpleGeometricObject)object).getArea());
}
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.ArrayList;

public class TestArrayList {
public static void main(String[] args) {
// Create a list to store cities
ArrayList<String> cityList = new ArrayList<>();

// Add some cities in the list
cityList.add("London");
// cityList now contains [London]
cityList.add("Denver");
// cityList now contains [London, Denver]
cityList.add("Paris");
// cityList now contains [London, Denver, Paris]
cityList.add("Miami");
// cityList now contains [London, Denver, Paris, Miami]
cityList.add("Seoul");
// contains [London, Denver, Paris, Miami, Seoul]
cityList.add("Tokyo");
// contains [London, Denver, Paris, Miami, Seoul, Tokyo]

System.out.println("List size? " + cityList.size());
System.out.println("Is Miami in the list? " +
cityList.contains("Miami"));
System.out.println("The location of Denver in the list? "
+ cityList.indexOf("Denver"));
System.out.println("Is the list empty? " +
cityList.isEmpty()); // Print false

// Insert a new city at index 2
cityList.add(2, "Xian");
// contains [London, Denver, Xian, Paris, Miami, Seoul, Tokyo]

// Remove a city from the list
cityList.remove("Miami");
// contains [London, Denver, Xian, Paris, Seoul, Tokyo]

// Remove a city at index 1
cityList.remove(1);
// contains [London, Xian, Paris, Seoul, Tokyo]

// Display the contents in the list
System.out.println(cityList.toString());

// Display the contents in the list in reverse order
for (int i = cityList.size() - 1; i >= 0; i--)
System.out.print(cityList.get(i) + " ");
System.out.println();

// Create a list to store two circles
java.util.ArrayList<CircleFromSimpleGeometricObject> list
= new java.util.ArrayList<>();

// Add two circles
list.add(new CircleFromSimpleGeometricObject(2));
list.add(new CircleFromSimpleGeometricObject(3));

// Display the area of the first circle in the list
System.out.println("The area of the circle? " +
list.get(0).getArea());
}
}

//---------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.ArrayList;
import java.util.Scanner;

public class DistinctNumbers {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();

Scanner input = new Scanner(System.in);
System.out.print("Enter integers (input ends with 0): ");
int value;

do {
value = input.nextInt(); // Read a value from the input

if (!list.contains(value) && value != 0)
list.add(value); // Add the value if it is not in the list
} while (value != 0);

// Display the distinct numbers
for (int i = 0; i < list.size(); i++)
System.out.print(list.get(i) + " ");
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.ArrayList;

public class MyStack {
private ArrayList<Object> list = new ArrayList<>();

public boolean isEmpty() {
return list.isEmpty();
}

public int getSize() {
return list.size();
}

public Object peek() {
return list.get(getSize() - 1);
}

public Object pop() {
Object o = list.get(getSize() - 1);
list.remove(getSize() - 1);
return o;
}

public void push(Object o) {
list.add(o);
}

@Override /** Override the toString in the Object class */
public String toString() {
return "stack: " + list.toString();
}
}

//------------

Example 10

Chapter 10

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class TestLoanClass {
/** Main method */
public static void main(String[] args) {
// Create a Scanner
Scanner input = new Scanner(System.in);

// Enter yearly interest rate
System.out.print(
"Enter yearly interest rate, for example, 8.25: ");
double annualInterestRate = input.nextDouble();

// Enter number of years
System.out.print("Enter number of years as an integer: ");
int numberOfYears = input.nextInt();

// Enter loan amount
System.out.print("Enter loan amount, for example, 120000.95: ");
double loanAmount = input.nextDouble();

// Create Loan object
Loan loan =
new Loan(annualInterestRate, numberOfYears, loanAmount);

// Display loan date, monthly payment, and total payment
System.out.printf("The loan was created on %s\n" +
"The monthly payment is %.2f\nThe total payment is %.2f\n",
loan.getLoanDate().toString(), loan.getMonthlyPayment(),
loan.getTotalPayment());
}
}

//----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class Loan {
private double annualInterestRate;
private int numberOfYears;
private double loanAmount;
private java.util.Date loanDate;

/** Default constructor */
public Loan() {
this(2.5, 1, 1000);
}

/** Construct a loan with specified annual interest rate,
number of years, and loan amount
*/
public Loan(double annualInterestRate, int numberOfYears,
double loanAmount) {
this.annualInterestRate = annualInterestRate;
this.numberOfYears = numberOfYears;
this.loanAmount = loanAmount;
loanDate = new java.util.Date();
}

/** Return annualInterestRate */
public double getAnnualInterestRate() {
return annualInterestRate;
}

/** Set a new annualInterestRate */
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}

/** Return numberOfYears */
public int getNumberOfYears() {
return numberOfYears;
}

/** Set a new numberOfYears */
public void setNumberOfYears(int numberOfYears) {
this.numberOfYears = numberOfYears;
}

/** Return loanAmount */
public double getLoanAmount() {
return loanAmount;
}

/** Set a newloanAmount */
public void setLoanAmount(double loanAmount) {
this.loanAmount = loanAmount;
}

/** Find monthly payment */
public double getMonthlyPayment() {
double monthlyInterestRate = annualInterestRate / 1200;
double monthlyPayment = loanAmount * monthlyInterestRate / (1 -
(1 / Math.pow(1 + monthlyInterestRate, numberOfYears * 12)));
return monthlyPayment;
}

/** Find total payment */
public double getTotalPayment() {
double totalPayment = getMonthlyPayment() * numberOfYears * 12;
return totalPayment;
}

/** Return loan date */
public java.util.Date getLoanDate() {
return loanDate;
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class UseBMIClass {
public static void main(String[] args) {
BMI bmi1 = new BMI("John Doe", 18, 145, 70);
System.out.println("The BMI for " + bmi1.getName() + " is "
+ bmi1.getBMI() + " " + bmi1.getStatus());

BMI bmi2 = new BMI("Peter King", 215, 70);
System.out.println("The BMI for " + bmi2.getName() + " is "
+ bmi2.getBMI() + " " + bmi2.getStatus());
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class BMI {
private String name;
private int age;
private double weight; // in pounds
private double height; // in inches
public static final double KILOGRAMS_PER_POUND = 0.45359237;
public static final double METERS_PER_INCH = 0.0254;

public BMI(String name, int age, double weight, double height) {
this.name = name;
this.age = age;
this.weight = weight;
this.height = height;
}

public BMI(String name, double weight, double height) {
this(name, 20, weight, height);
}

public double getBMI() {
double bmi = weight * KILOGRAMS_PER_POUND /
((height * METERS_PER_INCH) * (height * METERS_PER_INCH));
return Math.round(bmi * 100) / 100.0;
}

public String getStatus() {
double bmi = getBMI();
if (bmi < 18.5)
return "Underweight";
else if (bmi < 25)
return "Normal";
else if (bmi < 30)
return "Overweight";
else
return "Obese";
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public double getWeight() {
return weight;
}

public double getHeight() {
return height;
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestCourse {
public static void main(String[] args) {
Course course1 = new Course("Data Structures");
Course course2 = new Course("Database Systems");

course1.addStudent("Peter Jones");
course1.addStudent("Brian Smith");
course1.addStudent("Anne Kennedy");

course2.addStudent("Peter Jones");
course2.addStudent("Steve Smith");

System.out.println("Number of students in course1: "
+ course1.getNumberOfStudents());
String[] students = course1.getStudents();
for (int i = 0; i < course1.getNumberOfStudents(); i++)
System.out.print(students[i] + ", ");

System.out.println();
System.out.print("Number of students in course2: "
+ course2.getNumberOfStudents());
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class Course {
private String courseName;
private String[] students = new String[100];
private int numberOfStudents;

public Course(String courseName) {
this.courseName = courseName;
}

public void addStudent(String student) {
students[numberOfStudents] = student;
numberOfStudents++;
}

public String[] getStudents() {
return students;
}

public int getNumberOfStudents() {
return numberOfStudents;
}

public String getCourseName() {
return courseName;
}

public void dropStudent(String student) {
// Left as an exercise in Exercise 10.9
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestStackOfIntegers {
public static void main(String[] args) {
StackOfIntegers stack = new StackOfIntegers();

for (int i = 0; i < 10; i++)
stack.push(i);

while (!stack.empty())
System.out.print(stack.pop() + " ");
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class StackOfIntegers {
private int[] elements;
private int size;
public static final int DEFAULT_CAPACITY = 16;

/** Construct a stack with the default capacity 16 */
public StackOfIntegers() {
this(DEFAULT_CAPACITY);
}

/** Construct a stack with the specified maximum capacity */
public StackOfIntegers(int capacity) {
elements = new int[capacity];
}

/** Push a new integer into the top of the stack */
public void push(int value) {
if (size >= elements.length) {
int[] temp = new int[elements.length * 2];
System.arraycopy(elements, 0, temp, 0, elements.length);
elements = temp;
}

elements[size++] = value;
}

/** Return and remove the top element from the stack */
public int pop() {
return elements[--size];
}

/** Return the top element from the stack */
public int peek() {
return elements[size - 1];
}

/** Test whether the stack is empty */
public boolean empty() {
return size == 0;
}

/** Return the number of elements in the stack */
public int getSize() {
return size;
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.math.*;

public class LargeFactorial {
public static void main(String[] args) {
System.out.println("50! is \n" + factorial(50));
}

public static BigInteger factorial(long n) {
BigInteger result = BigInteger.ONE;
for (int i = 1; i <= n; i++)
result = result.multiply(new BigInteger(i+""));

return result;
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class PalindromeIgnoreNonAlphanumeric {
/** Main method */
public static void main(String[] args) {
// Create a Scanner
Scanner input = new Scanner(System.in);

// Prompt the user to enter a string
System.out.print("Enter a string: ");
String s = input.nextLine();

// Display result
System.out.println("Ignoring non-alphanumeric characters, \nis "
+ s + " a palindrome? " + isPalindrome(s));
}

/** Return true if a string is a palindrome */
public static boolean isPalindrome(String s) {
// Create a new string by eliminating non-alphanumeric chars
String s1 = filter(s);

// Create a new string that is the reversal of s1
String s2 = reverse(s1);

// Compare if the reversal is the same as the original string
return s2.equals(s1);
}

/** Create a new string by eliminating non-alphanumeric chars */
public static String filter(String s) {
// Create a string builder
StringBuilder stringBuilder = new StringBuilder();

// Examine each char in the string to skip alphanumeric char
for (int i = 0; i < s.length(); i++) {
if (Character.isLetterOrDigit(s.charAt(i))) {
stringBuilder.append(s.charAt(i));
}
}

// Return a new filtered string
return stringBuilder.toString();
}

/** Create a new string by reversing a specified string */
public static String reverse(String s) {
StringBuilder stringBuilder = new StringBuilder(s);
stringBuilder.reverse(); // Invoke reverse in StringBuilder
return stringBuilder.toString();
}
}

//---------

Example 9

Chapter 9

//----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestSimpleCircle {
/** Main method */
public static void main(String[] args) {
// Create a circle with radius 1
SimpleCircle circle1 = new SimpleCircle();
System.out.println("The area of the circle of radius "
+ circle1.radius + " is " + circle1.getArea());

// Create a circle with radius 25
SimpleCircle circle2 = new SimpleCircle(25);
System.out.println("The area of the circle of radius "
+ circle2.radius + " is " + circle2.getArea());

// Create a circle with radius 125
SimpleCircle circle3 = new SimpleCircle(125);
System.out.println("The area of the circle of radius "
+ circle3.radius + " is " + circle3.getArea());

// Modify circle radius
circle2.radius = 100; // or circle2.setRadius(100)
System.out.println("The area of the circle of radius "
+ circle2.radius + " is " + circle2.getArea());
}
}

// Define the circle class with two constructors
class SimpleCircle {
double radius;

/** Construct a circle with radius 1 */
SimpleCircle() {
radius = 1;
}

/** Construct a circle with a specified radius */
SimpleCircle(double newRadius) {
radius = newRadius;
}

/** Return the area of this circle */
double getArea() {
return radius * radius * Math.PI;
}

/** Return the perimeter of this circle */
double getPerimeter() {
return 2 * radius * Math.PI;
}

/** Set a new radius for this circle */
void setRadius(double newRadius) {
radius = newRadius;
}
}

//---------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class SimpleCircle {
/** Main method */
public static void main(String[] args) {
// Create a circle with radius 1
SimpleCircle circle1 = new SimpleCircle();
System.out.println("The area of the circle of radius "
+ circle1.radius + " is " + circle1.getArea());

// Create a circle with radius 25
SimpleCircle circle2 = new SimpleCircle(25);
System.out.println("The area of the circle of radius "
+ circle2.radius + " is " + circle2.getArea());

// Create a circle with radius 125
SimpleCircle circle3 = new SimpleCircle(125);
System.out.println("The area of the circle of radius "
+ circle3.radius + " is " + circle3.getArea());

// Modify circle radius
circle2.radius = 100;
System.out.println("The area of the circle of radius "
+ circle2.radius + " is " + circle2.getArea());
}

double radius;

/** Construct a circle with radius 1 */
SimpleCircle() {
radius = 1;
}

/** Construct a circle with a specified radius */
SimpleCircle(double newRadius) {
radius = newRadius;
}

/** Return the area of this circle */
double getArea() {
return radius * radius * Math.PI;
}

/** Return the perimeter of this circle */
double getPerimeter() {
return 2 * radius * Math.PI;
}

/** Set a new radius for this circle */
void setRadius(double newRadius) {
radius = newRadius;
}
}

//-----------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TV {
int channel = 1; // Default channel is 1
int volumeLevel = 1; // Default volume level is 1
boolean on = false; // By default TV is off

public TV() {
}

public void turnOn() {
on = true;
}

public void turnOff() {
on = false;
}

public void setChannel(int newChannel) {
if (on && newChannel >= 1 && newChannel <= 120)
channel = newChannel;
}

public void setVolume(int newVolumeLevel) {
if (on && newVolumeLevel >= 1 && newVolumeLevel <= 7)
volumeLevel = newVolumeLevel;
}

public void channelUp() {
if (on && channel < 120)
channel++;
}

public void channelDown() {
if (on && channel > 1)
channel--;
}

public void volumeUp() {
if (on && volumeLevel < 7)
volumeLevel++;
}

public void volumeDown() {
if (on && volumeLevel > 1)
volumeLevel--;
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestTV {
public static void main(String[] args) {
TV tv1 = new TV();
tv1.turnOn();
tv1.setChannel(30);
tv1.setVolume(3);

TV tv2 = new TV();
tv2.turnOn();
tv2.channelUp();
tv2.channelUp();
tv2.volumeUp();

System.out.println("tv1's channel is " + tv1.channel
+ " and volume level is " + tv1.volumeLevel);
System.out.println("tv2's channel is " + tv2.channel
+ " and volume level is " + tv2.volumeLevel);
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;
import javafx.geometry.Point2D;

public class TestPoint2D {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);

System.out.print("Enter point1's x-, y-coordinates: ");
double x1 = input.nextDouble();
double y1 = input.nextDouble();
System.out.print("Enter point2's x-, y-coordinates: ");
double x2 = input.nextDouble();
double y2 = input.nextDouble();

Point2D p1 = new Point2D(x1, y1);
Point2D p2 = new Point2D(x2, y2);
System.out.println("p1 is " + p1.toString());
System.out.println("p2 is " + p2.toString());
System.out.println("The distance between p1 and p2 is " +
p1.distance(p2));
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class CircleWithStaticMembers {
/** The radius of the circle */
double radius;

/** The number of the objects created */
static int numberOfObjects = 0;

/** Construct a circle with radius 1 */
CircleWithStaticMembers() {
radius = 1.0;
numberOfObjects++;
}

/** Construct a circle with a specified radius */
CircleWithStaticMembers(double newRadius) {
radius = newRadius;
numberOfObjects++;
}

/** Return numberOfObjects */
static int getNumberOfObjects() {
return numberOfObjects;
}

/** Return the area of this circle */
double getArea() {
return radius * radius * Math.PI;
}
}

//------------

public class TestCircleWithStaticDataFields {
/** Main method */
public static void main(String[] args) {
System.out.println("Before creating objects");
System.out.println("The number of Circle objects is " +
CircleWithStaticMembers.numberOfObjects);

// Create c1
CircleWithStaticMembers c1 = new CircleWithStaticMembers();

// Display c1 BEFORE c2 is created
System.out.println("\nAfter creating c1");
System.out.println("c1: radius (" + c1.radius +
") and number of Circle objects (" +
c1.numberOfObjects + ")");

// Create c2
CircleWithStaticMembers c2 = new CircleWithStaticMembers(5);

// Modify c1
c1.radius = 9;

// Display c1 and c2 AFTER c2 was created
System.out.println("\nAfter creating c2 and modifying c1");
System.out.println("c1: radius (" + c1.radius +
") and number of Circle objects (" +
c1.numberOfObjects + ")");
System.out.println("c2: radius (" + c2.radius +
") and number of Circle objects (" +
c2.numberOfObjects + ")");
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class CircleWithPrivateDataFields {
/** The radius of the circle */
private double radius = 1;

/** The number of the objects created */
private static int numberOfObjects = 0;

/** Construct a circle with radius 1 */
public CircleWithPrivateDataFields() {
numberOfObjects++;
}

/** Construct a circle with a specified radius */
public CircleWithPrivateDataFields(double newRadius) {
radius = newRadius;
numberOfObjects++;
}

/** Return radius */
public double getRadius() {
return radius;
}

/** Set a new radius */
public void setRadius(double newRadius) {
radius = (newRadius >= 0) ? newRadius : 0;
}

/** Return numberOfObjects */
public static int getNumberOfObjects() {
return numberOfObjects;
}

/** Return the area of this circle */
public double getArea() {
return radius * radius * Math.PI;
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestCircleWithPrivateDataFields {
/** Main method */
public static void main(String[] args) {
// Create a Circle with radius 5.0
CircleWithPrivateDataFields myCircle =
new CircleWithPrivateDataFields(5.0);
System.out.println("The area of the circle of radius "
+ myCircle.getRadius() + " is " + myCircle.getArea());

// Increase myCircle's radius by 10%
myCircle.setRadius(myCircle.getRadius() * 1.1);
System.out.println("The area of the circle of radius "
+ myCircle.getRadius() + " is " + myCircle.getArea());
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TestPassObject {
/** Main method */
public static void main(String[] args) {
// Create a Circle object with radius 1
CircleWithPrivateDataFields myCircle =
new CircleWithPrivateDataFields(1);

// Print areas for radius 1, 2, 3, 4, and 5.
int n = 5;
printAreas(myCircle, n);

// See myCircle.radius and times
System.out.println("\n" + "Radius is " + myCircle.getRadius());
System.out.println("n is " + n);
}

/** Print a table of areas for radius */
public static void printAreas(
CircleWithPrivateDataFields c, int times) {
System.out.println("Radius \t\tArea");
while (times >= 1) {
System.out.println(c.getRadius() + "\t\t" + c.getArea());
c.setRadius(c.getRadius() + 1);
times--;
}
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class TotalArea {
/** Main method */
public static void main(String[] args) {
// Declare circleArray
CircleWithPrivateDataFields[] circleArray;

// Create circleArray
circleArray = createCircleArray();

// Print circleArray and total areas of the circles
printCircleArray(circleArray);
}

/** Create an array of Circle objects */
public static CircleWithPrivateDataFields[] createCircleArray() {
CircleWithPrivateDataFields[] circleArray =
new CircleWithPrivateDataFields[5];

for (int i = 0; i < circleArray.length; i++) {
circleArray[i] =
new CircleWithPrivateDataFields(Math.random() * 100);
}

// Return Circle array
return circleArray;
}

/** Print an array of circles and their total area */
public static void printCircleArray(
CircleWithPrivateDataFields[] circleArray) {
System.out.printf("%-30s%-15s\n", "Radius", "Area");
for (int i = 0; i < circleArray.length; i++) {
System.out.printf("%-30f%-15f\n", circleArray[i].getRadius(),
circleArray[i].getArea());
}

System.out.println("-----------------------------------------");

// Compute and display the result
System.out.printf("%-30s%-15f\n", "The total areas of circles is",
sum(circleArray));
}

/** Add circle areas */
public static double sum(
CircleWithPrivateDataFields[] circleArray) {
// Initialize sum
double sum = 0;

// Add areas to sum
for (int i = 0; i < circleArray.length; i++)
sum += circleArray[i].getArea();

return sum;
}
}

//--------------

Example 8

Chapter 8

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class PassTwoDimensionalArray {
public static void main(String[] args) {
int[][] m = getArray(); // Get an array

// Display sum of elements
System.out.println("\nSum of all elements is " + sum(m));
}

public static int[][] getArray() {
// Create a Scanner
Scanner input = new Scanner(System.in);

// Enter array values
int[][] m = new int[3][4];
System.out.println("Enter " + m.length + " rows and "
+ m[0].length + " columns: ");
for (int i = 0; i < m.length; i++)
for (int j = 0; j < m[i].length; j++)
m[i][j] = input.nextInt();

return m;
}

public static int sum(int[][] m) {
int total = 0;
for (int row = 0; row < m.length; row++) {
for (int column = 0; column < m[row].length; column++) {
total += m[row][column];
}
}

return total;
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

public class GradeExam {
/** Main method */
public static void main(String args[]) {
// Students' answers to the questions
char[][] answers = {
{'A', 'B', 'A', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'D', 'B', 'A', 'B', 'C', 'A', 'E', 'E', 'A', 'D'},
{'E', 'D', 'D', 'A', 'C', 'B', 'E', 'E', 'A', 'D'},
{'C', 'B', 'A', 'E', 'D', 'C', 'E', 'E', 'A', 'D'},
{'A', 'B', 'D', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'B', 'B', 'E', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'B', 'B', 'A', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'E', 'B', 'E', 'C', 'C', 'D', 'E', 'E', 'A', 'D'}};

// Key to the questions
char[] keys = {'D', 'B', 'D', 'C', 'C', 'D', 'A', 'E', 'A', 'D'};

// Grade all answers
for (int i = 0; i < answers.length; i++) {
// Grade one student
int correctCount = 0;
for (int j = 0; j < answers[i].length; j++) {
if (answers[i][j] == keys[j])
correctCount++;
}

System.out.println("Student " + i + "'s correct count is " +
correctCount);
}
}
}

//--------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class FindNearestPoints {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter the number of points: ");
int numberOfPoints = input.nextInt();

// Create an array to store points
double[][] points = new double[numberOfPoints][2];
System.out.print("Enter " + numberOfPoints + " points: ");
for (int i = 0; i < points.length; i++) {
points[i][0] = input.nextDouble();
points[i][1] = input.nextDouble();
}

// p1 and p2 are the indices in the points array
int p1 = 0, p2 = 1; // Initial two points
double shortestDistance = distance(points[p1][0], points[p1][1],
points[p2][0], points[p2][1]); // Initialize shortestDistance

// Compute distance for every two points
for (int i = 0; i < points.length; i++) {
for (int j = i + 1; j < points.length; j++) {
double distance = distance(points[i][0], points[i][1],
points[j][0], points[j][1]); // Find distance

if (shortestDistance > distance) {
p1 = i; // Update p1
p2 = j; // Update p2
shortestDistance = distance; // Update shortestDistance
}
}
}

// Display result
System.out.println("The closest two points are " +
"(" + points[p1][0] + ", " + points[p1][1] + ") and (" +
points[p2][0] + ", " + points[p2][1] + ")");
}

/** Compute the distance between two points (x1, y1) and (x2, y2)*/
public static double distance(
double x1, double y1, double x2, double y2) {
return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class CheckSudokuSolution {
public static void main(String[] args) {
// Read a Sudoku solution
int[][] grid = readASolution();

System.out.println(isValid(grid) ? "Valid solution"
: "Invalid solution");
}

/** Read a Sudoku solution from the console */
public static int[][] readASolution() {
// Create a Scanner
Scanner input = new Scanner(System.in);

System.out.println("Enter a Sudoku puzzle solution:");
int[][] grid = new int[9][9];
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++)
grid[i][j] = input.nextInt();

return grid;
}

/** Check whether a solution is valid */
public static boolean isValid(int[][] grid) {
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++)
if (grid[i][j] < 1 || grid[i][j] > 9
|| !isValid(i, j, grid))
return false;
return true; // The solution is valid
}

/** Check whether grid[i][j] is valid in the grid */
public static boolean isValid(int i, int j, int[][] grid) {
// Check whether grid[i][j] is valid at the i's row
for (int column = 0; column < 9; column++)
if (column != j && grid[i][column] == grid[i][j])
return false;

// Check whether grid[i][j] is valid at the j's column
for (int row = 0; row < 9; row++)
if (row != i && grid[row][j] == grid[i][j])
return false;

// Check whether grid[i][j] is valid in the 3 by 3 box
for (int row = (i / 3) * 3; row < (i / 3) * 3 + 3; row++)
for (int col = (j / 3) * 3; col < (j / 3) * 3 + 3; col++)
if (row != i && col != j && grid[row][col] == grid[i][j])
return false;

return true; // The current value at grid[i][j] is valid
}
}

//------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class Weather {
public static void main(String[] args) {
final int NUMBER_OF_DAYS = 10;
final int NUMBER_OF_HOURS = 24;
double[][][] data
= new double[NUMBER_OF_DAYS][NUMBER_OF_HOURS][2];

Scanner input = new Scanner(System.in);
// Read input using input redirection from a file
for (int k = 0; k < NUMBER_OF_DAYS * NUMBER_OF_HOURS; k++) {
int day = input.nextInt();
int hour = input.nextInt();
double temperature = input.nextDouble();
double humidity = input.nextDouble();
data[day - 1][hour - 1][0] = temperature;
data[day - 1][hour - 1][1] = humidity;
}

// Find the average daily temperature and humidity
for (int i = 0; i < NUMBER_OF_DAYS; i++) {
double dailyTemperatureTotal = 0, dailyHumidityTotal = 0;
for (int j = 0; j < NUMBER_OF_HOURS; j++) {
dailyTemperatureTotal += data[i][j][0];
dailyHumidityTotal += data[i][j][1];
}

// Display result
System.out.println("Day " + i + "'s average temperature is "
+ dailyTemperatureTotal / NUMBER_OF_HOURS);
System.out.println("Day " + i + "'s average humidity is "
+ dailyHumidityTotal / NUMBER_OF_HOURS);
}
}
}

//-------------

Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.util.Scanner;

public class GuessBirthdayUsingArray {
public static void main(String[] args) {
int day = 0; // Day to be determined
int answer;

int[][][] dates = {
{{ 1, 3, 5, 7},
{ 9, 11, 13, 15},
{17, 19, 21, 23},
{25, 27, 29, 31}},
{{ 2, 3, 6, 7},
{10, 11, 14, 15},
{18, 19, 22, 23},
{26, 27, 30, 31}},
{{ 4, 5, 6, 7},
{12, 13, 14, 15},
{20, 21, 22, 23},
{28, 29, 30, 31}},
{{ 8, 9, 10, 11},
{12, 13, 14, 15},
{24, 25, 26, 27},
{28, 29, 30, 31}},
{{16, 17, 18, 19},
{20, 21, 22, 23},
{24, 25, 26, 27},
{28, 29, 30, 31}}};

// Create a Scanner
Scanner input = new Scanner(System.in);

for (int i = 0; i < 5; i++) {
System.out.println("Is your birth day in Set" + (i + 1) + "?");
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++)
System.out.printf("%4d", dates[i][j][k]);
System.out.println();
}

System.out.print("\nEnter 0 for No and 1 for Yes: ");
answer = input.nextInt();

if (answer == 1)
day += dates[i][0][0];
}

System.out.println("Your birth day is " + day);
}
}

//------------------

Menu