ఫ్యాక్టరీ పద్ధతి నమూనా

ఈ సమయంలో, మీరు బహుశా ఇప్పటికే డిజైన్ నమూనాలను ఎదుర్కొన్నారు. ఉదాహరణకు, సింగిల్టన్ .

నమూనాలు ఏమిటి, అవి ఎందుకు అవసరమవుతాయి మరియు సృష్టి నమూనాలు ఏమిటి (సింగిల్టన్ ఒక ఉదాహరణ). మేము కొత్త నమూనాను కూడా అధ్యయనం చేస్తాము: ఫ్యాక్టరీ పద్ధతి.

సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో, డిజైన్ నమూనా అనేది పునరావృతమయ్యే ఆర్కిటెక్చరల్ నిర్మాణం, ఇది కొన్ని పునరావృత సందర్భంలో డిజైన్ సమస్యకు పరిష్కారాన్ని సూచిస్తుంది.

సాధారణంగా, నమూనా నేరుగా కోడ్‌గా మార్చబడే తుది పరిష్కారం కాదు. ఇది వివిధ పరిస్థితులలో ఉపయోగించగల సమస్యకు ఒక నమూనా పరిష్కారం మాత్రమే.

సృజనాత్మక నమూనాలు వస్తువులను సృష్టించే ప్రక్రియతో వ్యవహరించే డిజైన్ నమూనాలు. వస్తువులను సృష్టించడానికి, కంపోజ్ చేయడానికి మరియు ప్రదర్శించడానికి ఉపయోగించే పద్ధతికి స్వతంత్రంగా ఉండే వ్యవస్థను సృష్టించడం సాధ్యమవుతుంది.

ఫ్యాక్టరీ పద్ధతి అనేది ఒక క్రియేషనల్ డిజైన్ నమూనా, ఇది పేరెంట్ క్లాస్‌లో వస్తువులను సృష్టించడానికి ఒక సాధారణ ఇంటర్‌ఫేస్‌ను నిర్వచిస్తుంది, దాని వారసులకు ఈ వస్తువులను సృష్టించే సామర్థ్యాన్ని ఇస్తుంది. సృష్టి సమయంలో, వారసులు ఏ తరగతిని సృష్టించాలో నిర్ణయించగలరు.

నమూనా ఏ సమస్యను పరిష్కరిస్తుంది?

మీరు డెలివరీ ప్రోగ్రామ్‌ను రూపొందించాలని నిర్ణయించుకున్నారని ఊహించండి. ప్రారంభంలో, మీరు కార్లతో కొరియర్‌లను అద్దెకు తీసుకుంటారు మరియు ఎకారుప్రోగ్రామ్‌లో డెలివరీ వాహనాన్ని సూచించడానికి ఆబ్జెక్ట్. కొరియర్లు పాయింట్ A నుండి పాయింట్ B వరకు ప్యాకేజీలను బట్వాడా చేస్తాయి. చాలా సులభం.

కార్యక్రమం ప్రజాదరణ పొందుతోంది. మీ వ్యాపారం పెరుగుతోంది మరియు మీరు కొత్త మార్కెట్లలోకి విస్తరించాలనుకుంటున్నారు. ఉదాహరణకు, మీరు ఆహారాన్ని పంపిణీ చేయడం మరియు సరుకు రవాణాను కూడా ప్రారంభించవచ్చు. ఈ సందర్భంలో, ఆహారాన్ని కొరియర్‌ల ద్వారా కాలినడకన, స్కూటర్‌లపై మరియు సైకిళ్లపై పంపిణీ చేయవచ్చు, అయితే సరుకు రవాణాకు ట్రక్కులు అవసరం.

ఇప్పుడు మీరు ప్రతి కొరియర్ ఎంత క్యారీ చేయగలరో సహా అనేక విషయాలను (ఎప్పుడు, ఎవరికి, ఏది మరియు ఎంత డెలివరీ చేయబడుతుంది) ట్రాక్ చేయాలి. కొత్త రవాణా విధానాలు వేర్వేరు వేగం మరియు సామర్థ్యాలను కలిగి ఉంటాయి. మీ ప్రోగ్రామ్‌లోని చాలా ఎంటిటీలు దీనితో బలంగా ముడిపడి ఉన్నాయని మీరు గమనించవచ్చుకారుతరగతి. మీ ప్రోగ్రామ్‌ను ఇతర డెలివరీ పద్ధతులతో పని చేయడానికి, మీరు ఇప్పటికే ఉన్న కోడ్ బేస్‌ను తిరిగి వ్రాయవలసి ఉంటుందని మరియు మీరు కొత్త వాహనాన్ని జోడించిన ప్రతిసారీ దాన్ని మళ్లీ చేయవలసి ఉంటుందని మీరు గ్రహించారు.

ఫలితంగా రవాణా రకాన్ని బట్టి వివిధ చర్యలను చేసే షరతులతో కూడిన ప్రకటనలతో నిండిన భయంకరమైన కోడ్.

పరిష్కారం

ఫ్యాక్టరీ పద్ధతి నమూనా నేరుగా కొత్త ఆపరేటర్‌ను ఉపయోగించకుండా ప్రత్యేక ఫ్యాక్టరీ పద్ధతిని కాల్ చేయడం ద్వారా వస్తువులను సృష్టించాలని సూచిస్తుంది. ఫ్యాక్టరీ పద్ధతిని కలిగి ఉన్న తరగతి యొక్క ఉపవర్గాలు నిర్దిష్ట వాహనాల యొక్క సృష్టించిన వస్తువులను సవరించగలవు. మొదటి చూపులో, ఇది అర్ధంలేనిదిగా అనిపించవచ్చు: మేము ప్రోగ్రామ్‌లోని ఒక స్థలం నుండి మరొక ప్రదేశానికి కన్స్ట్రక్టర్ కాల్‌ని తరలించాము. కానీ ఇప్పుడు మీరు సృష్టించబడుతున్న రవాణా రకాన్ని మార్చడానికి సబ్‌క్లాస్‌లో ఫ్యాక్టరీ పద్ధతిని భర్తీ చేయవచ్చు.

ఈ విధానం కోసం తరగతి రేఖాచిత్రాన్ని చూద్దాం:

ఈ సిస్టమ్ పనిచేయాలంటే, తిరిగి వచ్చిన అన్ని వస్తువులు తప్పనిసరిగా సాధారణ ఇంటర్‌ఫేస్‌ను కలిగి ఉండాలి. ఈ ఇంటర్‌ఫేస్‌ని అమలు చేసే వివిధ తరగతుల వస్తువులను సబ్‌క్లాస్‌లు ఉత్పత్తి చేయగలవు.

ఉదాహరణకు, ట్రక్ మరియు కార్ తరగతులు డెలివరీ పద్ధతితో కొరియర్ ట్రాన్స్‌పోర్ట్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తాయి . ఈ తరగతుల్లో ప్రతి ఒక్కటి పద్ధతిని వేరొక విధంగా అమలు చేస్తుంది: ట్రక్కులు సరుకును పంపిణీ చేస్తాయి, అయితే కార్లు ఆహారం, ప్యాకేజీలు మరియు మొదలైనవి పంపిణీ చేస్తాయి. ట్రక్‌క్రియేటర్ క్లాస్‌లోని ఫ్యాక్టరీ పద్ధతి ట్రక్ ఆబ్జెక్ట్‌ను అందిస్తుంది మరియు కార్‌క్రియేటర్ క్లాస్ కారు వస్తువును తిరిగి ఇస్తుంది.

ఫ్యాక్టరీ పద్ధతి యొక్క క్లయింట్ కోసం, ఈ వస్తువుల మధ్య ఎటువంటి తేడా లేదు, ఎందుకంటే ఇది వాటిని ఒక రకమైన వియుక్త కొరియర్‌ట్రాన్స్‌పోర్ట్‌గా పరిగణిస్తుంది . ఆబ్జెక్ట్ డెలివరీ చేయడానికి ఒక పద్ధతిని కలిగి ఉందని క్లయింట్ లోతుగా శ్రద్ధ వహిస్తాడు, అయితే ఆ పద్ధతి ఎలా పని చేస్తుందనేది ముఖ్యం కాదు.

జావాలో అమలు:

public interface CourierTransport {
	void deliver();
}
public class Car implements CourierTransport {
	@Override
	public void deliver() {
    		System.out.println("The package is being delivered by car");
	}
}
public class Truck implements CourierTransport {
	@Override
	public void deliver() {
    		System.out.println("The freight is being delivered by truck");
	}
}
public abstract class CourierTransportCreator {
	public abstract CourierTransport createTransport();
}
public class CarCreator extends CourierTransportCreator {
	@Override
	public CourierTransport createTransport() {
    		return new Car();
	}
}
public class TruckCreator extends CourierTransportCreator {
	@Override
	public CourierTransport createTransport() {
    		return new Truck();
	}
}
 
public class Delivery {
	private String address;
	private CourierTransport courierTransport;
 
	public void Delivery() {
	}
 
	public Delivery(String address, CourierTransport courierTransport) {
    	this.address = address;
    	this.courierTransport = courierTransport;
	}
 
	public CourierTransport getCourierTransport() {
    		return courierTransport;
	}
 
	public void setCourierTransport(CourierTransport courierTransport) {
    		this.courierTransport = courierTransport;
	}
 
	public String getAddress() {
    		return address;
	}
 
	public void setAddress(String address) {
    		this.address = address;
	}
}
public static void main(String[] args) {
    	// Accept a new type of order from the database (pseudocode)
    	String type = database.getTypeOfDeliver();
 
    	Delivery delivery = new Delivery();
    	
    	// Set the transport for delivery
        delivery.setCourierTransport(getCourierTransportByType(type));
    	
    	// Make the delivery
        delivery.getCourierTransport().deliver();
 
	}
 
	public static CourierTransport getCourierTransportByType(String type) {
    	switch (type) {
        	case "CarDelivery":
            	return new CarCreator().createTransport();
        	case "TruckDelivery":
            	return new TruckCreator().createTransport();
        	default:
            	throw new RuntimeException();
	    }
	}
    

మేము కొత్త డెలివరీ వస్తువును సృష్టించాలనుకుంటే, ప్రోగ్రామ్ స్వయంచాలకంగా తగిన రవాణా వస్తువును సృష్టిస్తుంది.

మేము ఈ నమూనాను ఎప్పుడు వర్తింపజేయాలి?

1. మీ కోడ్‌తో పని చేయాల్సిన ఆబ్జెక్ట్‌ల రకాలు మరియు డిపెండెన్సీలు మీకు ముందుగా తెలియనప్పుడు.

ఫ్యాక్టరీ పద్ధతి, రవాణాను ఉపయోగించే కోడ్ నుండి రవాణా రూపాలను ఉత్పత్తి చేసే కోడ్‌ను వేరు చేస్తుంది. ఫలితంగా, ఆబ్జెక్ట్‌లను సృష్టించే కోడ్‌ను మిగిలిన కోడ్‌ను తాకకుండా పొడిగించవచ్చు.

ఉదాహరణకు, కొత్త రకం రవాణాకు మద్దతును జోడించడానికి, మీరు కొత్త సబ్‌క్లాస్‌ని సృష్టించాలి మరియు కొత్త రవాణా యొక్క ఉదాహరణను అందించే ఫ్యాక్టరీ పద్ధతిని దానిలో నిర్వచించాలి.

2. మీరు కొత్త వాటిని సృష్టించడానికి బదులుగా ఇప్పటికే ఉన్న వస్తువులను మళ్లీ ఉపయోగించడం ద్వారా సిస్టమ్ వనరులను సేవ్ చేయాలనుకున్నప్పుడు.

డేటాబేస్ కనెక్షన్‌లు, ఫైల్ సిస్టమ్‌లు మొదలైన వనరుల-ఇంటెన్సివ్ ఆబ్జెక్ట్‌లతో పని చేస్తున్నప్పుడు ఈ సమస్య సాధారణంగా సంభవిస్తుంది.

ఇప్పటికే ఉన్న వస్తువులను తిరిగి ఉపయోగించడానికి మీరు తీసుకోవలసిన దశల గురించి ఆలోచించండి:

1. ముందుగా, మీరు సృష్టించిన అన్ని వస్తువులను నిల్వ చేయడానికి మీరు భాగస్వామ్య రిపోజిటరీని సృష్టించాలి.

2. కొత్త వస్తువును అభ్యర్థించేటప్పుడు, మీరు రిపోజిటరీలో చూసి, అది అందుబాటులో ఉన్న వస్తువును కలిగి ఉందో లేదో తనిఖీ చేయాలి.

3. ఆబ్జెక్ట్‌ను క్లయింట్ కోడ్‌కి తిరిగి ఇవ్వండి.

4. కానీ అందుబాటులో ఉన్న వస్తువులు లేనట్లయితే, కొత్తదాన్ని సృష్టించి, దానిని రిపోజిటరీకి జోడించండి.

క్లయింట్ కోడ్‌ను అస్తవ్యస్తం చేయని చోట ఈ కోడ్ అంతా ఉంచాలి. అత్యంత అనుకూలమైన ప్రదేశం కన్స్ట్రక్టర్, ఎందుకంటే వస్తువులను సృష్టించేటప్పుడు మాకు ఈ తనిఖీలన్నీ మాత్రమే అవసరం. అయ్యో, కన్స్ట్రక్టర్ ఎల్లప్పుడూ కొత్త వస్తువును సృష్టిస్తుంది - ఇది ఇప్పటికే ఉన్న వస్తువును తిరిగి ఇవ్వదు.

అంటే ఇప్పటికే ఉన్న మరియు కొత్త వస్తువులను తిరిగి ఇవ్వగల మరొక పద్ధతి అవసరం. ఇది ఫ్యాక్టరీ పద్ధతి అవుతుంది.

3. మీరు మీ ఫ్రేమ్‌వర్క్ లేదా లైబ్రరీలోని భాగాలను విస్తరించడానికి వినియోగదారులను అనుమతించాలనుకున్నప్పుడు.

వినియోగదారులు వారసత్వం ద్వారా మీ ఫ్రేమ్‌వర్క్ తరగతులను విస్తరించవచ్చు. కానీ మీరు ఫ్రేమ్‌వర్క్‌ని ప్రామాణికమైన వాటి కంటే ఈ కొత్త తరగతుల వస్తువులను ఎలా సృష్టించాలి?

వినియోగదారులను భాగాలు మాత్రమే కాకుండా, ఆ భాగాలను సృష్టించే తరగతులను కూడా విస్తరించడానికి అనుమతించడం దీనికి పరిష్కారం. మరియు దీని కోసం, సృష్టించే తరగతులు తప్పనిసరిగా నిర్వచించగల నిర్దిష్ట సృష్టి పద్ధతులను కలిగి ఉండాలి.

ప్రయోజనాలు

• నిర్దిష్ట రవాణా తరగతుల నుండి తరగతిని విడదీస్తుంది.
• రవాణా రూపాలను సృష్టించడం కోసం కోడ్‌ను ఒకే చోట ఉంచుతుంది, కోడ్‌ను నిర్వహించడం సులభం చేస్తుంది.
• ప్రోగ్రామ్‌కు కొత్త రవాణా మార్గాల జోడింపును సులభతరం చేస్తుంది.
• ఓపెన్-క్లోజ్డ్ సూత్రాన్ని అమలు చేస్తుంది.

ప్రతికూలతలు

ప్రతి ఉత్పత్తి తరగతికి దాని స్వంత సృష్టికర్త సబ్‌క్లాస్ ఉండాలి కాబట్టి, పెద్ద సమాంతర తరగతి సోపానక్రమాలకు దారితీయవచ్చు.

సారాంశం చేద్దాం

మీరు ఫ్యాక్టరీ పద్ధతి నమూనా గురించి తెలుసుకున్నారు మరియు ఒక సాధ్యమైన అమలును చూశారు. ఈ నమూనా తరచుగా ఇతర వస్తువులను రూపొందించడానికి వస్తువులను అందించే వివిధ లైబ్రరీలలో ఉపయోగించబడుతుంది.

మీరు మీ ప్రధాన వ్యాపార లాజిక్‌తో పరస్పర చర్య చేయడానికి మరియు విభిన్న సందర్భాల కారణంగా మీ కోడ్‌ను పెంచకుండా ఉండటానికి ఇప్పటికే ఉన్న తరగతుల సబ్‌క్లాస్‌ల యొక్క కొత్త వస్తువులను సులభంగా జోడించాలనుకున్నప్పుడు ఫ్యాక్టరీ పద్ధతి నమూనాను ఉపయోగించండి.