函数的定义和调用
1.认识函数
1）函数定义：就是封装了一个功能的方法。函数又叫方法。
2）函数的格式
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数是传递给参数的实际参数。
实际参数：传递给形式参数的具体数值。
如果函数没有返回值，格式是：
public void test(int a){
......
//不需要return
}如果函数需要有返回值，格式是：
public String test(int a){
......
return "";//必须有
}
函数可以有输入的参数，也可以没有输入的参数。3）定义函数的目的：
封装代码、避免重复编写代码(比如定义了一个求最值的函数，以后再有这种功能需求的时候，可以直接把这个函数拿过来用，不用再重新写实现)
4）典型的，必须要掌握的函数，自己要手动的数量的敲出来：
public static void main(String[] args){}
2.函数分为：
1）静态函数：定义函数的时候，在返回值前面加static
public static void test(){}
2）非静态函数：不加static
public int test()静态函数的调用：类名.方法名
非静态函数的调用：对象.方法名比如：
public class B
{
public static void main(String[] args){
//调用静态方法
A.test2();
//调用非静态方法
new A().test1();
}
}
class A
{
//非静态方法
public void test1(){
int x = 1;
//调用静态方法
A.test2();
}//静态方法
public static void test2(){
int x = 2;
//调用非静态方法
new A().test1();
}
}
例子：
public class Test { public static void main(String[] args) { //调用函数 int max = getMax(1,2); System.out.println("最大值是："+max); Test test = new Test(); test.sum(3); } //求最大值 public static int getMax(int a,int b){ int max = a; if(b > max){ max = b; } return max; } //累加求和 public void sum(int n){ long sum = 0; //用long类型，因为数据大 for(int i=0;i<=n;i++){ sum = sum +1; } System.out.println(sum); } }函数的特点：
1.定义函数可以将功能代码封装。
2.便于对该功能进行复用。
3.函数只有被调用才会被执行。
4.函数的出现提高了代码的复用性。
5.对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中return语句如果在最后一行可以省略不写
注意：函数中只能调用函数，不可以再函数内定义函数。定义函数时，函数的结果返回给调用者，交由调用者处理。
函数的应用两个明确：
1.明确要定义的功能过后的结果是什么？
2.明确在定义该功能的过程中，是否需要未知的内容参与运算？
作业：
1）定义函数，函数名为max，功能：输入三个int型参数，求最大值。(函数为static静态的,函数有返回值，在main中调用该函数)
2）定义函数，函数名为sum，功能：输入一个int型参数n，累加求1到n之和。要求用for和while循环分别做一遍。(非静态的函数，函数有返回值，在main中调用该函数)
3）定义函数，函数名为getData，功能：没有输入参数，打印hello world到控制台
3.函数的重载（overload）
1）函数的重载：在一个类中有多个相同名称，但是参数个数或者类型不同的函数
2）注意：函数的重载与返回值无关，即不能根据返回值来判断函数是否重载
3）重载的好处：方便维护代码public class A
{
public static void main(String[] args){
}public void test(int a,int b){}
//public void test(int a,int b,int c){} //是重载的方法
//public String test(int a,int b,int c){} //是重载的方法，因为不看返回值
public void test(int b,int a){} //不是重载的方法，编译不能通过
}
public class Test { public static void main(String[] args) { Test test = new Test(); int sum = test.add(1,2); test.add(1,2,3); } //两个重载的方法 public int add(int a,int b){ return a+b; } public void add(int a,int b,int c){ System.out.println(a+b+c); } }作业：用代码实现下面三个重载的方法：
public class Arrayemo {
public static void main(String[] args) {
System.out.println(add(1,2));
System.out.println(add(1,2,3));
System.out.println(add(1.2,3));
}
public static int add(int a,int b) {
int sum = 0;
sum=a+b;
return sum;
}
public static int add(int a,int b,int c) {
int sum=0;
sum=a+b+c;
return sum;
}
public static double add(double a,double b) {
double sum=0;
sum=a + b;
return sum;
}
}数组
1）数组：同一种类型数据的集合。数组就是一个容器。数组是连续的空间。
2）数组的第一种定义：
这种只对数组进行了定义，还没有赋值，里面的默认的值是：
int[] arr = new int[5] //此时数组中每个元素都是0
String[] arr = new String[5] //此时数组中每个元素都是null
3）数组的第二种定义：
这种既对数组进行了定义，又进行了赋值。
使用数组的例子：
public static void main(String[] args){ //arr就相当于一个指针，指着一个大容器 int[] arr = new int[3]; //1.注意：length是数组的属性，不是方法 System.out.println(arr.length); //2.访问数组元素：通过下标来进行访问 System.out.println(arr[0]); //3.修改数组元素，为数组指定下标处设值 arr[1]=10; //4.arr数组的长度是3,可以访问的下标是0,1,2. //如果下标超过范围，会抛出java.lang.ArrayIndexOutOfBoundsException //也就是会出现数组越界异常 //自己上机演示这个问题 System.out.println(arr[3]); //5.如果数组的指针的值为null，会出现java.lang.NullPointerException //也就是空指针异常 arr=null; System.out.println(arr); //数组越界 和 空指针异常是数组中最常见的两个异常 //6.数组的遍历 for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } //串拼接 for(int i=0;i<arr.length;i++){ arr[i] = i; } //一定要有一个串，写在前面 System.out.println(""+arr[0]+arr[1]+arr[2]); }public class Test { public static void main(String[] args) { int[] arr = {4,1,5,2}; getMax(arr); //调用函数 getData();//调用函数 } //得到数组的最大值 public static void getMax(int[] arr){ int max = -1; int index = 0; //if 判断是为了保证arr数组是可用的，规范 if(null != arr && arr.length>0){ max = arr[0]; index = 0; for(int i=1;i<arr.length;i++){ if(arr[i]>max){ max = arr[i]; index = i; } } } System.out.println("最大值下标："+index); System.out.println("最大值是："+max); } //定义并初始化一个int类型长度为3的数组，遍历数组，打印下标为1的元素，修改下标为0的元素并将值打印出来 public static void getData(){ int[] arr = {2,5,1}; //遍历数组 for(int i=0;i<arr.length;i++){ System.out.print(arr[i]+"\t"); } System.out.println(); //打印下标为1的元素 System.out.println("下标为1的元素是："+arr[1]); //修改下标为0的元素并将值打印出来 arr[0]=12; System.out.println("下标为0的元素是："+arr[0]); } }
内存结构
内存由三部分组成：
1）栈 2）堆 3）方法区
1）关于栈
一个类包括成员变量和成员方法：
public class Test {
//成员变量
int age1= 10;//成员变量即使不赋值都有默认值，int->0，String->null，所以可以直接使用
//成员变量存在于堆内存中，生命周期与对象一样
int age;
//成员方法
public void test(){}
}方法内部定义的变量是局部变量，局部变量存储在栈中，test方法结束之后就释放：
public class Test{
//a,b都是局部变量，局部变量必须初始化之后才能使用
public void test(int a){
int b;
}
}2）关于堆(先不看)
public class Test {
public static void main(String[] args) {
//t,arr在main函数中，所以t,arr是局部变量，main函数执行完之后就会释放
Test t = new Test();//t在栈中，new出来的对象在堆中
int[] arr = new int[2];//arr在栈中，数组对象在堆中
}
//成员变量即使不赋值都有默认值，int->0，String->null，所以可以直接使用
//成员变量存在于堆内存中，生命周期与对象一样
int age;
//局部变量必须初始化之后才能使用
public void test(int a){
int b;
//b必须给值之后才能使用
}
}3）关于方法区
类的成员方法都在方法区中。
二维数组
定义二维数组的三种格式：
格式3：int[][] arr = {{1,2},{2,3}};//定义并初始化了一个二维数组[2][2]
public class Test { public static void main(String[] args) { //二维数组的定义与赋值 //理解！！！ //只是对a进行了定义 int[][] a1 = new int[3][2]; //里面是0 //为一维数组开辟空间(定义) //a[0] = {1,2};//不能这样写，因为没有开辟空间，不能直接赋值 int[][] a = new int[3][]; a[0] = new int[2]; a[1] = new int[2]; a[2] = new int[2]; //为一位数组赋值 a[0][0]=1; a[0][1]=2; a[1][0]=3; a[1][1]=4; } //二维数组的遍历 public void getData(int[][] a){ for(int i=0;i<a.length;i++){ for(int j=0;j<a[i].length;j++){ System.out.println(a[i][j]); } } } }
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
