CODEWITHSUNDEEP
oopobjectinterfaceabstract-class
runcode
runcode

Reputation: 3653

In Object oriented programming when do we need abstraction?

I read many posts about the "Interface" and "Abstract Class"

Basically, we use "Abstract Class" when we talking about the characteristic of the Object.

And we use "Interface" when we taling about what the object capable can do.

But it still confuse so I make up an example for myself to practice.

so now I thinking of a Object 'Cargo;

    public abstract class cargo {

        protected int id;

        public abstract int getWidth(int width);

        public abstract int setWidth(int width);

        public abstract int setHeight(int h);

        public abstract int getHeight(int h);

        public abstract int setDepth(int d);

        public abstract int getDepth(int d);

        public abstract int volume(int w,int h,int d);

        public int getId(){
            return this.id;
        }

        public abstract int setId();

        public abstract void setBrand();

        public abstract void getBrand( );

        .....so on , still have a lot of characteristic of a cargo
    }

    //in the other class
    public class usaCargo extends cargo{
                  ....
                  private 

    }

So here is few Question about my design.

1.So in the real programming project world, are we actually doing like above? for me i think it's ok design, we meet the basic characteristic of cargo.

  1. if we setup "private id" , then we actually can't use "id" this variable in any subclass because it's private, so is that mean every variable we defined in abstract class must be either public/ protected?

  2. can someone give some suitable example so my cargo can implement some interface?

    public interface registration{
     public void lastWarrantyCheck();
}

    But seems not suitable here...

  3. we dont usually define variable inside interface, do we ??

I try to gain more sense on OOP . Forgive my long questions.

Upvotes: 1

Views: 1479

Answers (3)

John Hornsby
John Hornsby

Reputation: 321

  1. Variables in an abstract class may be declared as protected, and they will only be available within it and any extending classes. Private variables are never accessible inside extending classes.

  2. Interfaces provide a list of functions that are required by the classes that implement them. For example, you might use an interface hasWarranty to define all the functions that an object would need to handle warranty-related activities.

    public interface hasWarranty {
    public void lastWarrantyCheck();
    public void checkWarranty();
}

    Then, any objects that need to perform warranty-related activities should implement that interface:

    // Disclaimer: been away from Java for a long time, so please interpret as pseudo-code.

// Will compile
public class Car implements hasWarranty {
    public void lastWarrantyCheck() {
        ... need to have this exact function or program won't compile ...
    }
    public void checkWarranty() {
        ... need to have this exact function or program won't compile ...
    }
}

// Missing one of the required functions defined in hasWarranty
public class Bus implements hasWarranty {
    public void lastWarrantyCheck() {
        ... need to have this exact function or program won't compile ...
    }
}

  3. Only constants, really, as variables declared in an interface are immutable and are shared by all objects that implement that interface. They are implicitly "static final".

Upvotes: 1

Jeremy
Jeremy

Reputation: 831

You would define variables in the Abstract class so that methods defined in the abstract class have variables to use. The scope of those variables depend on how you want concrete classes to access those variables:

private should be used when you want to force a concrete class to go through a getter or setter defined in the abstract class.

protected should be used when you want to give the concrete class direct access to the variable.

public should be used when you want the variable to be accessible by any class.

A reasonable interface that a Cargo object might implement could be Shippable as in how to move the cargo from a source to a destination. Some cargo may be shipped via freight train, some might be shippable by airplane, etc. It is up to the concrete class to implement Shippable and define just how that type of cargo would be shipped.

public interface Shippable {
    public void ship();
}

Lastly a variable defined in an interface must be public static and final meaning it would be a constant variable.

Hope this clears it up for you!

Upvotes: 1

WLin
WLin

Reputation: 1454

  1. Abstract classes can contain implementation, so they can have private variables and methods. Interfaces on the other hand cannot.

  2. You can find some examples on how to implement interfaces here. However, I included how you would implement your registration example below.

    public class Cargo implements Registration{
   public void lastWarrantyCheck(){
      System.out.println("Last warranty check");
   }           
}

  3. Interface variables are possible, but they should only include constant declarations (variable declarations that are declared to be both static and final). More information about this can be found here.

Upvotes: 1

Related Questions