Basic principles of OOP

Basic principles of object-oriented programming (OOP) are follows:

  • Encapsulation is implementation hiding.
  • Inheritance is the creation of a new entity based on an existing one.
  • Polymorphism is the ability to have different forms for the same entity.
  • Abstraction is a set of common characteristics.
  • Sending messages is a form of communication, interaction between entities.
  • Reuse - everything listed above works for code reuse.

This is the only correct order of OOP paradigms, since each subsequent one uses the previous ones.

Read also:


Comments

Post a Comment

Popular posts from this blog

ArrayList and LinkedList in Java, memory usage and speed

Image
How much extra memory is needed when calling ArrayList.add()? If there is enough space in the array to accommodate a new element, then no additional memory is required. Otherwise, a new array is created, 1.5 times larger than the existing one (this is true for JDK above 1.7, in earlier versions the size of the increase is different). How much extra memory is allocated when you call LinkedList.add()? One new instance of the nested Node class is created. How much memory to store one byte primitive in LinkedList? Each LinkedList element stores a link to the previous element, the next element, and a data link. private static class Node<E> { E item; Node<E> next; Node<E> prev; //... } For 32-bit systems, each link is 32 bits (4 bytes). The object (header) of the nested Node class itself takes 8 bytes. 4 + 4 + 4 + 8 = 20 bytes, and since the size of each object in Java is a multiple of 8, so we get 24 bytes. A byte primitive occupies 1 by...
Read more

volatile keyword in Java

Image
Defining a variable with the volatile keyword means that the value of that variable can be changed by other threads. To understand what volatile does, it is helpful to understand how threads handle regular variables. For performance reasons, the Java language specification allows the JRE to store a local copy of the variable for each thread that references it. These "local" copies of variables are like a cache and help a thread avoid accessing main memory every time it needs to retrieve the value of a variable. When two threads start, one of them reads variable A as 10, and the other as 20. If the value of variable A has changed from 10 to 20, then the first thread will not know about the change and will store the wrong value A. But if variable A is marked as volatile, then whenever the thread reads the value of A, it will access the master copy of A and read its current value. A thread-local cache makes sense if the variables in your applications will not be changed extern...
Read more

What characters can a variable name consist of (a valid identifier) in Java

Image
The name or identifier of a variable is a sequence of lowercase and uppercase Latin letters, numbers, as well as the symbols "$" and "_". A variable name can start with any of the listed characters, except a number. It is technically possible to start a variable name with "$" or "_" as well, but this is prohibited by the Java Code Conventions. Also, the dollar symbol "$" is never used at all by convention. By convention, a variable name must begin with a lowercase letter (class names begin with a capital letter). Spaces are not allowed when naming variables. Read also: Methods for reading XML in Java XML, well-formed XML and valid XML XSD
Read more