方法引入

方法的定义和调用

方法定义,方法(Method),函数(function),其实就指一个特定的功能操作:

程序中完成独立功能，可重复使用的一段代码的集合；

方法定义格式:

[修饰符] 返回值的类型 方法名称([ 形式参数 ,….])

{

方法体

[return 值];

}

方法必须要调用才能生效(想想娶媳妇生孩子的故事/看着菜单点菜).

如果方法使用了 static 修饰:

此时我们使用方法所在类的名称.方法名(参数);

如果方法没有使用static修饰:

此时我们得使用方法所在类的对象来调用(暂且不讨论,面向对象).

方法中的术语和如何定义方法

方法的定义格式:

[修饰符] 返回值类型 方法名称([形参1, 形参 2,…])

{

方法体;

[如果方法需要给调用者返回一个结果,此时使用return 值];

}

方法中的术语是:

修饰符:public,static等,static修饰的方法属于类,直接使用类名调用即可,现在都使用static修饰.

返回值类型: 方法其实是在完成一个功能,该功能操作完毕之后,是否需要给调用者返回一个结果.

如果不需要给调用者返回结果,此时使用关键字 void 来声明,无返回的意思.

方法名称:遵循标识符的规范,使用动词表示,首字母小写,若是多个单词组成,使用驼峰表示法,以后的每一个单词首字母都大写,getEmployeeName.

形式参数:方法圆括号中的变量,仅仅只是占位而已,参数的名称其实无所谓,形式参数可以有多个.

参数列表:参数列表 == 参数的类型 + 参数的个数 + 参数的顺序.

方法签名:方法签名 == 方法名称 + 方法参数列表;

在同一个类中,方法签名是唯一的,否则编译报错.

方法体:方法的{}中的代码,表示具体完成该功能的代码.

返回值: 在方法内部,使用return关键字;

功能1:给调用者返回一个结果值,此时该方法不能使用void修饰.

功能2:结束当前方法.

实际参数:调用者在调用某一个具体方法的时候,实际传递的参数值.

方法的调用者:在哪里调用某一个方法,那么哪里就是该方法的调用者.

如何来定义/设计方法:

如何定义方法:

1):到底需要定义什么功能方法.不要太纠结,跟着我做.

2):是否需要定义返回值类型.

3):是否需要形式参数.

———————————————————————–

1):是否需要定义返回值类型:

我们说方法其实就是在完成某一个功能,那么完成该功能之后,是否需要给调用者返回一个结果数据,如果不需要返回结果数据,此时使用void声明(无返回).

如果需要返回一个结果数据,我们就把该结果数据的类型作为该方法的返回值类型.

打印操作:我们在乎的是方法执行的过程,而不是结果,所以此时使用void声明.

求两个数之和:我们在乎的方法执行的过程,并且执行完毕之后,需要给调用者一个反馈.

2):是否需要形式参数.

该方法在完成该功能的过程之中,是否有未知的因素参与,如果有请作为参数传递,如果没有则没有形参.

求两个数之和的时候,这两个数到底是多少,其实对于方法来说,是未知的,仅仅是调用者知道,而且不同的调用者传递不同的参数值.

———————————————————————–

针对于有返回的方法,调用者应该定义一个变量去接受返回的结果.

———————————————————————–

a:无参数无返回，b:有参数无返回，c:无参数有返回，d:有参数有返回

方法设计练习

方法重载 设计

方法的 重载 设计(overload):

重载方法的定义是在同一个类中，某方法允许存在一个以上的同名方法，只要它们的参数列表不同即可。

方法重载的作用：屏蔽了同一功能的方法由于参数不同所造成方法名称不同。

方法重载判断原则： “两者同一不同”

两同：同类中，方法名相同；

一不同：方法参数列表不同（参数类型、参数个数、参数顺序）；

只要参数类型,参数个数,参数顺序有一个不同,参数列表就不同.

注意：方法重载和方法的返回值类型无关，只是一般要求返回值类型一致。

参数列表和参数的名称没关系,方法的重载和形参没关系.

为什么 System .out.println()可以打印任意类型的数据？查看源代码，证明多个println方法的重载关系。

方法递归操作

读高中学数列的时候，我们见过斐波纳契数列，其通项公式为：F（0）=0，F(1)=1，Fn=F(n-1) +F(n-2)（n>=3，n∈N*），现在求F(5)的值，怎么做呢？

观察：这个数列从第三项开始，每一项都等于前两项之和。

要求F(5)的值，肯定要先求F(4)和F(3)的值，而求F(4)的值又需要求F(3)和F(2)的值… …

解决办法1：

依次求出F(1)、F(2)、F(3)、F(4)值，再处理。

这种办法很笨，效率极低。

方法fn的作用就是求num数的函数值，而求函数值又需要num-1和num-2的函数值，而这两个函数值的求法和求num一样，那么也就可以使用同一个方法。

JVM 内存模型

JVM内存划分,人为的根据不同内存空间的存储特点以及存储的数据:

程序计数器 ：当前 线程 所执行的字节码的行号指示器。

本地方法栈：为 虚拟机 使用的native方法服务。

java 虚拟机栈：描述 Java 方法执行的内存模型，每个方法被执行的时候都会同时创建一个栈帧用于存储局部变量表、操作栈、动态链接、方法出口等信息。

每一个方法,创建一个栈帧,,栈帧存放了当前方法的数据信息(局部变量),当方法调用完毕,该方法的栈帧就被销毁了.

Java堆：被所有线程共享的一块内存区域，在虚拟机启动时创建。所有的对象实例以及数组都要在堆上分配(使用new关键字,就表示在堆中开辟一块新的存储空间)。

方法区：线程共享的内存区域，存储已被虚拟机加载的类信息、常量、 静态变量 即时编译器编译后的代码数据等(这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载)。

GC(Garbage Collection):垃圾回收器。

Java的自动垃圾回收机制:简单理解为,

程序员 就不需要再手动的去控制内存的释放。当JVM发觉内存资源紧张的时候，就会自动地去清理无用对象（没有被引用到的对象）所占用的内存空间。

引出数组和数组定义

为什么使用数组:

问题1:

声明变量时，每一个单独的变量都要对应一个变量名，但现在要处理一组相同类型的数据时，如要表示班上100个人的年龄，绝对不希望定义100个变量来表示每个人的年龄，那怎么办呢？再看下列例子。

int age = 17;//表示一个年龄

问题2:

求两个数之和，需要一个方法，求5个数之和，需要重载一个方法，求100个数之和、1000个数之和、10000个数之和，方法的参数列表会很长很长，而且方法得有很多个，而且还得去记住哪个方法是两个参数的，哪个方法是三个参数的。这样总感觉很不爽，仔细分析这个功能，其实就是求一组数值的和而已，这个方法并不在乎具体是多少个加数，它只在乎需要把哪些数加起来。

大师的建议:定义方法的形参时,最好不好超过5个.

static int getSum(int a,int b){}

static int getSum(int a,int b,int c,int d,int e){}

什么是数组,一组数据,一堆数据:

所谓数组，是在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来的一种数据形式。这些按一定顺序排列的同类型数据的集合称为数组。而数组中的每一个数据称之为数组元素，数组中的元素以 索引 来表示其存放的位置，索引从0开始，步长是1，有点像Excel表格的行号，逐行递增。 好比宾馆的房间.

基本数据类型: byte , short ,int,long,float,double, char , boolean

引用数据类型:类,接口,数组.

变量的定义:

数据类型 变量名; 如: int age;

数组的定义:

方式1: 数组元素的类型[] 数组名; int[] ages;推荐的. 可以吧int[]看成是一种数据类型,int类型的数组类型.

方式2:数组元素的类型 数组名[]; int ages[];

在java中数组必须先初始化,才能使用,因为初始化表示在内存中分配空间.

数组初始化

Java中数组必先初始化后才能使用，所谓初始化就是给数组元素分配内存，并为每个元素赋初始值。

初始化数组的两种方式：

静态初始化；

动态初始化；

无论，以哪种方式初始化数组，一旦初始化完成，数组的长度就固定了，不能改变，除非重新初始化。也就是说数组是定长的。

数组是定长的: 数组一旦初始化成功,数组中的元素个数就已经固定了,不能更改,如果需要更改,只能重新做初始化.

数组的静态初始化操作:

特点:有我们自己来为每一个数组元素设置初始化值,而数组的长度由系统(JVM)决定.

语法:

数组元素类型[] 数组名 = new 数组元素类型[]{元素1,元素2,元素3,…….};

举例:

int[] nums = new int[]{1,3,5,7,9};

简单写法,必须声明之后,立刻初始化,不能先声明后初始化:

int[] nums = {1,3,5,7,9};

数组的动态初始化操作:

由我们来设置数组的元素个数(数组长度),而每一个数组元素的初始值有系统决定.

语法:

数组元素类型[] 数组名 = new 数组元素类型[ length ];

比如:

int[] ages = new int[100];

————————————————————-

int[] nums = new int[5]{1,3,5,7,9};//写法是错误的,不能同时使用静态初始化和动态初始化.

————————————————————-

什么时候使用静态初始化,什么时候使用动态初始化.

当我们事先知道,需要存储哪一些数据的时候,选用静态初始化.

当我们事先不知道,需要存储哪些数据的时候,只能使用动态初始化.

数组基本操作

数组的基本操作:

1:数组基本操作:

获取元素: 元素类型 变量 = 数组名[index];

设置元素: 数组名[index] = 值;

遍历数组元素: 建议使用for循环,事先知道循环的次数.

数组长度: int len = 数组名.length; length 是属性,不是方法.

索引范围: 从0开始,逐一递增. [0,数组名.length-1]

2:操作数组常见异常:

NullPointerException:空指针异常(空引用).

当数组还未初始化,就直接操作数组.

String[] bs = null;

System.out.println(bs.length)

ArrayIndexOutOfBoundsException:数组的索引越界异常.

3:获取数组最大最小元素(getMax,getMin).

4:打印数组元素:

直接打印数组的时候,打印出来是 hashCode 值,如[I@7439aca7.

我们不喜欢,我们想打印数组的时候,把该数组的元素打印出来.

String[] arr = {“A”,”B”,”C”,”D”,”E”};

定义方法打印:

字符串 表示形式由数组的元素列表组成，括在方括号（”[]”）中。相邻元素用字符 “, “（逗号加空格）分隔。

打印格式:[A, B, C, D, E]

5:逆序排列数组元素:

原数组:[A, B, C, D, E]

逆序操作

新数组:[E, D, C, B, A]

6:元素出现索引(第一次/最后一次),线性搜索.

int[] arr = {10,20,30,10,50,-30,10};

获取元素10在arr数组中第一次出现的索引(indexOf): 0

获取元素10在arr数组中最后一次出现的索引(lastIndexOf):6