Connect to blog method, overload, recursion

1. In and out
Enter the reference ： Do it Unknown condition required
The ginseng ： Feedback needed after completion
2. Method overloading （overload）
Definition ： Same method name , Different parameter list . The list is divided into ： Different numbers and types
The method is unique ： Method name and parameters
3. Memory division ：

Java Runtime Data Area : java Runtime area , General name JVM Memory
*

• Program counter :

•  	 A small area of memory . Action can be seen as a position indicator of the current program execution 
  

• Static zone / Method area :

•  	 Save program files (class file )  And static data , Before the method is called , Also stored in the static area , There is also a runtime constant pool inside 
  

• VM Stack : Also called stack memory

•  	 Stack memory is a space opened up based on stack data structure ,  The feature is first in and last out 
  

•  	 Stack  :  It's a data structure , First in, then out , Like a clip 
  

• The components of the stack

•   Stack space  :  Stack memory is stack space 
  

•   Stack frame 	:  Every stack element in the stack space   It's called stack frame ( such as   Every bullet in the magazine   It's called stack frame )
  

•   Stack bottom element  :  The first stack frame put in 
  

•   Top element of stack   :  The last stack frame put in 
  

• Stack operation

•   Pressing stack  :  It refers to the process of putting elements into stack space 
  

•   Bomb stack  :  Is the process of ejecting elements 
  

• Stack memory , Is used to execute methods , Execution of all methods , Must be done in stack memory
• Native Method Stack :

•   Used to execute some local methods , such as hashCode  etc.  ,  The model and operation are similar to VM Stack consistency  ,  Never mind ,
  

• Heap memory :

•  	 To save objects 
  

4. recursive
Definition ： Method calls the current method
recursive thinking ： a. Recursion and iteration are equivalent It's a cycle b. The basic idea is to analogy in turn
Application scenarios ： What a cycle can do , Recursion can do , But in this case, it is preferred to use loops , Recursion should be very memory consuming , Low operating efficiency ; however Like tree structure , You can't do a loop , It can only be done by handing it back

Common recursive application scenarios ： So the tree structure ; Folder copy ; Fibonacci sequence
difficulty ： It's not easy to understand recursion , drawing , Stack frame call graph
Be careful ： There must be termination conditions , Otherwise, it will be like an endless cycle , As a result, the stack memory overflow problem occurs when you keep pressing the stack without bouncing the stack
5. Fibonacci sequence ： It means that from the third item, each item is the sum of the first two items namely f（n）=f（n-1）+f（n-2） （n>2）