├── .gitignore ├── .idea ├── .gitignore ├── description.html ├── misc.xml ├── modules.xml ├── project-template.xml ├── runConfigurations.xml └── vcs.xml ├── README.md ├── src └── com │ └── company │ ├── Behavioraldesignpatterns │ ├── chain_of_responsibility │ │ ├── Client.java │ │ ├── Dean.java │ │ ├── Handler.java │ │ ├── Principal.java │ │ ├── Secretary.java │ │ └── Tutor.java │ ├── commandpatterns │ │ ├── Client.java │ │ ├── CommandProcessor.java │ │ ├── OrderAddCommand.java │ │ ├── OrderCommand.java │ │ └── OrderPayCommand.java │ ├── iterator │ │ ├── Book.java │ │ ├── BookIterable.java │ │ ├── Client.java │ │ ├── Iterator.java │ │ ├── Literature.java │ │ └── LiteratureIterator.java │ ├── mediator │ │ ├── ChatMediator.java │ │ ├── ChatMediatorImpl.java │ │ ├── Client.java │ │ ├── User.java │ │ └── UserImpl.java │ ├── memento │ │ ├── Caretaker.java │ │ ├── Client.java │ │ ├── Memento.java │ │ └── ToDo.java │ ├── observer │ │ ├── Bookstore.java │ │ ├── Client.java │ │ ├── Magazine.java │ │ ├── Observer.java │ │ ├── Subject.java │ │ └── Subscriber.java │ ├── state │ │ ├── Client.java │ │ ├── GameOverState.java │ │ ├── GameStartState.java │ │ ├── GameState.java │ │ └── Player.java │ ├── strategy │ │ ├── Client.java │ │ ├── Context.java │ │ ├── GoToCairo.java │ │ ├── GoToGona.java │ │ └── Strategy.java │ ├── template_method │ │ ├── AssemblyLine.java │ │ ├── Client.java │ │ ├── ComputerAssemblyLine.java │ │ └── RadioAssemblyLine.java │ └── visitor │ │ ├── Applicant.java │ │ ├── Client.java │ │ ├── Engineer.java │ │ ├── Interviewer.java │ │ ├── LaborMarket.java │ │ ├── Leader.java │ │ └── Student.java │ ├── Creationaldesignpattern │ ├── Prototype │ │ └── WordDocument.java │ ├── abstractfactory │ │ ├── CakeCream.java │ │ ├── CakeFactory.java │ │ ├── CakeStyle.java │ │ ├── Client.java │ │ ├── HeartStyle.java │ │ ├── MangoCream.java │ │ ├── MangoHeartCake.java │ │ ├── MangoSquareCake.java │ │ └── SquareStyle.java │ ├── builder │ │ ├── Builder.java │ │ ├── Car.java │ │ ├── CarBuilder.java │ │ ├── Client.java │ │ └── Director.java │ ├── factory │ │ ├── Cake.java │ │ ├── CakeFactory.java │ │ ├── Client.java │ │ ├── Factory.java │ │ └── MangoCake.java │ └── singleton │ │ └── Counter.java │ └── Structuraldesignpatterns │ ├── adapter │ ├── Client.java │ ├── Volt220.java │ ├── VoltAdapter.java │ └── VoltFive.java │ ├── decorator │ ├── Cake.java │ ├── CakeEmbryo.java │ ├── DecoratorCake.java │ ├── FruitCake.java │ └── client.java │ ├── facade │ ├── Client.java │ ├── Frenchkitchen.java │ ├── FrenchkitchenImpl.java │ ├── Italykitchen.java │ ├── ItalykitchenImpl.java │ └── Menu.java │ ├── flyweight │ ├── Client.java │ ├── MovieTicket.java │ ├── Ticket.java │ └── TicketFactory.java │ └── proxy │ ├── Client.java │ ├── IPicker.java │ ├── ProxyPicker.java │ └── RealPicker.java └── untitled104.iml /.gitignore: -------------------------------------------------------------------------------- 1 | # Project exclude paths 2 | /out/ -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | -------------------------------------------------------------------------------- /.idea/description.html: -------------------------------------------------------------------------------- 1 | Simple Java application that includes a class with main() method -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /.idea/project-template.xml: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.idea/runConfigurations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 9 | 10 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # DesignPatterns-Java 2 | 3 | ## Design Patterns 4 | - In software engineering, 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. 5 | ## Creational design patterns 6 | - Singleton 7 | - Prototype 8 | - Object Pool 9 | - Factory Method 10 | - Builder 11 | - Abstract Factory 12 | 13 | 14 | ## Structural design patterns 15 | - Adapter 16 | - Bridge 17 | - Composite 18 | - Decorator 19 | - Facade 20 | - Flyweight 21 | - Private Class Data 22 | - Proxy 23 | 24 | ## Behavioral design patterns 25 | - Chain of responsibility 26 | - Command 27 | - Interpreter 28 | - Iterator 29 | - Mediator 30 | - Memento 31 | - Null Object 32 | - Observer 33 | - State 34 | - Strategy 35 | - Template method 36 | - Visitor 37 | 38 | 39 | 40 | ## Creational design patterns 41 | 42 | >In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation. 43 | > 44 | 45 | ### Singleton 46 | 47 | The singleton pattern ensures that only one object of a particular class is ever created. All further references to objects of the singleton class refer to the same underlying instance. There are very few applications, do not overuse this pattern! 48 | 49 | ## UML : 50 | 51 | 52 | 53 | ### Example: 54 | 55 | ```java 56 | public class Counter { 57 | 58 | public int count = 0; 59 | 60 | private static Counter instance = new Counter(); 61 | 62 | private Counter() { 63 | } 64 | 65 | public static Counter getInstance() { 66 | return instance; 67 | } 68 | 69 | public void addOne() { 70 | count++; 71 | } 72 | } 73 | ``` 74 | 75 | ### Usage : 76 | 77 | ```java 78 | Counter obj1 = Counter.getInstance(); 79 | Counter obj2 = Counter.getInstance(); 80 | obj1.addOne(); 81 | obj2.addOne(); 82 | System.out.println("Counter 1 : " + obj1.count); 83 | System.out.println("Counter 2 : " + obj2.count); 84 | 85 | obj1.addOne(); 86 | obj2.addOne(); 87 | System.out.println("Counter 1 : " + obj1.count); 88 | System.out.println("Counter 2 : " + obj2.count); 89 | ``` 90 | 91 | ### Output : 92 | 93 | ```code 94 | Counter 1 : 2 95 | Counter 2 : 2 96 | Counter 1 : 4 97 | Counter 2 : 4 98 | ``` 99 | 100 | ## 101 | ## prototype 102 | The Prototype pattern delegates the cloning process to the actual objects that are being cloned. The pattern declares a common interface for all objects that support cloning. This interface lets you clone an object without coupling your code to the class of that object. Usually, such an interface contains just a single clone method. 103 | 104 | The implementation of the clone method is very similar in all classes. The method creates an object of the current class and carries over all of the field values of the old object into the new one. You can even copy private fields because most programming languages let objects access private fields of other objects that belong to the same class. 105 | 106 | An object that supports cloning is called a prototype. When your objects have dozens of fields and hundreds of possible configurations, cloning them might serve as an alternative to subclassing. 107 | 108 | ## UML : 109 | 110 | 111 | 112 | ### Example: 113 | 114 | 115 | ```java 116 | import java.util.ArrayList; 117 | 118 | public class WordDocument implements Cloneable { 119 | 120 | private String text; 121 | private ArrayList images = new ArrayList<>(); 122 | 123 | public WordDocument() { 124 | System.out.println("-----Init-----"); 125 | } 126 | 127 | public String getText() { 128 | return text; 129 | } 130 | 131 | public void setText(String text) { 132 | this.text = text; 133 | } 134 | 135 | public ArrayList getImages() { 136 | return images; 137 | } 138 | 139 | public void setImages(ArrayList images) { 140 | this.images = images; 141 | } 142 | 143 | public void addImage(String image) { 144 | images.add(image); 145 | } 146 | 147 | public void showDocument() { 148 | System.out.println("-----Start-----"); 149 | System.out.println("Text : " + text); 150 | System.out.println("Image List : "); 151 | for (String mImage : images) { 152 | System.out.println("Image Name : " + mImage); 153 | } 154 | System.out.println("-----End-----"); 155 | } 156 | 157 | protected WordDocument clone() { 158 | try { 159 | WordDocument copy = (WordDocument) super.clone(); 160 | copy.text = this.text; 161 | // copy.images = this.images; 162 | copy.images = (ArrayList) this.images.clone(); 163 | return copy; 164 | } catch (CloneNotSupportedException e) { 165 | e.printStackTrace(); 166 | } 167 | return null; 168 | } 169 | 170 | ``` 171 | 172 | ### Usage : 173 | 174 | ```java 175 | public static void main(String[] args) { 176 | WordDocument originDoc = new WordDocument(); 177 | originDoc.setText("This is a document"); 178 | originDoc.addImage("Image 1"); 179 | originDoc.addImage("Image 2"); 180 | originDoc.addImage("Image 3"); 181 | originDoc.showDocument(); 182 | 183 | WordDocument copyDoc = originDoc.clone(); 184 | copyDoc.showDocument(); 185 | 186 | copyDoc.setText("This is a copy document"); 187 | 188 | // add this line to test the origin document what will happen after the copy document add a image 189 | copyDoc.addImage("a new Image"); 190 | 191 | 192 | copyDoc.showDocument(); 193 | copyDoc.showDocument(); 194 | } 195 | ``` 196 | ## Output: 197 | 198 | ```code 199 | -----Init----- 200 | -----Start----- 201 | Text: This is a document 202 | Images List: 203 | Image name: Image 1 204 | Image name: Image 2 205 | Image name: Image 3 206 | -----End----- 207 | -----Start----- 208 | Text: This is a document 209 | Images List: 210 | Image name: Image 1 211 | Image name: Image 2 212 | Image name: Image 3 213 | -----End----- 214 | -----Start----- 215 | Text: This is a copy document 216 | Images List: 217 | Image name: Image 1 218 | Image name: Image 2 219 | Image name: Image 3 220 | Image name: A new image 221 | -----End----- 222 | -----Start----- 223 | Text: This is a copy document 224 | Images List: 225 | Image name: Image 1 226 | Image name: Image 2 227 | Image name: Image 3 228 | Image name: A new image 229 | -----End----- 230 | 231 | ``` 232 | 233 | ## 234 | ## Builder 235 | The builder pattern is used to create complex objects with constituent parts that must be created in the same order or using a specific algorithm. An external class controls the construction algorithm. 236 | 237 | ## UML : 238 | 239 | 240 | 241 | ### Example: 242 | 243 | ```java 244 | public class Car { 245 | private String color; 246 | private String licensePlate; 247 | private String brand; 248 | 249 | public void setColor(String color) { 250 | this.color = color; 251 | } 252 | 253 | public void setLicensePlate(String licensePlate) { 254 | this.licensePlate = licensePlate; 255 | } 256 | 257 | public void setBrand(String brand) { 258 | this.brand = brand; 259 | } 260 | 261 | @Override 262 | public String toString() { 263 | return "Car{" + 264 | "color='" + color + '\'' + 265 | ", licensePlate='" + licensePlate + '\'' + 266 | ", brand='" + brand + '\'' + 267 | '}'; 268 | } 269 | } 270 | 271 | ``` 272 | 273 | ```java 274 | public interface Builder { 275 | void builderColor(String color); 276 | 277 | void builderLicensePlate(String licensePlate); 278 | 279 | void builderBrand(String brand); 280 | 281 | Car build(); 282 | } 283 | 284 | ``` 285 | 286 | ```java 287 | public class CarBuilder implements Builder { 288 | 289 | Car car; 290 | 291 | public CarBuilder() { 292 | car = new Car(); 293 | } 294 | 295 | @Override 296 | public void builderColor(String color) { 297 | car.setColor(color); 298 | } 299 | 300 | @Override 301 | public void builderLicensePlate(String licensePlate) { 302 | car.setLicensePlate(licensePlate); 303 | } 304 | 305 | @Override 306 | public void builderBrand(String brand) { 307 | car.setBrand(brand); 308 | } 309 | 310 | @Override 311 | public Car build() { 312 | return car; 313 | } 314 | } 315 | 316 | ``` 317 | 318 | ```java 319 | public class Director { 320 | 321 | Builder builder; 322 | 323 | public Director(Builder builder) { 324 | this.builder = builder; 325 | } 326 | 327 | 328 | public void construct(String color, String licensePlate, String brand) { 329 | builder.builderColor(color); 330 | builder.builderLicensePlate(licensePlate); 331 | builder.builderBrand(brand); 332 | } 333 | } 334 | 335 | ``` 336 | 337 | ### Usage : 338 | 339 | ```java 340 | Builder builder = new CarBuilder(); 341 | Director director = new Director(builder); 342 | director.construct("Red","A88888","Ferrari"); 343 | System.out.println(builder.build().toString()); 344 | ``` 345 | 346 | ### Outpu: 347 | 348 | ```code 349 | Car{color='Red', licensePlate='A88888', brand='Ferrari'} 350 | ``` 351 | 352 | 353 | 354 | 355 | ## 356 | ## Factory Method 357 | The factory pattern is used to replace class constructors, abstracting the process of object generation so that the type of the object instantiated can be determined at run-time. 358 | 359 | ## UML : 360 | 361 | 362 | 363 | ### Example: 364 | 365 | ```java 366 | public interface Cake { 367 | void prepareMaterials(); 368 | 369 | void baking(); 370 | } 371 | 372 | ``` 373 | 374 | ```java 375 | public class MangoCake implements Cake{ 376 | @Override 377 | public void prepareMaterials() { 378 | System.out.println("prepare Mango Cream"); 379 | } 380 | 381 | @Override 382 | public void baking() { 383 | System.out.println("Baking ten minutes"); 384 | } 385 | } 386 | 387 | ``` 388 | 389 | ```java 390 | public abstract class Factory { 391 | public abstract T createProduct(Class clz); 392 | } 393 | 394 | ``` 395 | 396 | ```java 397 | public class CakeFactory extends Factory{ 398 | 399 | @Override 400 | public T createProduct(Class clz) { 401 | Cake cake = null; 402 | try { 403 | cake = (Cake) Class.forName(clz.getName()).getDeclaredConstructor().newInstance(); 404 | }catch (Exception e) { 405 | e.printStackTrace(); 406 | } 407 | return (T) cake; 408 | } 409 | } 410 | 411 | 412 | ``` 413 | 414 | 415 | 416 | ### Usage : 417 | 418 | ```java 419 | Factory factory = new CakeFactory(); 420 | MangoCake mangoCake = factory.createProduct(MangoCake.class); 421 | mangoCake.prepareMaterials(); 422 | mangoCake.baking(); 423 | ``` 424 | 425 | ### Outpu: 426 | 427 | ```code 428 | prepare Mango Cream 429 | Baking ten minutes 430 | ``` 431 | 432 | 433 | 434 | 435 | ## 436 | ## Abstract Factory 437 | The abstract factory pattern is used to provide a client with a set of related or dependant objects. The "family" of objects created by the factory are determined at run-time. 438 | 439 | ## UML : 440 | 441 | 442 | 443 | ### Example: 444 | 445 | ```java 446 | public abstract class CakeFactory { 447 | public abstract CakeCream cream(); 448 | public abstract CakeStyle style(); 449 | } 450 | 451 | ``` 452 | 453 | ```java 454 | public abstract class CakeCream { 455 | public abstract void cream(); 456 | } 457 | 458 | ``` 459 | 460 | ```java 461 | public abstract class CakeStyle { 462 | public abstract void style(); 463 | } 464 | 465 | ``` 466 | 467 | ```java 468 | public class HeartStyle extends CakeStyle{ 469 | @Override 470 | public void style() { 471 | System.out.println("Heart Style"); 472 | } 473 | } 474 | 475 | ``` 476 | 477 | ```java 478 | public class MangoCream extends CakeCream{ 479 | @Override 480 | public void cream() { 481 | System.out.println("Mango Cream"); 482 | } 483 | } 484 | 485 | 486 | ``` 487 | 488 | ```java 489 | public class MangoHeartCake extends CakeFactory{ 490 | @Override 491 | public CakeCream cream() { 492 | return new MangoCream() ; 493 | } 494 | 495 | @Override 496 | public CakeStyle style() { 497 | return new HeartStyle(); 498 | } 499 | } 500 | 501 | 502 | ``` 503 | 504 | 505 | 506 | 507 | ### Usage : 508 | 509 | ```java 510 | CakeFactory mangoHeartCake = new MangoHeartCake(); 511 | mangoHeartCake.cream().cream(); 512 | mangoHeartCake.style().style(); 513 | 514 | System.out.println("================="); 515 | 516 | CakeFactory mangoSquareCake = new MangoSquareCake(); 517 | mangoSquareCake.cream().cream(); 518 | mangoSquareCake.style().style(); 519 | ``` 520 | 521 | ### Outpu: 522 | 523 | ```code 524 | Mango Cream 525 | Heart Style 526 | ================= 527 | Mango Cream 528 | Square Style 529 | ``` 530 | 531 | 532 | ## 533 | ## Structural Patterns : 534 | 535 | >In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities. 536 | > 537 | 538 | ## Protection Proxy 539 | The proxy pattern is used to provide a surrogate or placeholder object, which references an underlying object. Protection proxy is restricting access. 540 | 541 | 542 | ## UML : 543 | 544 | 545 | 546 | ### Example: 547 | 548 | ```java 549 | public interface IPicker { 550 | void receiveMessage(); 551 | 552 | void takeCourier(); 553 | 554 | void signatureAcceptance(); 555 | 556 | } 557 | 558 | ``` 559 | 560 | ```java 561 | public class RealPicker implements IPicker{ 562 | @Override 563 | public void receiveMessage() { 564 | System.out.println("Receive text Message"); 565 | } 566 | 567 | @Override 568 | public void takeCourier() { 569 | System.out.println("Take the Courier"); 570 | } 571 | 572 | @Override 573 | public void signatureAcceptance() { 574 | System.out.println("Signature Acceptance"); 575 | } 576 | } 577 | 578 | 579 | ``` 580 | 581 | ```java 582 | public class ProxyPicker implements IPicker { 583 | 584 | private IPicker picker; 585 | 586 | public ProxyPicker(IPicker picker) { 587 | this.picker = picker; 588 | } 589 | 590 | @Override 591 | public void receiveMessage() { 592 | picker.receiveMessage(); 593 | } 594 | 595 | @Override 596 | public void takeCourier() { 597 | picker.takeCourier(); 598 | } 599 | 600 | @Override 601 | public void signatureAcceptance() { 602 | picker.signatureAcceptance(); 603 | } 604 | } 605 | 606 | ``` 607 | 608 | 609 | 610 | ### Usage : 611 | 612 | ```java 613 | IPicker picker = new RealPicker(); 614 | ProxyPicker proxyPicker = new ProxyPicker(picker); 615 | 616 | proxyPicker.receiveMessage(); 617 | proxyPicker.takeCourier(); 618 | proxyPicker.signatureAcceptance(); 619 | ``` 620 | 621 | ### Outpu: 622 | 623 | ```code 624 | Receive text Message 625 | Take the Courier 626 | Signature Acceptance 627 | ``` 628 | 629 | 630 | 631 | ## Decorator 632 | The decorator pattern is used to extend or alter the functionality of objects at run-time by wrapping them in an object of a decorator class. This provides a flexible alternative to using inheritance to modify behaviour. 633 | 634 | ## UML : 635 | 636 | 637 | 638 | ### Example: 639 | 640 | ```java 641 | public interface Cake { 642 | 643 | void make(); 644 | } 645 | 646 | ``` 647 | 648 | ```java 649 | public class CakeEmbryo implements Cake{ 650 | @Override 651 | public void make() { 652 | System.out.println("Baking Cake"); 653 | } 654 | } 655 | 656 | ``` 657 | 658 | ```java 659 | public abstract class DecoratorCake implements Cake { 660 | Cake cake; 661 | 662 | public DecoratorCake(Cake cake) { 663 | this.cake = cake; 664 | } 665 | 666 | @Override 667 | public void make() { 668 | cake.make(); 669 | } 670 | } 671 | 672 | ``` 673 | 674 | ```java 675 | public class FruitCake extends DecoratorCake{ 676 | 677 | public FruitCake(Cake cake) { 678 | super(cake); 679 | } 680 | 681 | @Override 682 | public void make() { 683 | addSomeFruit(); 684 | super.make(); 685 | } 686 | 687 | private void addSomeFruit(){ 688 | System.out.println("Add Some fruit"); 689 | } 690 | } 691 | 692 | ``` 693 | 694 | 695 | 696 | ### Usage : 697 | 698 | ```java 699 | Cake cake = new CakeEmbryo(); 700 | cake.make(); 701 | 702 | System.out.println("--------Decorate Fruit Cake--------"); 703 | DecoratorCake fruitCake = new FruitCake(cake); 704 | fruitCake.make(); 705 | ``` 706 | 707 | ### Outpu: 708 | 709 | ```code 710 | Baking Cake 711 | --------Decorate Fruit Cake-------- 712 | Add Some fruit 713 | Baking Cake 714 | ``` 715 | 716 | 717 | ## Adapter 718 | The adapter pattern is used to provide a link between two otherwise incompatible types by wrapping the "adaptee" with a class that supports the interface required by the client. 719 | 720 | ## UML : 721 | 722 | 723 | 724 | ### Example: 725 | 726 | ```java 727 | public interface VoltFive { 728 | int provideVoltFive(); 729 | } 730 | 731 | ``` 732 | 733 | ```java 734 | public class Volt220 { 735 | public int provideVolt220(){ 736 | return 220; 737 | } 738 | } 739 | 740 | ``` 741 | 742 | ```java 743 | public class VoltAdapter implements VoltFive{ 744 | 745 | private Volt220 volt220; 746 | 747 | public VoltAdapter(Volt220 volt220) { 748 | this.volt220 = volt220; 749 | } 750 | 751 | @Override 752 | public int provideVoltFive() { 753 | int volt = volt220.provideVolt220(); 754 | return 5; 755 | } 756 | 757 | public int provideVolt220() { 758 | return volt220.provideVolt220(); 759 | } 760 | 761 | } 762 | 763 | ``` 764 | 765 | 766 | ### Usage : 767 | 768 | ```java 769 | Volt220 volt220 = new Volt220(); 770 | VoltAdapter adapter = new VoltAdapter(volt220); 771 | 772 | int volt = adapter.provideVoltFive(); 773 | System.out.println("After adapter, the volt is :" + volt); 774 | ``` 775 | 776 | ### Outpu: 777 | 778 | ```code 779 | After adapter, the volt is :5 780 | ``` 781 | 782 | 783 | 784 | 785 | ## Facade 786 | The facade pattern is used to define a simplified interface to a more complex subsystem. 787 | 788 | ## UML : 789 | 790 | 791 | 792 | ### Example: 793 | 794 | ```java 795 | public interface Italykitchen { 796 | 797 | void lasagneWithTomatoAndCheese(); 798 | 799 | void prawnRisotto(); 800 | 801 | void creamCaramel(); 802 | 803 | 804 | } 805 | 806 | ``` 807 | 808 | ```java 809 | public class ItalykitchenImpl implements Italykitchen{ 810 | @Override 811 | public void lasagneWithTomatoAndCheese() { 812 | System.out.println("Lasagne With Tomato And Cheese"); 813 | } 814 | 815 | @Override 816 | public void prawnRisotto() { 817 | System.out.println("Prawn Risotto"); 818 | } 819 | 820 | @Override 821 | public void creamCaramel() { 822 | System.out.println("Cream Caramel"); 823 | } 824 | } 825 | 826 | ``` 827 | 828 | ```java 829 | public interface Frenchkitchen { 830 | 831 | void bouillabaisse(); 832 | 833 | void cassoulet(); 834 | 835 | void pouleAuPot(); 836 | } 837 | 838 | 839 | ``` 840 | 841 | ```java 842 | public class FrenchkitchenImpl implements Frenchkitchen{ 843 | @Override 844 | public void bouillabaisse() { 845 | System.out.println("Bouillabaisse"); 846 | } 847 | 848 | @Override 849 | public void cassoulet() { 850 | System.out.println("Cassoulet"); 851 | } 852 | 853 | @Override 854 | public void pouleAuPot() { 855 | System.out.println("PouleAuPot"); 856 | } 857 | } 858 | 859 | 860 | ``` 861 | 862 | ```java 863 | public class Menu { 864 | private Italykitchen italykitchen; 865 | private Frenchkitchen frenchkitchen; 866 | 867 | public Menu() { 868 | italykitchen = new ItalykitchenImpl(); 869 | frenchkitchen = new FrenchkitchenImpl(); 870 | } 871 | 872 | 873 | public void bouillabaisse() { 874 | frenchkitchen.bouillabaisse(); 875 | } 876 | 877 | public void cassoulet() { 878 | frenchkitchen.cassoulet(); 879 | } 880 | 881 | public void pouleAuPot() { 882 | frenchkitchen.pouleAuPot(); 883 | } 884 | 885 | public void lasagneWithTomatoAndCheese() { 886 | italykitchen.lasagneWithTomatoAndCheese(); 887 | } 888 | 889 | public void prawnRisotto() { 890 | italykitchen.prawnRisotto(); 891 | } 892 | 893 | public void creamCaramel() { 894 | italykitchen.creamCaramel(); 895 | } 896 | 897 | 898 | } 899 | 900 | ``` 901 | 902 | 903 | ### Usage : 904 | 905 | ```java 906 | Menu menu = new Menu(); 907 | 908 | System.out.println("Customer order"); 909 | menu.lasagneWithTomatoAndCheese(); 910 | menu.creamCaramel(); 911 | 912 | System.out.println("===========New Order=========="); 913 | System.out.println("Customer two orders"); 914 | menu.bouillabaisse(); 915 | menu.prawnRisotto(); 916 | ``` 917 | 918 | ### Outpu: 919 | 920 | ```code 921 | Customer order 922 | Lasagne With Tomato And Cheese 923 | Cream Caramel 924 | ===========New Order========== 925 | Customer two orders 926 | Bouillabaisse 927 | Prawn Risotto 928 | ``` 929 | 930 | 931 | ## Flyweight 932 | Flyweight is a structural design pattern that lets you fit more objects into the available amount of RAM by sharing common parts of state between multiple objects instead of keeping all of the data in each object. 933 | 934 | ## UML : 935 | 936 | 937 | 938 | ### Example: 939 | 940 | ```java 941 | public interface Ticket { 942 | public void printTicket(String time, String seat); 943 | } 944 | 945 | ``` 946 | 947 | ```java 948 | public class TicketFactory { 949 | 950 | private static Map map = new ConcurrentHashMap<>(); 951 | 952 | public static Ticket getTicket(String movieName) { 953 | if (map.containsKey(movieName)) { 954 | return map.get(movieName); 955 | } else { 956 | Ticket ticket = new MovieTicket(movieName); 957 | map.put(movieName, ticket); 958 | return ticket; 959 | } 960 | } 961 | 962 | } 963 | 964 | ``` 965 | 966 | ```java 967 | public class MovieTicket implements Ticket { 968 | 969 | private String movieName; 970 | private String price; 971 | 972 | public MovieTicket(String movieName){ 973 | this.movieName = movieName; 974 | price = "Price " + new Random().nextInt(100); 975 | } 976 | 977 | @Override 978 | 979 | public void printTicket(String time, String seat) { 980 | System.out.println("+-------------------+"); 981 | System.out.printf("| %-12s |\n", movieName); 982 | System.out.println("| |"); 983 | System.out.printf("| %-12s|\n", time); 984 | System.out.printf("| %-12s|\n", seat); 985 | System.out.printf("| %-12s|\n", price); 986 | System.out.println("| |"); 987 | System.out.println("+-------------------+"); 988 | } 989 | } 990 | 991 | ``` 992 | 993 | 994 | 995 | ### Usage : 996 | 997 | ```java 998 | MovieTicket movieTicket1 = (MovieTicket) TicketFactory.getTicket("Transformers 5"); 999 | movieTicket1.printTicket("14:00-16:30", "Seat D-5"); 1000 | MovieTicket movieTicket2 = (MovieTicket) TicketFactory.getTicket("Transformers 5"); 1001 | movieTicket2.printTicket("14:00-16:30", "Seat F-6"); 1002 | MovieTicket movieTicket3 = (MovieTicket) TicketFactory.getTicket("Transformers 5"); 1003 | movieTicket3.printTicket("18:00-22:30", "Seat A-2"); 1004 | ``` 1005 | 1006 | ### Outpu: 1007 | 1008 | ```code 1009 | +-------------------+ 1010 | | Transformers 5 | 1011 | | | 1012 | | 14:00-16:30 | 1013 | | Seat D-5 | 1014 | | Price 33 | 1015 | | | 1016 | +-------------------+ 1017 | +-------------------+ 1018 | | Transformers 5 | 1019 | | | 1020 | | 14:00-16:30 | 1021 | | Seat F-6 | 1022 | | Price 33 | 1023 | | | 1024 | +-------------------+ 1025 | +-------------------+ 1026 | | Transformers 5 | 1027 | | | 1028 | | 18:00-22:30 | 1029 | | Seat A-2 | 1030 | | Price 33 | 1031 | | | 1032 | +-------------------+ 1033 | 1034 | ``` 1035 | 1036 | 1037 | 1038 | 1039 | ## 1040 | ## Behavioral Patterns : 1041 | 1042 | >In software engineering, behavioral design patterns are design patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication. 1043 | > 1044 | 1045 | 1046 | ## Template Method 1047 | Template Method is a behavioral design pattern that defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure. 1048 | 1049 | ## UML : 1050 | 1051 | 1052 | 1053 | ### Example: 1054 | 1055 | ```java 1056 | public abstract class AssemblyLine { 1057 | 1058 | protected void onProduceShell() { 1059 | System.out.println("Produce Shell"); 1060 | } 1061 | 1062 | protected void onProduceComponents() { 1063 | System.out.println("Produce some components"); 1064 | } 1065 | 1066 | protected void onAssemblyComponents() { 1067 | System.out.println("Assembly Components"); 1068 | } 1069 | 1070 | protected void onTestProducts() { 1071 | System.out.println("Test Products"); 1072 | } 1073 | 1074 | protected void onProductPacking() { 1075 | System.out.println("Product Packing"); 1076 | } 1077 | 1078 | public final void product() { 1079 | System.out.println("+------Start Product------+"); 1080 | onProduceShell(); 1081 | onProduceComponents(); 1082 | onAssemblyComponents(); 1083 | onTestProducts(); 1084 | onProduceComponents(); 1085 | onProductPacking(); 1086 | System.out.println("+------Finish Product------+"); 1087 | } 1088 | 1089 | } 1090 | 1091 | ``` 1092 | 1093 | ```java 1094 | public class ComputerAssemblyLine extends AssemblyLine{ 1095 | 1096 | @Override 1097 | protected void onProduceShell() { 1098 | System.out.println("Product Aluminum housing and Liquid Crystal Display"); 1099 | } 1100 | 1101 | @Override 1102 | protected void onProduceComponents() { 1103 | System.out.println("Product Components and keyboard"); 1104 | } 1105 | 1106 | @Override 1107 | protected void onProductPacking() { 1108 | System.out.println("Pack and Mark the Apple trademark"); 1109 | } 1110 | } 1111 | ``` 1112 | 1113 | ```java 1114 | public class RadioAssemblyLine extends AssemblyLine{ 1115 | 1116 | @Override 1117 | protected void onProduceComponents() { 1118 | System.out.println("Product Radio Components and Antennas"); 1119 | } 1120 | } 1121 | 1122 | 1123 | ``` 1124 | 1125 | 1126 | 1127 | ### Usage : 1128 | 1129 | ```java 1130 | AssemblyLine assemblyLine = new ComputerAssemblyLine(); 1131 | assemblyLine.product(); 1132 | 1133 | System.out.println(); 1134 | 1135 | assemblyLine = new RadioAssemblyLine(); 1136 | assemblyLine.product(); 1137 | ``` 1138 | 1139 | ### Outpu: 1140 | 1141 | ```code 1142 | +------Start Product------+ 1143 | Product Aluminum housing and Liquid Crystal Display 1144 | Product Components and keyboard 1145 | Assembly Components 1146 | Test Products 1147 | Product Components and keyboard 1148 | Pack and Mark the Apple trademark 1149 | +------Finish Product------+ 1150 | 1151 | +------Start Product------+ 1152 | Produce Shell 1153 | Product Radio Components and Antennas 1154 | Assembly Components 1155 | Test Products 1156 | Product Radio Components and Antennas 1157 | Product Packing 1158 | +------Finish Product------+ 1159 | 1160 | ``` 1161 | 1162 | 1163 | ## Chain of Responsibility 1164 | The chain of responsibility pattern is used to process varied requests, each of which may be dealt with by a different handler. 1165 | 1166 | ## UML : 1167 | 1168 | 1169 | 1170 | ### Example: 1171 | 1172 | ```java 1173 | public abstract class Handler { 1174 | 1175 | protected Handler successor; 1176 | 1177 | public abstract int capital(); 1178 | 1179 | public abstract void handle(int money); 1180 | 1181 | public final void handleRequest(int money) { 1182 | if (money <= capital()) { 1183 | handle(money); 1184 | }else { 1185 | if (null != successor) { 1186 | successor.handleRequest(money); 1187 | }else { 1188 | System.out.println("Your requested funds could not be approved"); 1189 | } 1190 | } 1191 | } 1192 | 1193 | } 1194 | 1195 | ``` 1196 | 1197 | ```java 1198 | public class Tutor extends Handler{ 1199 | @Override 1200 | public int capital() { 1201 | return 100; 1202 | } 1203 | 1204 | @Override 1205 | public void handle(int money) { 1206 | System.out.println("Approved by the instructor: approved " + money + " Dollar"); 1207 | } 1208 | } 1209 | ``` 1210 | 1211 | ```java 1212 | public class Secretary extends Handler { 1213 | @Override 1214 | public int capital() { 1215 | return 1000; 1216 | } 1217 | 1218 | @Override 1219 | public void handle(int money) { 1220 | System.out.println("Secretary approved: approved " + money + " Dollar"); 1221 | } 1222 | } 1223 | 1224 | 1225 | ``` 1226 | 1227 | ```java 1228 | public class Principal extends Handler { 1229 | @Override 1230 | public int capital() { 1231 | return 1000; 1232 | } 1233 | 1234 | @Override 1235 | public void handle(int money) { 1236 | System.out.println("Approved by the principal: approved " + money + " Dollar"); 1237 | } 1238 | } 1239 | 1240 | 1241 | ``` 1242 | 1243 | ```java 1244 | public class Dean extends Handler { 1245 | @Override 1246 | public int capital() { 1247 | return 5000; 1248 | } 1249 | 1250 | @Override 1251 | public void handle(int money) { 1252 | System.out.println("Dean approved: approved " + money + " Dollar"); 1253 | } 1254 | } 1255 | 1256 | ``` 1257 | 1258 | 1259 | 1260 | ### Usage : 1261 | 1262 | ```java 1263 | Tutor tutor = new Tutor(); 1264 | Secretary secretary = new Secretary(); 1265 | Dean dean = new Dean(); 1266 | Principal principal = new Principal(); 1267 | 1268 | tutor.successor = secretary; 1269 | secretary.successor = dean; 1270 | dean.successor = principal; 1271 | principal.successor = null; 1272 | 1273 | tutor.handleRequest(12000); 1274 | secretary.handleRequest(100); 1275 | ``` 1276 | 1277 | ### Outpu: 1278 | 1279 | ```code 1280 | Your requested funds could not be approved 1281 | Secretary approved: approved 100 Dollar 1282 | 1283 | ``` 1284 | 1285 | 1286 | 1287 | ## Command 1288 | The command pattern is used to express a request, including the call to be made and all of its required parameters, in a command object. The command may then be executed immediately or held for later use. 1289 | 1290 | ## UML : 1291 | 1292 | 1293 | 1294 | 1295 | ### Example: 1296 | 1297 | ```java 1298 | public interface OrderCommand { 1299 | void execute(); 1300 | } 1301 | 1302 | ``` 1303 | 1304 | ```java 1305 | public class OrderPayCommand implements OrderCommand{ 1306 | 1307 | public Long id; 1308 | 1309 | public OrderPayCommand(Long id) { 1310 | this.id = id; 1311 | } 1312 | 1313 | @Override 1314 | public void execute() { 1315 | System.out.println("Paying for order with id : " + id); 1316 | } 1317 | } 1318 | 1319 | ``` 1320 | 1321 | ```java 1322 | public class OrderAddCommand implements OrderCommand{ 1323 | public Long id; 1324 | 1325 | public OrderAddCommand(Long id) { 1326 | this.id = id; 1327 | } 1328 | 1329 | @Override 1330 | public void execute() { 1331 | System.out.println("Adding Order With id : " + id); 1332 | } 1333 | } 1334 | 1335 | ``` 1336 | 1337 | ```java 1338 | public class CommandProcessor { 1339 | 1340 | ArrayList queue = new ArrayList<>(); 1341 | 1342 | public void addToQueue(OrderCommand orderCommand) { 1343 | queue.add(orderCommand); 1344 | } 1345 | 1346 | public void processCommands() { 1347 | queue.forEach(OrderCommand::execute); 1348 | queue.clear(); 1349 | } 1350 | } 1351 | 1352 | ``` 1353 | 1354 | 1355 | ### Usage : 1356 | 1357 | ```java 1358 | CommandProcessor obj = new CommandProcessor(); 1359 | obj.addToQueue(new OrderAddCommand(1L)); 1360 | obj.addToQueue(new OrderAddCommand(2L)); 1361 | obj.addToQueue(new OrderPayCommand(2L)); 1362 | obj.addToQueue(new OrderPayCommand(1L)); 1363 | obj.processCommands(); 1364 | ``` 1365 | 1366 | ### Outpu: 1367 | 1368 | ```code 1369 | Adding Order With id : 1 1370 | Adding Order With id : 2 1371 | Paying for order with id : 2 1372 | Paying for order with id : 1 1373 | 1374 | ``` 1375 | 1376 | 1377 | 1378 | ## Iterator 1379 | Iterator is a behavioral design pattern that lets you traverse elements of a collection without exposing its underlying representation (list, stack, tree, etc.). 1380 | 1381 | ## UML : 1382 | 1383 | 1384 | 1385 | 1386 | ### Example: 1387 | 1388 | ```java 1389 | public interface Iterator { 1390 | boolean hasNext(); 1391 | T next(); 1392 | } 1393 | 1394 | ``` 1395 | 1396 | ```java 1397 | public interface BookIterable { 1398 | Iterator iterator(); 1399 | } 1400 | 1401 | ``` 1402 | 1403 | ```java 1404 | public class Book { 1405 | 1406 | private String name; 1407 | private String ISBN; 1408 | private String press; 1409 | 1410 | public Book(String name, String ISBN, String press) { 1411 | this.name = name; 1412 | this.ISBN = ISBN; 1413 | this.press = press; 1414 | } 1415 | 1416 | @Override 1417 | public String toString() { 1418 | return "Book{" + 1419 | "name='" + name + '\'' + 1420 | ", ISBN='" + ISBN + '\'' + 1421 | ", press='" + press + '\'' + 1422 | '}'; 1423 | } 1424 | 1425 | /* 1426 | Don't forget geeter and setter !!!! 1427 | */ 1428 | ``` 1429 | 1430 | ```java 1431 | public class Literature implements BookIterable{ 1432 | 1433 | private Book[] literature; 1434 | 1435 | public Literature() { 1436 | literature = new Book[4]; 1437 | literature[0] = new Book("Three Kingdoms", "9787532237357", "Shanghai People's Fine Arts Publishing House"); 1438 | literature[1] = new Book("Journey to the West", "9787805200552", "Yuelu Publishing House"); 1439 | literature[2] = new Book("Water Margin", "9787020015016", "People's Literature Publishing House"); 1440 | literature[3] = new Book("Dream of Red Mansions", "9787020002207", "People's Literature Publishing House"); 1441 | } 1442 | 1443 | public Book[] getLiterature() { 1444 | return literature; 1445 | } 1446 | 1447 | @Override 1448 | public Iterator iterator() { 1449 | return new LiteratureIterator(literature); 1450 | } 1451 | } 1452 | ``` 1453 | 1454 | ```java 1455 | public class LiteratureIterator implements Iterator{ 1456 | 1457 | 1458 | private Book[] literatures; 1459 | 1460 | private int index; 1461 | 1462 | public LiteratureIterator(Book[] literatures) { 1463 | this.literatures = literatures; 1464 | } 1465 | 1466 | @Override 1467 | public boolean hasNext() { 1468 | return (index < literatures.length - 1 && literatures[index] != null); 1469 | } 1470 | 1471 | @Override 1472 | public Book next() { 1473 | return literatures[index++]; 1474 | } 1475 | } 1476 | ``` 1477 | 1478 | 1479 | 1480 | ### Usage : 1481 | 1482 | ```java 1483 | public static void main(String[] args) { 1484 | Literature literature = new Literature(); 1485 | itr(literature.iterator()); 1486 | 1487 | } 1488 | 1489 | private static void itr(Iterator iterator) { 1490 | while (iterator.hasNext()) { 1491 | System.out.println(iterator.next()); 1492 | } 1493 | } 1494 | ``` 1495 | 1496 | ### Outpu: 1497 | 1498 | ```code 1499 | Book{name='Three Kingdoms', ISBN='9787532237357', press='Shanghai People's Fine Arts Publishing House'} 1500 | Book{name='Journey to the West', ISBN='9787805200552', press='Yuelu Publishing House'} 1501 | Book{name='Water Margin', ISBN='9787020015016', press='People's Literature Publishing House'} 1502 | ``` 1503 | 1504 | 1505 | 1506 | ## Mediator 1507 | Mediator design pattern is used to provide a centralized communication medium between different objects in a system. This pattern is very helpful in an enterprise application where multiple objects are interacting with each other. 1508 | 1509 | ## UML : 1510 | 1511 | 1512 | 1513 | 1514 | ### Example: 1515 | 1516 | ```java 1517 | public interface ChatMediator { 1518 | void sendMessage(String msg, User user); 1519 | void addUser(User user); 1520 | } 1521 | 1522 | ``` 1523 | 1524 | ```java 1525 | public abstract class User { 1526 | protected ChatMediator mediator; 1527 | protected String name; 1528 | 1529 | public User(ChatMediator med, String name) { 1530 | this.mediator = med; 1531 | this.name = name; 1532 | } 1533 | 1534 | public abstract void send(String msg); 1535 | public abstract void receive(String msg); 1536 | } 1537 | 1538 | ``` 1539 | 1540 | ```java 1541 | public class ChatMediatorImpl implements ChatMediator { 1542 | private final List users; 1543 | 1544 | public ChatMediatorImpl() { this.users = new ArrayList<>(); } 1545 | 1546 | @Override 1547 | public void addUser(User user) { 1548 | this.users.add(user); 1549 | } 1550 | 1551 | @Override 1552 | public void sendMessage(String msg, User toUser) { 1553 | for (User user : users) { 1554 | //Message should not be received by the user sending it. 1555 | if(user != toUser) { user.receive(msg); } 1556 | } 1557 | } 1558 | } 1559 | ``` 1560 | 1561 | ```java 1562 | public class UserImpl extends User { 1563 | public UserImpl(ChatMediator med, String name) { 1564 | super(med, name); 1565 | } 1566 | 1567 | @Override 1568 | public void send(String msg) { 1569 | System.out.println(this.name + ": Sending Message = " + msg); 1570 | mediator.sendMessage(msg, this); 1571 | } 1572 | 1573 | @Override 1574 | public void receive(String msg) { 1575 | System.out.println(this.name + ": Message received: " + msg); 1576 | } 1577 | } 1578 | ``` 1579 | 1580 | 1581 | 1582 | ### Usage : 1583 | 1584 | ```java 1585 | ChatMediator mediator = new ChatMediatorImpl(); 1586 | User user1 = new UserImpl(mediator, "Tamer"); 1587 | User user2 = new UserImpl(mediator, "Mohab"); 1588 | User user3 = new UserImpl(mediator, "Mohand"); 1589 | User user4 = new UserImpl(mediator, "Habiba"); 1590 | 1591 | mediator.addUser(user1); 1592 | mediator.addUser(user2); 1593 | mediator.addUser(user3); 1594 | mediator.addUser(user4); 1595 | 1596 | user1.send("Hi everyone!"); 1597 | ``` 1598 | 1599 | ### Outpu: 1600 | 1601 | ```code 1602 | Mohab: Message received: Hi everyone! 1603 | Mohand: Message received: Hi everyone! 1604 | Habiba: Message received: Hi everyone! 1605 | ``` 1606 | 1607 | 1608 | 1609 | 1610 | ## Memento 1611 | The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). 1612 | 1613 | ## UML : 1614 | 1615 | 1616 | 1617 | 1618 | ### Example: 1619 | 1620 | ```java 1621 | public class Memento { 1622 | private String mDate; 1623 | private String mTodo; 1624 | private boolean mIsFinish; 1625 | 1626 | public void setDate(String date) { 1627 | mDate = date; 1628 | } 1629 | 1630 | public String getDate() { 1631 | return mDate; 1632 | } 1633 | 1634 | public String getTodo() { 1635 | return mTodo; 1636 | } 1637 | 1638 | public void setTodo(String mTodo) { 1639 | this.mTodo = mTodo; 1640 | } 1641 | 1642 | public boolean isFinish() { 1643 | return mIsFinish; 1644 | } 1645 | 1646 | public void setIsFinish(boolean mIsFinish) { 1647 | this.mIsFinish = mIsFinish; 1648 | } 1649 | 1650 | @Override 1651 | public String toString() { 1652 | return "memento{" + 1653 | "Date='" + mDate + '\'' + 1654 | ", Todo='" + mTodo + '\'' + 1655 | ", IsFinish=" + mIsFinish + 1656 | '}'; 1657 | } 1658 | } 1659 | 1660 | ``` 1661 | 1662 | ```java 1663 | public class Caretaker { 1664 | private Memento mMemoto; 1665 | 1666 | public void archive(Memento memoto) { 1667 | mMemoto = memoto; 1668 | } 1669 | 1670 | public Memento getMemoto() { 1671 | return mMemoto; 1672 | } 1673 | } 1674 | 1675 | ``` 1676 | 1677 | ```java 1678 | public class ToDo { 1679 | private String mDate; 1680 | private String mTodo; 1681 | private boolean mIsFinish; 1682 | 1683 | public ToDo() { 1684 | mDate = new SimpleDateFormat("yyyy/MM/dd EE HH:mm:ss").format(new Date()); 1685 | } 1686 | 1687 | public void setToDoDetail(String todo, boolean isFinish) { 1688 | mTodo = todo; 1689 | mIsFinish = isFinish; 1690 | } 1691 | 1692 | public Memento createMemoto() { 1693 | Memento memento = new Memento(); 1694 | memento.setDate(mDate); 1695 | memento.setTodo(mTodo); 1696 | memento.setIsFinish(mIsFinish); 1697 | return memento; 1698 | } 1699 | 1700 | public void restore(Memento memento) { 1701 | mDate = memento.getDate(); 1702 | mTodo = memento.getTodo(); 1703 | mIsFinish = memento.isFinish(); 1704 | } 1705 | 1706 | public String getDate() { 1707 | return mDate; 1708 | } 1709 | 1710 | public String getTodo() { 1711 | return mTodo; 1712 | } 1713 | 1714 | public void setTodo(String mTodo) { 1715 | this.mTodo = mTodo; 1716 | } 1717 | 1718 | public boolean isIsFinish() { 1719 | return mIsFinish; 1720 | } 1721 | 1722 | public void setIsFinish(boolean mIsFinish) { 1723 | this.mIsFinish = mIsFinish; 1724 | } 1725 | 1726 | @Override 1727 | public String toString() { 1728 | return "ToDo{" + 1729 | "Date='" + mDate + '\'' + 1730 | ", Todo='" + mTodo + '\'' + 1731 | ", IsFinish=" + mIsFinish + 1732 | '}'; 1733 | } 1734 | } 1735 | ``` 1736 | 1737 | 1738 | 1739 | 1740 | ### Usage : 1741 | 1742 | ```java 1743 | ToDo toDo = new ToDo(); 1744 | 1745 | toDo.setToDoDetail("Write Java at 2 pm", false); 1746 | 1747 | Caretaker caretaker = new Caretaker(); 1748 | caretaker.archive(toDo.createMemoto()); 1749 | 1750 | System.out.println(toDo.toString()); 1751 | 1752 | ToDo newToDo = new ToDo(); 1753 | newToDo.restore(caretaker.getMemoto()); 1754 | newToDo.setIsFinish(true); 1755 | 1756 | System.out.println(newToDo.toString()); 1757 | ``` 1758 | 1759 | ### Outpu: 1760 | 1761 | ```code 1762 | ToDo{Date='2021/11/06 Sat 16:04:55', Todo='Write Java at 2 pm', IsFinish=false} 1763 | ToDo{Date='2021/11/06 Sat 16:04:55', Todo='Write Java at 2 pm', IsFinish=true} 1764 | ``` 1765 | 1766 | 1767 | 1768 | 1769 | ## Observer 1770 | The observer pattern is used to allow an object to publish changes to its state. Other objects subscribe to be immediately notified of any changes. 1771 | 1772 | ## UML : 1773 | 1774 | 1775 | 1776 | 1777 | ### Example: 1778 | 1779 | ```java 1780 | public interface Observer { 1781 | public void update(String magazine); 1782 | } 1783 | 1784 | ``` 1785 | 1786 | ```java 1787 | public interface Subject { 1788 | void registerObserver(Observer observer); 1789 | void removeObserver(Observer observer); 1790 | void notifyObservers(); 1791 | } 1792 | 1793 | ``` 1794 | 1795 | ```java 1796 | public class Magazine implements Subject{ 1797 | private List observerList; 1798 | private String magazine; 1799 | 1800 | public Magazine() { 1801 | observerList = new ArrayList<>(); 1802 | } 1803 | 1804 | @Override 1805 | public void registerObserver(Observer observer) { 1806 | observerList.add(observer); 1807 | } 1808 | 1809 | @Override 1810 | public void removeObserver(Observer observer) { 1811 | observerList.remove(observer); 1812 | } 1813 | 1814 | @Override 1815 | public void notifyObservers() { 1816 | for (int i = 0; i < observerList.size(); i++) { 1817 | Observer observer= observerList.get(i); 1818 | observer.update(magazine); 1819 | } 1820 | } 1821 | 1822 | public void setMagazine(String magazine) { 1823 | this.magazine = magazine; 1824 | notifyObservers(); 1825 | } 1826 | 1827 | } 1828 | 1829 | ``` 1830 | 1831 | ```java 1832 | public class Subscriber implements Observer { 1833 | 1834 | private final String subscriber; 1835 | 1836 | public Subscriber(Subject magazine, String subscriber) { 1837 | magazine.registerObserver(this); 1838 | this.subscriber = subscriber; 1839 | } 1840 | 1841 | @Override 1842 | public void update(String magazine) { 1843 | System.out.println("Dear" + subscriber + ": Your magazine has arrived, and today’s magazine is called《" + magazine +"》"); 1844 | } 1845 | } 1846 | ``` 1847 | 1848 | ```java 1849 | public class Bookstore implements Observer{ 1850 | public Bookstore(Subject magazine) { 1851 | magazine.registerObserver(this); 1852 | } 1853 | 1854 | @Override 1855 | public void update(String magazine) { 1856 | System.out.println("Our shop updates the magazine today：《" + magazine+ "》"); 1857 | } 1858 | } 1859 | ``` 1860 | 1861 | 1862 | 1863 | ### Usage : 1864 | 1865 | ```java 1866 | Magazine magazine = new Magazine(); 1867 | 1868 | Subscriber mohamed = new Subscriber(magazine, "Mohamed"); 1869 | Subscriber tamer = new Subscriber(magazine, "Tamer"); 1870 | Subscriber habiba = new Subscriber(magazine, "Habiba"); 1871 | Bookstore bookstore = new Bookstore(magazine); 1872 | 1873 | magazine.setMagazine("Shock! Today's magazine since..."); 1874 | ``` 1875 | 1876 | ### Outpu: 1877 | 1878 | ```code 1879 | DearMohamed: Your magazine has arrived, and today’s magazine is called《Shock! Today's magazine since...》 1880 | DearTamer: Your magazine has arrived, and today’s magazine is called《Shock! Today's magazine since...》 1881 | DearHabiba: Your magazine has arrived, and today’s magazine is called《Shock! Today's magazine since...》 1882 | Our shop updates the magazine today：《Shock! Today's magazine since...》 1883 | ``` 1884 | 1885 | 1886 | 1887 | 1888 | ## State 1889 | The state pattern is used to alter the behaviour of an object as its internal state changes. The pattern allows the class for an object to apparently change at run-time. 1890 | 1891 | ## UML : 1892 | 1893 | 1894 | 1895 | 1896 | ### Example: 1897 | 1898 | ```java 1899 | public interface GameState { 1900 | void killMonster(); 1901 | void gainExperience(); 1902 | void next(); 1903 | void pick(); 1904 | } 1905 | 1906 | ``` 1907 | 1908 | ```java 1909 | public class Player { 1910 | 1911 | GameState state; 1912 | 1913 | public void setState(GameState state) { 1914 | this.state = state; 1915 | } 1916 | 1917 | public void gameStart() { 1918 | setState(new GameStartState()); 1919 | System.out.println("\n-----Game Start, ready to fight-----\n"); 1920 | } 1921 | 1922 | public void gameOver() { 1923 | setState(new GameOverState()); 1924 | System.out.println("\n----- Game Over -----\n"); 1925 | } 1926 | 1927 | public void killMonster() { 1928 | state.killMonster(); 1929 | } 1930 | 1931 | public void gainExperience() { 1932 | state.gainExperience(); 1933 | } 1934 | 1935 | public void next() { 1936 | state.next(); 1937 | } 1938 | 1939 | public void pick() { 1940 | state.pick(); 1941 | } 1942 | 1943 | } 1944 | 1945 | ``` 1946 | 1947 | ```java 1948 | public class GameStartState implements GameState { 1949 | 1950 | @Override 1951 | public void killMonster() { 1952 | System.out.println("Kill a Monster"); 1953 | } 1954 | 1955 | @Override 1956 | public void gainExperience() { 1957 | System.out.println("Gain 5 EXP"); 1958 | } 1959 | 1960 | @Override 1961 | public void next() { 1962 | System.out.println("Good! please enter next level"); 1963 | } 1964 | 1965 | @Override 1966 | public void pick() { 1967 | System.out.println("Wow! You pick a good thing"); 1968 | } 1969 | } 1970 | 1971 | ``` 1972 | 1973 | ```java 1974 | public class GameOverState implements GameState { 1975 | 1976 | @Override 1977 | public void killMonster() { 1978 | System.out.println("Please start game first"); 1979 | } 1980 | 1981 | @Override 1982 | public void gainExperience() {} 1983 | 1984 | @Override 1985 | public void next() { 1986 | System.out.println("You want to challenge again?"); 1987 | } 1988 | 1989 | @Override 1990 | public void pick() { 1991 | System.out.println("Please start game first"); 1992 | } 1993 | } 1994 | ``` 1995 | 1996 | 1997 | 1998 | ### Usage : 1999 | 2000 | ```java 2001 | Player player = new Player(); 2002 | player.gameStart(); 2003 | player.killMonster(); 2004 | player.gainExperience(); 2005 | player.next(); 2006 | player.pick(); 2007 | player.gameOver(); 2008 | player.next(); 2009 | player.killMonster(); 2010 | player.pick(); 2011 | ``` 2012 | 2013 | ### Outpu: 2014 | 2015 | ```code 2016 | -----Game Start, ready to fight----- 2017 | 2018 | Kill a Monster 2019 | Gain 5 EXP 2020 | Good! please enter next level 2021 | Wow! You pick a good thing 2022 | 2023 | ----- Game Over ----- 2024 | 2025 | You want to challenge again? 2026 | Please start game first 2027 | Please start game first 2028 | 2029 | ``` 2030 | 2031 | 2032 | 2033 | 2034 | ## Strategy 2035 | The strategy pattern is used to create an interchangeable family of algorithms from which the required process is chosen at run-time. 2036 | 2037 | ## UML : 2038 | 2039 | 2040 | 2041 | 2042 | ### Example: 2043 | 2044 | ```java 2045 | public interface Strategy { 2046 | void transportation(); 2047 | } 2048 | ``` 2049 | 2050 | ```java 2051 | public class Context { 2052 | private Strategy goToStrategy; 2053 | 2054 | public void setGoToStrategy(Strategy strategy) { 2055 | this.goToStrategy = strategy; 2056 | } 2057 | 2058 | public void take() { 2059 | goToStrategy.transportation(); 2060 | } 2061 | } 2062 | 2063 | ``` 2064 | 2065 | ```java 2066 | public class GoToCairo implements Strategy{ 2067 | @Override 2068 | public void transportation() { 2069 | System.out.println("take my car"); 2070 | } 2071 | } 2072 | ``` 2073 | 2074 | ```java 2075 | public class GoToGona implements Strategy{ 2076 | @Override 2077 | public void transportation() { 2078 | System.out.println("take plane"); 2079 | } 2080 | } 2081 | ``` 2082 | 2083 | 2084 | 2085 | ### Usage : 2086 | 2087 | ```java 2088 | Context context = new Context(); 2089 | 2090 | context.setGoToStrategy(new GoToCairo()); 2091 | context.take(); 2092 | 2093 | context.setGoToStrategy(new GoToGona()); 2094 | context.take(); 2095 | ``` 2096 | 2097 | ### Outpu: 2098 | 2099 | ```code 2100 | take my car 2101 | take plane 2102 | 2103 | ``` 2104 | 2105 | 2106 | 2107 | 2108 | ## Visitor 2109 | The visitor pattern is used to separate a relatively complex set of structured data classes from the functionality that may be performed upon the data that they hold. 2110 | 2111 | ## UML : 2112 | 2113 | 2114 | 2115 | 2116 | ### Example: 2117 | 2118 | ```java 2119 | public interface Interviewer { 2120 | void visit(Student student); 2121 | void visit(Engineer engineer); 2122 | } 2123 | 2124 | ``` 2125 | 2126 | ```java 2127 | public interface Applicant { 2128 | void accept(Interviewer visitor); 2129 | } 2130 | ``` 2131 | 2132 | ```java 2133 | public class Engineer implements Applicant { 2134 | 2135 | private String name; 2136 | private int workExperience; 2137 | private int projectNumber; 2138 | 2139 | public Engineer(String name, int workExperience, int projectNumber) { 2140 | this.name = name; 2141 | this.workExperience = workExperience; 2142 | this.projectNumber = projectNumber; 2143 | } 2144 | 2145 | @Override 2146 | public void accept(Interviewer visitor) { 2147 | visitor.visit(this); 2148 | } 2149 | 2150 | public String getName() { 2151 | return name; 2152 | } 2153 | 2154 | public void setName(String name) { 2155 | this.name = name; 2156 | } 2157 | 2158 | public int getWorkExperience() { 2159 | return workExperience; 2160 | } 2161 | 2162 | public void setWorkExperience(int workExperience) { 2163 | this.workExperience = workExperience; 2164 | } 2165 | 2166 | public int getProjectNumber() { 2167 | return projectNumber; 2168 | } 2169 | 2170 | public void setProjectNumber(int projectNumber) { 2171 | this.projectNumber = projectNumber; 2172 | } 2173 | } 2174 | ``` 2175 | 2176 | ```java 2177 | public class Student implements Applicant{ 2178 | private String name; 2179 | private double gpa; 2180 | private String major; 2181 | 2182 | public Student(String name, double gpa, String major) { 2183 | this.name = name; 2184 | this.gpa = gpa; 2185 | this.major = major; 2186 | } 2187 | 2188 | @Override 2189 | public void accept(Interviewer visitor) { 2190 | visitor.visit(this); 2191 | } 2192 | 2193 | public String getName() { 2194 | return name; 2195 | } 2196 | 2197 | public void setName(String name) { 2198 | this.name = name; 2199 | } 2200 | 2201 | 2202 | public double getGpa() { 2203 | return gpa; 2204 | } 2205 | 2206 | public void setGpa(double gpa) { 2207 | this.gpa = gpa; 2208 | } 2209 | 2210 | public String getMajor() { 2211 | return major; 2212 | } 2213 | 2214 | public void setMajor(String major) { 2215 | this.major = major; 2216 | } 2217 | } 2218 | ``` 2219 | 2220 | ```java 2221 | public class Leader implements Interviewer { 2222 | @Override 2223 | public void visit(Student student) { 2224 | System.out.println("Student " + student.getName() + "'s gpa is " + student.getGpa()); 2225 | } 2226 | 2227 | @Override 2228 | public void visit(Engineer engineer) { 2229 | System.out.println("Engineer " + engineer.getName() + "'s number of projects is " + engineer.getProjectNumber()); 2230 | } 2231 | } 2232 | ``` 2233 | 2234 | ```java 2235 | public class LaborMarket { 2236 | 2237 | List applicants = new ArrayList<>(); 2238 | 2239 | { 2240 | applicants.add(new Student("Tamer", 3.2, "Computer Science")); 2241 | applicants.add(new Student("Mohamed", 3.4, "Network Engineer")); 2242 | applicants.add(new Student("Habiba", 3.4, "Computer Science")); 2243 | applicants.add(new Engineer("Ahmed", 4, 15)); 2244 | applicants.add(new Engineer("Mohand", 3, 10)); 2245 | applicants.add(new Engineer("Mohab", 6, 20)); 2246 | } 2247 | 2248 | 2249 | public void showApplicants(Interviewer visitor) { 2250 | for (Applicant applicant : applicants) { 2251 | applicant.accept(visitor); 2252 | } 2253 | } 2254 | } 2255 | 2256 | ``` 2257 | 2258 | 2259 | 2260 | ### Usage : 2261 | 2262 | ```java 2263 | LaborMarket laborMarket = new LaborMarket(); 2264 | System.out.println("===== Round 1: Leader ====="); 2265 | laborMarket.showApplicants(new Leader()); 2266 | 2267 | /* 2268 | You can add more rounds and implements ............. 2269 | */ 2270 | ``` 2271 | 2272 | ### Outpu: 2273 | 2274 | ```code 2275 | ===== Round 1: Leader ===== 2276 | Student Tamer's gpa is 3.2 2277 | Student Mohamed's gpa is 3.4 2278 | Student Habiba's gpa is 3.4 2279 | Engineer Ahmed's number of projects is 15 2280 | Engineer Mohand's number of projects is 10 2281 | Engineer Mohab's number of projects is 20 2282 | 2283 | ``` 2284 | 2285 | 2286 | 2287 | 2288 | 2289 | 2290 | 2291 | 2292 | 2293 | 2294 | 2295 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/chain_of_responsibility/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.chain_of_responsibility; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | 6 | Tutor tutor = new Tutor(); 7 | Secretary secretary = new Secretary(); 8 | Dean dean = new Dean(); 9 | Principal principal = new Principal(); 10 | 11 | tutor.successor = secretary; 12 | secretary.successor = dean; 13 | dean.successor = principal; 14 | principal.successor = null; 15 | 16 | tutor.handleRequest(12000); 17 | secretary.handleRequest(100); 18 | 19 | 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/chain_of_responsibility/Dean.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.chain_of_responsibility; 2 | 3 | public class Dean extends Handler { 4 | @Override 5 | public int capital() { 6 | return 5000; 7 | } 8 | 9 | @Override 10 | public void handle(int money) { 11 | System.out.println("Dean approved: approved " + money + " Dollar"); 12 | } 13 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/chain_of_responsibility/Handler.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.chain_of_responsibility; 2 | 3 | public abstract class Handler { 4 | 5 | protected Handler successor; 6 | 7 | public abstract int capital(); 8 | 9 | public abstract void handle(int money); 10 | 11 | public final void handleRequest(int money) { 12 | if (money <= capital()) { 13 | handle(money); 14 | }else { 15 | if (null != successor) { 16 | successor.handleRequest(money); 17 | }else { 18 | System.out.println("Your requested funds could not be approved"); 19 | } 20 | } 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/chain_of_responsibility/Principal.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.chain_of_responsibility; 2 | 3 | public class Principal extends Handler { 4 | @Override 5 | public int capital() { 6 | return 1000; 7 | } 8 | 9 | @Override 10 | public void handle(int money) { 11 | System.out.println("Approved by the principal: approved " + money + " Dollar"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/chain_of_responsibility/Secretary.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.chain_of_responsibility; 2 | 3 | public class Secretary extends Handler { 4 | @Override 5 | public int capital() { 6 | return 1000; 7 | } 8 | 9 | @Override 10 | public void handle(int money) { 11 | System.out.println("Secretary approved: approved " + money + " Dollar"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/chain_of_responsibility/Tutor.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.chain_of_responsibility; 2 | 3 | public class Tutor extends Handler{ 4 | @Override 5 | public int capital() { 6 | return 100; 7 | } 8 | 9 | @Override 10 | public void handle(int money) { 11 | System.out.println("Approved by the instructor: approved " + money + " Dollar"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/commandpatterns/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.commandpatterns; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | CommandProcessor obj = new CommandProcessor(); 6 | obj.addToQueue(new OrderAddCommand(1L)); 7 | obj.addToQueue(new OrderAddCommand(2L)); 8 | obj.addToQueue(new OrderPayCommand(2L)); 9 | obj.addToQueue(new OrderPayCommand(1L)); 10 | obj.processCommands(); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/commandpatterns/CommandProcessor.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.commandpatterns; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class CommandProcessor { 6 | 7 | ArrayList queue = new ArrayList<>(); 8 | 9 | public void addToQueue(OrderCommand orderCommand) { 10 | queue.add(orderCommand); 11 | } 12 | 13 | public void processCommands() { 14 | queue.forEach(OrderCommand::execute); 15 | queue.clear(); 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/commandpatterns/OrderAddCommand.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.commandpatterns; 2 | 3 | public class OrderAddCommand implements OrderCommand{ 4 | public Long id; 5 | 6 | public OrderAddCommand(Long id) { 7 | this.id = id; 8 | } 9 | 10 | @Override 11 | public void execute() { 12 | System.out.println("Adding Order With id : " + id); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/commandpatterns/OrderCommand.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.commandpatterns; 2 | 3 | public interface OrderCommand { 4 | void execute(); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/commandpatterns/OrderPayCommand.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.commandpatterns; 2 | 3 | public class OrderPayCommand implements OrderCommand{ 4 | 5 | public Long id; 6 | 7 | public OrderPayCommand(Long id) { 8 | this.id = id; 9 | } 10 | 11 | @Override 12 | public void execute() { 13 | System.out.println("Paying for order with id : " + id); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/iterator/Book.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.iterator; 2 | 3 | public class Book { 4 | 5 | private String name; 6 | private String ISBN; 7 | private String press; 8 | 9 | public Book(String name, String ISBN, String press) { 10 | this.name = name; 11 | this.ISBN = ISBN; 12 | this.press = press; 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return "Book{" + 18 | "name='" + name + '\'' + 19 | ", ISBN='" + ISBN + '\'' + 20 | ", press='" + press + '\'' + 21 | '}'; 22 | } 23 | 24 | public String getName() { 25 | return name; 26 | } 27 | 28 | public void setName(String name) { 29 | this.name = name; 30 | } 31 | 32 | public String getISBN() { 33 | return ISBN; 34 | } 35 | 36 | public void setISBN(String ISBN) { 37 | this.ISBN = ISBN; 38 | } 39 | 40 | public String getPress() { 41 | return press; 42 | } 43 | 44 | public void setPress(String press) { 45 | this.press = press; 46 | } 47 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/iterator/BookIterable.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.iterator; 2 | 3 | public interface BookIterable { 4 | 5 | Iterator iterator(); 6 | 7 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/iterator/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.iterator; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Literature literature = new Literature(); 6 | itr(literature.iterator()); 7 | 8 | 9 | } 10 | 11 | private static void itr(Iterator iterator) { 12 | while (iterator.hasNext()) { 13 | System.out.println(iterator.next()); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/iterator/Iterator.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.iterator; 2 | 3 | public interface Iterator { 4 | 5 | boolean hasNext(); 6 | 7 | T next(); 8 | 9 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/iterator/Literature.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.iterator; 2 | 3 | public class Literature implements BookIterable{ 4 | 5 | private Book[] literature; 6 | 7 | public Literature() { 8 | literature = new Book[4]; 9 | literature[0] = new Book("Three Kingdoms", "9787532237357", "Shanghai People's Fine Arts Publishing House"); 10 | literature[1] = new Book("Journey to the West", "9787805200552", "Yuelu Publishing House"); 11 | literature[2] = new Book("Water Margin", "9787020015016", "People's Literature Publishing House"); 12 | literature[3] = new Book("Dream of Red Mansions", "9787020002207", "People's Literature Publishing House"); 13 | } 14 | 15 | public Book[] getLiterature() { 16 | return literature; 17 | } 18 | 19 | @Override 20 | public Iterator iterator() { 21 | return new LiteratureIterator(literature); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/iterator/LiteratureIterator.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.iterator; 2 | 3 | public class LiteratureIterator implements Iterator{ 4 | 5 | 6 | private Book[] literatures; 7 | 8 | private int index; 9 | 10 | public LiteratureIterator(Book[] literatures) { 11 | this.literatures = literatures; 12 | } 13 | 14 | @Override 15 | public boolean hasNext() { 16 | return (index < literatures.length - 1 && literatures[index] != null); 17 | } 18 | 19 | @Override 20 | public Book next() { 21 | return literatures[index++]; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/mediator/ChatMediator.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.mediator; 2 | 3 | 4 | 5 | public interface ChatMediator { 6 | void sendMessage(String msg, User user); 7 | void addUser(User user); 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/mediator/ChatMediatorImpl.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.mediator; 2 | 3 | 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | 7 | public class ChatMediatorImpl implements ChatMediator { 8 | private final List users; 9 | 10 | public ChatMediatorImpl() { this.users = new ArrayList<>(); } 11 | 12 | @Override 13 | public void addUser(User user) { 14 | this.users.add(user); 15 | } 16 | 17 | @Override 18 | public void sendMessage(String msg, User toUser) { 19 | for (User user : users) { 20 | //Message should not be received by the user sending it. 21 | if(user != toUser) { user.receive(msg); } 22 | } 23 | } 24 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/mediator/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.mediator; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | ChatMediator mediator = new ChatMediatorImpl(); 6 | 7 | User user1 = new UserImpl(mediator, "Tamer"); 8 | User user2 = new UserImpl(mediator, "Mohab"); 9 | User user3 = new UserImpl(mediator, "Mohand"); 10 | User user4 = new UserImpl(mediator, "Habiba"); 11 | 12 | mediator.addUser(user1); 13 | mediator.addUser(user2); 14 | mediator.addUser(user3); 15 | mediator.addUser(user4); 16 | 17 | user1.send("Hi everyone!"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/mediator/User.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.mediator; 2 | 3 | 4 | public abstract class User { 5 | protected ChatMediator mediator; 6 | protected String name; 7 | 8 | public User(ChatMediator med, String name) { 9 | this.mediator = med; 10 | this.name = name; 11 | } 12 | 13 | public abstract void send(String msg); 14 | public abstract void receive(String msg); 15 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/mediator/UserImpl.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.mediator; 2 | 3 | 4 | public class UserImpl extends User { 5 | public UserImpl(ChatMediator med, String name) { 6 | super(med, name); 7 | } 8 | 9 | @Override 10 | public void send(String msg) { 11 | System.out.println(this.name + ": Sending Message = " + msg); 12 | mediator.sendMessage(msg, this); 13 | } 14 | 15 | @Override 16 | public void receive(String msg) { 17 | System.out.println(this.name + ": Message received: " + msg); 18 | } 19 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/memento/Caretaker.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.memento; 2 | 3 | public class Caretaker { 4 | private Memento mMemoto; 5 | 6 | public void archive(Memento memoto) { 7 | mMemoto = memoto; 8 | } 9 | 10 | public Memento getMemoto() { 11 | return mMemoto; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/memento/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.memento; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | ToDo toDo = new ToDo(); 6 | 7 | toDo.setToDoDetail("Write Java at 2 pm", false); 8 | 9 | Caretaker caretaker = new Caretaker(); 10 | caretaker.archive(toDo.createMemoto()); 11 | 12 | System.out.println(toDo.toString()); 13 | 14 | ToDo newToDo = new ToDo(); 15 | newToDo.restore(caretaker.getMemoto()); 16 | newToDo.setIsFinish(true); 17 | 18 | System.out.println(newToDo.toString()); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/memento/Memento.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.memento; 2 | 3 | public class Memento { 4 | private String mDate; 5 | private String mTodo; 6 | private boolean mIsFinish; 7 | 8 | public void setDate(String date) { 9 | mDate = date; 10 | } 11 | 12 | public String getDate() { 13 | return mDate; 14 | } 15 | 16 | public String getTodo() { 17 | return mTodo; 18 | } 19 | 20 | public void setTodo(String mTodo) { 21 | this.mTodo = mTodo; 22 | } 23 | 24 | public boolean isFinish() { 25 | return mIsFinish; 26 | } 27 | 28 | public void setIsFinish(boolean mIsFinish) { 29 | this.mIsFinish = mIsFinish; 30 | } 31 | 32 | @Override 33 | public String toString() { 34 | return "memento{" + 35 | "Date='" + mDate + '\'' + 36 | ", Todo='" + mTodo + '\'' + 37 | ", IsFinish=" + mIsFinish + 38 | '}'; 39 | } 40 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/memento/ToDo.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.memento; 2 | 3 | import java.text.SimpleDateFormat; 4 | import java.util.Date; 5 | 6 | public class ToDo { 7 | private String mDate; 8 | private String mTodo; 9 | private boolean mIsFinish; 10 | 11 | public ToDo() { 12 | mDate = new SimpleDateFormat("yyyy/MM/dd EE HH:mm:ss").format(new Date()); 13 | } 14 | 15 | public void setToDoDetail(String todo, boolean isFinish) { 16 | mTodo = todo; 17 | mIsFinish = isFinish; 18 | } 19 | 20 | public Memento createMemoto() { 21 | Memento memento = new Memento(); 22 | memento.setDate(mDate); 23 | memento.setTodo(mTodo); 24 | memento.setIsFinish(mIsFinish); 25 | return memento; 26 | } 27 | 28 | public void restore(Memento memento) { 29 | mDate = memento.getDate(); 30 | mTodo = memento.getTodo(); 31 | mIsFinish = memento.isFinish(); 32 | } 33 | 34 | public String getDate() { 35 | return mDate; 36 | } 37 | 38 | public String getTodo() { 39 | return mTodo; 40 | } 41 | 42 | public void setTodo(String mTodo) { 43 | this.mTodo = mTodo; 44 | } 45 | 46 | public boolean isIsFinish() { 47 | return mIsFinish; 48 | } 49 | 50 | public void setIsFinish(boolean mIsFinish) { 51 | this.mIsFinish = mIsFinish; 52 | } 53 | 54 | @Override 55 | public String toString() { 56 | return "ToDo{" + 57 | "Date='" + mDate + '\'' + 58 | ", Todo='" + mTodo + '\'' + 59 | ", IsFinish=" + mIsFinish + 60 | '}'; 61 | } 62 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/observer/Bookstore.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.observer; 2 | 3 | public class Bookstore implements Observer{ 4 | 5 | public Bookstore(Subject magazine) { 6 | magazine.registerObserver(this); 7 | } 8 | 9 | @Override 10 | public void update(String magazine) { 11 | System.out.println("Our shop updates the magazine today：《" + magazine+ "》"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/observer/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.observer; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Magazine magazine = new Magazine(); 6 | 7 | Subscriber mohamed = new Subscriber(magazine, "Mohamed"); 8 | Subscriber tamer = new Subscriber(magazine, "Tamer"); 9 | Subscriber habiba = new Subscriber(magazine, "Habiba"); 10 | Bookstore bookstore = new Bookstore(magazine); 11 | 12 | magazine.setMagazine("Shock! Today's magazine since..."); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/observer/Magazine.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.observer; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Magazine implements Subject{ 7 | private List observerList; 8 | private String magazine; 9 | 10 | public Magazine() { 11 | observerList = new ArrayList<>(); 12 | } 13 | 14 | @Override 15 | public void registerObserver(Observer observer) { 16 | observerList.add(observer); 17 | } 18 | 19 | @Override 20 | public void removeObserver(Observer observer) { 21 | observerList.remove(observer); 22 | } 23 | 24 | @Override 25 | public void notifyObservers() { 26 | for (int i = 0; i < observerList.size(); i++) { 27 | Observer observer= observerList.get(i); 28 | observer.update(magazine); 29 | } 30 | } 31 | 32 | 33 | public void setMagazine(String magazine) { 34 | this.magazine = magazine; 35 | notifyObservers(); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/observer/Observer.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.observer; 2 | 3 | public interface Observer { 4 | public void update(String magazine); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/observer/Subject.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.observer; 2 | 3 | public interface Subject { 4 | 5 | void registerObserver(Observer observer); 6 | void removeObserver(Observer observer); 7 | void notifyObservers(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/observer/Subscriber.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.observer; 2 | 3 | public class Subscriber implements Observer { 4 | 5 | private final String subscriber; 6 | 7 | public Subscriber(Subject magazine, String subscriber) { 8 | magazine.registerObserver(this); 9 | this.subscriber = subscriber; 10 | } 11 | 12 | @Override 13 | public void update(String magazine) { 14 | System.out.println("Dear" + subscriber + ": Your magazine has arrived, and today’s magazine is called《" + magazine +"》"); 15 | } 16 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/state/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.state; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Player player = new Player(); 6 | player.gameStart(); 7 | player.killMonster(); 8 | player.gainExperience(); 9 | player.next(); 10 | player.pick(); 11 | player.gameOver(); 12 | player.next(); 13 | player.killMonster(); 14 | player.pick(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/state/GameOverState.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.state; 2 | 3 | public class GameOverState implements GameState { 4 | 5 | @Override 6 | public void killMonster() { 7 | System.out.println("Please start game first"); 8 | } 9 | 10 | @Override 11 | public void gainExperience() { 12 | 13 | } 14 | 15 | @Override 16 | public void next() { 17 | System.out.println("You want to challenge again?"); 18 | } 19 | 20 | @Override 21 | public void pick() { 22 | System.out.println("Please start game first"); 23 | } 24 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/state/GameStartState.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.state; 2 | 3 | public class GameStartState implements GameState { 4 | 5 | @Override 6 | public void killMonster() { 7 | System.out.println("Kill a Monster"); 8 | } 9 | 10 | 11 | @Override 12 | public void gainExperience() { 13 | System.out.println("Gain 5 EXP"); 14 | } 15 | 16 | 17 | @Override 18 | public void next() { 19 | System.out.println("Good! please enter next level"); 20 | } 21 | 22 | 23 | @Override 24 | public void pick() { 25 | System.out.println("Wow! You pick a good thing"); 26 | } 27 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/state/GameState.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.state; 2 | 3 | public interface GameState { 4 | void killMonster(); 5 | 6 | void gainExperience(); 7 | 8 | void next(); 9 | 10 | void pick(); 11 | } 12 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/state/Player.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.state; 2 | 3 | public class Player { 4 | 5 | GameState state; 6 | 7 | public void setState(GameState state) { 8 | this.state = state; 9 | } 10 | 11 | public void gameStart() { 12 | setState(new GameStartState()); 13 | System.out.println("\n-----Game Start, ready to fight-----\n"); 14 | } 15 | 16 | public void gameOver() { 17 | setState(new GameOverState()); 18 | System.out.println("\n----- Game Over -----\n"); 19 | } 20 | 21 | public void killMonster() { 22 | state.killMonster(); 23 | } 24 | 25 | public void gainExperience() { 26 | state.gainExperience(); 27 | } 28 | 29 | public void next() { 30 | state.next(); 31 | } 32 | 33 | public void pick() { 34 | state.pick(); 35 | } 36 | 37 | 38 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/strategy/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.strategy; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Context context = new Context(); 6 | 7 | context.setGoToStrategy(new GoToCairo()); 8 | context.take(); 9 | 10 | context.setGoToStrategy(new GoToGona()); 11 | context.take(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/strategy/Context.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.strategy; 2 | 3 | public class Context { 4 | private Strategy goToStrategy; 5 | 6 | public void setGoToStrategy(Strategy strategy) { 7 | this.goToStrategy = strategy; 8 | } 9 | 10 | public void take() { 11 | goToStrategy.transportation(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/strategy/GoToCairo.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.strategy; 2 | 3 | public class GoToCairo implements Strategy{ 4 | @Override 5 | public void transportation() { 6 | System.out.println("take my car"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/strategy/GoToGona.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.strategy; 2 | 3 | public class GoToGona implements Strategy{ 4 | @Override 5 | public void transportation() { 6 | System.out.println("take plane"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/strategy/Strategy.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.strategy; 2 | 3 | public interface Strategy { 4 | void transportation(); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/template_method/AssemblyLine.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.template_method; 2 | 3 | public abstract class AssemblyLine { 4 | 5 | 6 | protected void onProduceShell() { 7 | System.out.println("Produce Shell"); 8 | } 9 | 10 | protected void onProduceComponents() { 11 | System.out.println("Produce some components"); 12 | } 13 | 14 | protected void onAssemblyComponents() { 15 | System.out.println("Assembly Components"); 16 | } 17 | 18 | protected void onTestProducts() { 19 | System.out.println("Test Products"); 20 | } 21 | 22 | protected void onProductPacking() { 23 | System.out.println("Product Packing"); 24 | } 25 | 26 | public final void product() { 27 | System.out.println("+------Start Product------+"); 28 | onProduceShell(); 29 | onProduceComponents(); 30 | onAssemblyComponents(); 31 | onTestProducts(); 32 | onProduceComponents(); 33 | onProductPacking(); 34 | System.out.println("+------Finish Product------+"); 35 | } 36 | 37 | } 38 | 39 | 40 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/template_method/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.template_method; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | AssemblyLine assemblyLine = new ComputerAssemblyLine(); 6 | assemblyLine.product(); 7 | 8 | System.out.println(); 9 | 10 | assemblyLine = new RadioAssemblyLine(); 11 | assemblyLine.product(); 12 | 13 | 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/template_method/ComputerAssemblyLine.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.template_method; 2 | 3 | public class ComputerAssemblyLine extends AssemblyLine{ 4 | 5 | @Override 6 | protected void onProduceShell() { 7 | System.out.println("Product Aluminum housing and Liquid Crystal Display"); 8 | } 9 | 10 | @Override 11 | protected void onProduceComponents() { 12 | System.out.println("Product Components and keyboard"); 13 | } 14 | 15 | @Override 16 | protected void onProductPacking() { 17 | System.out.println("Pack and Mark the Apple trademark"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/template_method/RadioAssemblyLine.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.template_method; 2 | 3 | public class RadioAssemblyLine extends AssemblyLine{ 4 | 5 | @Override 6 | protected void onProduceComponents() { 7 | System.out.println("Product Radio Components and Antennas"); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/Applicant.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | public interface Applicant { 4 | void accept(Interviewer visitor); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | LaborMarket laborMarket = new LaborMarket(); 6 | System.out.println("===== Round 1: Leader ====="); 7 | laborMarket.showApplicants(new Leader()); 8 | 9 | /* 10 | You can add more rounds and implements ............. 11 | */ 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/Engineer.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | public class Engineer implements Applicant { 4 | 5 | private String name; 6 | private int workExperience; 7 | private int projectNumber; 8 | 9 | public Engineer(String name, int workExperience, int projectNumber) { 10 | this.name = name; 11 | this.workExperience = workExperience; 12 | this.projectNumber = projectNumber; 13 | } 14 | 15 | @Override 16 | public void accept(Interviewer visitor) { 17 | visitor.visit(this); 18 | } 19 | 20 | public String getName() { 21 | return name; 22 | } 23 | 24 | public void setName(String name) { 25 | this.name = name; 26 | } 27 | 28 | public int getWorkExperience() { 29 | return workExperience; 30 | } 31 | 32 | public void setWorkExperience(int workExperience) { 33 | this.workExperience = workExperience; 34 | } 35 | 36 | public int getProjectNumber() { 37 | return projectNumber; 38 | } 39 | 40 | public void setProjectNumber(int projectNumber) { 41 | this.projectNumber = projectNumber; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/Interviewer.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | public interface Interviewer { 4 | void visit(Student student); 5 | void visit(Engineer engineer); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/LaborMarket.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class LaborMarket { 7 | 8 | List applicants = new ArrayList<>(); 9 | 10 | { 11 | applicants.add(new Student("Tamer", 3.2, "Computer Science")); 12 | applicants.add(new Student("Mohamed", 3.4, "Network Engineer")); 13 | applicants.add(new Student("Habiba", 3.4, "Computer Science")); 14 | applicants.add(new Engineer("Ahmed", 4, 15)); 15 | applicants.add(new Engineer("Mohand", 3, 10)); 16 | applicants.add(new Engineer("Mohab", 6, 20)); 17 | } 18 | 19 | 20 | public void showApplicants(Interviewer visitor) { 21 | for (Applicant applicant : applicants) { 22 | applicant.accept(visitor); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/Leader.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | public class Leader implements Interviewer { 4 | @Override 5 | public void visit(Student student) { 6 | System.out.println("Student " + student.getName() + "'s gpa is " + student.getGpa()); 7 | } 8 | 9 | @Override 10 | public void visit(Engineer engineer) { 11 | System.out.println("Engineer " + engineer.getName() + "'s number of projects is " + engineer.getProjectNumber()); 12 | } 13 | } -------------------------------------------------------------------------------- /src/com/company/Behavioraldesignpatterns/visitor/Student.java: -------------------------------------------------------------------------------- 1 | package com.company.Behavioraldesignpatterns.visitor; 2 | 3 | public class Student implements Applicant{ 4 | private String name; 5 | private double gpa; 6 | private String major; 7 | 8 | public Student(String name, double gpa, String major) { 9 | this.name = name; 10 | this.gpa = gpa; 11 | this.major = major; 12 | } 13 | 14 | @Override 15 | public void accept(Interviewer visitor) { 16 | visitor.visit(this); 17 | } 18 | 19 | public String getName() { 20 | return name; 21 | } 22 | 23 | public void setName(String name) { 24 | this.name = name; 25 | } 26 | 27 | 28 | public double getGpa() { 29 | return gpa; 30 | } 31 | 32 | public void setGpa(double gpa) { 33 | this.gpa = gpa; 34 | } 35 | 36 | public String getMajor() { 37 | return major; 38 | } 39 | 40 | public void setMajor(String major) { 41 | this.major = major; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/Prototype/WordDocument.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.Prototype; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class WordDocument implements Cloneable { 6 | private String text; 7 | private ArrayList images = new ArrayList<>(); 8 | 9 | public WordDocument() { 10 | System.out.println("-----Init-----"); 11 | } 12 | 13 | public String getText() { 14 | return text; 15 | } 16 | 17 | public void setText(String text) { 18 | this.text = text; 19 | } 20 | 21 | public ArrayList getImages() { 22 | return images; 23 | } 24 | 25 | public void setImages(ArrayList images) { 26 | this.images = images; 27 | } 28 | 29 | public void addImage(String image) { 30 | images.add(image); 31 | } 32 | 33 | public void showDocument() { 34 | System.out.println("-----Start-----"); 35 | System.out.println("Text : " + text); 36 | System.out.println("Image List : "); 37 | for (String mImage : images) { 38 | System.out.println("Image Name : " + mImage); 39 | } 40 | System.out.println("-----End-----"); 41 | } 42 | 43 | protected WordDocument clone() { 44 | try { 45 | WordDocument copy = (WordDocument) super.clone(); 46 | copy.text = this.text; 47 | // copy.images = this.images; 48 | copy.images = (ArrayList) this.images.clone(); 49 | return copy; 50 | } catch (CloneNotSupportedException e) { 51 | e.printStackTrace(); 52 | } 53 | return null; 54 | } 55 | 56 | 57 | public static void main(String[] args) { 58 | WordDocument originDoc = new WordDocument(); 59 | originDoc.setText("This is a document"); 60 | originDoc.addImage("Image 1"); 61 | originDoc.addImage("Image 2"); 62 | originDoc.addImage("Image 3"); 63 | originDoc.showDocument(); 64 | WordDocument copyDoc = originDoc.clone(); 65 | copyDoc.showDocument(); 66 | copyDoc.setText("This is a copy document"); 67 | // add this line to test the origin document what will happen after the copy document add a image 68 | copyDoc.addImage("a new Image"); 69 | copyDoc.showDocument(); 70 | copyDoc.showDocument(); 71 | } 72 | 73 | } 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/CakeCream.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public abstract class CakeCream { 4 | public abstract void cream(); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/CakeFactory.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public abstract class CakeFactory { 4 | public abstract CakeCream cream(); 5 | public abstract CakeStyle style(); 6 | } 7 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/CakeStyle.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public abstract class CakeStyle { 4 | public abstract void style(); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | CakeFactory mangoHeartCake = new MangoHeartCake(); 6 | mangoHeartCake.cream().cream(); 7 | mangoHeartCake.style().style(); 8 | 9 | System.out.println("================="); 10 | 11 | CakeFactory mangoSquareCake = new MangoSquareCake(); 12 | mangoSquareCake.cream().cream(); 13 | mangoSquareCake.style().style(); 14 | 15 | 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/HeartStyle.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public class HeartStyle extends CakeStyle{ 4 | @Override 5 | public void style() { 6 | System.out.println("Heart Style"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/MangoCream.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public class MangoCream extends CakeCream{ 4 | @Override 5 | public void cream() { 6 | System.out.println("Mango Cream"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/MangoHeartCake.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public class MangoHeartCake extends CakeFactory{ 4 | @Override 5 | public CakeCream cream() { 6 | return new MangoCream() ; 7 | } 8 | 9 | @Override 10 | public CakeStyle style() { 11 | return new HeartStyle(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/MangoSquareCake.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public class MangoSquareCake extends CakeFactory{ 4 | @Override 5 | public CakeCream cream() { 6 | return new MangoCream(); 7 | } 8 | 9 | @Override 10 | public CakeStyle style() { 11 | return new SquareStyle(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/abstractfactory/SquareStyle.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.abstractfactory; 2 | 3 | public class SquareStyle extends CakeStyle{ 4 | @Override 5 | public void style() { 6 | System.out.println("Square Style"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/builder/Builder.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.builder; 2 | 3 | public interface Builder { 4 | void builderColor(String color); 5 | 6 | void builderLicensePlate(String licensePlate); 7 | 8 | void builderBrand(String brand); 9 | 10 | Car build(); 11 | } 12 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/builder/Car.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.builder; 2 | 3 | public class Car { 4 | private String color; 5 | private String licensePlate; 6 | private String brand; 7 | 8 | public void setColor(String color) { 9 | this.color = color; 10 | } 11 | 12 | public void setLicensePlate(String licensePlate) { 13 | this.licensePlate = licensePlate; 14 | } 15 | 16 | public void setBrand(String brand) { 17 | this.brand = brand; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "Car{" + 23 | "color='" + color + '\'' + 24 | ", licensePlate='" + licensePlate + '\'' + 25 | ", brand='" + brand + '\'' + 26 | '}'; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/builder/CarBuilder.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.builder; 2 | 3 | public class CarBuilder implements Builder { 4 | 5 | Car car; 6 | 7 | public CarBuilder() { 8 | car = new Car(); 9 | } 10 | 11 | @Override 12 | public void builderColor(String color) { 13 | car.setColor(color); 14 | } 15 | 16 | @Override 17 | public void builderLicensePlate(String licensePlate) { 18 | car.setLicensePlate(licensePlate); 19 | } 20 | 21 | @Override 22 | public void builderBrand(String brand) { 23 | car.setBrand(brand); 24 | } 25 | 26 | @Override 27 | public Car build() { 28 | return car; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/builder/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.builder; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Builder builder = new CarBuilder(); 6 | Director director = new Director(builder); 7 | director.construct("Red","A88888","Ferrari"); 8 | System.out.println(builder.build().toString()); 9 | 10 | 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/builder/Director.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.builder; 2 | 3 | public class Director { 4 | 5 | Builder builder; 6 | 7 | public Director(Builder builder) { 8 | this.builder = builder; 9 | } 10 | 11 | 12 | public void construct(String color, String licensePlate, String brand) { 13 | builder.builderColor(color); 14 | builder.builderLicensePlate(licensePlate); 15 | builder.builderBrand(brand); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/factory/Cake.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.factory; 2 | 3 | public interface Cake { 4 | void prepareMaterials(); 5 | 6 | void baking(); 7 | } 8 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/factory/CakeFactory.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.factory; 2 | 3 | public class CakeFactory extends Factory{ 4 | 5 | @Override 6 | public T createProduct(Class clz) { 7 | Cake cake = null; 8 | try { 9 | cake = (Cake) Class.forName(clz.getName()).getDeclaredConstructor().newInstance(); 10 | }catch (Exception e) { 11 | e.printStackTrace(); 12 | } 13 | return (T) cake; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/factory/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.factory; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Factory factory = new CakeFactory(); 6 | MangoCake mangoCake = factory.createProduct(MangoCake.class); 7 | mangoCake.prepareMaterials(); 8 | mangoCake.baking(); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/factory/Factory.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.factory; 2 | 3 | public abstract class Factory { 4 | public abstract T createProduct(Class clz); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/factory/MangoCake.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.factory; 2 | 3 | public class MangoCake implements Cake{ 4 | @Override 5 | public void prepareMaterials() { 6 | System.out.println("prepare Mango Cream"); 7 | } 8 | 9 | @Override 10 | public void baking() { 11 | System.out.println("Baking ten minutes"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Creationaldesignpattern/singleton/Counter.java: -------------------------------------------------------------------------------- 1 | package com.company.Creationaldesignpattern.singleton; 2 | 3 | public class Counter { 4 | 5 | public int count = 0; 6 | 7 | private static Counter instance = new Counter(); 8 | 9 | private Counter() { 10 | } 11 | 12 | public static Counter getInstance() { 13 | return instance; 14 | } 15 | 16 | public void addOne() { 17 | count++; 18 | } 19 | 20 | 21 | public static void main(String[] args) { 22 | 23 | Counter obj1 = Counter.getInstance(); 24 | Counter obj2 = Counter.getInstance(); 25 | obj1.addOne(); 26 | obj2.addOne(); 27 | System.out.println("Counter 1 : " + obj1.count); 28 | System.out.println("Counter 2 : " + obj2.count); 29 | 30 | obj1.addOne(); 31 | obj2.addOne(); 32 | System.out.println("Counter 1 : " + obj1.count); 33 | System.out.println("Counter 2 : " + obj2.count); 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/adapter/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.adapter; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Volt220 volt220 = new Volt220(); 6 | VoltAdapter adapter = new VoltAdapter(volt220); 7 | 8 | int volt = adapter.provideVoltFive(); 9 | System.out.println("After adapter, the volt is :" + volt); 10 | 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/adapter/Volt220.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.adapter; 2 | 3 | public class Volt220 { 4 | public int provideVolt220(){ 5 | return 220; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/adapter/VoltAdapter.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.adapter; 2 | 3 | public class VoltAdapter implements VoltFive{ 4 | 5 | private Volt220 volt220; 6 | 7 | public VoltAdapter(Volt220 volt220) { 8 | this.volt220 = volt220; 9 | } 10 | 11 | @Override 12 | public int provideVoltFive() { 13 | int volt = volt220.provideVolt220(); 14 | return 5; 15 | } 16 | 17 | public int provideVolt220() { 18 | return volt220.provideVolt220(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/adapter/VoltFive.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.adapter; 2 | 3 | public interface VoltFive { 4 | int provideVoltFive(); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/decorator/Cake.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.decorator; 2 | 3 | public interface Cake { 4 | 5 | void make(); 6 | } 7 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/decorator/CakeEmbryo.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.decorator; 2 | 3 | public class CakeEmbryo implements Cake{ 4 | @Override 5 | public void make() { 6 | System.out.println("Baking Cake"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/decorator/DecoratorCake.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.decorator; 2 | 3 | public abstract class DecoratorCake implements Cake { 4 | Cake cake; 5 | 6 | public DecoratorCake(Cake cake) { 7 | this.cake = cake; 8 | } 9 | 10 | @Override 11 | public void make() { 12 | cake.make(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/decorator/FruitCake.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.decorator; 2 | 3 | public class FruitCake extends DecoratorCake{ 4 | 5 | public FruitCake(Cake cake) { 6 | super(cake); 7 | } 8 | 9 | @Override 10 | public void make() { 11 | addSomeFruit(); 12 | super.make(); 13 | } 14 | 15 | private void addSomeFruit(){ 16 | System.out.println("Add Some fruit"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/decorator/client.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.decorator; 2 | 3 | public class client { 4 | public static void main(String[] args) { 5 | Cake cake = new CakeEmbryo(); 6 | cake.make(); 7 | 8 | System.out.println("--------Decorate Fruit Cake--------"); 9 | DecoratorCake fruitCake = new FruitCake(cake); 10 | fruitCake.make(); 11 | 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/facade/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.facade; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Menu menu = new Menu(); 6 | 7 | System.out.println("Customer order"); 8 | menu.lasagneWithTomatoAndCheese(); 9 | menu.creamCaramel(); 10 | 11 | System.out.println("===========New Order=========="); 12 | System.out.println("Customer two orders"); 13 | menu.bouillabaisse(); 14 | menu.prawnRisotto(); 15 | 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/facade/Frenchkitchen.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.facade; 2 | 3 | public interface Frenchkitchen { 4 | 5 | void bouillabaisse(); 6 | 7 | void cassoulet(); 8 | 9 | void pouleAuPot(); 10 | } 11 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/facade/FrenchkitchenImpl.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.facade; 2 | 3 | public class FrenchkitchenImpl implements Frenchkitchen{ 4 | @Override 5 | public void bouillabaisse() { 6 | System.out.println("Bouillabaisse"); 7 | } 8 | 9 | @Override 10 | public void cassoulet() { 11 | System.out.println("Cassoulet"); 12 | } 13 | 14 | @Override 15 | public void pouleAuPot() { 16 | System.out.println("PouleAuPot"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/facade/Italykitchen.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.facade; 2 | 3 | public interface Italykitchen { 4 | 5 | void lasagneWithTomatoAndCheese(); 6 | 7 | void prawnRisotto(); 8 | 9 | void creamCaramel(); 10 | 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/facade/ItalykitchenImpl.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.facade; 2 | 3 | public class ItalykitchenImpl implements Italykitchen{ 4 | @Override 5 | public void lasagneWithTomatoAndCheese() { 6 | System.out.println("Lasagne With Tomato And Cheese"); 7 | } 8 | 9 | @Override 10 | public void prawnRisotto() { 11 | System.out.println("Prawn Risotto"); 12 | } 13 | 14 | @Override 15 | public void creamCaramel() { 16 | System.out.println("Cream Caramel"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/facade/Menu.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.facade; 2 | 3 | public class Menu { 4 | private Italykitchen italykitchen; 5 | private Frenchkitchen frenchkitchen; 6 | 7 | public Menu() { 8 | italykitchen = new ItalykitchenImpl(); 9 | frenchkitchen = new FrenchkitchenImpl(); 10 | } 11 | 12 | 13 | public void bouillabaisse() { 14 | frenchkitchen.bouillabaisse(); 15 | } 16 | 17 | public void cassoulet() { 18 | frenchkitchen.cassoulet(); 19 | } 20 | 21 | public void pouleAuPot() { 22 | frenchkitchen.pouleAuPot(); 23 | } 24 | 25 | public void lasagneWithTomatoAndCheese() { 26 | italykitchen.lasagneWithTomatoAndCheese(); 27 | } 28 | 29 | public void prawnRisotto() { 30 | italykitchen.prawnRisotto(); 31 | } 32 | 33 | public void creamCaramel() { 34 | italykitchen.creamCaramel(); 35 | } 36 | 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/flyweight/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.flyweight; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | MovieTicket movieTicket1 = (MovieTicket) TicketFactory.getTicket("Transformers 5"); 6 | movieTicket1.printTicket("14:00-16:30", "Seat D-5"); 7 | MovieTicket movieTicket2 = (MovieTicket) TicketFactory.getTicket("Transformers 5"); 8 | movieTicket2.printTicket("14:00-16:30", "Seat F-6"); 9 | MovieTicket movieTicket3 = (MovieTicket) TicketFactory.getTicket("Transformers 5"); 10 | movieTicket3.printTicket("18:00-22:30", "Seat A-2"); 11 | 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/flyweight/MovieTicket.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.flyweight; 2 | 3 | import java.util.Random; 4 | 5 | public class MovieTicket implements Ticket { 6 | 7 | private String movieName; 8 | private String price; 9 | 10 | public MovieTicket(String movieName){ 11 | this.movieName = movieName; 12 | price = "Price " + new Random().nextInt(100); 13 | } 14 | 15 | @Override 16 | 17 | public void printTicket(String time, String seat) { 18 | System.out.println("+-------------------+"); 19 | System.out.printf("| %-12s |\n", movieName); 20 | System.out.println("| |"); 21 | System.out.printf("| %-12s|\n", time); 22 | System.out.printf("| %-12s|\n", seat); 23 | System.out.printf("| %-12s|\n", price); 24 | System.out.println("| |"); 25 | System.out.println("+-------------------+"); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/flyweight/Ticket.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.flyweight; 2 | 3 | public interface Ticket { 4 | public void printTicket(String time, String seat); 5 | } 6 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/flyweight/TicketFactory.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.flyweight; 2 | 3 | import java.util.Map; 4 | import java.util.concurrent.ConcurrentHashMap; 5 | 6 | public class TicketFactory { 7 | 8 | private static Map map = new ConcurrentHashMap<>(); 9 | 10 | public static Ticket getTicket(String movieName) { 11 | if (map.containsKey(movieName)) { 12 | return map.get(movieName); 13 | } else { 14 | Ticket ticket = new MovieTicket(movieName); 15 | map.put(movieName, ticket); 16 | return ticket; 17 | } 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/proxy/Client.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.proxy; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | IPicker picker = new RealPicker(); 6 | ProxyPicker proxyPicker = new ProxyPicker(picker); 7 | 8 | proxyPicker.receiveMessage(); 9 | proxyPicker.takeCourier(); 10 | proxyPicker.signatureAcceptance(); 11 | 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/proxy/IPicker.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.proxy; 2 | 3 | public interface IPicker { 4 | void receiveMessage(); 5 | 6 | void takeCourier(); 7 | 8 | void signatureAcceptance(); 9 | 10 | } 11 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/proxy/ProxyPicker.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.proxy; 2 | 3 | public class ProxyPicker implements IPicker { 4 | 5 | private IPicker picker; 6 | 7 | public ProxyPicker(IPicker picker) { 8 | this.picker = picker; 9 | } 10 | 11 | @Override 12 | public void receiveMessage() { 13 | picker.receiveMessage(); 14 | } 15 | 16 | @Override 17 | public void takeCourier() { 18 | picker.takeCourier(); 19 | } 20 | 21 | @Override 22 | public void signatureAcceptance() { 23 | picker.signatureAcceptance(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/com/company/Structuraldesignpatterns/proxy/RealPicker.java: -------------------------------------------------------------------------------- 1 | package com.company.Structuraldesignpatterns.proxy; 2 | 3 | public class RealPicker implements IPicker{ 4 | @Override 5 | public void receiveMessage() { 6 | System.out.println("Receive text Message"); 7 | } 8 | 9 | @Override 10 | public void takeCourier() { 11 | System.out.println("Take the Courier"); 12 | } 13 | 14 | @Override 15 | public void signatureAcceptance() { 16 | System.out.println("Signature Acceptance"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /untitled104.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | --------------------------------------------------------------------------------