Book Your slot
X
ONLINE BOOKING
BOOK NOW
OFFLINE BOOKING
Call or WhatsApp 7993732682 (WhatsApp Now), 9177341827 (WhatsApp Now)
search
Menu Login home
  • Questions

  • Library

  • University Updates

  • Informatives

  • Technology Lines

  • Training & Internships

  • X
    Menu
  • Home
  • Privacy Policy
  • Legal Disclaimer
  • Terms & Conditions
  • Return Policy
  • About Us
  • Need any help?? write to us at

    support@engineershub.co

    Follow Us

    X
    LOGIN
    Login to access posts, links, updates, question papers, materials, one liners!
    Use Your Email Address/Mobile and Password to Login
    Forgot Password?
    Not a member? Sign Up
    LOGIN WITH EMAIL/MOBILE
    Forgot Password?
    Go Back
    FORGOT PASSWORD
    Go Back
    RESET PASSWORD
    Go Back
    Continue with LinkedIn
    OR
    Fill Up a Simple Form
    Already a Member? Login
    SIGN UP
    Fill all the below details correctly and click on Next
    Go Back
    Design Pattern - Tag - questions - EngineersHub
    Tag results found for "Design Pattern" in Questions.
    Question
    Vamshi
    4 months ago
    1 Answer(s) posted Write an answer 155
    Answer
    Read Mode
    Answer posted by Naseem Shaik
    4 months ago

    CHARISTOPHER ALEXANDER Says that each pattern describes a problem which occurs over and over again in our environment and that describes the core of the solution to that problem in such a way that you can use these solutions a million times without ever doing it.A design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern isn't a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.

    Uses of design pattern: 

    • Design patterns are the best solution for the recording problem in the application programming environment.
    • It is responsible for design pattern analysis in another arms including GUI (graphical user interface)
    • It is mainly used in object oriented programming

    Design pattern elements:

      In general a pattern has four essential elements they are

    PATTERN NAME: The pattern name is a handle we can use to describe a design problem, its solutions, and consequences in a word or two. Naming a pattern immediately increases our design vocabulary. It lets us design at a higher level of abstraction. Having a vocabulary for patterns lets us talk about them with our colleagues, in our documentation, and even to ourselves. It makes it easier to think about designs and to communicate them and their trade-offs to others. Finding good names has been one of the hardest parts of developing our catalog.  

    PROBLEMS: The problem describes when to apply the pattern. It explains the problem and its context. It might describe specific design problems such as how to represent algorithms as objects. It might describe class or object structures that are symptomatic of an inflexible design. Sometimes the problem will include a list of conditions that must be met before it makes sense to apply the pattern.

    SOLUTIONS:The solution describes the elements that make of the design there relationships responsibilities and collaborations.

    CONSEQUENCES: The consequences are the result and trade of applying the pattern The consequence of a pattern includes its impact on a system i.e;Every problem  will be having some consequences

    1
    Question
    KURVA SHEKER
    5 months ago
    1 Answer(s) posted Write an answer 270
    Answer
    Read Mode
    Answer posted by Arunbavu Arun
    5 months ago

    1.ABSTRACT FACTORY:

                   Provides an interface for creating families of related or dependent objects without specifying their concrete classes  

     2.Adapter:

                Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

    3.Bridge:

          Decouple (separate) the abstraction from its implementation so that the two can vary independently.

    4.Builder:Separate (hide) the construction process from its representation so that the same construction process can create different representations.

    5.Chain of Responsibility:

    Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

    6.Command:

    Encapsulate a request as an object which allows us to parametrize the clients with different requests and support undoable operations.

    7.Composite:

    Combine objects into tree structures to form part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

    8.Decorator:

    Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub classing for extending functionality.

    9.Facade:

    Provide a uniform interface for a set of interfaces in a subsystem. Facade defines a higher level interface to make the subsystem easier to use.

    10.Factory Method:

    Defines an interface to create an object, but lets subclasses decide which class to instantiate. Factory Method lets a class differ instantiation to subclasses.

     11.Flyweight:

           Use sharing to support large numbers of fine-grained objects efficiently.

    12.Interpreter:

    Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

    13.Iterator:

    Provides a way to access the individual elements of an aggregate object without exposing its underlying representation.

    14.Mediator:

    Define an object that encapsulates how a set of objects interact.

    15.Memento:

    Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.

    16.Observer:

    Defines a one-to-many dependency between objects so that if one object changes its state, it will notify the change to all other objects and update automatically.

    17.Prototype:

    Specifies the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

    18.Proxy:

    Provide a placeholder for another object to control access to it.

    19.Singleton:

    Ensure a class has only one object and a global point of access to that object.

    20.State:

    Allow an object to change its behavior when its internal state changes. The object will appear to change its class.

    21.Strategy:

    Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

    22.Template Method:

    Define the skeleton of an algorithm in an operation, deferring some steps to sub classes.

    23.Visitor:

    Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.

    8
    Question
    ANAND NAYUDU
    5 months ago
    1 Answer(s) posted Write an answer 736
    Answer
    Read Mode
    Answer posted by KURVA SHEKER
    5 months ago

    Design Pattern name and classification: The pattern name specifies the essence of the pattern precisely. A good name is a key as it will become a part of our design vocabulary. Classification specifies the type of pattern. 

    Intent: A short statement that tells us what the pattern does and which design issue or problem the pattern addresses.

    Other well known names for the pattern, if any.

     Motivation:

    A scenario that illustrates a design problem and how the class and object structures solve that problem. The scenario will help us understand the abstract pattern definition.

    Applicability:

    This specifies in which situations a design pattern can be applied. What are the examples of poor designs that the pattern can address? How to recognize these situations?

    Structure:

    A graphical representation of the classes involved in the pattern following the notations of Object Modeling Technique (OMT). We also use interaction diagrams to illustrate sequences of the requests and the collaborations between objects.

    Participants:

    The classes and / or objects participating in the pattern and their responsibilities.

    Collaborations:

    How the classes and objects collaborate to carry out their responsibilities.

    Consequences:

    Tells us what are the costs and benefits of using the pattern. Also tells us which part of the system can be changed independently.

    Implementation:

    Specifies what techniques we should be aware of when implementing the pattern and also tells us if there are any language specific issues.

    Sample code:

    Code fragments that tell us how to implement the pattern in java.

    Known uses: Example usage of the patterns in the real world.

     Related patterns: Specifies which other patterns are related to this pattern and what are the differences between them.

    66

    Users Joined

    Conor
    4 days ago
    121810801029
    5 days ago
    Haritha
    1 week ago
    Himaja
    2 weeks ago
    Vennela Madikonda
    2 weeks ago
    EngineersHub Logo
    x
    Loading...