Creating a connection between a class Bill and a class SimplifiedBill: Best practices

Question

Creating a connection between a class Bill and a class SimplifiedBill: Best practices

As stated in the title, I am faced with a situation where I have two classes: SimplifiedBill, which includes only date and finalPayment, and Bill, which has the same properties as SimplifiedBill but also additional details such as taxes, user data, and services.

One possible solution could be for Bill to inherit from SimplifiedBill. However, I believe this approach may not be conceptually accurate because SimplifiedBill is essentially derived from Bill; therefore, Bill does not inherit anything from SimplifiedBill.

Do you have any suggestions on how to design the classes in this scenario?

EDIT: The process works as follows.
I retrieve a list of SimplifiedBill objects from the backend. When I select one of these objects, I then fetch the corresponding Bill from the API to view its details.

In case you are curious, I am using Angular. I have a ListComponent (or view) that displays my SimpleBill objects. Clicking on an object takes me to the DetailComponent, where I can view the specific Bill. Unfortunately, when transitioning between views, I am unable to transfer the entire SimpleBill object; I can only pass its ID or another field.

javascript typescript inheritance entity-relationship class-design

Answer 1

Answer №1

I completely agree that inheriting from SimplifiedBill would be conceptually inaccurate. In my opinion, it's best to use inheritance sparingly and with caution as it is often misused.

Instead of using inheritance, I suggest taking a compositional approach. For example, if Bill contains SimplifiedBill, a more sensible solution could be creating a data structure for Bill that includes properties for the details:

let bill = {
  details: {...},
  simplifiedBill: {...}
}

Although I used a simple object in this example (which is suitable considering you are working with javascript), the same concept can also be applied to a class-based approach. You may want to consider choosing a different name for the simplified bill, such as "summary".

Overall, it's commendable that you recognized the limitations of using inheritance in this scenario.

Answer 2

I completely agree that inheriting from SimplifiedBill would be conceptually inaccurate. In my opinion, it's best to use inheritance sparingly and with caution as it is often misused.

Instead of using inheritance, I suggest taking a compositional approach. For example, if Bill contains SimplifiedBill, a more sensible solution could be creating a data structure for Bill that includes properties for the details:

let bill = {
  details: {...},
  simplifiedBill: {...}
}

Although I used a simple object in this example (which is suitable considering you are working with javascript), the same concept can also be applied to a class-based approach. You may want to consider choosing a different name for the simplified bill, such as "summary".

Overall, it's commendable that you recognized the limitations of using inheritance in this scenario.

Answer 3

Answer №2

It's possible that a relationship isn't necessary in this case; it seems like the SimplifiedBill class is more of a basic representation of the Bill class.

One approach could be to maintain the separation of the two classes and introduce a third class, such as a SimplifiedBillFactory, which takes a Bill object and generates a SimplifiedBill.

For example (pseudo code, may not be valid typescript!)

export class SimplifiedBillFactory
{

  createSimplifiedBill(bill: Bill) : SimplifiedBill
  {
     return new SimplifiedBill{
             billId=bill.Id,
             date=bill.date,
             finalPayment=bill.calculateFinalPayment()
     };         
   }
}

An advantage of this method is that if you need to add more details to SimplifiedBill later on (such as additional aggregates like total line item count), it can easily be done within this class. It also promotes keeping the specific behaviors of a bill within the Bill class itself and accessing them through methods (e.g. the calculateFinalPayment method on Bill).

You could alternatively use a factory method within the Bill class instead of creating a separate factory class, but personally I prefer to keep them distinct. This allows for flexibility in adding other classes in the future alongside the Bill class for generating instances of SimplifiedBill.

Answer 4

It's possible that a relationship isn't necessary in this case; it seems like the SimplifiedBill class is more of a basic representation of the Bill class.

One approach could be to maintain the separation of the two classes and introduce a third class, such as a SimplifiedBillFactory, which takes a Bill object and generates a SimplifiedBill.

For example (pseudo code, may not be valid typescript!)

export class SimplifiedBillFactory
{

  createSimplifiedBill(bill: Bill) : SimplifiedBill
  {
     return new SimplifiedBill{
             billId=bill.Id,
             date=bill.date,
             finalPayment=bill.calculateFinalPayment()
     };         
   }
}

An advantage of this method is that if you need to add more details to SimplifiedBill later on (such as additional aggregates like total line item count), it can easily be done within this class. It also promotes keeping the specific behaviors of a bill within the Bill class itself and accessing them through methods (e.g. the calculateFinalPayment method on Bill).

You could alternatively use a factory method within the Bill class instead of creating a separate factory class, but personally I prefer to keep them distinct. This allows for flexibility in adding other classes in the future alongside the Bill class for generating instances of SimplifiedBill.

Answer 5

Answer №3

This is a thought-provoking question,

When it comes to Inheritance, it's important to consider the relationship as an "is-a" connection. Before establishing an inheritance relationship between two entities, ask yourself if entity A can truly be categorized as entity B.

Here's the first question to ponder: What defines the simplest form of a Bill or what are the essential components that every Bill must possess? Knowing this will ultimately define what a Bill should encompass.

If we reason that SimpleBill is essentially a type of Bill, then items belonging to SimpleBill collectively formulate a Bill. According to popular opinion, a Bill at its most basic level might comprise solely of a billId. Thus, a barebones representation of Bill may look like:

interface Bill{
    billId: string;
}

The second query arises: Is VerboseBill essentially a SimpleBill or vice versa? This assessment will clarify whether an inheritance relationship exists between them.

Rather than labeling SimpleBill as a subset of VerboseBill or vice versa, it seems more appropriate to conclude that they do not share an inheritance relation;

Considering potential future variations such as AaaBill{taxes}, BbbBill{services}..., do these new iterations inherit from one another? Despite their differences, all these variations ultimately stem from being labeled as Bill!

In light of the above discussion, here is a proposed solution:

export interface SimpleBill extends Bill{
  date: number;
  finalPayment: number;

}

export interface VerboseBill extends Bill{
    date: number;
    finalPayment: number;
    taxes:number;
    services;...
    userData;...
}

export namespace Bill{

    export function simplify(bill:Bill): SimpleBill{
        return {id: bill.id, date: bill.date, finalPayment: bill.finalPayment};
    }

    export function verbose(bill:Bill): VerboseBill{
        if((bill as VerboseBill).taxes !==undefined){
            return bill as VerboseBill;
        }
        return fetchVerboseBill(bill.id);
    }
}

export namespace SimpleBill{
    export const verbose = Bill.verbose
}

export namespace VerboseBill{
    export const simplify = Bill.simplify
}

Answer 6

This is a thought-provoking question,

When it comes to Inheritance, it's important to consider the relationship as an "is-a" connection. Before establishing an inheritance relationship between two entities, ask yourself if entity A can truly be categorized as entity B.

Here's the first question to ponder: What defines the simplest form of a Bill or what are the essential components that every Bill must possess? Knowing this will ultimately define what a Bill should encompass.

If we reason that SimpleBill is essentially a type of Bill, then items belonging to SimpleBill collectively formulate a Bill. According to popular opinion, a Bill at its most basic level might comprise solely of a billId. Thus, a barebones representation of Bill may look like:

interface Bill{
    billId: string;
}

The second query arises: Is VerboseBill essentially a SimpleBill or vice versa? This assessment will clarify whether an inheritance relationship exists between them.

Rather than labeling SimpleBill as a subset of VerboseBill or vice versa, it seems more appropriate to conclude that they do not share an inheritance relation;

Considering potential future variations such as AaaBill{taxes}, BbbBill{services}..., do these new iterations inherit from one another? Despite their differences, all these variations ultimately stem from being labeled as Bill!

In light of the above discussion, here is a proposed solution:

export interface SimpleBill extends Bill{
  date: number;
  finalPayment: number;

}

export interface VerboseBill extends Bill{
    date: number;
    finalPayment: number;
    taxes:number;
    services;...
    userData;...
}

export namespace Bill{

    export function simplify(bill:Bill): SimpleBill{
        return {id: bill.id, date: bill.date, finalPayment: bill.finalPayment};
    }

    export function verbose(bill:Bill): VerboseBill{
        if((bill as VerboseBill).taxes !==undefined){
            return bill as VerboseBill;
        }
        return fetchVerboseBill(bill.id);
    }
}

export namespace SimpleBill{
    export const verbose = Bill.verbose
}

export namespace VerboseBill{
    export const simplify = Bill.simplify
}

Creating a connection between a class Bill and a class SimplifiedBill: Best practices

Answer №1

Answer №2

Answer №3

Similar questions

Node OOM Error in Webpack Dev Server due to Material UI Typescript Integration

"Utilize Ajax and PHP to seamlessly upload a PDF file directly into a MYSQL database

Encountering a 500 error while attempting to send data to an API route within a Laravel web page using XMLHttpRequest at http://127:8000/api/v1/exemp. Can anyone

Is it possible to trim a video using HTML code?

Mapping strings bidirectionally in Typescript

Leverage generic types and allow acceptance of objects with arbitrary keys

Using jQuery idle timeout to abort jQuery AJAX calls in Laravel 5.2

The component is rendering properly, however the router-outlet in Angular seems to be getting overlooked

Laravel error 500 (Internal Server Error) is encountered when making an ajax post request

Creating gifs from an array of base64 strings with gifshot doesn't seem to function properly on Firefox browsers

Confirm that a specific value exists within an enumerated set

Substitute all items identified by a particular tag with a component

Guide to developing a manual tally counter with recorded logs using HTML and JavaScript

Ensure that each class element contains a value before using jQuery to toggle the disabled class

Vue appears to be having trouble waiting for the axios Post request

Take out a specific element from an array consisting of multiple objects

"The error message "Node JS, MYSQL connection.query is not a valid method" indicates

Unexpected results are being produced in React due to code, functions are not being executed upon pressing the submit button

One click wonder: Easily print any webpage content with just the click of a button!

Changing the key name for each element in an array using ng-repeat: a guide