The Decision of the Synod of Dordt on the Five Main Points of Doctrine in Dispute in the Netherlands is popularly known as the Canons of Dordt. It consists of statements of doctrine adopted by the great Synod of Dordt which met in the city of Dordrecht in 1618-19. Although this was a national synod of the Reformed churches of the Netherlands, it had an international character, since it was composed not only of Dutch delegates but also of twenty-six delegates from eight foreign countries.

The Decision of the Synod of Dordt on the Five Main Points of Doctrine in Dispute in the Netherlands is popularly known as the Canons of Dordt. It consists of statements of doctrine adopted by the great Synod of Dordt which met in the city of Dordrecht in 1618-19. Although this was a national synod of the Reformed churches of the Netherlands, it had an international character, since it was composed not only of Dutch delegates but also of twenty-six delegates from eight foreign countries.

The original preface called them a "judgment, in which both the true view, agreeing with God's Word, concerning the aforesaid five points of doctrine is explained, and the false view, disagreeing with God's Word, is rejected." The Canons also have a limited character in that they do not cover the whole range of doctrine, but focus on the five points of doctrine in dispute.

Article 1: God's Right to Condemn All People

Since all people have sinned in Adam and have come under the sentence of the curse and eternal death, God would have done no one an injustice if it had been his will to leave the entire human race in sin and under the curse, and to condemn them on account of their sin. As the apostle says: The whole world is liable to the condemnation of God (Rom. 3:19), All have sinned and are deprived of the glory of God (Rom. 3:23), and The wages of sin is death (Rom. 6:23).*

Article 3: The Preaching of the Gospel

In order that people may be brought to faith, God mercifully sends proclaimers of this very joyful message to the people he wishes and at the time he wishes. By this ministry people are called to repentance and faith in Christ crucified. For how shall they believe in him of whom they have not heard? And how shall they hear without someone preaching? And how shall they preach unless they have been sent? (Rom. 10:14-15).

Article 5: The Sources of Unbelief and of Faith

The cause or blame for this unbelief, as well as for all other sins, is not at all in God, but in man. Faith in Jesus Christ, however, and salvation through him is a free gift of God. As Scripture says, It is by grace you have been saved, through faith, and this not from yourselves; it is a gift of God (Eph. 2:8). Likewise: It has been freely given to you to believe in Christ (Phil. 1:29).

Election [or choosing] is God's unchangeable purpose by which he did the following:

Before the foundation of the world, by sheer grace, according to the free good pleasure of his will, he chose in Christ to salvation a definite number of particular people out of the entire human race, which had fallen by its own fault from its original innocence into sin and ruin. Those chosen were neither better nor more deserving than the others, but lay with them in the common misery. He did this in Christ, whom he also appointed from eternity to be the mediator, the head of all those chosen, and the foundation of their salvation.

 ²⁵Therefore each of you must put off falsehood and speak truthfully to his neighbor, for we are all members of one body. ²⁶"In your anger do not sin"^[d]: Do not let the sun go down while you are still angry, ²⁷and do not give the devil a foothold. ²⁸He who has been stealing must steal no longer, but must work, doing something useful with his own hands, that he may have something to share with those in need.

 ²⁹Do not let any unwholesome talk come out of your mouths, but only what is helpful for building others up according to their needs, that it may benefit those who listen. ³⁰And do not grieve the Holy Spirit of God, with whom you were sealed for the day of redemption. ³¹Get rid of all bitterness, rage and anger, brawling and slander, along with every form of malice. ³²Be kind and compassionate to one another, forgiving each other, just as in Christ God forgave you.

A string can be built up from smaller pieces using the + operator,
but this is not very efficient. If str is a String and
ch is a character, then executing the command
"str = str + ch;" involves creating a whole new
string that is a copy of str, with the value of ch appended
onto the end. Copying the string takes some time. Building up a long string
letter by letter would require a surprising amount of processing. The class
StringBuffer makes it possible to be efficient about
building up a long string from a number of smaller pieces. To do this,
you must make an object belonging to the StringBuffer
class. For example:

StringBuffer buffer = new StringBuffer();

System.out.println( new Date() );

Of course, to use the Date class in this way, you must make it
available by importing it with one of the statements
"import java.util.Date;" or "import java.util.*;"
at the beginning of your program. (See Subsection 4.5.3
for a discussion of packages and import.)

If randGen is created
with the command:

Random randGen = new Random();

and if N is a positive integer, then randGen.nextInt(N)
generates a random integer in the range from 0 to N-1. For
example, this makes it a little easier to roll a pair of dice. Instead of
saying "die1 = (int)(6*Math.random())+1;", one can say
"die1 = randGen.nextInt(6)+1;". (S

You could say:

java.awt.Color  rectColor;

This is just an ordinary variable declaration of the form
"type-name variable-name;".
Of course, using the full name of every class can get tiresome, so Java makes it
possible to avoid using the full name of a class by importing
the class. If you put

import java.awt.Color;

at the beginning of a Java source code file, then, in the rest of the file,
you can abbreviate the full name java.awt.Color to just the simple name of
the class, Color.

There is a shortcut for importing all
the classes from a given package. You can import all the classes from
java.awt by saying

import java.awt.*;

The "*" is a wildcard that matches every class in the package.
(However, it does not match sub-packages; you cannot import the entire
contents of all the sub-packages of the java package by saying
import java.*.)

I often
use wildcards to import all the classes from the most relevant packages, and use
individual imports when I am using just one or two classes from a given package.

In fact, any Java program that uses a graphical user interface is likely to
use many classes from the java.awt and java.swing packages
as well as from another package named java.awt.event,
and I usually begin such programs with

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

For initialization of static member variables, of course, the situation
is quite different. There is only one copy of a static variable, and
initialization of that variable is executed just once, when the class is first
loaded.

The constructor is declared as "public PairOfDice(int val1, int
val2) ...", with no return type and with the same name as the name of the
class. This is how the Java compiler recognizes a constructor. The constructor
has two parameters, and values for these parameters must be provided when the
constructor is called. For example, the expression "new PairOfDice(3,4)"
would create a PairOfDice object in which the
values of the instance variables die1 and die2 are initially
3 and 4. Of course, in a program, the value returned by the constructor should
be used in some way, as in

PairOfDice dice;            // Declare a variable of type PairOfDice.

dice = new PairOfDice(1,1); // Let dice refer to a new PairOfDice
                            //   object that initially shows 1, 1.

Unlike other subroutines, a constructor can only be called using the
new operator, in an expression that has the form

new class-name ( parameter-list )

where the parameter-list is possibly empty.

A constructor call is more complicated than an ordinary subroutine or
function call. It is helpful to understand the exact steps that the computer
goes through to execute a constructor call:








1. First, the computer gets a block of unused memory in the heap, large enough
   to hold an object of the specified type.
2. It initializes the instance variables of the object. If the declaration of
   an instance variable specifies an initial value, then that value is computed
   and stored in the instance variable. Otherwise, the default initial value is
   used.
3. The actual parameters in the constructor, if any, are evaluated, and the
   values are assigned to the formal parameters of the constructor.
4. The statements in the body of the constructor, if any, are executed.
5. A reference to the object is returned as the value of the constructor
   call.

Objects of type
Student can be created with statements such as:

std = new Student("John Smith");
std1 = new Student("Mary Jones");

In the original version of this class, the value of name had to be
assigned by a program after it created the object of type Student.

For example, the following class could be used to store information
about the person who is using the program:

class UserData {
    static String name;
    static int age;
}

Now, consider a similar class that includes non-static
variables:

class PlayerData {
   String name;
   int age;
}

In this case, there is no such variable as PlayerData.name or
PlayerData.age, since name and age are not static
members of PlayerData. So, there is nothing much in the class at all -- except
the potential to create objects.

n a program, objects are created using an operator called new, which
creates an object and returns a reference to that object. For example, assuming
that std is a variable of type Student, declared as above,
the assignment statement

std = new Student();

It is possible for a variable like std, whose type is given by a
class, to refer to no object at all. We say in this case that std
holds a null reference. The null reference is
written in Java as "null". You can store a null reference in the
variable std by saying

std = null;

and you could test whether the value of std is null by testing

if (std == null) . . .

Suppose that a variable that refers to an object is declared to be
final. This means that the value stored in the variable can never be
changed, once the variable has been initialized. The value stored in the
variable is a reference to the object. So the variable will continue to refer
to the same object as long as the variable exists. However, this does not
prevent the data in the object from changing. The variable is
final, not the object. It's perfectly legal to say

final Student stu = new Student();

stu.name = "John Doe";  // Change data in the object;
                        // The value stored in stu is not changed!
                        // It still refers to the same object.

accessor method that returns the
value of the variable. For example, if your class contains a private
member variable, title, of type String, you
can provide a method

public String getTitle() {
    return title;
}

That is, you might want to make it possible for other classes to specify a new value
for the variable. This is done with a setter method. (If you don't
like simple, Anglo-Saxon words, you can use the fancier term mutator method.)
The name of a setter method should consist of "set" followed by a capitalized copy of
the variable's name, and it should have a parameter with the same type as the
variable. A setter method for the variable title could be written

public void setTitle( String newTitle ) {
   title = newTitle;
}