HW3 프로젝트 디렉토리 안에 모든 파일(src/*.java & bin/*.class)와 보고서 (3~4장)를 넣고 JAVA21-2_HW3_학번_이름.zip 압축한 후 제출 (due by 10/3)
HW2 프로젝트 디렉토리 안에 모든 파일(src/*.java & bin/*.class)와 보고서 (3~4장)를 넣고 JAVA21-2_HW2_학번_이름.zip 압축한 후 제출 (due by 9/26)
Abstract Factory – allows the creation of objects without specifying their concrete type
Builder – uses to create complex objects
Factory Method – creates objects without specifying the exact class to create
Prototype – creates a new object from an existing object
Singleton – ensures only one instance of an object is created
Adapter – allows for two incompatible classes to work together by wrapping an interface around one of the existing classes.
Bridge – decouples an abstraction so two classes can vary independently.
Composite – takes a group of objects into a single object.
Decorator – allows for an object’s behavior to be extended dynamically at run time.
Facade – provides a simple interface to a more complex underlying object.
Flyweight – reduces the cost of complex object models.
Proxy – provides a placeholder interface to an underlying object to control access, reduce cost, or reduce complexity.
Chain of Responsibility – delegates commands to a chain of processing objects.
Command – creates objects which encapsulate actions and parameters.
Interpreter – implements a specialized language.
Iterator – accesses the elements of an object sequentially without exposing its underlying representation.
Mediator – allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
Memento – provides the ability to restore an object to its previous state.
Observer – is a publish/subscribe pattern which allows a number of observer objects to see an event.
State – allows an object to alter its behavior when its internal state changes.
Strategy – allows one of a family of algorithms to be selected on-the-fly at run-time.
Template Method – defines the skeleton of an algorithm as an abstract class, allowing its sub-classes to provide concrete behavior.
Visitor – separates an algorithm from an object structure by moving the hierarchy of methods into one object.
HW1 프로젝트 디렉토리 안에 모든 파일(src/*.java & bin/*.class)와 보고서 (3~4장)를 넣고 JAVA21-2_HW1_학번_이름.zip 압축한 후 제출 (due by 9/19)
A class should only have a single responsibility, that is, only changes to one part of the software’s specification should be able to affect the specification of the class.
“Software entities … should be open for extension, but closed for modification.”
Liskov substitution principle
“Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.” See also design by contract.
Interface segregation principle
“Many client-specific interfaces are better than one general-purpose interface.”
Dependency inversion principle
One should “depend upon abstractions, [not] concretions.”
Object − objects have states and behaviors.
Class – defines the grouping of data and code, the “type” of an object
Instance – a specific allocation of a class
Message – sent to objects to make them act
Method – a “function” that an object knows how to perform
Local Variables − variables defined inside methods, constructors or blocks
Instance Variables – variables within a class but outside any method (a specific piece of data belonging to an object)
Class Variables − variables declared within a class, outside any method, with the static keyword
Abstraction – show only “relevant” data and “hide” unnecessary details of object from the user
Encapsulation – keep implementation private and seperate from interface
Polymorphism – process objects differently based on their data type, using same interface
Inheritance – hierarchical organization, share code, customize or extend behaviors