If your end goal is to be able to potentially switch libraries in the future, you don't want to be passing Window objects anywhere. Basically, you don't want to pass any SFML objects between classes if you can help it, those are exactly the couplings you need to break.
This is the point where you might want to start looking in to design patterns. The
mediator design pattern is all about having different objects able to interact, while knowing nothing about each other. The
observer pattern is all about having objects automatically updated if another object's state changes ( ie, an input object has new input, or a keyboards key state changed ), while in my own tutorial I demonstrate
the service locator, in which I illustrate how you could swap out SFML's sound subsystem for FMOD, without changing a line of code.
EDIT:
To put into more simple terms to directly answer your question, you are going to have to access the window object at some point, as simply put, that is the interface SFML provided. Your goal is to abstract away that dependency.
So for example, instead of creating a SFMLInput class you create a generic Input class ( or interface ) and a SFMLInput class and your code interacts with the Input class, not the implementation specific class, so making changes in the future is trivial. In this scenario, the SFMLInput class is the only one that needs to know about the SFML specifics.
EDIT2:
Decoupling the dependency on a library like SFML ( which handles so much of your overall game ) is a right pain in the ass. It's good form and over all a pretty good idea, especially if you plan to port to portables or possibly other platforms that SFML doesn't support, just be sure you know what you are getting into. If you are working on your first or second game, I don't really think I would be worried too much about this.
This is where using a really light weight interface can be a good comprimise. So then what you do is have a (global) class like Game with methods like Game::GetInput() or Game::GetWindow() etc. You are creating a coupling every single time you call that GetWhatever() method, but you are creating a
very easy to find coupling. Mean that if you want to changes things out in the future, its mostly a matter of find and replace. A choir to be sure, but a hell of a lot easier than have to scour your code for all IO calls, etc.