获得更多资源关注Java帮帮IT资源分享网
二、黑马程序员—方法与数组
第二篇：
1、什么是方法（Method）？
方法是一组为了实现特定功能的代码块的集合。方法在语法上的功能主要有以下两个：
①：结构化代码
将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护
性强。
②：减少代码重复
一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复
书写对应的功能代码。
方法在书写时需要注意以下两点：
①：逻辑严谨
方法实现的一个完整的功能，所以在书写时要考虑到各种可能的情况，并对每种情况做出恰
当的处理。
②：通用性强（可重复利用）
方法实现的是一种功能，在实际实现时，可以根据需要，使方法具备一定的通用性，除非必
要，否则不要写专用的方法。在 Java 语言中，恰当的使用方法，将使程序更加优雅，便于
阅读和使用。
我的总结：
方法：一段可重复使用的代码段；
程序中完成独立功能的一段代码的集合。
2、Java 中方法的格式：
[修饰符] 返回值类型 方法名([参数类型 形式参数 1，参数类型 形式参数 2，……])
{
执行语句; [return 返回值;]//需要的话
}
参数列表（参数的类型 ，参数的个数，参数的顺序）
我的总结：只要上述有一个不一样，那么这个参数列表就不一样！对于方法而言，即使同
名也不是同一个方法，也就是下面讲的方法签名。
3、方法里的属性
访问控制符：访问控制符限定方法的可见范围，或者说是方法被调用的范围。方法的访问控
制符有四种，按可见范围从大到小依次是：public、protected，无访问控制符,private。其中
无访问控制符不书写关键字即可。具体的范围在后续有详细介绍。
形式参数：在方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型 void。
方法签名：方法名和方法的参数列表(能区别方法)；//最关键的
java 语言中调用方法：对象名.方法名（实参列表）。
实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。
return 语句终止方法的运行并指定要返回的数据。
4、方法特点
它可以实现独立的功能;
必须定义在类里面;
它只有被调用才会执行;
它可以被重复使用;
方法结束后方法里的对象失去引用;
如何定义一个功能,并通过方法体现出来：
1 明确该功能运算后的结果.明确返回值类型;
2 明确在实现该功能过程中是否有未知内容参与运算，确定参数列表;
Eg：
package reviewDemo;
/**
* player 的值分别是1,2,3或者其他值时，该方法返回“大明”，“二明”，“小明”，“我没
有这个孩子”。
*/
public class Demo2 {
public static void main(String[] args) {
int player = 5;
System.out.println("返回的结果是："+show(player));
}
public static String show(int p){
switch (p) {
case 1:
return "大明";
case 2:
return "二明";
case 3:
return "小明";
default:
return "我没有这个孩子！";
}
}
}
5、什么是方法的重载（Overload）？
概念：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或
参数顺序不同即可。
存在的原因：
屏蔽了一个对象的同一类方法由于参数不同所造成的差异。
特点：
与返回值类型无关，只看参数列表。
以下是方法重载的示例：
public void a(int a){}
public int a(){}
public void a(int a,String s){}
Eg：
class Chongzai
{
public static void main(String[] args)
{
int ret = name(3,4,5);
System.out.println(ret);
}
public static int name(int a, int b)
{
int c = a+b;
return c;
}
public static int name(int a, int b, int m)//这就叫做方法的重载，只
要参数列表不一样。好处：用户使用时限制很小；
{
int c = a+b+m;
return c;
}
}
我的总结：方法重载，方法名相同，但是参数列表不一致！（和方法覆写不一样，方法覆写
的方法名和参数列表都必须一样），注意方法重载和方法覆写的不同！
6、可变参数
从 java5 开始出现了可变参数，这是对 java 方法及数组的拓展！
方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。
定义格式： 返回值类型 方法名(参数类型 ... 形式参数){ }
可变参数的特点：
只能出现在参数列表的最后；
... 位于变量类型和变量名之间，前后有无空格都可以;
调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式
访问可变参数。
Eg：
package reviewDemo;
import java.util.Arrays;
public class Demo6 {
public static void main(String[] args) {
int []age = {1,2,3,69,36,636,459};
show(age);
}
public static void show(int...a){//此时这里写的就是可变参数，和数组
的作用一样！
//把数组给打印出来！
System.out.println(Arrays.toString(a));
}
}
7、数组简介：
数组(Array)是 Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，
目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化
代码的书写。
备注：
1. 数组的好处：数组里的每个元素都有编号，编号从 0 开始，并且依次递增，方便操作这
些元素；
2. 使用 Java 数组：必须先声明数组，再给该数组分配内存；
3. 数组对应在内存中一段连续空间。
4. 数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须
是同一类数据类型。
8、一维数组的声明与初始化：
一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；
一维数组的声明方式：
type varName[]; 或 type[] varName;(推荐)
Eg：int age[]; int []age;
数组的长度一旦确定,就不能改变,也就数组是定长的;
我的总结：java 语言声明数组的时候不能指定其长度（元素的个数）
Eg：int a[5]; //非法
初始化：
Java 中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每
个数组元素赋值；
数组初始化的两种方式：
静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；
格式：数组名 = new 数组类型[]{元素 1,元素 2,元素 3...元素 n};
简化语法：数组名 = {元素 1,元素 2,元素 3...元素 n};
动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；
格式：数组名 = new 数组类型[数组长度];
我的总结：
不能静态和动态初始化同时使用：
也就是说不能同时指定数组的长度和元素；
Eg:
package reviewDemo;
/**
* 声明数组及初始化
*/
public class Demo3 {
public static void main(String[] args) {
int []age = new int[10];
//动态初始化
for (int i = 0; i < age.length; i++) {
age[i] = i;
System.out.print(age[i]+" ");
}
}
}
输出：0 1 2 3 4 5 6 7 8 9
9、数组的使用：
Java 语言的数组索引是从 0 开始的，也就是说数组里的第一个元素的索引是 0,第二个元素的
索引是 1，依次可以类推。
常见操作：
给数组元素赋值
数组名[索引] = 数组类型的值 ;
访问数组元素
数组类型 变量 = 数组名[索引];
得到数组的长度
int len = 数组名.length; //length 是数组的属性
遍历数组（备注：length 属性和循环语句）
数组元素的索引范围（0，长度—1）
Eg：判断数组是否重复
package reviewDemo;
/**
* 判断数组是否重复
*/
public class Demo3 {
public static void main(String[] args) {
int []age = {1,2,3,4,5,6,5};
for (int i = 0; i < age.length-1; i++) {//双层循环，定住一个，
再考虑下一个！
for (int j = i+1; j < age.length; j++) {
if(age[i] == age[j]){
System.out.println("有重复的！"+i+" "+j);
break;
}
}
}
}
}
求最大值：
package reviewDemo;
public class Demo4 {
public static void main(String[] args) {
int age[] = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };
int max = age[0];
for (int i = 0; i < age.length; i++) {
if (max < age[i]) {
max = age[i];
}
}
System.out.println(max);
}
}
经典用法：冒泡法排序
class Bubblesort
{
public static void main(String args[])
{
int [] arr={5,1,6,4,2,8,9};
bubble(arr);
printarray(arr);
}
public static void bubble(int[] arr)
{
for (int i=0;i<arr.length-1 ;i++ )
{
for (int y=0;y<arr.length-i-1 ; y++) //让每一次比较的元素减
少，-1是为了防止数组角标越界；
{
if(arr[y]>arr[y+1]) //相邻两元素相比
{
int temp = 0;
temp = arr[y];
arr[y] = arr[y+1] ;
arr[y+1] = temp;
}
}
}
}
public static void printarray(int[] arr)
{
for (int i=0;i<arr.length ;i++ )
{
if(i!=arr.length-1)
System.out.print(arr[i]+",");
else
System.out.println(arr[i]);
}
}
}
//选择排序
public class Demo6 {
public static void main(String[] args) {
int []age = {1,2,36,363,56,95,12,32,1232,3263};
for (int i = 0; i < age.length; i++) {
for (int j = i+1; j <= age.length-1; j++) {
if(age[i] > age[j]){
int temp = age[i];
age[i] = age[j];
age[j] = temp;
}
}
}
System.out.println(Arrays.toString(age));
}
}
//输出为：[1, 2, 12, 32, 36, 56, 95, 363, 1232, 3263]
10、分配内存空间
分配内存空间
数组名=new 数据类型[数组长度]；
new 关键字用来实现为数组或对象分配内存 （堆内存）
数组具有固定的长度。获取数组的长度： 数组名.length
定义数组+分配内存空间
数据类型[]数组名=new 数据类型[数组长度];
定义数组时不指定长度，分配空间时指定数组长度；如：String cities[] = new String[6];
数组元素：
数组名[下标值];
数组下标从 0 开始 scores[0]=75；
数组的内存分配 栈内存和堆内存
如定义一个数组 int[]scores 将在栈内存中为 scores 分配内存空间，其值是一个不确定的值。
当执行语句 scores=new int[5]时，将在堆内存分配连续 5 个空间，每个空间 4 个字节，用于
存放整型数据，其初始值为 0，然后将该段空间首地址，也就是第一个元素的地址，比如
0*3000，赋给 scores 变量。该地址相当于一个指针，指向堆内存中分配的空间。此时堆内存
中分配的 5 个空间可以分别使用 scores[0],一直到 scores[4]来表示。当执行四个赋值语句时，
分别用指定值填充到对应元素位置。如果此时将 null 值赋给 scores 时，scores 变量将不再指
向任何位置，此时堆内存中分配的空间就变成了垃圾，由垃圾回收器在某一时间进行回收。
在方法中定义的变量，包括基本数据类型变量和引用数据类型变量，都将在栈内存中分配空
间，当超过变量作用范围后，自动回收
我的总结：初始化=定义数组+分配空间+赋值
11、二维数组：
二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),
可以看做是一张表格。
初始化：
动态初始化
int[ ][ ] arr = new int[3][2];
定义了一个二维数组，其中有 3 个一维数组，每一个一维数组中有 2 个元素
静态初始化
int[ ][ ] arr = new int[][]{{1,2},{3,4},{5,6}};
int[ ][ ] arr = {{1,2},{3,4},{5,6}};
Eg：
public class Demo3 {
public static void main(String[] args) {
int age[][] = new int[][]{{1,2},{3,4},{5,6,7}};
System.out.println(age[0].length);//2
System.out.println(age[2].length);//3
}
}
12、操作数组的工具类-Arrays
static int binarySearch(type[] a, type key) 使用二分搜索法来搜索 key 元素在数组中的索引；若
a 数组不包括 key，返回负数。（该方法必须已按升序排列后调用）。
static int binarySearch(type[] a, int fromIndex, int toIndex, type key) 使用二分搜索法来搜索
key 元素在数组中从 fromIndex 到 toIndex 的索引；若 a 数组不包括 key，返回负数。（该方
法必须已按升序排列后调用）。
static boolean[] copyOf(type[] original, int newLength) 复制指定的数组见下面备注
static byte[] copyOfRange(type[] original, int from, int to) 将数组的指定范围复制到一个新数
组。
static boolean equals(type[] a, type[] a2) 如果两个数组长度相等和元素一一相等，则返回 true
static void fill(type[] a, type val) 将 a 数组所有元素都赋为 val。
static void fill(type[] a, int fromIndex, int toIndex, type val) 将 a 数组从 formIndex 到 tiondex 索
引之间的元素都赋为 val。
static void sort(type[] a) //sort(int[] arr)对指定的数组按数字升序进行排序。
static void sort(type[] a, int fromIndex, int toIndex) 对指定数组的从 formIndex 到 tiondex 索引
之间的元素按数字升序进行排序。
static String toString(type[] a) 返回指定数组内容的字符串表示形式。多个数组元素之间用英
文逗号或空格隔开。
我的总结：使用数组工具类可以节省时间，提高效率，注意常查阅 api；
Eg：
package reviewDemo;
import java.util.Arrays;
//使用Arrays类
public class Demo4 {
public static void main(String[] args) {
int[] age = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };
System.out.println(Arrays.toString(age));//直接打印出数组的方
法
int []age2 = {1,2,3,4,5,6,98,65,23};
int i = Arrays.binarySearch(age2, 98);
System.out.println(i);
}
}
13、Java5 新特性对数组的支持：
增强 for 循环 → for-each
for (参数类型 参数名 : 数组名) {
代码块
}
Eg：
package reviewDemo;
public class Demo6 {
public static void main(String[] args) {
int []age = {1,2,3,69,36,636,459};
for (int i : age) {
System.out.println(i);
}
}
}
这样就用 for-each 把数组遍历输出！
我的总结：for-each 用于数组和 Iterable 对象！在以后的集合学习中还会经常用到 for-each
循环。
获得更多资源关注Java帮帮IT资源分享网