黑马程序员之 ---- 基础语法下（方法、数组）

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

方法:

方法就是完成特定功能的代码块

在很多语言里面都有函数的定义

函数在Java中被称为方法

格式：

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {

方法体;

return 返回值;

    }

方法格式解释

修饰符 比较多，后面会详细介绍。目前public static

返回值类型 用于限定返回值的数据类型

方法名 一个名称，为了方便我们调用方法

参数类型 限定调用方法时传入参数的数据类型

参数名 是一个变量，接收调用方法时传入的参数

方法体 完成功能的代码

return 结束方法以及返回方法指定类型的值 

返回值 程序被return带回的结果，返回给调用者

注意：

1：方法不调用，不执行

2：方法与方法是平级关系，不能嵌套定义

3：方法定义的时候参数之间用逗号隔开

4： 方法调用的时候不用在传递数据类型

5： 如果方法有明确的返回值，一定要有return带回一个值

6： 如果方法没有明确返回值，请使用void来表示方法返回类型

void空类型

定义一个变量的时候，不能定义void类型变量

7: 如果方法的返回值是void类型，那么该方法的return语句可以省略

要是相加的话， 请使用 return ;

如何写一个方法呢?两个明确

返回值类型 明确功能结果的数据类型

参数列表 明确有几个参数，以及参数的类型

方法调用的过程：

 

例题：有返回值

class MethodDemo {

public static void main(String[] args) {

//直接调用方法

getSum(3, 4);

//赋值调用方法

int sum = getSum(4,5);

System.out.println(sum);

//输出调用方法

System.out.println( getSum(4,5)  );

 

//-------------------------

int i = 10;

int j = 20;

int sum2 = getSum( i, j);

System.out.println("sum2="+sum2);

}

//完成两个int数据相加，返回相加的结果

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

//int sum = a + b;

//return sum;

 

return a+b;

}

}

没有返回值的方法调用

import java.util.Scanner;

class MethodDemo5 {

public static void main(String[] args) {

//创建对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入行数：" );

int row = sc.nextInt();

System.out.println("请输入列数");

int col = sc.nextInt();

//3: 调用方法，输出图形

//没有返回值的方法，如何调用呢？

//赋值调用--不可以调用

//void result = printXing(row, col);

//定义一个变量的时候，

//不能使用void空类型，void在方法没有明确返回值的时候使用

 

//输出调用--不可以调用

//System.out.println( printXing(row, col) );//输出语句中，不可以打印void类型数据

 

//直接调用--可以使用

printXing(row, col);

}

//2： 定义打印图形的方法

public static void printXing(int row, int col){

for (int i=0; i<row; i++) {//控制行数

for (int j=0; j<col; j++) {//控制列数

System.out.print("*");

}

System.out.println();//换行

}

}

}

方法重载

概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可

方法重载特点

与返回值类型无关，与参数名无关，只看方法名和参数列表

在调用时，JVM虚拟机通过参数列表的不同来区分同名方法

例题：

方发重载：参数个数不同

class MethodDemo7 {

public static void main(String[] args) {

System.out.println( add(2,3) );

System.out.println( add(2,3,5) );

System.out.println( add(2,3,5,10) );

}

//两个数相加  

public static int add(int a, int b){

return a+b;

}

//三个数相加

public static int add(int a, int b, int c){

return a+b+c;

}

//四个数相加

public static int add(int a, int b, int c, int d){

return a+b+c+d;

}

}

方法重载：参数类型不同

class MethodDemo8 {

public static void main(String[] args) {

byte b1 = 5;//3;

byte b2 = 5;

System.out.println( equals(b1,b2) );

System.out.println("---------");

int i1 = 100;

int i2 = 200;

System.out.println( equals(i1, i2) );

}

//两个byte类型

public static boolean equals(byte by1, byte by2){

return by1 == by2;

}

//两个short类型

public static boolean equals(short sh1, short sh2){

return sh1 == sh2;

}

//两个int类型

public static boolean equals(int i1, int i2){

return i1 == i2;

}

//两个long类型

public static boolean equals(long l1, long l2){

return l1 == l2;

}

}

数组：

概念：数组是存储同一种数据类型多个元素的容器

   数组就是一个框，里面可以存储多个相同类型的元素

如何访问数组中的元素呢？

可以通过数组名下标的方式访问

格式: 数组名[索引]

数组的格式1：

数据类型[] 数组名；

数据类型 数组名[];

格式：数据类型[] 数组名 = new 数据类型[数组长度];

数组的格式2：

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

数组常见问题：

数组索引越界

ArrayIndexOutOfBoundsException

访问到了数组中的不存在的索引时发生。

空指针异常

NullPointerException

数组引用没有指向实体，却在操作实体中的元素时。

图解：

 

数组的练习：

遍历

class ArrayTest {

public static void main(String[] args) {

//定义数组

int[] arr = new int[]{1,2,3,4,5};

//方法直接调用

printArray3(arr);

}

public static void printArray3(int[] array){

System.out.print("[");

for (int i=0; i<array.length; i++) {

if (i == array.length-1) {

//最后一个元素

System.out.print(array[i]);

} else {

System.out.print(array[i]+", ");

}

}

System.out.println("]");

}

}

 

获取最值

class ArrayTest2 {

public static void main(String[] args) {

//定义一个数组

int[] arr = {10,35,76,12,55};

int max = getArrayMax(arr);

System.out.println("max="+max);

int min = getArrayMin(arr);

System.out.println("min="+min);

}

//最小值

public static int getArrayMin(int[] array){

//指定参照者

int min = array[0];

//依次和min比较

for (int i=1; i<array.length; i++) {

//比较大小

if (array[i] < min) {

//更新最小值

min = array[i];

}

}

return min;

}

//最大值

public static int getArrayMax(int[] array){

//指定参照者

int max = array[0];

//依次和max比较

for (int i=1; i<array.length; i++) {

//比较大小

if (array[i] > max) {

//更新最大值

max = array[i];

}

}

return max;

}

}

反转

class ArrayTest3 {

public static void main(String[] args) {

//定义一个数组

//互换前

int[] arr = {1,2,3,4,5,6,7};

printArray(arr);

//互换后

reverse(arr);

//int[] result = reverse(arr);

printArray(arr);

}

//反转

//public static int[] reverse(int[] arr){

public static void reverse(int[] arr){

//通过循环来完成互换

//int start = 0;//前面元素的索引

//int end = arr.length-1;//后面元素的索引

for (int start=0, end=arr.length-1; start<end ;start++,end--) {

int temp = arr[start];

arr[start] = arr[end];

arr[end] = temp;

}

//return arr;返回值为空的时候可以没有return

}

public static void printArray(int[] array){

System.out.print("[");

for (int i=0; i<array.length; i++) {

if (i == array.length-1) {

//最后一个元素

System.out.print(array[i]);

} else {

System.out.print(array[i]+", ");

}

}

System.out.println("]");

}

}

冒泡排序：

public class ArrayTest1 {

public static void main(String[] args) {

int[] arr = {24,69,80,57,13};

System.out.println("排序前:");

System.out.println(Arrays.toString(arr));

//排序

bubbleSort(arr);

System.out.println("排序后:");

System.out.println(Arrays.toString(arr));

}

//冒泡排序

public static void bubbleSort(int[] arr){

//外层循环用来控制比较的次数

for (int i = 0; i < arr.length-1; i++) {

//j < arr.length-1-i 为了避免重复比较

//j < arr.length-1 为了避免角标越界异常

for (int j = 0; j < arr.length-1-i; j++) {

if (arr[j] > arr[j+1]) {

//两个数交换

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

}

}

选择排序：

public class ArrayTest2 {

public static void main(String[] args) {

int[] arr = {24,69,80,57,13};

System.out.println("排序前:");

System.out.println(Arrays.toString(arr));

//排序

selectSort(arr);

System.out.println("排序后:");

System.out.println(Arrays.toString(arr));

}

//选择排序

public static void selectSort(int[] arr) {

//外循环控制比较的次数

for (int i = 0; i < arr.length-1; i++) {

//内循环控制参与比较的元素

for (int j = i+1; j < arr.length; j++) {

//比较元素大小

if (arr[i] > arr[j]) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

}

}

二分查找法：

public class ArrayTest3 {

public static void main(String[] args) {

int[] arr = {11,23,34,45,56,67,78};

//查找23出现的位置

int index = halfSearch(arr, 23);

System.out.println("23的位置：" + index);

}

public static int halfSearch(int[] arr, int key) {

//定义三个变量，max,min,mid

int min = 0;

int max = arr.length -1 ;

int mid = (min+max)/2;

//判断key与数组中的元素是否相等

while (arr[mid] != key) {

if (key < arr[mid]) {

//在左边

//更新最大值

max = mid -1;

} else {

//在右边

//更新最小值

min = mid+1;

}

//判断,超出范围，证明没找到，返回-1

if (min > max) {

return -1;

}

//更新mid值

mid = (min+max)/2;

}

return mid;

}

 

}

Java中的参数传递

实际参数：调用方法时，使用的参数就是实际参数，如下面的a,b

getMax(a,b);

int[] arr = {1,2,3};

change(arr);

形式参数：定义方法时，参数列表中的参数,如下面的x,y

public static int getMax(int x, int y){

x = 200;

y = 100;

}

public static void change(int[] arr){

for (int i=0; i<arr.length; i++ ) {

arr[i] *= 2;

}

}

结论：

如果调用方法时，使用的参数是基本数据类型的值

那么，形式参数(x,y)的改变 对 实际参数(a,b)没有影响

如果调用方法时，使用的参数是引用数据类型的值

那么，形式参数的改变 对 实际参数有影响

class ArrayTest6 {

public static void main(String[] args) {

int a = 5;

int b = 3;

System.out.println("a="+a+",b="+b);//  a=5 ， b= 3

change(a, b);

System.out.println("a="+a+",b="+b);  //a=5 ， b= 3

System.out.println("--------------------");

int[] arr = {1,2,3,4,5};

change(arr);

System.out.println(“arr[0]=”+arr[0]);  //arr[0] = 2

}

public static void change(int x, int y){

x=100;

y=200;

}

public static void change(int[] arr){

for (int i=0; i<arr.length; i++) {

arr[i] *= 2;

}

}

}

结果为：a=5 ， b= 3

a=5 ， b= 3

arr[0] = 2

二维数组

概念：其实就是一个元素为一维数组的数组。

大框里 存放着多个小框，每个小框中存放着多个菠萝

格式1：

数据类型[][] 变量名 = new 数据类型[m][n];

m表示这个二维数组有多少个一维数组

n表示每一个一维数组的元素个数

 例： int[][] arr = new int[3][2];

格式2：

数据类型[][] 变量名 = new 数据类型[m][];

m表示这个二维数组有多少个一维数组

这一次没有直接给出一维数组的元素个数，可以动态的给出。

int[][] arr = new int[3][];

arr[0] = new int[2];

arr[1] = new int[3]

arr[2] = new int[1];

格式3：

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

简化版格式：

数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

int[][] arr =  {{1,2,3},{4,6},{6}};

 

二维数组的练习：

1、遍历：

class Array2Test {

public static void main(String[] args) {

int[][] arr = {{1,2,3},{9},{5,6}};

printArray2(arr);

}

//打印二维数组

public static void printArray2(int[][] arr){

for (int i=0; i<arr.length; i++) {

//arr[i]--- 得到一个维数组

//arr[0],arr[1],arr[2]

//遍历一维数组

for (int j=0; j<arr[i].length; j++) {

//arr[i][j]

System.out.print(arr[i][j]+"\t");

}

System.out.println();//换行

}

}

}

2、求和：

class Array2Test2 {

public static void main(String[] args) {

int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

int sum = getArraySum( arr );

System.out.println("sum="+sum);

}

//返回二维数组元素累加和

public static int getArraySum(int[][] arr){

int sum = 0;

for (int i=0; i<arr.length; i++) {

//arr[0],arr[1],arr[2],arr[3]

for (int j=0; j<arr[i].length; j++) {

//得到元素  arr[i][j]

sum += arr[i][j];

}

}

return sum;//返回累加和

}

}

3、杨辉三角：

 

import java.util.Scanner;

class Array2Test3 {

public static void main(String[] args) {

//创建对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入杨辉三角形的行数：");

int row = sc.nextInt();

//创建二维数组，用来存储图形

int[][] arr = new int[row][row];

//两边赋值规律：

for (int i=0; i<row; i++) {

arr[i][0] = 1;

arr[i][i] = 1;

}

//中间赋值规律:

for (int i=2; i<arr.length; i++) {

//arr[0],arr[1] 一维数组

for (int j=1; j<i; j++) {

//arr[i][j] 具体一维数组的元素

arr[i][j] = arr[i-1][j-1] + arr[i-1][j];

}

}

//打印图形

printArray( arr );

}

 

//打印图形

public static void printArray(int[][] arr){

for (int i=0; i<arr.length; i++) {

for (int j=0; j<=i; j++) {

//arr[i][j] 元素值

System.out.print(arr[i][j] + "\t");

}

System.out.println();//换行

}

}

}

结果为：1

11

121

1331

14641

.......