protected

if you declare a variable or method as protected, it is (kind of)just like declaring it as private except that the subclasses have access to them as if they were public. the "kind of" from above is that a protected member can also be accessed by the same compilation unit...

compilation unit

you can have multiple classes in one file. only one class can be public, and that is the one that the file is named after. the other classes are not public. this file is called a compilation unit. classes in the same compilation units have special access. protected variables are accessable by all classes in the same compilation unit. classes in the same compilation unit also have access to variables with undeclared access types...

undeclared access types

you can declare a variable without public, private, or protected. if you leave that off, then classes and methods in the same compilation unit have access to the variables. however, subclasses in a different compilation unit (a different file), do NOT have access.

Calling Other Constructors

The culmination of all of this is that you may want to use some constructors while you are using others. For example, in a subclass, you may want to call a superclass constructor which sets some variables. It is important to note that when you create a subclass object, the superclass constuctor is always called first. This creates all of the inherited variables that the subclass uses and then sets. The default constructor of the superclass is ALWAYS the one that's called. If you'd rather use a non-default constructor, you can do that like this: 
public class Round {
	protected int radius;
	protected double circ;
	protected const double pi = 3.1415926535;

	public Round () {
		radius = 1;
		circ = pi*2;
	}

	public Round(int inR) {
		radius = inR;
		circ = 2*pi*radius;
	}
}

public class Circle extends Round {
	private double Area;

	public Round(int inR) {
		super(inR);
		Area = pi*radius*radius;
	}
}
using super() calls the superclass constructor function with the same signature (that means it takes the same number of arguments with the same type as we called).

In the superclass constructors, though, we repeat some code. we can call other constructors in the same class in the same way as we do for super. in the round class, we would redefine it like this:

public class Round {
        protected int radius;
        protected double circ;
        protected const double pi = 3.1415926535;

        public Round () {
		this(1);
        }

        public Round(int inR) {
                radius = inR;
                circ = pi*2*radius;
        }
}
in this case, the default constructor calls our 1 argument constuctor with a default value passed as an argument. it uses the method this which calls a constructor in the same class with the appropriate signature.

super and this must always be the first line in a constructor. You can only have one in each constructor function (you can't have two calls to super, two calls to this, or one of each). That is because, aside from just setting variables, they also allocate memory for them and actually construct objects. Those objects can only be constructed once.