Object used parameter in a method

I'm a Java newbie so excuse me if this sounds like a dumb question.
Can someone explain to me what is going on with this method?

public static void policyInNoFaultState( AutoPolicy policy ) <===line in question

Is "policy" of object type from AutoPolicy? therefore policy inherits everything AoutoPolicy has?
Is this the reason I can use the "Dot" command exp. policy.getAccountNumber(), policy.getMakeAndModel()

I pasted part of the program I think applies to this question.

I appreciate any help you can give.

//Creating AutoPolicy ojbects
AutoPolicy policy1 = new AutoPolicy(11111111,"Toyota Camary", "NJ");
AutoPolicy policy2 = new AutoPolicy(22222222, "Ford Fusion", "ME");

//Creating policyInNoFaultState method to display results
  public static void policyInNoFaultState( AutoPolicy policy ){

            System.out.println("The auto policy:");
            System.out.printf("Account #: %d; Car: %s;%nState %s %s a no-fault state%n%n",
            policy.getAccountNumber(), policy.getMakeAndModel(),policy.getState(),(policy.isNoFaultState() ? "is": "is not"));

}//End of policyInNoFaultState

A class in Java defines a type and basically acts as template for all instances (objects) created from that class. This template defines data (fields) and behavior (methods) available for all of instances of this type. "Static" members of the type are shared between all instances and non-static members (also called "instance members") are distinct between instances.

Consider the following simple example (beware, this makes no promises about best practices how to define and use classes and instances):

class MyType {
  public static int Shared = 42;
  public int NonShared;

  public void Print() {
    System.out.println("This is me: " + (Shared + NonShared));
  }
}

You can create several instances of this class which will all share the same shared field but each have their own value for the instance field:

MyType a = new MyType();
MyType b = new MyType();

a.NonShared = 21;
b.NonShared = 84;

a.Print(); // prints "This is me: 63"
b.Print(); // prints "This is me: 126"

a.Shared = 0;

a.Print(); // now prints "This is me: 21"
b.Print(); // now prints "This is me: 84"

a and b are instances of class/type MyType. In a way, 42, 21, and 84 are instances of the type int.

When you define a method to act on values, you have to specify which kind of values the method should be able to handle. This is done by specifying the type for each of its parameters. Let's have a look at another arbitrary example method:

static String format(MyType object, String info) {
  return info + ".NonShared = " + object.NonShared;
}

Above method returns a single instance of type String and works one two parameters of type MyType and String respectively. This is required so that the compiler knows which members (fields or methods) are available for each parameter. Otherwise calling object.NonShared would not be possible.

MyType c = new MyType();
c.NonShared = 7;
String formatted = format(c, "formatting");
System.out.println(formatted); // prints "formatting.NonShared = 7"

Note that in this simple case, the type of variable c matches the type of the parameter object exactly. This is not required, you can pass any subtype (or "child class") to the parameter. The parameter's type merely defines the minimum number of members that must be supported by any argument that is passed to the function. You can think of it as a contract between the input parameter and the processing function.

static Integer firstValue(Collection<Integer> list) {
  list.get(0);
}

List<Integers> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);

firstValue(numbers);

The above code will not work. It will not even compile! Even though numbers is an instance of the interface type List with concrete implementation type ArrayList and has an instance-method get, this is not available (nor known) inside the method, which can only work with Collection types. The Collection type does not define an get method, despite implementations of it (sub types, child classes) might provide it.

By using the smallest possible type for any given task, you gain a lot of flexibility. All collections implement the add method. By defining a method which can work with Collection, you can pass in any implementation which adheres to this type and modify it:

static void addValue(Collection<Integer> bag) {
  bag.add(4);
}

List<Integer> list = new ArrayList<>();
Set<Integer> set = new HashSet<>();
Deque<Integer> stack = new ArrayDeque<>();
Queue<Integer> queue = new PriorityQueue<>();

addValue(list);
addValue(set);
addValue(stack);
addValue(queue);

I hope this clears things up! If there is any detail that is still unclear, please point it out in the comments and I will try to extend my answer with further points.

Here "policy" is holding the reference number of an object of "AutoPolicy" type. That is pointing the object passed in parameter.

For better understanding you can go through topic "pass by value and pass by reference in java"