Do inherited methods use the visibility, methods and attributes of the superclass or subclass?

What I assume is that an inherited method will, by standard, use the methods and attributes of the class whose object is used to execute that method.

Here's an example for my question, it's from a task from an older exam:

public class Test {
	public static void main(String[] args) {
		A a = new A(3);
		A b = new B(1, 4);
		b.methodOne(6);       // <----- This. I think that this uses "b.m" and "b.increase"
	}
}

public class A {
	private int m;
	private int n;

	public A(int n) {
		m = n;
	}

	public void methodOne(int i) {
		m -= i;
		increase(i);
	}

	public void increase(int i) {
		m += 2 * i;
	}

        public void visilibityTest() {
                n++;                   // <----- I think that b.visibilityTest() would work
                                       // Because it uses the visibility "rights" of A.
        }
}

public class B extends A {
	private int m;

	public B(int m, int n) {
		super(n);
		this.m = m + 1;
	}

	public void increase(int i) {
		m += i;
	}
}

As I said in the comments, I think that by executing b.methodOne, the attribute "b.m" and the method "b.increase" are used, even though methodOne is inherited from class A. (I mean this.m of b, not super.m)

1. Is this true? Do inherited methods normally use the methods and attributes of the subclass?

2. What role do the static/dynamic type play in this task? ("A b = new B")

And what about visibility? In another task I found out that if you use inherited methods to access private attributes of the superclass (that should not be visible to a subclass), you can access those attributes, as if you were accessing superclass's visibility rights. I added an example method called visibilityTest() to show that example on this task. Would that work?

3. Do inherited methods use the visibility of the superclass?

I apologize for any unclear wording. I'm both still trying to understand most of this, and also have to find out what many terms are called like in English, for the purpose of translation.
Any pointing out of unclear wording will be appreciated.

Yes, this is correct. When a method is inherited from a superclass, the subclass can override it to change the behavior, but if not overridden, it will use the implementation in the superclass. In this case, calling b.methodOne(6) will use the m and increase from the B class, since b is an object of type B.

The static type refers to the type of a reference variable (in this case A b) whereas the dynamic type refers to the actual type of the object referred to by the reference variable (in this case B). When you call b.methodOne(6), the static type is A but the dynamic type is B. This means that the method methodOne is resolved based on the type of the object b refers to (dynamic type B) rather than the type of the reference variable b (static type A).

Inherited methods use the visibility of the superclass unless they are overridden in the subclass. In this case, b.visibilityTest() would work, because it is a method in the superclass A and visibility is not changed by inheritance.