Cheat Sheet by SCJP. Part two

Encapsulation and inheritance

• Remember the difference in terms that define the relationship between classes. IS-A is when one class inherits another class (extends) or implements an interface (implements). HAS-A is said when in one class a reference to an object of another class is used.
• The code, written on the principle of encapsulation, contains private variables that are accessed through methods (setVarName and getVarName).
• Inheritance is the basic concept underlying polymorphism, type casting, overloading, and redefinition of methods.
• In java, all classes are descendants of Object.

Polymorphism

• Cannot change the type of reference variable. But a variable can refer to a descendant object of its class. That is, variables of different types can refer to one object. The main thing is that all these types are superclasses for the object class. Therefore, a variable of type Object can refer to an object of any type.

  List<Integer> list; list = new ArrayList<Integer>(); //ArrayList  LinkedList   List,      list = new LinkedList<Integer>(); list = new String(); //   

• Only the type of the reference variable determines which object methods you can call. In other words, if you want to use methods that are specific to this class, then you cannot call them from a variable of type superclass.

   public class Fruit { public void eat(){ System.out.println("NomNomNom"); } } class Apple extends Fruit{ public void grow(){ System.out.println("I'm growing"); } public static void main(String[] args) throws InterruptedException { Fruit fruit; fruit = new Apple(); fruit.eat(); // eat   ,      fruit.grow(); //!  grow    Apple,           Fruit } } 

• Polymorphism works only with object methods, but not with static methods.

Overload and override

• Methods can be overloaded and redefined. Designers are just overwhelmed.
• When overriding methods
  1. Must have a constant list of arguments.
  2. Must have a constant return type.
  3. The access level cannot be lower than the inherited method.
  4. Should not throw new exception'ov.
• Only inherited methods can be overridden.
• You can access the override method as follows:

   public class Fruit { public void eat(){ System.out.println("NomNomNom"); } } class Apple extends Fruit{ public void grow(){ System.out.println("I'm growing"); } public void eat(){ System.out.println("NomAppleNom"); } public void test(){ eat();//   super.eat();//   } } 

• Overload methods
  1. Must have a new list of arguments.
  2. May have a new return type.
  3. May have new access level without restrictions.
  4. May throw new exception
• Superclass methods can be overloaded in a successor.
• Polymorphism applies only to redefinition - not to reload.

Types of return values

• You can use null and arrays as a return value.
• If the return type is primitive (byte, int, float etc), then java will perform an implicit type conversion, if possible.

   public class Fruit { public int eat(){ byte b = 127; return b; //   byte b  int. } public int grow(){ long l = 42; return l; //!     int     42  , //     return (int) l; } } 

  
  
• For void methods, you can use the return keyword if you want to abort the method.
• If the method returns an object, you can use the heirs of the class of this object as the return value.

Constructors

• Each class when creating an object first calls the constructor. The compiler automatically inserts a call to the superclass constructor with no parameters into each constructor. Thus, first the constructor Object is always executed, then the constructor of the first successor of Object, and so on.
• Constructors have the same name as the class, any level of access, but do not have a return value.
• If you do not create a constructor, the compiler will create it for you. The generated constructor has no arguments taken, and its body consists of a call to the superclass constructor super () ;.
• Abstract classes have a constructor, but interfaces do not.
• If the superclass has no constructor with no arguments, then you need to explicitly declare the super () call in the class constructor; and pass the necessary variables.
• Designers are never inherited, but they can be overloaded.
• Constructors can only be directly called from other constructors using this (); and super () ;.
• Example:

   public class Fruit { public Fruit(String str){ System.out.println("Fruit constructor"); } } class Apple extends Fruit{ public Apple(){ super("apple"); System.out.println("Apple's constructor"); } } public class GreenApple extends Apple{ public GreenApple(){ System.out.println("GreenApple's constructor"); }; : Fruit constructor Apple's constructor GreenApple's constructor } 

Static methods and variables

• Use static methods if its behavior does not depend on the state of the object.
• Static methods have access only to static variables.
• Static members are not bound to an object, but to a class.
• Static methods cannot be overridden.