Java基础Day05

day05

1. 方法
   1.1 方法的概念
   方法的概念: 程序中有一部分的代码,具有独立功能,可能会被反复的使用到,将这一部分代码包裹到一对大括号中{},然后给这对大括号起个名字,以后就用这个名字代替这一段的使用

方法的好处:

1. 方法体现了封装的概念
2. 方法可能提高代码的复用性
3. 方法抽取好了之后,实际开发中,代码写起来会便捷性

1.2 方法的定义
方法定义的语法结构:

修饰符 返回值类型 方法名(参数列表){
// 方法要实现的功能
return 语句;
}

public static void main(String[] args) {
System.out.println(“Hello World!”);
}

解释说明:

1. 修饰符 : 表示对于这个方法的修饰,目前先将修饰符默认为 public static (目前就是为了让方法能够直接在main方法中调用)
2. 返回值类型 : 指方法的功能执行结束之后,可能需要一个产出.让你得到一个什么样的结果,void表示没有任何返回值
   返回值类型,可以是任意的数据类型
   举例 : Scanner sc = new Scanner(System.in); int x = sc.nextInt();
3. 方法名 : 需要符合标识符的定义规范,方法的名字,如果只有一个单词,全小写; 如果方法名字有多个单词,那么从第二个单词开始,首字母大写
4. 参数列表 : 指如果方法要实现一个功能,在实现的过程中,可以需要一些资源,这些资源通过参数的方法传递到方法中来,参数定义方式 : 数据类型 变量名 , 数据类型 变量名
   举例 : 定义一个方法,求长方形的周长, 需要长方形的长和宽两个数据(长和宽就是方法需要的资源)
5. return : 关键字,表示返回. 将方法功能的结果,返回到方法的调用者处

代码
// 方法的定义的使用
public class FunctionDefine{
public static void main(String[] args)
{
System.out.println(“Hello World!”);
}

// 要求: 定义一个方法,求长方形的周长, 
// 需要长方形的长和宽两个数据,需要将得到的周长返回给客户
/*
   修饰符 返回值类型  方法名(参数列表){
     方法要实现的功能
		return 语句;
  }
  注意: 方法的名字,如果只有一个单词,全小写; 如果方法名字有多个单词,
  那么从第二个单词开始,首字母大写
*/
 public static int getZhouChang ( int height , int weigth){
     // 做功能 : 求长方形的周长
     int w = (height + weigth) * 2 ;
	 // 将得到的周长进行返回
	 return w;
 } 

}

1.3方法的调用

1. 定义在同一个类中的方法,如果方法的修饰符与main方法的修饰符一致,就可以直接在main中调用,调用方式,直接将方法名字写在main方法中即可,需要提供方法运行时需要的参数列表

代码
// 方法的定义的使用
public class FunctionDefine{
public static void main(String[] args)
{
// 方法的调用,需要将实际参数传递到方法当中
// getZhouChang 方法可以得到一个整数结果
int result = getZhouChang(10,8);// (10+8) *2 = 36
System.out.println(result);
}

// 要求: 定义一个方法,求长方形的周长
// 需要长方形的长和宽两个数据,需要将得到的周长返回给客户
/*
   修饰符 返回值类型  方法名(参数列表){
     方法要实现的功能
		return 语句;
  }

  注意: 方法的名字,如果只有一个单词,全小写; 如果方法名字有多个单词,
  那么从第二个单词开始,首字母大写

*/
 public static int getZhouChang(int h,int w){
     // 做功能 : 求长方形的周长
     int ww = (h + w) * 2 ;
	 // 将得到的周长进行返回
	 return ww;
 } 

}

1.3 方法在内存中的运行过程

1.4 方法定义时的注意事项
方法定义:

1. 方法需要写在类当中
2. main方法是程序的唯一的执行入口, 但是类中的方法,无论定义的位置先后,方法之间都是平级关系
3. 方法中不能再嵌套的进行方法定义
4. 但是方法中可以调用其他方法(举例: main方法可以调用类中其他方法)

方法参数:

1. 方法在定义时,如果需要资源,可以将资源设置成方法的参数,方法定义时的参数,叫做形式参数, 形式参数的写作形式 : 数据类型 变量名 , 数据类型 变量名 …
   方法的参数数量任意:

1. 方法可以没有参数,小括号为空
2. 方法可以有一个参数,写作方式: 数据类型 变量名
3. 方法可以有多个参数,写作方式: 数据类型 变量名,数据类型 变量名…

2. 方法的调用时,需要提供实际参数列表,提供的实际参数,要与定义时的形式参数的列表保持一致

return 返回:

1. return : 关键字,表示返回,将方法得到的结果返回到方的调用者处
2. 如果方法没有返回值类型,那么返回值类型处,写上void,方法内部可以写return ;
   可以不写return
3. 如果方法,有返回值类型,返回值类型可以是任意的数据类型(可以是基本数据类型也可以是引用数据类型),那么方法内部必须要有return返回,return之后的数据需要与返回值类型保持一致

练习1:
要求: 定义一个方法,方法能实现,比较出两个int类型整数的较大值进行输出

代码
// 方法的练习
public class FunctionLianXi {
public static void main(String[] args) {
// 方法调用,需要传递实际参数
int fanhui = getMax(-2,7);
System.out.println(fanhui);
}

// 要求: 定义一个方法,方法能实现,比较出两个int类型整数的较大值进行输出
public static int getMax(int w , int y){   
     int max = w >= y ? w : y ;
     System.out.println("两个数中较大的数为:"+max);
     // 方法的返回值类型为int,于是方法内部必须要写return
	 return max;
}

}

练习2:
定义一个方法 isEqual,判断两个小数是否相等
说明 : main 方法中,键盘录入两个整数,自动提升为小数,调用方法比较键盘录入的两数是否相等

代码
// 方法的练习
import java.util.Scanner;
public class FunctionLianXi2{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int w = sc.nextInt();
int y = sc.nextInt();
boolean result = isEqual(w , y);
System.out.println(result);
}

public static boolean isEqual(double w , double y){
     // 比较w和y的值是否相等
	 if( w == y ){
	     return true;
	 }else {
	     return false;
	 }
}

}

1.5 方法的重载
为什么要有方法的重载:
在代码中,可能会有很多的方法,但是这些方法具有相似的功能,客户记忆多个方法的名字,不方便,于是想了一个办法,让同一类的方法,具有一个相同的名字,如此,客户值需要记忆一个方法名字,根据不同的方法参数,来解决使用哪个方法

方法重载(Override): 指在同一个类中 , 方法的名字相同 , 方法的参数列表不同 ,与方法的返回值类型无关

方法参数列表不同有哪些:

1. 参数个数不同 举例 : getSum(int x) getSum(int x ,int y)
2. 参数数据类型不同 举例 : getSum(int x) getSum(double x)
3. 不同类型参数的排列顺序不同 : 举例 : getSum(int x , double y) getSum(double y , int x)

代码
// 方法重载
public class FunctionOverride {
public static void main(String[] args) {
int w = getSum(3,5);
int q = getSum(3,4,5);
double e = getSum(7.0,8.0);
System.out.println(w);// 8
System.out.println(q);// 12
System.out.println(e);// 9.0
}

public static int getSum( int x , int y){
   int  w = x + y ;
   return w ;
}

public static int getSum(int x , int y , int z){  
  return x+y+z;
}

public static double getSum(int x , int y){
   return x * y ;
}

}

2. 数组
   2.1 数组的概述
   案例: 班级里,500个学生,500个学生都有姓名,存储500个学生的姓名,将500个学生的姓名信息打印出来
   想法: 我需要一个容器,能不能将500个学生的姓名存储在一个容器中,为这个容器起一个名字,容器中存储的每一个学生姓名都有属于自己的编号,你只需要通过容器的名字和对应的编号,就可以将学生的姓名获取到

数组 : 数组就是一个容器,每个容器只能存储相同的数据类型数据,数组容器也是有名字,数组中每一个元素(数据),都有自己的编号,并且变化还有规律, 通过容器名字+容器中编号,就能获取到执行的容器中的元素

2.2 数组的定义

1. 数组的动态定义
   说明 : 因为数组中的元素值,需要跟着代码的运行进行动态的赋值

数据定义的格式:
数据类型[] 数组名 = new 数据类型[数组容器的大小];
int[] arr = new int[3];

解释说明:

1. 数据类型 : 表示数据容器中可以存储什么类型的数据
2. [] : 中括号,就表示一维数组
3. 数组名 : 起名,需要符合标识符的规范
4. = : 赋值运算符,表示将等号右边的地址,赋值给等号左边的变量
5. new : 关键字, 表示在内存中给数组容器开辟空间
6. 数据类型 : 与前面的数据类型保持一致
7. [容器大小] : 必须给出,表示数组中能存储几个元素

注意: 数组是引用数据类型

代码
// 数组的定义
public class ArrDefine {
public static void main(String[] args) {
// 数据类型[] 数组名 = new 数据类型[数组容器的大小];
// 注意: 数组是引用数据类型,arr就是一个变量
int[] arr = new int[3];
System.out.println(arr);//[I@15db9742
}
}

打印数组的变量,得到的结果: [I@15db9742
[I@15db9742 就表示数组arr在内存中占据的内存地址值

[ : 表示是一个的一维数组
I : 大写的字母I,表示数组中存储的是int类型,int类型的首字母大写
@ : 没有特殊含义,就表示一个简单的分隔符,将前后进行分隔
15db9742 : 是一个16进制数(指在进行数值的进位的时候,逢16进1), 就表示数组在内存中的地址值

2. 数组的静态定义
   如果你在定义数组的时候,已经明确了数组中的元素的内容,就可以使用静态的方式定义
   数据类型[] 数组名 = {元素内容};
   int[] arr = {2,3,-8,99,0,26}; // 数组长度为6,因为数组中有6个元素,索引范围0-5

代码
// 数组的静态定义
public class ArrDemo1 {
public static void main(String[] args) {
int[] arr = {2,3,-8,99,0,26};
System.out.println(arr);// [I@15db9742
System.out.println(arr[2]);// -8
}
}

2.3向数组中添加和获取元素
索引: 数组中存储的每一个元素,在数组中都有一个编号,编号有规律,从0开始,依次加1,
索引范围,从0开始,到数组的长度-1结束
int[] arr = new int[3]; // 可以存储3个int类型元素,数组长度3,索引范围0-2

1. 获取数组中的元素值:
   int first = 数组名[索引值] ;
   注意 : 当通过动态的方式(int[] arr = new int[3])创建一个数组,JVM将动态定义的数组中的数据元素进行一个默认的赋初值动作, 因为数组是int类型,所以默认的赋值为0

2. 给数组中的元素进行赋值:
   数组名[索引值] = 值;

代码
// 数组的定义
public class ArrDefine {
public static void main(String[] args) {
// 1. 数据类型[] 数组名 = new 数据类型[数组容器的大小];
// 注意: 数组是引用数据类型,arr就是一个变量
int[] arr = new int[3];

	// 2. 获取到数组中的元素,获取方式: 数组名[索引值]
	// 索引值的范围从0开始到数组的长度-1
	//将数组容器中的第一个元素获取到
	// JVM将动态定义的数组中的数据元素进行一个默认的赋初值动作, 
	// 因为数组是int类型,所以默认的赋值为0
	int first = arr[0];
	int second = arr[1];
	int third = arr[2];

	System.out.println(first);// 0
	System.out.println(second);// 0
	System.out.println(third);// 0

	// 3. 给数组中元素进行赋值
	arr[0] = 88;
	arr[1] = -2;

	System.out.println(arr);//[I@15db9742
	System.out.println(arr[0]);// 88
	System.out.println(arr[1]);// -2
	System.out.println(arr[2]);// 0
}

}

2.4 数组在内存中的运行过程

数组在内存中的运行过程:

1. int[] arr = new int[3]; 该行语句在内存中的运行过程为

1. new 关键字到堆内存中开辟一块数组空间,空间中有三个元素位置
2. JVM虚拟机,为数组中的元素进行默认的赋初值动作,因为数组为int类型,因此默认赋值为0
3. 数组中的索引止从0开始,到数组长度-1结束
4. 数组容器在内存中产生一个内存地址15db9742,让后返回给arr变量,以后arr就表示15db9742地址

2. int first = arr[0],表示到15db9742内存地址处,找到0索引对应的元素值
3. arr[1] = -2 ,表示到15db9742内存地址处,找到0索引对应的元素,将其值赋值为-2

2.5 数组的遍历
数组的遍历 : 指将数组中的元素,一个一个获取到,称为遍历
将元素一个一个获取到是重复动作,使用循环实现

如果获取到数组中的某一个元素:
数组名[索引值]-----> 索引值0-数组长度-1-----> 数组元素的获取,依靠索引值----> 如果我能将所有的索引值获取到,你就能获取到每一个索引对应的元素值

索引值的规律 : 0-数组长度-1
数组求长度 : 数组中有一个属性,length ,数组名.length

要求 : 给你任意一个int[] 数组,能将数组中的所有的元素获取到
分析 : 根据数组中的索引,获取到数组中每一个元素

代码
// 数组的遍历
public class ArrBianLi{
public static void main(String[] args) {
// 1. 定义一个数组
int[] arr = {4,45,6,-3,9,99,88,0};
// 2. 定义一个循环，获取到数组中的每一个索引
/for(int i = 0 ; i <= arr.length - 1; i ++){
// 循环中的每一个i都是表示索引值
int w = arr[i];
System.out.println(w);
}/
// 方法调用
getArr(arr);
}

// 要求: 将int[] 数组的遍历共功能，封装成一个方法
// arr变量只能在方法的大括号中使用
public static void getArr(int[] arr){//方法的参数，需要一个数组类型arr
    
   for(int i = 0  ; i < arr.length ; i ++ ){
      int result  = arr[i];
      System.out.println(result);
   }
}

}