What does the following Java statement mean "A reference variable can be declared as a class type or an interface type. If the variable is declared as an interface type, it can reference any object of any class that implements the interface."?

This is a sample of polymorphism, and also the major reason for even having an interface. As sample: It allows you to "plug-in" a different implementation into your code using minimal changes. Say (e.g.) you're using an LinkedList, then later you decide you rather want to try a ArrayList (just to see if it's more performant in this case). So you have a variable defined as a http://docs.oracle.com/javase/7/docs/api/java/util/List.html type. This interface defines how all the methods should look from the outside - not how they're implemented. So in your code you can use all the goodies like add, get, remove, etc. Now when you first write your code you instantiate the contents of that variable with a new LinkedList(). Then later you change just that one line to use new ArrayList() instead. And voila, no further changes needed, since you know that both ArrayList and LinkedList implement all the methods defined in the List interface. If however you had your variable set as a LinkedList type, you might have use the addLast method. Now changing to an ArrayList means you'd need to search through all your code to find all those method calls to LindekList-specific methods and change them to the ArrayList specific ones. See how this can become a lot more complicated? Note, this is only an example. You could even have the option of choosing between Array/Linked at runtime if you use this. A simple if statement can instantiate either one depending on some "setting". so you can even get the user to choose what they want to use.

You can't create an instance of an interface directly.  You must create an instance of an object that implements the interface.  The purpose of interfaces is to simplify the multiple inheritance problem from other object-oriented programming languages like C++.  Think of an interface as a personality.  An object can have multiple personalities based on the interfaces it implements. An interface defines a set of programming contracts and behaviors we expect from a component but leaves out the details.  In other words, an interface describes what we want an object to do and leaves the how to the implementor. It's a form of abstraction.  We as the user of the object only care that is does the job it defines.  We aren't particularly concerned as to how it does that job.  Kind of like when you press the accelerator in a car.  All accelerators make a care speed up or slow down.  That's the interface.  The engine is the implementation.  You have many different types and styles of engine design and behavior but you don't care what's under the hood.  You only care the car speeds up or slows down. To answer question #1, you have create an instance of class that implements the Interface_Animals interface.  That is an Animals, Pets or Dog class.  Any of of these can be referenced as Interface_Animals. On #2, the animalanimal member variable has default scope.  It is not visible to classes outside of the Animal class.  You'd have to scope the variable as public (public Animal animalanimal) to make it visible outside of the class.  FYI, this is a bad practice. On #3, you can't call the pets() method on a reference type of Interface_Animals because the Interface_Animals interface does not declare the pets() method.  That is part of the Animal class.  Only references of the Animal type can call that method. This can be confusing because you can see all of the code and can't figure out why Interface_Animals and Animal can't share.  They are different types.  An Animal is a Interface_Animals but Interface_Animals is not an Animal. In development, especially in Java, much of what we do revolves around a simple concept: Program to interfaces, not implementations.  We focus on the abstract of what an object does, not how.  We defer that to "someone else".  Virtually all modern Java frameworks and components are developed around this concept. Feel free to ask if you want some other examples to help clarify.  This is a rather advanced concept that takes time to absorb.  Examples are best to learn from.