String Matching w/o repeating the comparisons for common part of the two strings
Confirm if things work the way I explained. My tests seem to be working fine.


I'm afraid not. For example, for text hehehello and pattern hehello, the output is 0 instead of 2. You see, the algorithm prematurely exits after heheh, when it should continue searching from position 2.

With your modified version this test case passes, but fails for text heheehello and pattern hehello, incorrectly returning 3 instead of -1.
(In the future, please do not modify the code in the question after you received answers. Changing the code typically invalidates answers, as it did in this example too.)

See the Knuth-Morris-Pratt algorithm for something that actually works.


  What is the complexity of this approach? Is it worst case O(n⋅k) still?


The complexity of your algorithm is \$O(n + k)\$, same as that of KMP. Unfortunately it doesn't really matter, because it doesn't work correctly. 

Usage

The usage of your class is a bit awkward:

int index = new ModifiedSearch(text).findPattern(pattern);


I recommend to rewrite to make it work this way:

int index = ModifiedSearch.findPattern(text, pattern);


That is, turn the class into a static utility method.
It will be lighter that you don't have to create an instance of the class.

Looking at the function name "findPattern" alone, it's not obvious what it returns. Since the function returns an index, like String.indexOf, I recommend to rename it to indexOf. Or, rename to contains and make it return a boolean.