☕️JAVA Language Community
#Composite_Design_Pattern 👉Opinions The whole point of the Composite pattern is that the Composite can be treated atomically, just like a leaf. If you want to provide an Iterator protocol, fine, but I think that is outside the pattern itself. At the heart…
👉Opinion
Being able to treat a heterogeneous collection of objects atomically (or transparently) requires that the "child management" interface be defined at the root of the Composite class hierarchy (the abstract Component class). However, this choice costs you safety, because clients may try to do meaningless things like add and remove objects from leaf objects. On the other hand, if you "design for safety", the child management interface is declared in the Composite class, and you lose transparency because leaves and Composites now have different interfaces.
Smalltalk implementations of the Composite pattern usually do not have the interface for managing the components in the Component interface, but in the Composite interface. C++ implementations tend to put it in the Component interface. This is an extremely interesting fact, and one that I often ponder. I can offer theories to explain it, but nobody knows for sure why it is true.
☑️to be continued...
@javaCode☕️
Being able to treat a heterogeneous collection of objects atomically (or transparently) requires that the "child management" interface be defined at the root of the Composite class hierarchy (the abstract Component class). However, this choice costs you safety, because clients may try to do meaningless things like add and remove objects from leaf objects. On the other hand, if you "design for safety", the child management interface is declared in the Composite class, and you lose transparency because leaves and Composites now have different interfaces.
Smalltalk implementations of the Composite pattern usually do not have the interface for managing the components in the Component interface, but in the Composite interface. C++ implementations tend to put it in the Component interface. This is an extremely interesting fact, and one that I often ponder. I can offer theories to explain it, but nobody knows for sure why it is true.
☑️to be continued...
@javaCode☕️
#Java_Interview_Question
143) What is the difference between HashMap and TreeMap?
HashMap maintains no order but TreeMap maintains ascending order.
@javaCode☕️
143) What is the difference between HashMap and TreeMap?
HashMap maintains no order but TreeMap maintains ascending order.
@javaCode☕️
#Java_Interview_Question
144) What is the difference between HashMap and Hashtable?
1) HashMap is not synchronized. Hashtable is synchronized.
2) HashMap can contain one null key and multiple null values.
@javaCode☕️
144) What is the difference between HashMap and Hashtable?
1) HashMap is not synchronized. Hashtable is synchronized.
2) HashMap can contain one null key and multiple null values.
@javaCode☕️
👍1
#Java_Interview_Question
145) What is the difference between Collection and Collections?
Collection is an interface whereas Collections is a class.
Collection interface provides normal functionality of data structure to List, Set and Queue.
But, Collections class is to sort and synchronize collection elements.
@javaCode☕️
145) What is the difference between Collection and Collections?
Collection is an interface whereas Collections is a class.
Collection interface provides normal functionality of data structure to List, Set and Queue.
But, Collections class is to sort and synchronize collection elements.
@javaCode☕️
☕️JAVA Language Community
👉Opinion Being able to treat a heterogeneous collection of objects atomically (or transparently) requires that the "child management" interface be defined at the root of the Composite class hierarchy (the abstract Component class). However, this choice costs…
#Composite_Design_Pattern
👉Opinion
My Component classes do not know that Composites exist. They provide no help for navigating Composites, nor any help for altering the contents of a Composite. This is because I would like the base class (and all its derivatives) to be reusable in contexts that do not require Composites. When given a base class pointer, if I absolutely need to know whether or not it is a Composite, I will use dynamic_cast to figure this out. In those cases where dynamic_cast is too expensive, I will use a Visitor.
Common complaint: "if I push the Composite interface down into the Composite class, how am I going to enumerate (i.e. traverse) a complex structure?" My answer is that when I have behaviors which apply to hierarchies like the one presented in the Composite pattern, I typically use Visitor, so enumeration isn't a problem - the Visitor knows in each case, exactly what kind of object it's dealing with. The Visitor doesn't need every object to provide an enumeration interface.
☑️to be continued...
@javaCode☕️
👉Opinion
My Component classes do not know that Composites exist. They provide no help for navigating Composites, nor any help for altering the contents of a Composite. This is because I would like the base class (and all its derivatives) to be reusable in contexts that do not require Composites. When given a base class pointer, if I absolutely need to know whether or not it is a Composite, I will use dynamic_cast to figure this out. In those cases where dynamic_cast is too expensive, I will use a Visitor.
Common complaint: "if I push the Composite interface down into the Composite class, how am I going to enumerate (i.e. traverse) a complex structure?" My answer is that when I have behaviors which apply to hierarchies like the one presented in the Composite pattern, I typically use Visitor, so enumeration isn't a problem - the Visitor knows in each case, exactly what kind of object it's dealing with. The Visitor doesn't need every object to provide an enumeration interface.
☑️to be continued...
@javaCode☕️
#Java_Interview_Question
👉The rules for #overriding a method are as follows:
* The argument list must exactly match that of the overridden method. If they don't match, you can end up with an overloaded method you didn't intend.
* The return type must be the same as, or a subtype of, the return type declared in the original overridden method in the superclass.
* The access level can't be more restrictive than the overridden method's.
* The access level CAN be less restrictive than that of the overridden method.
* Instance methods can be overridden only if they are inherited by the subclass. A subclass within the same package as the instance's superclass can override any superclass method that is not marked private or final. A subclass in a different package can override only those non-final methods marked pub- lic or protected (since protected methods are inherited by the subclass).
* The overriding method CAN throw any unchecked (runtime) exception, regardless of whether the overridden method declares the exception.
* The overriding method must NOT throw checked exceptions that are new or broader than those declared by the overridden method. For example, a method that declares a FileNotFoundException cannot be overridden by a method that declares a SQLException, Exception, or any other non-runtime exception unless it's a subclass of FileNotFoundException.
* The overriding method can throw narrower or fewer exceptions. Just because an overridden method "takes risks" doesn't mean that the overriding subclass' exception takes the same risks. Bottom line: an overriding method doesn't have to declare any exceptions that it will never throw, regardless of what the overridden method declares.
* You cannot override a method marked final.
* You cannot override a method marked static.
* If a method can't be inherited, you cannot override it. Remember that overriding implies that you're reimplementing a method you inherited!
@javaCode☕️
👉The rules for #overriding a method are as follows:
* The argument list must exactly match that of the overridden method. If they don't match, you can end up with an overloaded method you didn't intend.
* The return type must be the same as, or a subtype of, the return type declared in the original overridden method in the superclass.
* The access level can't be more restrictive than the overridden method's.
* The access level CAN be less restrictive than that of the overridden method.
* Instance methods can be overridden only if they are inherited by the subclass. A subclass within the same package as the instance's superclass can override any superclass method that is not marked private or final. A subclass in a different package can override only those non-final methods marked pub- lic or protected (since protected methods are inherited by the subclass).
* The overriding method CAN throw any unchecked (runtime) exception, regardless of whether the overridden method declares the exception.
* The overriding method must NOT throw checked exceptions that are new or broader than those declared by the overridden method. For example, a method that declares a FileNotFoundException cannot be overridden by a method that declares a SQLException, Exception, or any other non-runtime exception unless it's a subclass of FileNotFoundException.
* The overriding method can throw narrower or fewer exceptions. Just because an overridden method "takes risks" doesn't mean that the overriding subclass' exception takes the same risks. Bottom line: an overriding method doesn't have to declare any exceptions that it will never throw, regardless of what the overridden method declares.
* You cannot override a method marked final.
* You cannot override a method marked static.
* If a method can't be inherited, you cannot override it. Remember that overriding implies that you're reimplementing a method you inherited!
@javaCode☕️
#Java_Interview_Question
👉The rules for #overloading a method are as follows:
■ Overloaded methods MUST change the argument list.
■ Overloaded methods CAN change the return type.
■ Overloaded methods CAN change the access modifier.
■ Overloaded methods CAN declare new or broader checked exceptions.
■ A method can be overloaded in the same class or in a subclass. In other words, if class A defines a doStuff(int i) method, the subclass B could define a doStuff(String s) method without overriding the superclass version that takes an int. So two methods with the same name but in different classes can still be considered overloaded, if the subclass inherits one version of the method and then declares another overloaded version in its class definition.
@javaCode☕️
👉The rules for #overloading a method are as follows:
■ Overloaded methods MUST change the argument list.
■ Overloaded methods CAN change the return type.
■ Overloaded methods CAN change the access modifier.
■ Overloaded methods CAN declare new or broader checked exceptions.
■ A method can be overloaded in the same class or in a subclass. In other words, if class A defines a doStuff(int i) method, the subclass B could define a doStuff(String s) method without overriding the superclass version that takes an int. So two methods with the same name but in different classes can still be considered overloaded, if the subclass inherits one version of the method and then declares another overloaded version in its class definition.
@javaCode☕️
👍2
#Java_Interview_Question
☑️NOTICE:
Which overridden version of the method to call (in other words, from which class in the inheritance tree) is decided at runtime based on object type, but which overloaded version of the method to call is based on the reference type of the argument passed at compile time.
@javaCode☕️
☑️NOTICE:
Which overridden version of the method to call (in other words, from which class in the inheritance tree) is decided at runtime based on object type, but which overloaded version of the method to call is based on the reference type of the argument passed at compile time.
@javaCode☕️
#Java_Interview_Question
👉Rules for #Constructors
■ Constructors can use any access modifier, including private. (A private constructor means only code within the class itself can instantiate an object of that type, so if the private constructor class wants to allow an instance of the class to be used, the class must provide a static method or variable that allows access to an instance created from within the class.)
■ The constructor name must match the name of the class.
■ Constructors must not have a return type.
■ It's legal (but stupid) to have a method with the same name as the class, but that doesn't make it a constructor. If you see a return type, it's a method rather than a constructor. In fact, you could have both a method and a constructor with the same name—the name of the class—in the same class, and that's not a problem for Java. Be careful not to mistake a method for a constructor—be sure to look for a return type.
■ If you don't type a constructor into your class code, a default constructor will be automatically generated by the compiler.
■ The default constructor is ALWAYS a no-arg constructor.
■ If you want a no-arg constructor and you've typed any other constructor(s) into your class code, the compiler won't provide the no-arg constructor (or any other constructor) for you. In other words, if you've typed in a constructor with arguments, you won't have a no-arg constructor unless you type it in yourself!
■ Every constructor has, as its first statement, either a call to an overloaded constructor (this()) or a call to the superclass constructor (super()), although remember that this call can be inserted by the compiler.
■ If you do type in a constructor (as opposed to relying on the compiler-gener- ated default constructor), and you do not type in the call to super() or a call to this(), the compiler will insert a no-arg call to super() for you, as the very first statement in the constructor.
■ A call to super() can be either a no-arg call or can include arguments passed to the super constructor.
■ A no-arg constructor is not necessarily the default (i.e., compiler-supplied) constructor, although the default constructor is always a no-arg constructor. The default constructor is the one the compiler provides! While the default constructor is always a no-arg constructor, you're free to put in your own no- arg constructor.
■ You cannot make a call to an instance method, or access an instance variable, until after the super constructor runs.
■ Only static variables and methods can be accessed as part of the call to super() or this().
■ Abstract classes have constructors, and those constructors are always called when a concrete subclass is instantiated.
■ Interfaces do not have constructors. Interfaces are not part of an object's inheritance tree.
■ The only way a constructor can be invoked is from within another constructor.
@javaCode☕️
👉Rules for #Constructors
■ Constructors can use any access modifier, including private. (A private constructor means only code within the class itself can instantiate an object of that type, so if the private constructor class wants to allow an instance of the class to be used, the class must provide a static method or variable that allows access to an instance created from within the class.)
■ The constructor name must match the name of the class.
■ Constructors must not have a return type.
■ It's legal (but stupid) to have a method with the same name as the class, but that doesn't make it a constructor. If you see a return type, it's a method rather than a constructor. In fact, you could have both a method and a constructor with the same name—the name of the class—in the same class, and that's not a problem for Java. Be careful not to mistake a method for a constructor—be sure to look for a return type.
■ If you don't type a constructor into your class code, a default constructor will be automatically generated by the compiler.
■ The default constructor is ALWAYS a no-arg constructor.
■ If you want a no-arg constructor and you've typed any other constructor(s) into your class code, the compiler won't provide the no-arg constructor (or any other constructor) for you. In other words, if you've typed in a constructor with arguments, you won't have a no-arg constructor unless you type it in yourself!
■ Every constructor has, as its first statement, either a call to an overloaded constructor (this()) or a call to the superclass constructor (super()), although remember that this call can be inserted by the compiler.
■ If you do type in a constructor (as opposed to relying on the compiler-gener- ated default constructor), and you do not type in the call to super() or a call to this(), the compiler will insert a no-arg call to super() for you, as the very first statement in the constructor.
■ A call to super() can be either a no-arg call or can include arguments passed to the super constructor.
■ A no-arg constructor is not necessarily the default (i.e., compiler-supplied) constructor, although the default constructor is always a no-arg constructor. The default constructor is the one the compiler provides! While the default constructor is always a no-arg constructor, you're free to put in your own no- arg constructor.
■ You cannot make a call to an instance method, or access an instance variable, until after the super constructor runs.
■ Only static variables and methods can be accessed as part of the call to super() or this().
■ Abstract classes have constructors, and those constructors are always called when a concrete subclass is instantiated.
■ Interfaces do not have constructors. Interfaces are not part of an object's inheritance tree.
■ The only way a constructor can be invoked is from within another constructor.
@javaCode☕️
#agile_manifesto
🔸Manifesto for Agile Software Development
We are uncovering better ways of developing software by doing it and helping others do it.
Through this work we have come to value:
1️⃣Individuals and interactions over processes and tools
2️⃣Working software over comprehensive documentation
3️⃣Customer collaboration over contract negotiation
4️⃣Responding to change over following a plan
That is, while there is value in the items on the right 👉️,
we value the items on the left 👈more.
@javaCode☕️
🔸Manifesto for Agile Software Development
We are uncovering better ways of developing software by doing it and helping others do it.
Through this work we have come to value:
1️⃣Individuals and interactions over processes and tools
2️⃣Working software over comprehensive documentation
3️⃣Customer collaboration over contract negotiation
4️⃣Responding to change over following a plan
That is, while there is value in the items on the right 👉️,
we value the items on the left 👈more.
@javaCode☕️
✅Principles behind the Agile Manifesto
We follow these principles:
1️⃣Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
2️⃣Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
3️⃣Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
4️⃣Business people and developers must work together daily throughout the project.
5️⃣Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
6️⃣The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
7️⃣Working software is the primary measure of progress.
8️⃣Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
9️⃣Continuous attention to technical excellence and good design enhances agility.
🔟Simplicity--the art of maximizing the amount of work not done--is essential.
1️⃣1️⃣The best architectures, requirements, and designs emerge from self-organizing teams.
1️⃣2️⃣At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
@javaCode☕️
We follow these principles:
1️⃣Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
2️⃣Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
3️⃣Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
4️⃣Business people and developers must work together daily throughout the project.
5️⃣Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
6️⃣The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
7️⃣Working software is the primary measure of progress.
8️⃣Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
9️⃣Continuous attention to technical excellence and good design enhances agility.
🔟Simplicity--the art of maximizing the amount of work not done--is essential.
1️⃣1️⃣The best architectures, requirements, and designs emerge from self-organizing teams.
1️⃣2️⃣At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
@javaCode☕️
👍1
#JSON or JavaScript Object Notation is a lightweight text-based open standard designed for human-readable data interchange. The JSON format was originally specified by Douglas Crockford, and is described in RFC 4627. The official Internet media type for JSON is application/json. The JSON filename extension is .json. This tutorial will help you understand JSON and its use within various programming languages such as PHP, PERL, Python, Ruby, Java, etc.
@javaCode☕️
@javaCode☕️
➡️Uses of #JSON
1️⃣It is used while writing JavaScript based applications that includes browser extensions and websites.
2️⃣JSON format is used for serializing and transmitting structured data over network connection.
3️⃣It is primarily used to transmit data between a server and web applications.
4️⃣Web services and APIs use JSON format to provide public data.
5️⃣It can be used with modern programming languages.
@javaCode☕️
1️⃣It is used while writing JavaScript based applications that includes browser extensions and websites.
2️⃣JSON format is used for serializing and transmitting structured data over network connection.
3️⃣It is primarily used to transmit data between a server and web applications.
4️⃣Web services and APIs use JSON format to provide public data.
5️⃣It can be used with modern programming languages.
@javaCode☕️
Why MicroServices Architecture?
https://www.linkedin.com/pulse/microservices-%DA%86%D8%B1%D8%A7-ali-sharifi
author: @alisharifi01
@javaCode☕️
https://www.linkedin.com/pulse/microservices-%DA%86%D8%B1%D8%A7-ali-sharifi
author: @alisharifi01
@javaCode☕️