Ιστολόγιο Velislav Krastev

Ποιες είναι οι αρχές SOLID;

Τι είναι η Αρχή της Ενιαίας Ευθύνης (SRP):

Μια τάξη πρέπει να έχει μόνο μία ευθύνη.
Θα πρέπει να έχει μόνο έναν λόγο να αλλάξει.
Τα οφέλη περιλαμβάνουν ευκολότερη δοκιμή, χαμηλότερη σύζευξη και καλύτερη οργάνωση.
Παράδειγμα:

Ιάβα

δημόσια τάξη Βιβλίο {
ιδιωτικό όνομα συμβολοσειράς;
ιδιωτικός συγγραφέας συμβολοσειρών;
ιδιωτικό κείμενο συμβολοσειράς.
// κατασκευαστές, λήπτες και ρυθμιστές
}

Τι είναι η αρχή ανοιχτού-κλειστού (OCP):

Οι οντότητες λογισμικού (κλάσεις, ενότητες, συναρτήσεις) θα πρέπει να είναι ανοιχτές για επέκταση αλλά κλειστές για τροποποίηση.
Επιτεύξτε αυτό χρησιμοποιώντας διεπαφές, αφηρημένες κλάσεις και κληρονομικότητα.
Παράδειγμα:
Ιάβα

Σχήμα διεπαφής {
διπλή περιοχή();
}
Η κλάση Circle υλοποιεί Shape { /* υλοποίηση / } κλάση Rectangle υλοποιεί Shape { / υλοποίηση */ }

Τι είναι η Αρχή Υποκατάστασης Liskov (LSP):

Οι υποτύποι πρέπει να μπορούν να αντικατασταθούν με τους βασικούς τους τύπους χωρίς να αλλοιώνεται η ορθότητα του προγράμματος.
Ακολουθεί τη σχέση «είναι-α».
Παράδειγμα:
Ιάβα

class Bird { /* κοινή συμπεριφορά πτηνών / } class Sparrow extends Bird { / συγκεκριμένη συμπεριφορά σπουργίτι */ }

Τι είναι η αρχή διαχωρισμού διεπαφής (ISP):

Οι πελάτες δεν πρέπει να αναγκάζονται να εξαρτώνται από διεπαφές που δεν χρησιμοποιούν.
Διαχωρίστε τις μεγάλες διεπαφές σε μικρότερες, πιο συγκεκριμένες.
Παράδειγμα:
Ιάβα

Εργαζόμενος διεπαφής {
void work();
}
διασύνδεση τρώγων {
void eat();
}
class Robot implements Worker { /* υλοποίηση */ }

Τι είναι η Αρχή Αντιστροφής Εξάρτησης (DIP):

Οι μονάδες υψηλού επιπέδου δεν πρέπει να εξαρτώνται από μονάδες χαμηλού επιπέδου. και τα δύο θα πρέπει να εξαρτώνται από αφαιρέσεις.
Οι αφαιρέσεις δεν πρέπει να εξαρτώνται από λεπτομέρειες. οι λεπτομέρειες πρέπει να εξαρτώνται από αφαιρέσεις.

// Αφαίρεση
διεπαφή MessageSender {
void sendMessage(Μήνυμα συμβολοσειράς);
}

// Μονάδα υψηλού επιπέδου
υπηρεσία ειδοποιήσεων τάξης {
ιδιωτικό MessageSender messageSender;

public NotificationService(MessageSender messageSender) {
    this.messageSender = messageSender;
}
public void send(String message) {
    messageSender.sendMessage(message);
}

}

// Μονάδα χαμηλού επιπέδου
κλάση EmailSender υλοποιεί MessageSender {
@Καταπατώ
δημόσιο κενό sendMessage(Μήνυμα συμβολοσειράς) {
System.out.println(“Αποστολή email: ” + μήνυμα);
}
}

// Μια άλλη λειτουργική μονάδα χαμηλού επιπέδου
κλάση SmsSender υλοποιεί MessageSender {
@Καταπατώ
δημόσιο κενό sendMessage(Μήνυμα συμβολοσειράς) {
System.out.println(“Αποστολή SMS: ” + μήνυμα);
}
}

// Κύρια τάξη
δημόσια τάξη Κύρια {
δημόσιο στατικό κενό main(String[] args) {
// Χρησιμοποιήστε το EmailSender
MessageSender emailSender = new EmailSender();
NotificationService notificationService1 = new NotificationService(emailSender);
notificationService1.send(“Γεια σας μέσω email!”);

    // Use SmsSender
    MessageSender smsSender = new SmsSender();
    NotificationService notificationService2 = new NotificationService(smsSender);
    notificationService2.send("Hello via SMS!");
}

}

Η διεπαφή MessageSender χρησιμεύει ως αφαίρεση.
Η υπηρεσία NotificationService της μονάδας υψηλού επιπέδου εξαρτάται από αυτήν την αφαίρεση αντί για συγκεκριμένες υλοποιήσεις.
Οι λειτουργικές μονάδες χαμηλού επιπέδου όπως το EmailSender και το SmsSender εξαρτώνται επίσης από την αφαίρεση υλοποιώντας τη διεπαφή MessageSender.

Τι είναι η κανονικοποίηση της SQL

Τι είναι η Κανονικοποίηση;
Η κανονικοποίηση περιλαμβάνει τη δόμηση δεδομένων μέσα σε μια σχεσιακή βάση δεδομένων για την εξάλειψη ανωμαλιών όπως ο πλεονασμός.
Διασπά μεγάλους, σύνθετους πίνακες σε μικρότερους, διατηρώντας παράλληλα σχέσεις δεδομένων.
Γιατί είναι σημαντική η κανονικοποίηση;
Μειώνει τον πλεονασμό: Διαχωρίζοντας τα δεδομένα σε μικρότερους πίνακες, αποφεύγουμε την αποθήκευση των ίδιων πληροφοριών πολλές φορές.
Βελτιώνει την απόδοση ερωτήματος: Οι μικρότεροι κανονικοποιημένοι πίνακες οδηγούν σε ταχύτερη εκτέλεση ερωτήματος.
Ελαχιστοποιεί τις ανωμαλίες ενημέρωσης: Οι ενημερώσεις μπορούν να γίνουν χωρίς να επηρεαστούν άλλες εγγραφές.
Ενισχύει την ακεραιότητα των δεδομένων: Εξασφαλίζει συνεπή και ακριβή δεδομένα.
Σενάρια ομαλοποίησης:
Ακεραιότητα δεδομένων: Αποτρέψτε τις ασυνέπειες κατά την ενημέρωση των δεδομένων (π.χ. αλλαγές ηλικίας πελατών).
Αποτελεσματική Ερώτηση: Απλοποιήστε πολύπλοκα ερωτήματα αναλύοντας δεδομένα.
Βελτιστοποίηση αποθήκευσης: Εξαλείψτε τον περιττό πλεονασμό για εξοικονόμηση χώρου.

Τι είναι το μονόλιθο της Microservices;

Τι είναι μονόλιθος;

Μια μονολιθική εφαρμογή δημιουργείται ως ενιαία, ενοποιημένη μονάδα. Συνδέει στενά όλα τα στοιχεία (όπως το περιβάλλον χρήστη, τη βάση δεδομένων και την εφαρμογή διακομιστή) σε μια βάση κώδικα.
Φόντα:
Εύκολη ανάπτυξη: Δεδομένου ότι είναι ένα μόνο εκτελέσιμο αρχείο ή κατάλογος, η ανάπτυξη είναι απλή.
Ταχύτητα ανάπτυξης: Από την αρχή της ζωής ενός έργου, οι μονόλιθοι επιτρέπουν γρήγορη ανάπτυξη λόγω της απλότητάς τους.
Απόδοση: Ο κεντρικός κώδικας μπορεί να χειριστεί διάφορες λειτουργίες.

Τι είναι οι Microservices;

Οι μικροϋπηρεσίες αναλύουν την εφαρμογή σε μικρότερες υπηρεσίες που μπορούν να αναπτυχθούν ανεξάρτητα. Κάθε υπηρεσία εστιάζει σε έναν συγκεκριμένο επιχειρηματικό τομέα.
Φόντα:
Επεκτασιμότητα: Οι μικροϋπηρεσίες επιτρέπουν την ανεξάρτητη κλιμάκωση μεμονωμένων στοιχείων.
Ευελιξία: Οι προγραμματιστές μπορούν να επιλέξουν διαφορετικές τεχνολογίες για κάθε υπηρεσία.
Απομόνωση: Οι βλάβες σε μια υπηρεσία δεν επηρεάζουν άλλες.
Προκλήσεις:
Πολυπλοκότητα: Η διαχείριση πολλαπλών υπηρεσιών απαιτεί ισχυρή ενορχήστρωση.
Επιβάρυνση δικτύου: Η επικοινωνία μεταξύ υπηρεσιών εισάγει λανθάνουσα κατάσταση.
Πολυπλοκότητα ανάπτυξης: Ο συντονισμός των ενημερώσεων μεταξύ των υπηρεσιών μπορεί να είναι δύσκολος.

Τι είναι ο Πολυμορφισμός;

Παράκαμψη μεθόδου:
Όταν μια υποκλάση παρέχει μια συγκεκριμένη υλοποίηση για μια μέθοδο που έχει ήδη οριστεί στην υπερκλάση της.

Υπερφόρτωση μεθόδου:
Όταν μια κλάση έχει πολλαπλές μεθόδους με το ίδιο όνομα αλλά διαφορετικές παραμέτρους (διαφορετικός αριθμός ή τύποι ορισμάτων).

Τι χρησιμοποιούν οι ιδιωτικοί κατασκευαστές;

–Οι ιδιωτικοί κατασκευαστές χρησιμοποιούνται σε κατηγορίες χρησιμότητας ή σταθερές κλάσεις.
Αυτές οι κλάσεις περιέχουν μόνο στατικές μεθόδους ή μέλη.

–Αποφυγή υποκατηγορίας

— Αντιπροσωπεία κατασκευαστή:
Οι ιδιωτικοί κατασκευαστές επιτρέπουν την ανάθεση κατασκευαστή, όπου συγκεκριμένοι κατασκευαστές καλούν έναν κοινό ιδιωτικό κατασκευαστή.

— Μοτίβο Singleton

Σχετικά με την JVM

–Συλλογή:
Όταν μεταγλωττίζετε ένα αρχείο .java, ο μεταγλωττιστής Java δημιουργεί αρχεία .class που περιέχουν bytecode (ενδιάμεση αναπαράσταση).
Το Bytecode είναι ανεξάρτητο από την πλατφόρμα και μπορεί να τρέξει σε οποιοδήποτε σύστημα με συμβατό JVM.
— Υποσύστημα φόρτωσης κλάσης:
Υπεύθυνος για τη φόρτωση τάξεων στη μνήμη.
Διαβάζει αρχεία .class, δημιουργεί δυαδικά δεδομένα και τα αποθηκεύει στην περιοχή μεθόδων.
Δημιουργεί ένα αντικείμενο Class που αντιπροσωπεύει τη φορτωμένη κλάση στη μνήμη σωρού.
Παράδειγμα: Student s1 = new Student(); Κλάση c1 = s1.getClass();
–Σύνδεσμος:
Αποτελείται από τρία βήματα:
Επαλήθευση: Εξασφαλίζει την ορθότητα του αρχείου .class.
Προετοιμασία: Εκχωρεί μνήμη για μεταβλητές κλάσης και τις προετοιμάζει.
Ανάλυση (προαιρετική): Επιλύει συμβολικές αναφορές σε άλλες κλάσεις ή μεθόδους.
— Αρχικοποίηση:
Εκτελεί στατικές αρχικοποιητές (π.χ. στατικά μπλοκ) και αρχικοποιεί στατικές μεταβλητές.
Οι μεταβλητές στιγμιότυπου αρχικοποιούνται όταν δημιουργείται ένα αντικείμενο.
— Μηχανή εκτέλεσης:
Μετατρέπει τον bytecode σε κώδικα μηχανής.
Περιλαμβάνει συλλογή Just-In-Time (JIT) για βελτιστοποίηση απόδοσης.

–Συνοπτικά, το JVM επιτρέπει στα προγράμματα Java να εκτελούνται οπουδήποτε με την ερμηνεία του bytecode και τη διαχείριση της μνήμης

Τι είναι η αφηρημένη μέθοδος Privat;

–Περιπτώσεις χρήσης για ιδιωτικές μεθόδους σε αφηρημένες τάξεις:
Ενώ οι αφηρημένες μέθοδοι δεν μπορούν να είναι ιδιωτικές, μπορείτε να χρησιμοποιήσετε ιδιωτικές μεθόδους σε μια αφηρημένη κλάση για διάφορους σκοπούς:
— Μέθοδοι βοήθειας: Εφαρμογή κοινής λειτουργικότητας που μοιράζεται με άλλες μεθόδους.
–Ενθυλάκωση: Απόκρυψη λεπτομερειών υλοποίησης από υποκλάσεις.
–Κλάσεις που μοιάζουν με δομή: Δημιουργήστε μικρές κλάσεις με ιδιωτικές μεθόδους που χρησιμεύουν ως δοχεία δεδομένων

Τι είναι ο Συλλέκτης σκουπιδιών;

–Μνήμη σωρού:
Τα αντικείμενα Java δημιουργούνται στο σωρό, μια ειδική περιοχή μνήμης.
Ορισμένα αντικείμενα γίνονται απρόσιτα (δεν αναφέρονται πλέον από το πρόγραμμα).
–Συλλέκτης απορριμμάτων (GC):
Το GC αναγνωρίζει και διαγράφει αχρησιμοποίητα αντικείμενα για να ελευθερώσει μνήμη.
Εκτελείται αυτόματα στο παρασκήνιο.
Δύο τύποι:
Minor GC: Αφαιρεί απρόσιτα αντικείμενα στη νέα γενιά.
Major GC (Full GC): Καθαρίζει αντικείμενα της παλιάς γενιάς.
–Οφέλη:
Οι προγραμματιστές δεν χρειάζεται να διαγράφουν ρητά αντικείμενα.
Το GC διασφαλίζει τη διαθεσιμότητα της μνήμης και αποτρέπει τα OutOfMemoryErrors

Τι είναι το OOP;

Τέσσερις αρχές του OOP:
–Ενθυλάκωση: Ομαδοποίηση δεδομένων (χαρακτηριστικών) και μεθόδων (συναρτήσεων) μαζί σε μια κλάση για απόκρυψη λεπτομερειών υλοποίησης και παροχή καθαρής διεπαφής.
–Κληρονομικότητα: Δημιουργία νέων κλάσεων με βάση τις υπάρχουσες, κληρονομώντας τις ιδιότητες και τις συμπεριφορές τους. Προωθεί την επαναχρησιμοποίηση κώδικα.
–Πολυμορφισμός: Επιτρέπει σε αντικείμενα διαφορετικών κατηγοριών να αντιμετωπίζονται ομοιόμορφα μέσω μιας κοινής διεπαφής. Επιτρέπει την ευελιξία και την επεκτασιμότητα.
— Αφαίρεση: Εστίαση σε βασικά χαρακτηριστικά κρύβοντας περιττές πολυπλοκότητες. Η αφαίρεση απλοποιεί το σχέδιο και το κάνει πιο διαχειρίσιμο.

Τι είναι οι ιδιότητες ACID διαδραματίζουν κρίσιμο ρόλο στη διασφάλιση της αξιοπιστίας και της συνέπειας των συναλλαγών.

— Ατομικότητα:
Οι συναλλαγές είτε εκτελούνται εξ ολοκλήρου είτε καθόλου.
Χωρίς μερική εκτέλεση: Εάν μια συναλλαγή αποτύχει στη μέση, τυχόν αλλαγές που έγιναν στη βάση δεδομένων επαναφέρονται.
Παράδειγμα: Εξετάστε το ενδεχόμενο μεταφοράς 100 $ από τον λογαριασμό X στον λογαριασμό Y. Εάν η συναλλαγή αποτύχει μετά την αφαίρεση από το X αλλά πριν από την προσθήκη στο Y, η βάση δεδομένων παραμένει συνεπής.
–Συνοχή:
Η βάση δεδομένων πρέπει να διατηρεί περιορισμούς ακεραιότητας πριν και μετά από μια συναλλαγή.
Παράδειγμα: Εάν το συνολικό ποσό πριν από μια συναλλαγή είναι $700 (X: $500, Y: $200), θα πρέπει να παραμείνει το ίδιο μετά τη συναλλαγή (X: $400, Y: $300).
–Απομόνωση:
Πολλαπλές συναλλαγές μπορούν να πραγματοποιηθούν ταυτόχρονα χωρίς να επηρεάζεται η μία την άλλη.
Οι αλλαγές που γίνονται από μια συναλλαγή δεν είναι ορατές σε άλλους μέχρι να πραγματοποιηθούν.
Εξασφαλίζει ισοδύναμα αποτελέσματα σαν να εκτελούνταν σειριακά οι συναλλαγές.
Παράδειγμα: Η απομόνωση συναλλαγών αποτρέπει τις ασυνέπειες που οφείλονται σε παρεμβαλλόμενες λειτουργίες.
–Αντοχή:
Μόλις δεσμευτεί μια συναλλαγή, οι αλλαγές της είναι μόνιμες.
Επιβιώνει από αποτυχίες ή κολλήματα συστήματος.
Εξασφαλίζει τη διατήρηση των δεδομένων.
Παράδειγμα: Ακόμη και μετά την επανεκκίνηση του συστήματος, οι δεσμευμένες αλλαγές παραμένουν άθικτες.
Θυμηθείτε, οι ιδιότητες ACID παρέχουν τη βάση για αξιόπιστες και συνεπείς λειτουργίες βάσης δεδομένων! 🌟

Τι είναι το Μοτίβο Στρατηγικής;
Περιγραφή: Ορίζει μια οικογένεια αλγορίθμων, ενσωματώνει τον καθένα και τους κάνει εναλλάξιμους. Επιτρέπει στον αλγόριθμο να ποικίλλει ανεξάρτητα από τους πελάτες που τον χρησιμοποιούν.
Παράδειγμα:
Ιάβα

// Διεπαφή για διατροφική συμπεριφορά
διεπαφή EatBehavior {
void eat();
}

// Συγκεκριμένες εφαρμογές της διατροφικής συμπεριφοράς
class NormalDiet υλοποιεί EatBehavior {
@Καταπατώ
public void eat() {
// Κανονικό φαγητό
}
}

τάξη LosingWeightDiet εφαρμόζει EatBehavior {
@Καταπατώ
public void eat() {
// Υγιεινή διατροφή
}
}

// Κατηγορία γάτας με συμπεριφορά φαγητού
αφηρημένη τάξη γάτα {
EatBehavior eatBehavior;

public void eat() {
    eatBehavior.eat();
}
public void setEatBehavior(EatBehavior eatBehavior) {
 this.eatBehavior = eatBehavior;
}

}

// Χρήση
Cat cat = new Cat();
cat.setEatBehavior(new LosingWeightDiet());
cat.eat(); // Η γάτα τρώει με πιο υγιεινή διατροφή

Δημιουργικά μοτίβα:
Αυτά τα μοτίβα επικεντρώνονται στη δημιουργία της τάξης.
Περιλαμβάνονται παραδείγματα

— Εργοστασιακή μέθοδος,
Δήλωση προβλήματος: Ας υποθέσουμε ότι θέλουμε να δημιουργήσουμε διαφορετικούς τύπους προϊόντων (π.χ. αυτοκίνητα, ποδήλατα, ποδήλατα) χωρίς να συνδέσουμε στενά τον κώδικά μας με συγκεκριμένες υλοποιήσεις.
Βασικά συστατικά:
Προϊόν: Μια αφηρημένη κλάση ή διεπαφή που ορίζει κοινές λειτουργίες για τα αντικείμενα που θα δημιουργήσει το εργοστάσιο.
Concrete Products: Πραγματικές κλάσεις που υλοποιούν τη διεπαφή προϊόντος, αντιπροσωπεύοντας συγκεκριμένους τύπους αντικειμένων.
Δημιουργός: Μια αφηρημένη κλάση ή διεπαφή που δηλώνει την εργοστασιακή μέθοδο. Είναι υπεύθυνο για τη δημιουργία αντικειμένων Προϊόντος, αλλά αναθέτει την πραγματική δημιουργία σε υποκλάσεις.
Concrete Creators: Υποκατηγορίες του Δημιουργού που εφαρμόζουν την εργοστασιακή μέθοδο. Αποφασίζουν ποιο συγκεκριμένο προϊόν σκυροδέματος να δημιουργήσουν με βάση τις παραμέτρους εισόδου ή τη διαμόρφωση.
Factory Method: Μια μέθοδος που ορίζεται στην κλάση Creator που δημιουργεί αντικείμενα Product. Συνήθως δηλώνεται ως αφηρημένο στον Δημιουργό και εφαρμόζεται στους Συγκεκριμένους Δημιουργούς.
Παράδειγμα σε Java: Ας υποθέσουμε ότι έχουμε ένα Εργοστάσιο που παράγει διαφορετικούς τύπους οχημάτων. Ακολουθεί ένα απλοποιημένο παράδειγμα:
Ιάβα

// AbstractProduct
Προϊόν διεπαφής {
void display();
}

// Προϊόντα σκυροδέματος
class car tools Product {
δημόσια εμφάνιση κενού() {
System.out.println(“Car δημιουργήθηκε”);
}
}

class Bike instruments Product {
δημόσια εμφάνιση κενού() {
System.out.println(“Το ποδήλατο δημιουργήθηκε”);
}
}

// Δημιουργός (Εργοστάσιο)
διεπαφή Factory {
Product factoryMethod();
}

// Concrete Creators
κλάση ConcreteFactoryA υλοποιεί Factory {
public Product factoryMethod() {
επιστροφή νέου αυτοκινήτου();
}
}

κλάση ConcreteFactoryB υλοποιεί Factory {
public Product factoryMethod() {
επιστροφή νέου ποδηλάτου();
}
}

δημόσια κλάση FactoryMethodExample {
δημόσιο στατικό κενό main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Προϊόν productA = factoryA.factoryMethod();
productA.display();

    Factory factoryB = new ConcreteFactoryB();
    Product productB = factoryB.factoryMethod();
    productB.display();
}

}

— Οικοδόμος
Το μοτίβο δόμησης είναι ένα δημιουργικό σχέδιο σχεδίασης που σας επιτρέπει να κατασκευάζετε σύνθετα αντικείμενα βήμα προς βήμα,
διαχωρίζοντας την κατασκευή τους από την αναπαράστασή τους. Ακολουθεί ένα απλό παράδειγμα σε Java:
// Καθορίστε την κλάση που θέλετε να δημιουργήσετε
ανάρτηση τάξης {
ιδιωτικός τελικός τίτλος συμβολοσειράς?
ιδιωτικό τελικό κείμενο συμβολοσειράς?
ιδιωτική τελική κατηγορία String?

Post(Builder builder) {
    this.title = builder.title;
    this.text = builder.text;
    this.category = builder.category;
}
// Getters for properties
public String getTitle() {
    return title;
}
public String getText() {
    return text;
}
public String getCategory() {
    return category;
}
// Builder class
public static class Builder {
    private String title;
    private String text;
    private String category;
    public Builder title(String title) {
        this.title = title;
        return this;
    }
    public Builder text(String text) {
        this.text = text;
        return this;
    }
    public Builder category(String category) {
        this.category = category;
        return this;
    }
    public Post build() {
        return new Post(this);
    }
}

}

// Χρήση
δημόσια τάξη Κύρια {
δημόσιο στατικό κενό main(String[] args) {
Δημοσίευση ανάρτησης = νέο Post.Builder()
.title (“Μοτίβο Java Builder”)
.text(“Εξήγηση πώς να εφαρμόσετε το μοτίβο δόμησης στην Java”)
.category (“Μοτίβα σχεδίασης”)
.οικοδομώ();

    System.out.println("Title: " + post.getTitle());
    System.out.println("Text: " + post.getText());
    System.out.println("Category: " + post.getCategory());
}

}

–Πρωτότυπο
Το Prototype Pattern είναι ένα δημιουργικό μοτίβο σχεδίασης που σας επιτρέπει να δημιουργείτε νέα αντικείμενα αντιγράφοντας ένα υπάρχον αντικείμενο.
Αντί να δημιουργείτε νέα στιγμιότυπα από την αρχή, κλωνοποιείτε ένα υπάρχον πρωτότυπο, το οποίο μπορεί να είναι πιο αποτελεσματικό και ευέλικτο. Ας δούμε ένα παράδειγμα στην Java:
Καθορισμός της Πρωτότυπου Διεπαφής: Αρχικά, δημιουργούμε μια αφηρημένη κλάση ή διεπαφή που ονομάζεται Δέντρο με μια αφηρημένη μέθοδο copy():
Ιάβα

δημόσια αφηρημένη κλάση δέντρο {
public abstract Αντίγραφο δέντρου();
}

Concrete Prototypes: Στη συνέχεια, υλοποιούμε δύο κατηγορίες σκυροδέματος που επεκτείνουν το Tree: PlasticTree και PineTree. Αυτές οι κλάσεις αντιπροσωπεύουν συγκεκριμένους τύπους δέντρων και παρέχουν τη δική τους υλοποίηση της μεθόδου copy():
Ιάβα

δημόσια τάξη PlasticTree επεκτείνει το δέντρο {
@Καταπατώ
δημόσιο αντίγραφο δέντρου() {
PlasticTree plasticTreeClone = νέο PlasticTree(this.getMass(), this.getHeight());
plasticTreeClone.setPosition(this.getPosition());
επιστροφή πλαστικόTreeClone?
}
}

δημόσια κλάση PineTree επεκτείνει το δέντρο {
@Καταπατώ
δημόσιο αντίγραφο δέντρου() {
PineTree pineTreeClone = νέο PineTree(this.getMass(), this.getHeight());
pineTreeClone.setPosition(this.getPosition());
επιστροφή pineTreeClone?
}
}
Σε αυτές τις κλάσεις, προσαρμόζουμε τη διαδικασία κλωνοποίησης με βάση τον συγκεκριμένο τύπο δέντρου. Για παράδειγμα, αντιγράφουμε τη μάζα, το ύψος και τη θέση του αρχικού δέντρου.
Χρήση: Τώρα, ας δημιουργήσουμε περιπτώσεις των συγκεκριμένων πρωτοτύπων μας:
Ιάβα

δημόσια τάξη Κύρια {
δημόσιο στατικό κενό main(String[] args) {
Δέντρο originalPlasticTree = new PlasticTree(10, 5);
Δέντρο κλωνοποιημένοPlasticTree = originalPlasticTree.copy();

    Tree originalPineTree = new PineTree(15, 8);
    Tree clonedPineTree = originalPineTree.copy();

    // Use the cloned trees as needed
    // ...
}

}

Τι είναι τα δομικά μοτίβα;
Αυτά τα μοτίβα ασχολούνται με τη δομή και τη σύνθεση μιας τάξης.

— Μοτίβο προσαρμογέα
Το μοτίβο προσαρμογέα είναι ένα μοτίβο δομικής σχεδίασης που σας επιτρέπει να κάνετε δύο μη συμβατές διεπαφές να συνεργάζονται.
Λειτουργεί ως γέφυρα μεταξύ αυτών των διεπαφών, επιτρέποντας τη συνεργασία χωρίς να τροποποιεί τον πηγαίο κώδικα τους.

Προσαρμογέας αντικειμένου:
Σε αυτήν την προσέγγιση, χρησιμοποιούμε σύνθεση για να εκχωρήσουμε τη λογική στον προσαρμογέα.
Ο προσαρμογέας περιέχει το Adaptee και εκχωρεί τη μέθοδο request() στη μέθοδο specificRequest() στο Adaptee.
Ιάβα

// Adaptee (υπάρχουσα κλάση)
Προσαρμοστής τάξης {
void specifiedRequest() {
System.out.println(“Συγκεκριμένο αίτημα του Adaptee”);
}
}

// Διεπαφή στόχου
Στόχος διεπαφής {
void request();
}

// Προσαρμογέας (με χρήση σύνθεσης)
Ο προσαρμογέας τάξης υλοποιεί το Target {
ιδιωτικός τελικός Adaptee adaptee;

Adapter(Adaptee adaptee) {
    this.adaptee = adaptee;
}
@Override
public void request() {
    adaptee.specificRequest();
}

}

ClassAdapter:
Απαιτεί πολλαπλή κληρονομικότητα (δεν είναι άμεσα δυνατή στην Java).
Μπορούμε να το πετύχουμε χρησιμοποιώντας διεπαφές με προεπιλεγμένες μεθόδους.
Ο προσαρμογέας επεκτείνει και τις δύο κατηγορίες Target και Adaptee.
Ιάβα

// Διεπαφή στόχου
Στόχος διεπαφής {
void request();
}

// Adaptee (υπάρχουσα κλάση)
Προσαρμοστής τάξης {
void specifiedRequest() {
System.out.println(“Συγκεκριμένο αίτημα του Adaptee”);
}
}

// Προσαρμογέας (με χρήση κλάσης κληρονομιάς)
Ο προσαρμογέας κλάσης επεκτείνει το Adaptee υλοποιεί Στόχος {
@Καταπατώ
δημόσιο κενό αίτημα() {
specifiedRequest();
}
}
Οφέλη και ανταλλαγές:
Ο προσαρμογέας κλάσης λειτουργεί καλά για αντιστοίχιση μεθόδων ένας προς έναν.
Ο Προσαρμογέας αντικειμένων παρέχει μεγαλύτερη ευελιξία και αποφεύγει την τροποποίηση κώδικα.

— Μοτίβο διακοσμητή
Το Μοτίβο Διακοσμητή είναι ένα δημιουργικό σχέδιο σχεδίασης που σας επιτρέπει να προσθέτετε δυναμικά λειτουργικότητα και συμπεριφορά σε ένα αντικείμενο χωρίς
επηρεάζοντας τη συμπεριφορά άλλων υπαρχόντων αντικειμένων στην ίδια κλάση. Είναι ιδιαίτερα χρήσιμο όταν θέλετε να επεκτείνετε ένα αντικείμενο
δυνατότητες χωρίς να αλλοιώνεται η δομή του.

Επισκόπηση:
Το Μοτίβο Διακοσμητή παρέχει μια βελτιωμένη διεπαφή με το αρχικό αντικείμενο τυλίγοντάς το με πρόσθετη λειτουργικότητα.
Προτιμούμε τη σύνθεση από την κληρονομικότητα για να μειώσουμε τα γενικά έξοδα υποκατηγορίας.
Μπορούν να προστεθούν διακοσμητές κατά το χρόνο εκτέλεσης, επιτρέποντας ευελιξία.
Παράδειγμα σεναρίου: Ας υποθέσουμε ότι έχουμε ένα αντικείμενο Χριστουγεννιάτικο Δέντρο και θέλουμε να το διακοσμήσουμε με διάφορα αντικείμενα όπως γιρλάντα, πούλιες και φωτάκια με φυσαλίδες. Θα ακολουθήσουμε τις αρχικές συμβάσεις σχεδιασμού Gang of Four:
Εκτέλεση:
Πρώτα, δημιουργήστε μια διεπαφή ChristmasTree:
Ιάβα

δημόσια διεπαφή Χριστουγεννιάτικο Δέντρο {
String διακόσμηση();
}

Υλοποιήστε τη διεπαφή με ένα βασικό δέντρο:
Ιάβα

δημόσια τάξη ChristmasTreeImpl υλοποιεί ChristmasTree {
@Καταπατώ
δημόσια διακόσμηση συμβολοσειράς() {
επιστροφή “χριστουγεννιάτικο δέντρο”?
}
}

Στη συνέχεια, δημιουργήστε μια αφηρημένη τάξη TreeDecorator που υλοποιεί το Χριστουγεννιάτικο Δέντρο και κρατά το στολισμένο δέντρο:
Ιάβα

δημόσια αφηρημένη κλάση TreeDecorator υλοποιεί το Χριστουγεννιάτικο Δέντρο {
ιδιωτικό τελικό Χριστουγεννιάτικο δέντρο?

public TreeDecorator(ChristmasTree tree) {
    this.tree = tree;
}
@Override
public String decorate() {
    return tree.decorate();
}

}

Τώρα δημιουργήστε συγκεκριμένους διακοσμητές. Για παράδειγμα, BubbleLights:
Ιάβα

δημόσια τάξη BubbleLights επεκτείνει το TreeDecorator {
δημόσια BubbleLights (χριστουγεννιάτικο δέντρο) {
σούπερ(δέντρο);
}

@Override
public String decorate() {
    return super.decorate() + " with Bubble Lights";
}

}

δημόσια τάξη Garland extends TreeDecorator {
δημόσια γιρλάντα (χριστουγεννιάτικο δέντρο) {
σούπερ(δέντρο);
}

@Override
public String decorate() {
    return super.decorate() + " with Garland";
}

}
Χρήση:
Δημιουργήστε στολισμένα δέντρα:
Ιάβα

δημόσια τάξη DecoratorPatternDemo {
δημόσιο στατικό κενό main(String[] args) {
ChristmasTree tree1 = new Garland(new ChristmasTreeImpl());
System.out.println(tree1.decorate()); // Έξοδος: “Χριστουγεννιάτικο δέντρο με γιρλάντα”

    ChristmasTree tree2 = new BubbleLights(new Garland(new Garland(new ChristmasTreeImpl())));
    System.out.println(tree2.decorate()); // Output: "Christmas tree with Garland with Garland with Bubble Lights"
}

}
Το μοτίβο επιτρέπει την προσθήκη διακοσμητών κατά την εκτέλεση, δίνοντας ευελιξία στη διακόσμηση όπως απαιτείται.
Θυμηθείτε, το Μοτίβο Διακοσμητή χρησιμοποιείται ευρέως σε σενάρια όπου θέλετε να βελτιώσετε τη συμπεριφορά ενός αντικειμένου χωρίς να τροποποιήσετε τη δομή του πυρήνα του

— Μοτίβο πρόσοψης
Το Μοτίβο Πρόσοψης είναι ένα δομικό σχέδιο σχεδιασμού που απλοποιεί την αλληλεπίδραση με ένα σύνθετο υποσύστημα παρέχοντας μια ενοποιημένη διεπαφή.
Λειτουργεί ως “μπροστινή πόρτα” για να κρύψει την υποκείμενη πολυπλοκότητα και να διευκολύνει τους πελάτες να χρησιμοποιούν το σύστημα

–Σύνθετος
Το Σύνθετο Μοτίβο είναι ένα δομικό μοτίβο σχεδίασης που σας επιτρέπει να συνθέσετε αντικείμενα σε δομές δέντρων για να αναπαραστήσετε ιεραρχίες μερικών ολόκληρων.
Η κύρια ιδέα πίσω από το Σύνθετο Μοτίβο είναι η κατασκευή μιας δενδρικής δομής αντικειμένων, όπου μεμονωμένα αντικείμενα και σύνθετα αντικείμενα μοιράζονται μια κοινή διεπαφή.

Βασικό στοιχείο (Τμήμα): Θα ορίσουμε μια απλή διεπαφή Τμήματος ως βασικό στοιχείο μας:
Ιάβα

Τμήμα δημόσιας διεπαφής {
void printDepartmentName();
}

Leaf Components (FinancialDepartment και SalesDepartment): Ας δημιουργήσουμε τάξεις για οικονομικά τμήματα και τμήματα πωλήσεων, υλοποιώντας και τα δύο τη διεπαφή Τμήματος:
Ιάβα

δημόσια τάξη FinancialDepartment Τμήμα υλοποιεί {
// Λεπτομέρειες υλοποίησης (π.χ. αναγνωριστικό, όνομα)
δημόσιο κενό printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
}

δημόσια τάξη Τμήμα Πωλήσεων Τμήμα υλοποιήσεων {
// Λεπτομέρειες υλοποίησης (π.χ. αναγνωριστικό, όνομα)
δημόσιο κενό printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
}

Αυτές οι κλάσεις φύλλων υλοποιούν τη μέθοδο printDepartmentName() και δεν περιέχουν αναφορές σε άλλα αντικείμενα Τμήματος.
Composite Element (HeadDepartment): Ως σύνθετη κλάση, ας δημιουργήσουμε ένα HeadDepartment που περιέχει μια συλλογή στοιχείων Τμήματος:
Ιάβα

εισαγωγή java.util.ArrayList;
εισαγωγή java.util.List;

δημόσια τάξη HeadDepartment υλοποιεί Τμήμα {
ιδιωτικό ακέραιο αναγνωριστικό?
ιδιωτικό όνομα συμβολοσειράς;
ιδιωτική λίστα childDepartments;

public HeadDepartment(Integer id, String name) {
    this.id = id;
    this.name = name;
    this.childDepartments = new ArrayList<>();
}
public void printDepartmentName() {
    childDepartments.forEach(Department::printDepartmentName);
}
public void addDepartment(Department department) {
    childDepartments.add(department);
}
public void removeDepartment(Department department) {
    childDepartments.remove(department);
}

}

Η κλάση HeadDepartment υλοποιεί τη μέθοδο printDepartmentName() και παρέχει μεθόδους για την προσθήκη και την αφαίρεση θυγατρικών τμημάτων.
Χρήση: Μπορείτε να δημιουργήσετε παρουσίες τμημάτων φύλλων (π.χ. Οικονομικό Τμήμα, Τμήμα Πωλήσεων) και ένα σύνθετο τμήμα (π.χ. Διευθυντικό Τμήμα). Προσθέστε τμήματα φύλλων στο σύνθετο και εκτυπώστε τα ονόματά τους.
Ιάβα

δημόσια τάξη Κύρια {
δημόσιο στατικό κενό main(String[] args) {
Οικονομικά Τμήματος = new FinancialDepartment();
Τμήμα πωλήσεων = new SalesDepartment();

    HeadDepartment headDepartment = new HeadDepartment(1, "Company Departments");
    headDepartment.addDepartment(finance);
    headDepartment.addDepartment(sales);

    headDepartment.printDepartmentName();
}

}

Παραγωγή:
Οικονομικό Τμήμα
Τμήμα Πωλήσεων

Το Σύνθετο Μοτίβο σάς επιτρέπει να δημιουργείτε ευέλικτες δομές δέντρων όπου
μεμονωμένα αντικείμενα και συνθέσεις (σύνθετα) μπορούν να αντιμετωπιστούν ομοιόμορφα.

Τι είναι η λειτουργία HASH!!!

Μια συνάρτηση κατακερματισμού είναι μια μαθηματική συνάρτηση που λαμβάνει μια είσοδο (ή “μήνυμα”) και επιστρέφει μια συμβολοσειρά χαρακτήρων σταθερού μεγέθους,
που είναι συνήθως μια ακολουθία αριθμών και γραμμάτων. Αυτή η έξοδος ονομάζεται “τιμή κατακερματισμού” ή απλά “κατακερματισμός”.
Οι συναρτήσεις κατακερματισμού χρησιμοποιούνται συνήθως στην επιστήμη των υπολογιστών και την κρυπτογραφία και έχουν μερικές σημαντικές ιδιότητες:

=== Πώς θα χρησιμοποιούσατε τη συνάρτηση κατακερματισμού και πώς λειτουργεί;

Ντετερμινιστικό: Η ίδια είσοδος θα παράγει πάντα τον ίδιο κατακερματισμό.

Γρήγορη: Η συνάρτηση μπορεί να υπολογίσει γρήγορα την τιμή κατακερματισμού για οποιαδήποτε δεδομένη είσοδο.
Μοναδικό (σχεδόν): Δύο διαφορετικές είσοδοι θα πρέπει να παράγουν διακριτούς κατακερματισμούς (αυτό είναι γνωστό ως ελαχιστοποίηση “συγκρούσεων”).
Μη αναστρέψιμο: Δεδομένου ενός κατακερματισμού, θα πρέπει να είναι υπολογιστικά ανέφικτο να προσδιοριστεί η αρχική είσοδος.
Ομοιόμορφη: Οι τιμές κατακερματισμού κατανέμονται ομοιόμορφα στο χώρο εξόδου.

Οι συναρτήσεις κατακερματισμού χρησιμοποιούνται ευρέως σε διάφορες εφαρμογές, όπως:

Ακεραιότητα δεδομένων: Για να διασφαλίσετε ότι τα δεδομένα δεν έχουν αλλάξει ή πλαστογραφηθεί, συγκρίνοντας τις τιμές κατακερματισμού.
Αποθήκευση κωδικών πρόσβασης: Ασφαλής αποθήκευση κατακερματισμένων κωδικών πρόσβασης αντί για τους πραγματικούς κωδικούς πρόσβασης.
Κρυπτογραφία: Χρησιμοποιείται σε ψηφιακές υπογραφές και άλλους κρυπτογραφικούς αλγόριθμους.
Πίνακες κατακερματισμού: Για αποτελεσματική ανάκτηση δεδομένων στον προγραμματισμό.

=== Δώσε μου ένα παράδειγμα χάρτη κατακερματισμού, πώς θα τον χρησιμοποιούσες;

SHA (Ασφαλής αλγόριθμος κατακερματισμού):
Περιλαμβάνει παραλλαγές όπως SHA-1, SHA-256, SHA-384 και SHA-512.
Τα SHA-256 και SHA-512 χρησιμοποιούνται ευρέως στην κρυπτογραφία και την τεχνολογία blockchain (π.χ. Bitcoin).

εισαγωγή java.security.MessageDigest;
εισαγωγή java.security.NoSuchAlgorithmException;

δημόσια τάξη HashExample {
δημόσιο στατικό κενό main(String[] args) {
δοκιμάστε {
// Η συμβολοσειρά εισόδου που θα κατακερματιστεί
Εισαγωγή συμβολοσειράς = “Γεια, κόσμο!”;

        // Create a MessageDigest instance for SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");

        // Compute the hash
        byte[] hash = digest.digest(input.getBytes());

        // Convert the hash bytes to a hexadecimal string
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = String.format("%02x", b);
            hexString.append(hex);
        }

        // Print the resulting hash
        System.out.println("SHA-256 Hash: " + hexString.toString());
    } catch (NoSuchAlgorithmException e) {
        System.err.println("Error: " + e.getMessage());
    }
}

}

Δεδομένα εισόδου: Η μεταβλητή εισόδου περιέχει τα δεδομένα που θέλετε να κατακερματίσετε.
Αρχικοποίηση MessageDigest: Η παρουσία του MessageDigest δημιουργείται χρησιμοποιώντας το getInstance(“SHA-256”), το οποίο καθορίζει τον αλγόριθμο κατακερματισμού SHA-256.
Κατακερματισμός: Η μέθοδος σύνοψης υπολογίζει τον κατακερματισμό των δεδομένων εισόδου.
Δεκαεξαδική μετατροπή: Εφόσον ο κατακερματισμός είναι σε δυαδική μορφή, χρησιμοποιούμε έναν βρόχο για να τον μετατρέψουμε σε μια πιο ευανάγνωστη δεκαεξαδική συμβολοσειρά.

Βάλτε και Patch; Πότε να το χρησιμοποιήσετε;

Τόσο το PUT όσο και το PATCH είναι μέθοδοι HTTP που χρησιμοποιούνται για την ενημέρωση πόρων σε έναν διακομιστή, αλλά διαφέρουν στον τρόπο με τον οποίο χειρίζονται τις ενημερώσεις:

ΒΑΖΩ:
Πλήρης ενημέρωση:
Το PUT χρησιμοποιείται για την πλήρη αντικατάσταση ενός υπάρχοντος πόρου.
Ολόκληρος ο πόρος πρέπει να σταλεί στο αίτημα, ακόμα κι αν μόνο ένα μέρος του αλλάζει.

Εάν ο πόρος δεν υπάρχει, το PUT τον δημιουργεί συχνά (αν και αυτή η συμπεριφορά μπορεί να διαφέρει).

Ανίκανος:

Οι επαναλαμβανόμενες αιτήσεις PUT με τα ίδια δεδομένα θα οδηγούν πάντα στην ίδια κατάσταση του πόρου.
Παράδειγμα: Ενημέρωση προφίλ χρήστη:

json
PUT /users/123
{
“όνομα”: “Βελισλάβ”,
“email”: OZYX2Zvelislav@example.comOZYX3Z,
“ηλικία”: 30
}
Εάν αλλάξει μόνο το όνομα αλλά το email και η ηλικία παραμένουν ίδια, πρέπει να συμπεριληφθούν στο αίτημα.

PACH:
Μερική ενημέρωση:

Το PATCH χρησιμοποιείται για την πραγματοποίηση μερικής ενημέρωσης σε έναν υπάρχοντα πόρο.
Μόνο τα πεδία που αλλάζουν πρέπει να αποστέλλονται στο αίτημα.

Ανίκανος (Κυρίως):

Όπως το PUT, οι επαναλαμβανόμενες αιτήσεις PATCH με τα ίδια δεδομένα έχουν γενικά ως αποτέλεσμα την ίδια κατάσταση του πόρου.
Ωστόσο, η συμπεριφορά μπορεί να εξαρτάται από την υλοποίηση του διακομιστή.

Παράδειγμα: Ενημέρωση μόνο του ονόματος χρήστη:

json
PATCH /users/123
{
“όνομα”: “Βελισλάβ”
}
Εδώ, μόνο το πεδίο ονόματος ενημερώνεται, αφήνοντας τα άλλα πεδία αμετάβλητα.

Βασική διαφορά:
Το PUT αντικαθιστά ολόκληρο τον πόρο, ενώ το PATCH τροποποιεί μόνο καθορισμένα πεδία του πόρου.

Μέθοδοι HTTP με σύντομη περιγραφή.

GET: Χρησιμοποιείται για την ανάκτηση δεδομένων από τον διακομιστή χωρίς να τα τροποποιήσετε. Χρησιμοποιείται συνήθως για την ανάκτηση πόρων ή πληροφοριών.
POST: Χρησιμοποιείται για την αποστολή δεδομένων στον διακομιστή, συνήθως για τη δημιουργία νέου πόρου. Για παράδειγμα, η υποβολή μιας φόρμας ή η μεταφόρτωση ενός αρχείου.
PUT: Χρησιμοποιείται για την ενημέρωση ή την πλήρη αντικατάσταση ενός υπάρχοντος πόρου στο διακομιστή. Εάν ο πόρος δεν υπάρχει, μπορεί να δημιουργηθεί.
PATCH: Χρησιμοποιείται για μερικές ενημερώσεις σε έναν υπάρχοντα πόρο, τροποποιώντας μόνο τα καθορισμένα πεδία.
DELETE: Χρησιμοποιείται για τη διαγραφή ενός πόρου από τον διακομιστή.
HEAD: Παρόμοιο με το GET, χρησιμοποιείται για την ανάκτηση κεφαλίδων χωρίς το σώμα ενός πόρου.
ΕΠΙΛΟΓΕΣ: Λέει ποιες μέθοδοι HTTP επιτρέπονται.
TRACE: Χρησιμοποιείται κυρίως για διαγνωστικούς σκοπούς, επαναλαμβάνοντας το αίτημα πίσω στον πελάτη
CONNECT: Δημιουργεί μια σήραγγα στον διακομιστή, που χρησιμοποιείται συχνά για συνδέσεις SSL/TLS.

========== Λειτουργική διεπαφή ====================================

Μια λειτουργική διεπαφή στη Java είναι μια διεπαφή που περιέχει ακριβώς μια αφηρημένη μέθοδο. Αυτές οι διεπαφές χρησιμοποιούνται κυρίως σε εκφράσεις λάμδα και αναφορές μεθόδων, επιτρέποντας πιο συνοπτικό και ευανάγνωστο λειτουργικό προγραμματισμό.

Βασικά Χαρακτηριστικά:

1. Ενιαία Αφηρημένη Μέθοδος: Μια λειτουργική διεπαφή έχει μόνο μία αφηρημένη μέθοδο. Αυτή είναι η ουσία της λειτουργικότητάς του.
2. Προεπιλεγμένες και στατικές μέθοδοι: Οι λειτουργικές διεπαφές μπορούν να περιλαμβάνουν προεπιλεγμένες και στατικές μεθόδους, αλλά αυτές δεν υπολογίζονται ως η μοναδική αφηρημένη μέθοδος.
3. Σχολιασμός @FunctionalInterface: Αν και αυτός ο σχολιασμός είναι προαιρετικός, βοηθάει δηλώνοντας ότι η διεπαφή προορίζεται να είναι λειτουργική. Εάν προστεθούν πρόσθετες αφηρημένες μέθοδοι στη διεπαφή, ο μεταγλωττιστής εκτελεί ένα σφάλμα.

Παράδειγμα:

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}
// Using lambda expression
public class Main {
    public static void main(String[] args) {
        // Implementing the calculate method using a lambda
        Calculator addition = (a, b) -> a + b;
        Calculator multiplication = (a, b) -> a * b;
        System.out.println("Addition: " + addition.calculate(5, 3));  // Output: 8
        System.out.println("Multiplication: " + multiplication.calculate(5, 3));  // Output: 15
    }
}

Περίπτωση χρήσης:

Ο Calculator Η διεπαφή στο παράδειγμα έχει μια ενιαία αφηρημένη μέθοδο calculate, καθιστώντας το μια λειτουργική διεπαφή.
Αυτό μας επιτρέπει να χρησιμοποιούμε εκφράσεις λάμδα για συντομία και κομψότητα στην εφαρμογή.

Κοινές λειτουργικές διεπαφές σε Java:

Η Java παρέχει πολλές ενσωματωμένες λειτουργικές διεπαφές στο java.util.function πακέτα, όπως:

• Κατηγορούμενο: Λαμβάνει μια είσοδο και επιστρέφει ένα boolean.
• Λειτουργία: Λαμβάνει μια είσοδο και επιστρέφει μια έξοδο τύπου R.
• Προμηθευτής: Παρέχει μια τιμή χωρίς εισαγωγή.
• Καταναλωτής: Αποδέχεται μια τιμή και εκτελεί μια ενέργεια.

Οι λειτουργικές διεπαφές απλοποιούν τις λειτουργίες, ειδικά σε σενάρια όπως η εργασία με συλλογές, ροές ή ασύγχρονες εργασίες.

Εξουσιοδοτούν την Java να υιοθετήσει παραδείγματα λειτουργικού προγραμματισμού διατηρώντας παράλληλα την αντικειμενοστραφή φύση της.

==============================================================
Μια συνάρτηση υψηλότερης τάξης είναι μια συνάρτηση που είτε λαμβάνει άλλες συναρτήσεις ως ορίσματα είτε επιστρέφει μια συνάρτηση ως αποτέλεσμα. Με άλλα λόγια, λειτουργεί σε λειτουργίες, αντιμετωπίζοντάς τους ως «πολίτες πρώτης κατηγορίας». Αυτό είναι ένα ισχυρό χαρακτηριστικό σε παραδείγματα λειτουργικού προγραμματισμού, που επιτρέπει την αφαίρεση, την επαναχρησιμοποίηση κώδικα και τη σύνθεση.

Παράδειγμα συνάρτησης υψηλότερης τάξης σε Java:

import java.util.function.Function;
public class Main {
    public static void main(String[] args) {
        // Higher-order function: applies a function to a value
        Function<Integer, Integer> squareFunction = x -> x * x;
        int result = applyFunction(5, squareFunction);
        System.out.println("Square of 5: " + result);  // Output: 25
    }
    public static int applyFunction(int value, Function<Integer, Integer> function) {
        return function.apply(value);
    }
}

Στο παραπάνω παράδειγμα:

• Ο applyFunction Η μέθοδος είναι συνάρτηση υψηλότερης τάξης επειδή δέχεται μια άλλη συνάρτηση (Function<Integer, Integer>) ως παράμετρος.

Χαρακτηριστικά:

1. Δέχεται συναρτήσεις ως ορίσματα: Οι συναρτήσεις υψηλότερης τάξης μπορούν να λάβουν άλλες λειτουργίες ως είσοδο για την εκτέλεση συγκεκριμένων λειτουργιών.
2. Επιστροφές Λειτουργίες: Μπορούν να δημιουργήσουν και να επιστρέψουν νέες συναρτήσεις δυναμικά.
3. Ενθαρρύνει την Επαναχρησιμοποίηση Κώδικα: Προωθεί τον αρθρωτό και επαναχρησιμοποιήσιμο κώδικα, καθώς οι συναρτήσεις μπορούν να μεταδοθούν και να συντεθούν μαζί.

Περίπτωση χρήσης:

Στην Java, οι συναρτήσεις υψηλότερης τάξης χρησιμοποιούνται συνήθως στον λειτουργικό προγραμματισμό με ροές, λάμδα και αναφορές μεθόδων. Για παράδειγμα:

List<String> names = Arrays.asList("John", "Jane", "Jake");
names.stream()
     .filter(name -> name.startsWith("J"))  // Takes a lambda function as argument
     .forEach(System.out::println);         // Takes a method reference as argument

Οι λειτουργίες υψηλότερης τάξης προσφέρουν ευελιξία και δύναμη στα προγράμματα Java, επιτρέποντας στους προγραμματιστές να γράφουν καθαρό, συνοπτικό και εκφραστικό κώδικα!

Ορισμένα σύνολα απαντήσεων σε πραγματικές συνεντεύξεις εδώ.

• Κατανοεί βασικά όπως ο πολυμορφισμός, οι στατικές μέθοδοι και το String pool
• εξοικειωμένοι με συλλογές (π.χ. HashSet, TreeSet) και τις περιπτώσεις χρήσης τους.
• Προσδιορίζει σωστά τα πεδία bean (singleton, πρωτότυπο)
• Γνωρίζει την ένεση εξάρτησης και τον σκοπό της.
• γνωρίζει πώς να υλοποιεί σχέσεις πολλά προς πολλά χρησιμοποιώντας πίνακες διασταύρωσης.
• Κατανοεί το σκοπό των ευρετηρίων (αν και επιφανειακά)
• μπορεί να κάνει διαφοροποίηση μεταξύ μονολιθικών και μικροϋπηρεσιών αρχιτεκτονικών
• κατανοεί βασικούς συμβιβασμούς (επεκτασιμότητα, δυνατότητα συντήρησης)
• παρεξηγεί το Liskov Substitution Principle and Dependency Inversion
• Αγωνίζεται να δώσει συγκεκριμένα παραδείγματα για την Αρχή του Ανοιχτού/Κλειστού.
• Δεν έχει βάθος στη διαχείριση του κύκλου ζωής των φασολιών
• Ασαφής σχετικά με την έγχυση προχωρημένης εξάρτησης
• επιφανειακή κατανόηση των ευρετηρίων (σύνθετα ευρετήρια, βελτιστοποίηση ερωτημάτων)
• Δεν είναι εξοικειωμένοι με τα επίπεδα απομόνωσης και το αισιόδοξο/απαισιόδοξο κλείδωμα

Πλεονεκτήματα:

• Εργάστηκε με κώδικα παλαιού τύπου σε ένα τεράστιο και πολύπλοκο σύστημα
• Γνωρίζει ΣΤΕΡΕΑ
• Γνώση ροών
• Επεξηγημένα δείκτες και ACID
• Καλό επίπεδο αγγλικών
  Μειονεκτήματα:
• Καμία ευθύνη για ανάπτυξη ή υποδομή, συμμετοχή στον αρχιτεκτονικό σχεδιασμό
• Έχει κάποια γνώση των αρχών του OOP, αλλά δυσκολεύτηκε πραγματικά να τις εξηγήσει και έκανε λάθος κάποιες έννοιες
• Γενικές γνώσεις συλλογών αλλά έχει κενά και πολύ αβέβαιο
• Δεν καταλαβαίνει τη διαφορά μεταξύ συγχρονισμού και παραλληλισμού, όχι πολύ ισχυρή γνώση συγχρονισμού
• Δεν εξέτασα πολύ την αρχιτεκτονική μικροϋπηρεσιών
• Αόριστες σε ορισμένες έννοιες της βάσης δεδομένων (η συζήτηση των ευρετηρίων ήταν σε επίπεδο επιφάνειας)
• Δεν μπορούσα να εξηγήσω το livelock
• Τα κενά τελικά εμποδίζουν την κατανόηση
• Περιορισμένη γνώση των ειδικών χειρισμού εξαιρέσεων
• Σύγχυση σχετικά με τους τροποποιητές πρόσβασης (Προστατευμένο έναντι Προσωπικού πακέτου)
  Η συναινετική γνώμη …..είναι
  δεν είναι κατάλληλο για τη θέση προγραμματιστή Mid-Java λόγω των κενών στις τεχνικές του γνώσεις.

Πλεονεκτήματα
Εξήγησε ΣΤΕΡΕΑ καλά
Εξήγησε καλά
Επεξηγημένη σύνθεση (αλλά δυσκολεύτηκε αρχικά λίγο)
Άριστη κατανόηση των συλλογών
Διαφορά μεταξύ λιστών και συνόλων
Hashset
Χασμάπ
ConcurrentHashmap
Καλή κατανόηση δομών δεδομένων – στοίβες, ουρές, δέντρα
Καλή γνώση της αρχιτεκτονικής jvm
Επεξήγηση συγχρονισμού έναντι παραλληλισμού, αποδείχθηκε καλή γνώση εφαρμογών πολλαπλών νημάτων
Καλή κατανόηση του REST
Εξήγησε καλά τους δείκτες db
Εξήγησε διαφορετικούς τύπους ενώσεων