17.函数（方法）：方法是一段能完成独立功能的代码块，我们只需要修一次方法，就可以多次被利用，提高代码的复用性
<public> <static> 返回值类型[void] 方法名([数据类型 变量名，数据类型1 变量名1，...]){
//方法体；
[return 结果值]；
}
如果一个方法的返回值是void，那么我们不需要返回值，所以不需要写return 变量值；可以有retur;代表程序终止
有返回值的调用写好的方法需要使用返回值来接收方法返回的结果，没有返回值的调用不需要只用返回值接收
方法的参数列表可有可无，可多个，先指定类型在指定变量名，多个参数用逗号分隔
return：在方法有返回值的情况下返回具体的数据
程序方法的调用需要满足：1.方法的名字y一致；2.调用的端必须符合参数定义（参数的类型和数量），要区分变量的作用域问题
运行程序时在内存区产生一个Jvm,Jvm分成三大块，堆、栈、数据共享区，理解java直传递的概念
class Demo1{
public static void main(String[] args){
int a=19;
int b=20;
//有返回值的，调用写好的方法，使用返回值来接收方法返回的结果
int result=compareNum(a,b);
System.out.println(result);
}
/*
<public> <static> 返回值类型[void] 方法名([数据类型 变量名，数据类型1 变量名1，...]){
//方法体；
[return 结果值]；
}
*/
//方法书写为驼峰式，见文知义原则，此处的a、b是形式参数，方法参数的作用域是在这个方法体内的
public static int compareNum(int a,int b){
int c=0;
if(a>=b){
c=a;
}
if(a<b){
c=b;
}
//返回结果值，且当有返回值的时候就不能有return；
return c;
}
}
class Demo2{
public static void main(String[] args){
int a=-7;
int b=20;
//调用写好的方法，没有返回值，不需要使用返回值来接收返回的结果
compareNum(a,b);
}
//如果一个方法返回值类型是void，那么就不需要返回值，return;代表程序终止，所以不需要再写return 变量名
public static void compareNum(int a,int b){
if(a<0||b<0){
System.out.println("程序被终止");
// return;代表程序终止
return;
}
if(a>=b){
System.out.println(a);
}else{
System.out.println(b);
}
}
}
18.方法的重载：在同一个类中方法名字一样，参数列表不一样（数量、类型）的两个方法是重载关系，跟返回值一点关系没有；目的：为了节约方法的功能命名提高代码的可读性
只有方法名和参数列表可以区分重载
class Demo3{
public static void main(String[] args){
int a=-7;
int b=20;
int c=12;
//调用写好的方法，没有返回值，不需要使用返回值来接收返回的结果
add(a,b);//13
add(a,b,c);//25
//实际参数的位置和类型与形式参数要一致，只有方法名和参数列表可以区分重载
add(a,12.5);//5.5
}
//输出调用两个参数求和的方法
public static void add(int a,int b){
System.out.println(a+b);
}
//输出调用三个参数求和的方法
public static void add(int a,int b,int c){
System.out.println(a+b+c);
}
//输出调用两个参数求和的方法，第二个参数类型是double
public static void add(int a,double b){
System.out.println(a+b);
}
}
19.数组的定义
数据类型分为基本数据类型（数值型、字符型、布尔类型）和引用数据类型，引用数据类型：类（class）、接口（interface）、数组（[]）
基本数据类型的变量都是存储在栈中，栈的特点是存储空间小但是存取速度快，先进后出；
引用数据类型所占空间比较大，存储在堆中，堆得特点是空间大存取速度比较慢
整数类型、小数类型默认值都是0，布尔类型默认值是false；字符类默认值是空格''
数组的的三种定义方式：
第一种定义方式，定义一个数组，数据类型[] 数组名=new 数据类型[整数(表示数组长度)],比较常用定义一个空数组后赋值
第二种定义方式，定义一个数组arr1，数据类型[] 数组名={值1，值2，......}，适合定义一个易于初始化的数组
第三种定义方式，定义一个数组arr2，数据类型[] 数组名=new 数据类型[]{值1，值2，......}，适合传递匿名常量数组
int[] arr=new int[8]
arr是数组类型的变量（如果引用数据类型习惯上叫做引用），new int[8]真正的数据存储在堆中，新创建的数据每一个位置上的值都是其所属数据类型的默认值，数组的索引是0开始；
获得数组的长度使用数组的属性length，通过数组的变量名（数组的整地址），通过数组的变量名加上数组的下标或者索引可以对数组的每一个值进行操作，数组的下标不要越界使用，否则会报错lang.ArrayIndexOutBoundsException
class Demo5{
public static void main(String[] args){
//第一种定义方式，定义一个数组，数据类型[] 数组名=new 数据类型[整数(表示数组长度)],比较常用定义一个空数组后赋值
int[] arr=new int[8];
//给数组里面的数据来设置值
arr[0]=5;
arr[1]=2;
arr[2]=1;
arr[3]=1;
arr[4]=3;
arr[5]=1;
arr[6]=4;
arr[7]=0;
/*
//访问数组中的每一个数
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
//获得数组的长度使用数组的属性
int len=arr.length;
System.out.println(len);
*/
printlnArr(arr);
//第二种定义方式，定义一个数组arr1，数据类型[] 数组名={值1，值2，......}，适合定义一个易于初始化的数组
int[] arr1={1111,2222,3333};
//第三种定义方式，定义一个数组arr2，数据类型[] 数组名=new 数据类型[]{值1，值2，......}，适合传递匿名常量数组
char[] arr2=new char[]{'a','b','c'};
//获得数组的长度使用数组的属性
int len=arr.length;
System.out.println(len);
printlnArr(arr1);
printlnArr(arr2);
}
/*
<public> <static> 返回值类型[void] 方法名([数据类型[] 数组名，数据类型1[] 数组名1，...]){
//方法体；
[return 结果值]；
}*/
//方法书写为驼峰式，见文知义原则，此处的a、b是形式参数，方法参数的作用域是在这个方法体内的
public static void printlnArr(int[] arr){
//使用for循环打印数组，注意数组的下标不要越界使用，否则会报错lang.ArrayIndexOutBoundsException
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
public static void printlnArr(char[] arr){
//使用for循环打印数组，注意数组的下标不要越界使用，否则会报错lang.ArrayIndexOutBoundsException
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
20.求极值
数组是引用数据类型，引用数据类型可能发生空指向的问题，引用数据类型定义为null就是空指向没有任何具体的指向目标，基本数据类型是不存在这种情况的
注意为了程序的严谨性，一定要判断null和0长度的问题，而且顺序不能颠倒！！
class Demo6{
public static void main(String[] args){
int[] arr=new int[]{45,72,9,63,84};
//有返回值的，调用写好的方法，使用返回值来接收方法返回的结果
int result=max(arr);
System.out.println(result);
}
/*
<public> <static> 返回值类型[void] 方法名([数据类型 变量名，数据类型1 变量名1，...]){
//方法体；
[return 结果值]；
}
*/
public static int max(int[] arr){
//定义一个最大值的结果
int maxvalue=1;
//为了程序的严谨性，一定要判断null和0长度的问题，而且判断顺序不能颠倒！！！
if(arr!=null&&arr.length!=0){
for(int i=0;i<arr.length;i++){
//如果遍历的数组中的值比最大值变量大的话需要更换赋值
if(arr[i]>=maxvalue){
maxvalue=arr[i];
}
}
}
return maxvalue;
}
}
21.冒泡排序：相邻两个数做比较，如果后一个数比前一个数大，那么就要交换位置，最终每一轮比较产生一个最小值
比较的轮数小于长度减一；比较的次数小于长度减轮数减一
class Demo7{
public static void main(String[] args){
int[] arr=new int[]{45,72,9,63,84};
//调用方法进行冒泡排序
sortPop(arr);
//打印排序之后的数组中的值
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
/*
<public> <static> 返回值类型[void] 方法名([数据类型 变量名，数据类型1 变量名1，...]){
//方法体；
[return 结果值]；
}
*/
public static void sortPop(int[] arr){
//为了程序的严谨性，一定要判断null和0长度的问题，而且判断顺序不能颠倒！！！
if(arr!=null&&arr.length!=0){
//外层为比较的轮数小于长度减一
for(int i=0;i<arr.length-1;i++){
//内层是比较的次数小于长度减轮数减一
for(int j=0;j<arr.length-i-1;j++){
if(arr[j+1]>arr[j]){
//定义一个临时值
int temp=arr[j];
//交换较大值与较小值的位置
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
}
22.数组的倒置
找到中间索引为length/2
获得第i位对应的对称的索引length-i-1
class Demo8{
public static void main(String[] args){
int[] arr=new int[]{45,72,9,63,84,51,99,106};
//调用方法进行倒序排序
reserveArr(arr);
//打印排序之后的数组中的值
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
/*
<public> <static> 返回值类型[void] 方法名([数据类型 变量名，数据类型1 变量名1，...]){
//方法体；
[return 结果值]；
}
*/
public static void reserveArr(int[] arr){
//为了程序的严谨性，一定要判断null和0长度的问题，而且判断顺序不能颠倒！！！
if(arr!=null&&arr.length!=0){
//找到中间索引length/2
for(int i=0;i<arr.length/2;i++){
//
int backNum=arr[arr.length-i-1];
int temp=arr[i];
arr[i]=backNum;
arr[arr.length-i-1]=temp;
}
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
