CODEWITHSUNDEEP
oopencapsulation
user99322
user99322

Reputation: 1207

Use of Interface for data hiding

I have an interface I with two methods func A and func B and a class C with the implementation of the interface, I have two users U1 and U2. I want the functionality so that if u1 accesses class C, func A should be called and if u2 accesses class C func B should be called. How do i implement this using OOPs ?

Upvotes: 1

Views: 470

Answers (3)

stakx - no longer contributing
stakx - no longer contributing

Reputation: 84735

I will focus on what you've asked. Why you would want to do this and whether it's actually a good idea with respect to OO design principles is another question.

First, your requirement would look similar to the following: (note)

interface I
{
    void A();
    void B();
}

// class C : I { ... }

Now, let's create a User role and two implementations for user 1 and user 2:

public interface User
{
    void Access(I x);
}

class User1 : User
{
    public void Access(I x)  {  x.A();  }
}

class User2 : User
{
    public void Access(I x)  {  x.B();  }
}

Finally, instantiate your users 1 and 2 as follows:

User u1 = new User1();
User u2 = new User2();

And "access" your C as follows:

I c = new C();
u1.Access(c);    // will call c.A()
u2.Access(c);    // will call c.B()

Note that this code almost completely leaves class C out of the game and instead focuses on the interface (I). If, however, you want your code to work specifically with C, simply replace I with C in the appropriate place (namely, with the parameter of method Access).

(note:) I've chosen C# for the examples, but translating to the language of your choice should be easy.

Upvotes: 0

Joe Enos
Joe Enos

Reputation: 40393

More clarification is definitely needed to determine exactly what you're trying to do, but...

Rather than having the logic in the User class, thinking OO-like, maybe a factory, like:

abstract class C : I
{
  public void A() { }
  public void B() { }
  public abstract void CallMethod();
}

class C1 : C
{
  public override void CallMethod() { A(); }
}

class C2 : C
{
  public override void CallMethod() { B(); }
}

static class Factory
{
  public static I GetI(User user) 
  {
    // This is where your if blocks will go, 
    // and it will return either a new C1 or a new C2
  }
}

This has the benefit of allowing the user to remain simple with no business code in it. The factory has to only be smart enough to know which C it wants to create based on the user. All of the actual work of calling the real method is done in the C itself.

EDIT: You may have to fiddle with the interface and the C class a little - in this case, you'd need the CallMethod() method to be in the interface. Or your factory could return a C instead of an I. Of course, without knowing the whole story, it's hard to say which is correct.

Upvotes: 0

Uberto
Uberto

Reputation: 2712

I think that what you really want is:

  1. an inteface I with just 1 method
  2. 2 classes implementing it in different way: func A and func B
  3. Factory for that interface that take the user as parameter

Example

Let's say:

  1. U1 is Barney, U2 is Fred.
  2. func A is printing "I love you Betty"
  3. func B is printing "Where's my club Wilma?!"
  4. interface Quote is defined with a method emitQuote()
  5. classes C and D will implement I with A and B respectively
  6. define a factory (factory class or factory method doesn't matter) and put the User switch there.

In this way you can call:

Quote q = myFactory.getQuoteFor(u);
q.emitQuote();

This is pure OOP and I think it's pretty simple to write in a TDD fashion.

Upvotes: 1

Related Questions