黑马程序员 二、方法与数组

时间:2022-07-24 00:25:24
获得更多资源关注 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资源分享网