Java中的方法
生活中:方法就是解决事情的办法,可以提高效率
Java中我们也可以使用方法来提高效率
Java中定义方法的注意事项:
1.方法的定义在类中方法外,方法不可以嵌套
2.方法如果不调用就不会执行
Java中的方法定义有两种类型:
一种是有返回值类型的方法,格式为:
修饰符 返回值类型 方法名([参数列表]){
方法体语句;解决功能的代码块;
return 返回值;
}
public static void main(String[] args){
//方法的调用 直接调用
getPI();
}
//需求:定义功能,得到一个pi的值
//返回值: 要 double 参数:没有
//有返回值,没有参数的方法
public static double getPI(){
System.out.println("有返回值,没有参数的方法");
return 3.1415926;
}
**注意事项**:有返回值类型的的方法必须要有return,return后面必须有数据
修饰符:访问权限修饰符 默认public static
返回值类型:方法运算后结果的数据类型
两种:基本数据类型 或 引用数据类型
方法名: 标识符 满足标识符的命名规范和规则
根据方法的名字区分方法
根据方法名对方法进行调用
上面的代码中,public static 是修饰符 return返回的数值是小数,默认double类型,所以放回的数值是double类型
public static void main(String[] args){
//方法的调用 直接调用
getPI();
}
//需求:定义功能,得到一个pi的值
//返回值: 要 double 参数:没有
//有返回值,没有参数的方法
public static double getPI(){
System.out.println("有返回值,没有参数的方法");
return 3.1415926;
}
()->参数列表
可以存在参数,可以没有参数
参数和参数之间使用,分隔
在方法定义时候,有没有未知的|不确定的数据,如果有,定义在参数列表上
在调用方法时候,必须赋值
相当于局部变量的声明 数据类型 参数名1,数据类型 参数名2,...
局部变量只声明不赋值是没有默认值的
public static void main(String[] args){
//输出调用
System.out.println(getSum(1,100));
}
//需求:求某个区间范围内的数据的和
//返回值:要 int 参数:要2个 int类型 int a,int b
//办法: 1)强制要求第一个参数必须比第二个参数<=,否则结束方法 2)交换两个变量的值,让第一个参数<=第二个参数
public static int getSum(int min,int max){
System.out.println("有返回值,有参数的方法");
if(min>max){
return -1; //提前结束方法
}
int sum=0;
for(int i=min;i<=max;i++){
sum+=i;
}
return sum;
}
形参与实参
形式参数(形参) : 定义方法时()中的参数 :局部变量的声明
实际参数(实参) : 调用方法时()中的参数 :局部变量的赋值
形参与实参之间是一一对应的
数据类型,顺序都要一致
上面的的代码中, min,max 都是形式参数(形参),在调用方法时,getSum(1,100)里的数值就是实际参数(实参).
上面的代码中 {} 中的内容就是解决功能的代码块;
上面的代码中,sum的值被带出,是有返回值类型方法.
return的作用 :
1.提前结束方法
2. 带出返回值
public static void main(String[] args){
//方法的调用 直接调用
getPI();
//赋值调用
double d=getPI();
System.out.println(d);
//输出调用
System.out.println(getPI());
//输出调用
System.out.println(getSum(1,100));
}
//需求:定义功能,得到一个pi的值
//返回值: 要 double 参数:没有
//有返回值,没有参数的方法
public static double getPI(){
System.out.println("有返回值,没有参数的方法");
return 3.1415926;
}
//需求:求某个区间范围内的数据的和
//返回值:要 int 参数:要2个 int类型 int a,int b
//办法: 1)强制要求第一个参数必须比第二个参数<=,否则结束方法 2)交换两个变量的值,让第一个参数<=第二个参数
public static int getSum(int min,int max){
System.out.println("有返回值,有参数的方法");
if(min>max){
return -1; //提前结束方法
}
int sum=0;
for(int i=min;i<=max;i++){
sum+=i;
}
return sum;
}
方法的调用: 方法名(实参) :执行方法中的代码 ()在这里插入代码片
直接调用:
方法名(参数); 有返回值类型的方法 不推荐使用,因为返回值获取不到
赋值调用:
数据类型 变量名=方法名(参数);
输出调用:
System.out.println(方法名(参数));
另外一种没有返回值类型的方法
修饰符 void 方法名([参数列表]){
方法体;
[return];
}
void: 就是没有返回值类型方法
return: 提前结束方法
方法的调用: 方法名(实参) :执行方法中的代码 ()
直接调用:
方法名(参数); 有返回值类型的方法不推荐使用,因为返回值获取不到
public static void main(String[] args){
print(9);
}
//打印m行乘法表
//返回值:不需要 参数: int row
public static void print(int row){
for(int i=1;i<=row;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
}
没有返回值类型的方法的优点:
1.隐藏方法内部的实现细节->安全
2.简化代码
3.提高代码的复用性
return
return的作用:
在返回值类型的方法中: 1.提前结束方法 2.把返回值返回给方法的调用处
没有返回值类型的方法中: 只有一个作用就是结束方法
在编写代码中,会有一些通过不了编译的过程,有不可达语句,有5中情况会造成
- List item
1.一定会执行到的return后面的语句;
2.break后
3.死循环后面
4.continue后面
5.while(false){语句}
方法签名:(方法名+参数列表)
标识方法的唯一性
方法的兼容类型:
形参和实参: 形参的类型>=实参的类型
返回值的数据类型<=方法返的回值类型<=接收返回值的变量类型:
形参的数据类型范围必须大于或等于实参的数据类型范围,否则编译会报错
方法的重载
在同一个类中,有多个方法,方法名相同,参数列表不同|方法签名不同,这些方法构造重载
public static void main(String[] args){
getSum(3,4);
getSum(2,3.0);
getSum(2.0,3);
getSum(2,3,4);
}
//求2个数的和
public static void getSum(int a,int b){
System.out.println("求2个数的和int,int");
System.out.println(a+b);
}
public static void getSum(int b,double a){
System.out.println("求2个数的和int,double");
System.out.println(a+b);
}
public static void getSum(double a,int b){
System.out.println("求2个数的和double,int");
System.out.println(a+b);
}
//求3个数的和
public static void getSum(int a,int b,int c){
System.out.println("求3个数的和int,int,int");
System.out.println(a+b+c);
}
参数列表不同:
参数个数不同
参数类型不同
顺序不同(不同类型的参数顺序不同)
上面的代码中,根据参数类型的不同,调用不同的方法,
由于实参与形参的数据类型是一一对应的,所以可以由参数列表的数据类型来调用不同的方法
当数据类型相同时也已由参数的个数来调用方法
重载方法的调用:
方法名(参数列表); 根据调用方法时实参决定
- 方法的重载与方法的修饰符无关
- 方法的重载与方法的有无返回值无关
- 方法的重载与方法的返回值类型无关
- 方法的重载与参数名无关
方法是一个类中封装的体现
方法的重载是一个类中多态的体现
Java中的数组
数组与变量的不同
变量储存单个数据
数组可以存储多个数据
. 数组的特点:
1.数组是一个引用数据类型
2.数组是一个容器,长度一旦确定不能改变
3.数组中的数据数据类型相同
4.数组中的数据是有序的,下标,索引
数组的定义:
数组的声明方式:
数据类型[] 数组名; —推荐使用此种方法
数据类型 数组名[];
数据类型 : 基本|引用数据类型
规范当前这个数组中能够存放的数据的类型
int a;
int[]arr; //数据类型[] 数组名;
double arr1; //数据类型 数组名[];
数组的初始化: 真实的在堆内存中为数组分配空间
动态初始化: 先创建数组,后续再往数组中存放数据
数据类型[] 数组名 = new 数据类型[整数n长度]; 数组中数据的个数-->数组的长度
在堆中为数组开辟指定长度的空间,存放对应类型的数据
不赋值存在默认值
整数->0
小数->0.0
boolean->false
char-> ' '
字符串->null
public static void main(String[] args){
//数组的声明 数组中能够存放int类型的数据
int[] arr1;//存放int类型的数据
//动态初始化:先创建数组,后续再往数组中存放数据
arr1 = new int[4];//数据类型[整数n长度]; 数组中数据的个数-->数组的长度
//为数组赋值
arr1[0] = 10;
arr1[1] = 11;
arr1[2] = 13;
arr1[3] = 14;
//获取数组的值
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println(arr1[3]);
静态初始化: 创建的同时赋值
数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,...};
数据类型[] 数组名 ={值1,值2,值3,...}; 推荐使用
public static void main(String[] args){
//数组的声明 数组中能够存放double类型的数据
double arr2[];
//静态初始化:创建的同时赋值
arr2=new double[]{1.1,2.2,3.3,4.4};//数据类型[] 数组名 ={值1,值2,值3,...};
//修改值
arr2[1]=123;
//获取数组的值
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);
数组的使用:
根据数组的索引,精度的定位的数组中的每一个位置,操作这个位置的数据(添加|修改|获取)
数组名[索引|下标]
下标从0开始
数组的最后一个数据的索引:
数组名.length-1
数组的属性:
数组名.length 数组的长度
想知道数组的长度只需要输入 数组名.length 打印输出就可以了.
public static void main(String[] args){
//数组的声明 数组中能够存放double类型的数据
//静态初始化
boolean[] arr3={false,1,2,true,4,5,6};
//获取数组的值
System.out.println(arr3[0]);//数组名[索引|下标],下标从0开始
System.out.println(arr3[1]);
System.out.println(arr3[2]);
System.out.println(arr3[3]);
System.out.println(arr3[4]);
System.out.println(arr3[5]);
System.out.println(arr3.length);//数组名.length 数组的长度
}
数组的遍历
获取数组中的每一个数据
1.普通for循环 获取值|赋值
public static void main(String[] args){
String[] arr={"张三","李四","王五","赵六"};
//for普通 i作为数组的索引
for(int i=0;i<=arr.length-1;i++){
System.out.println(arr[i]);
}
}
2.for..each|增强for 获取值
for(数据类型 变量名: 数组名){
变量->数组中从前到后的每一个空间的数据值
}
public static void main(String[] args){
String[] arr={"张三","李四","王五","赵六"};
//for..each|增强for
for(String str: arr/*数据类型 变量名: 数组名*/){
System.out.println(str);
}
3530
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
