Decouple parent class dependencies from child's dependencies

I have a parent class, let's call it BaseClass

And I have multiple child classes extending this BaseClass. These child classes overrides some of the methods of the BaseClass.

public class BaseClass {

}

public class ChildA extends BaseClass{

}
....

public class ChildN extends BaseClass{

}

Now, I have logic in BaseClass which keeps on changing quite often. This usually leads to adding dependencies for the BaseClass - the constructor arguments of this BaseClass keeps on increasing.

public class BaseClass {
  public BaseClass(BaseDependencyOne one, BaseDependencyTwo two...., BaseDependencyN n) {
  }
}

public class ChildA {
  public ChildA (BaseDependencyOne one, BaseDependencyTwo two,..., BaseDependencyN n){
    super(one, two,..., n);
  }
}

Since, the BaseClass constructor is modified to accommodate more dependencies, the child classes also have to accommodate these dependencies.
This involves making change in all child classes, which are very large in number. This in turn results in a huge change for a single addition of dependency in BaseClass

I thought of making the parent BaseClass as a dependency for all child classes. It will decouple the dependency of parent from child.
But, this will break the parent-child relation ship, therefore, I won't have the overriding behaviour of child.

It is possible to inject an interface which has all dependencies of your classes. It can be called a collector. You can immerse in this great technique by reading this outstanding article by Mark Seemann.

Let me show an example via C#.

public interface IFooCollector
{
	DependencyOne One { get; set; }

	DependencyTwo Two { get; set; }

	DependencyThree Three { get; set; }
}

Andd your dependency classes:

public class DependencyOne {}

public class DependencyTwo { }

public class DependencyThree { }

And then your BaseClass will have just the following dependency:

public class BaseClass
{
	IFooCollector _myDependencies;

	public BaseClass(IFooCollector myDependencies)
	{
		_myDependencies = myDependencies;
	}
}

It can be seen that there is no need to edit dependencies in all derived classes of BaseClass if you add new dependency to IFooCollector