方法
1.方法概述
假设有一个游戏程序，程序在运行过程中，要不断的发射炮弹。发射炮弹的动作需要写100行代码，在每次实现发射炮弹的地方我们都需要重复的编写这100行代码，这样程序会变得非常臃肿，可读性也比较差。为了解决代码重复编写的问题，可以把发射炮弹的代码提取出来放在一个{}中，并为这段代码块起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义一个 方法，程序在需要发射炮弹的地方调用该方法即可。
2.方法的定义及格式
方法的定义：简单的说，方法就是完成特定功能的代码块。在很多语言里面都有函数的定义，而函数在java中被称为方法。
方法的格式：
访问修饰符 返回值类型 方法名（参数类型 参数名1,参数类型 参数名2,...）{
函数体;
return 返回值;
}
那么如果写一个方法？1.返回值类型 明确功能结果的数据类型 2.参数列表 明确有几个参数，以及参数的类型
public int add(int a,int b){
return a + b;
}
3.有明确返回值的方法调用
有明确返回值的方法的调用，如果是单独调用，没有意义；如果是输出调用，有意义，但是不够好，因为我不一定将结果输出；如果是赋值调用，推荐方式。
/**
* 求两个数的和
*/
public class MethodDemo1 {
public static void main(String[] args){
//单独调用
//add(1,2);
//输出调用
//System.out.println(add(1,2));
//赋值调用
int sum = add(1,2);
System.out.println("两数之和是"+sum);
}
public static int add(int a ,int b){
return a + b;
}
}
import java.util.Scanner;
/**
* 键盘录入两个数据，返回两个数中的最大值
*/
public class MethodDemo1 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个数据：");
int num1 = input.nextInt();
System.out.println("请输入第二个数据：");
int num2 = input.nextInt();
System.out.printf("最大值"+getMax(num1,num2));
}
public static int getMax(int a ,int b){
return a > b ? a : b;
}
}
import java.util.Scanner;
/**
* 键盘录入两个数据，比较两个数据是否相等
*/
public class MethodDemo1 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个数据：");
int num1 = input.nextInt();
System.out.println("请输入第二个数据：");
int num2 = input.nextInt();
boolean flag = isEquals(num1,num2);
if(flag){
System.out.println("两个数据相等");
}else{
System.out.println("两个数据不相等");
}
}
public static boolean isEquals(int a ,int b){
return a == b;
}
}
import java.util.Scanner;
/**
* 键盘录入3个数据，找到3个数中的最大值
*/
public class MethodDemo1 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个数据：");
int num1 = input.nextInt();
System.out.println("请输入第二个数据：");
int num2 = input.nextInt();
System.out.println("请输入第三个数据：");
int num3 = input.nextInt();
System.out.println("最大值为"+getMax(num1,num2,num3));
}
public static int getMax(int a ,int b,int c){
return (a > b)?(a>c?a:c):(b>c?b:c);
}
}
4.方法的注意事项
方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用再传递数据类型
5.练习
/**
* 需求，在控制台输出如下图形
* *****
* *****
* *****
* *****
*/
public class MethodDemo2 {
public static void main(String[] args){
printXing(4,5);
}
public static void printXing(int m,int n){
for (int x = 0 ; x < m ; x++ ){
for (int y = 0 ; y < n ; y++ ){
System.out.print("*");
}
System.out.println();
}
}
}
/**
* 需求，在控制台输出如下图形
* 输出九九乘法表
*/
public class MethodDemo2 {
public static void main(String[] args){
printNN(9);
}
public static void printNN(int n){
for (int x = 1 ; x <= n ; x++){
for (int y = 1; y <= x; y++){
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
6.没有明确返回值的方法的调用
其实就是void类型方法的调用，只能单独调用。
7.方法重载
方法重载概述：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载的特点：1.与返回值类型无关，只看方法名和参数列表 2.在调用时，虚拟机通过参数列表的不同来区分同名方法
/**
* 方法重载
*/
public class overLoadDemo {
public static void main(String[] args){
System.out.println("两个数之和:"+sum(1,2));
System.out.println("三个数之和:"+sum(1,2,3));
System.out.println("四个数之和:"+sum(1,2,3,4));
}
public static int sum(int a,int b){
return a + b;
}
public static int sum(int a,int b,int c){
return a + b + c;
}
public static int sum(int a,int b,int c,int d){
return a + b + c + d;
}
}
数组
1.数组概述
现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，有前面所学的知识，程序首先需要声明80个变量来分别记住每个员工的工资，然后再进行操作，这样做会非常麻烦。为了解决这种问题，java就提供了数组供我们使用。
数组是存储多个变量（元素）的容器。多个元素的数据类型要一致。数组既可以存储基本数据类型，也可以存储引用数据类型。
2.数组的定义格式
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
这两个定义好了，数组中是没有元素值的，需要对数组进行初始化。
3.数组的初始化
数组初始化概述：java中的数组必须先初始化，然后才能使用。所谓的初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化的时候只指定数组长度，由系统为数组分配初始值。
静态初始化：吃石化的时候指定每个数组元素的初始值，由系统决定数组长度。
4.数组的动态初始化
动态初始化：初始化的时候只指定数组长度，由系统为其分配初始值。
格式：数据类型[] 数组名 = new 数据类型[数组长度]；
数组长度其实就是数组中元素的个数。
int[] arr = new int[3]; ==左边： int:说明数组中的元素的数据类型是int类型 []:说明这个是一个数组 arr:数组的名称 ==右边： new:为数组分配内存空间 int:数组中的元素的数据类型是int类型 []:说明这是一个数组 3:数组长度，其实就是数组中元素的个数
5.java中的内存分配
Java程序在运行时，需要在内存中分配空间。为了提高运行效率，需要对空间进行不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈：存放的是局部变量
堆：存放的是所有new出来的东西
方法区
本地方法区：和系统相关
寄存器：CPU使用
局部变量：在方法定义中或方法声明上的变量都称为局部变量。
堆内存的特点：1.每个new出来的东西都有地址值 2.每个变量都有默认值 3.使用完毕之后就变成了垃圾，但是并没有立即回收，会在垃圾回收器空闲的时候回收。
6.数组的静态初始化
静态初始化：初始化时指定每个数组元素额初始值，由系统决定其长度。
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...}
举例：
int[] arr = new int[]{1,2,3}
解释：定义了一个int类型的数组，这个数组可以存放3个int类型的值，并且值分别是1,2,3。
其简化形式可以为：int[] arr = {1,2,3};
7.数组练习
package cn;
/**
* 数组遍历:就是一次输出数组中的每一个元素
*
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[]{1,2,3,4,5};
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
}
package cn;
/**
* 获取最大值
*
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[]{1,2,3,4,5};
//输出最大值
System.out.println("最大值："+getMax(arr));
}
public static int getMax(int[] arr){
int max = arr[0];
for(int x = 0;x<arr.length;x++){
if(max<arr[x]){
max = arr[x];
}
}
return max ;
}
}
package cn;
/**
* 数组逆序
*
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[]{1,2,3,4,5};
//数组逆序
reverse(arr);
//打印逆序后的数组
printArray(arr);
}
public static void reverse(int[] arr){
for(int i =0,j=arr.length-1 ;i<arr.length/2;i++,j--){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
}
package cn;
/**
* 数组元素的查找,返回元素的索引值
*
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[]{1,2,3,4,5};
//调用方法
int index = getIndex(arr,2.1);
System.out.println(index);
}
public static int getIndex(int[] arr,int value){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == value){
return i;
}
}
return -1;
}
public static int getIndex(int[] arr,double value){
int index = -1 ;
for (int i = 0; i < arr.length; i++) {
if(arr[i] == value){
index = i;
break;
}
}
return index;
}
}