javaSE基础知识——day3 方法/加减法运算/重载/递归/阶乘/求和/斐波那契数列/数组/遍历/最值/查表/输出星期几

方法

• 功能：对一段功能的逻辑封装，用以实现重复调用。

• 定义：方法就是完成特定功能的代码块。定义在类中，方法和方法之间属平级关系，不能相互嵌套。

• 注意事项

  • 方法不调用不执行
  • 方法与方法是平级关系，不能嵌套定义
  • 方法定义的时候参数之间用逗号隔开
  • 方法调用的时候不用再传递数据类型
  • 如果方法有明确的返回值，一定要由return带回一个值

• 语法：

权限修饰符 状态修饰符 返回值类型 方法名（参数类型1 参数名1，参数类型2 参数名2）{
						方法体；//完成功能的代码
						return 返回值；//结束方法以及返回方法指定类型的值
			} 

• 方法的格式详细说明

修饰符 		 比较多,后面会详细介绍。目前使用  public static
返回值类型 	    用于限定返回值的数据类型//eg.void：无明确返回值类型 int：明确返回值类型为int 
方法名			 就是一个名称，它的存在是为了方便我们调用方法
参数类型 	    限定调用方法时传入参数的数据类型
参数名 		 是一个变量，接收调用方法时传入的实际参数参数
方法体 		 完成功能的代码
return 		   结束方法以及返回方法指定类型的值 
返回值 		 就是功能的结果，由return带回，带回给调用者
//一个方法一旦明确返回值类型，必须调用return关键字返回与明确类型一致的结果。

• 用Scanner输入whle循环switch选择的,调用方法加减乘除的运算

package day03.review;
/**
 * 用Scanner输入while循环swit判断
 * 完成加减乘除
 * 注意:
 * 键盘部分只放Scanner
 * 循环部分只放循环的那句话
 * seitch:注意输出方法和变量方式add(add1,add2)
 *
 * 注意方法,之用返回得数
 */
import java.util.Scanner;

public class ScannerCount {
    public static void main(String[] args) {
     
        Scanner sc=new Scanner(System.in);   //键盘录入
        
        while(true){//循环里面只放循环的那就话
            System.out.println("============================================");
            System.out.println("请按照标准输入:1.加法 2.减法 3.乘法 4.除法");
            int numb = sc.nextInt();
            
            switch(numb){//按照顺序调用方法,注意输出得数得用方法
                case 1://加法

                    System.out.print("请输入一个加数:");
                    int add1 = sc.nextInt();
                    System.out.print("请输入一个被加数:");
                    int add2 = sc.nextInt();
                    System.out.println("得数为:"+add(add1,add2));
                case 2://减法

                    System.out.print("请输入一个减数:");
                    int jian1 = sc.nextInt();
                    System.out.print("请输入一个被减数:");
                    int jian2 = sc.nextInt();
                    System.out.println("得数为:"+jian(jian1,jian2));

                case 4://乘法

                    System.out.print("请输入一个乘数:");
                    int cheng1 = sc.nextInt();
                    System.out.print("请输入一个被乘数:");
                    int cheng2 = sc.nextInt();
                    System.out.println("得数为:"+cheng(cheng1,cheng2));

                case 3://除法

                    System.out.print("请输入一个除数:");
                    int chu1 = sc.nextInt();
                    System.out.print("请输入一个被除数:");
                    int chu2 = sc.nextInt();
                    System.out.println("得数为:"+chu(chu1,chu2));
            }

        }
    }
    //定义的个方法,直接返回的是计算结果
    public static int add(int a,int b){

        return a+b;
    }
    public static int jian(int a,int b){
        return a-b;
    }
    public static  int chu(int a,int b){
     return a/b;
    }
    public static int cheng(int a,int b){
        return a*b;
    }

}

• 方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
调用的时候，会根据参数个数和参数类型去匹配

class MethodPractice02{
    public static void main(String[] args){
        add(1,2);//输入的参数为两个，参数类型都为int
        add(1,2.0);//输入的参数为两个，参数类型分别为int和double
        add(1,2,3);//输入的参数为三个，参数类型都为int
    }
    public static int add(int a,int b){
        int sum=0;
        sum=a+b;
        System.out.println("调用了两个int类型的add方法");
        System.out.println("和为"+sum);
        return sum;
    }
    public static double add(int a,double b){
        int sum=0;
        sum=a+b;
        System.out.println("调用了一个int类型和一个double类型的add方法");
        System.out.println("和为"+sum);
        return sum;
    }
    public static int add(int a,int b,int c){
        int sum=0;
        sum=a+b+c;
        System.out.println("调用了三个int类型的add方法");
        System.out.println("和为"+sum);
        return sum;
    }
}
运行结果：调用了两个int类型的add方法
		和为3
		调用了一个int类型和一个double类型的add方法
		和为3.0
		调用了三个int类型的add方法
		和为6

• 研究main方法

public class Demo04 {
    public static void main(String[] args) {
        System.out.println("研究main方法：");//main方法不能输出
        for (int i=0; i<args.length; i++){
            System.out.println(args[i]);
        }

    }
}

递归

• 递归：在方法中调用方法本身,或循环调用该方法。
• 递归注意的事项：1.递归要有出口，没有出口就是死递归，死递归会造成栈溢出
• 递归的次数不宜过多，过多也会造成栈溢出。
• 递归所体现的思想：拆分合并的思想

class RecursionPractice01{
	//计算1~100之间的整数和，拆分成100+99到1之间的整数和，100+99+98到1之间的整数和，依次类推...
    public static void main(String[] args){
        int sum=add(100);
		System.out.println("和为"+sum);
    }
    public static int add(int a){
        if(a==1){
            return 1;
        }else{
            return a+add(a-1);
        }
    }
}
运行结果：和为5050

• 输出5 的阶乘

class RecursionPractice02{
	//计算10的阶乘，拆分成10*9！，10*9*8！，依次类推...
  package day03.review;
/*递归算出阶乘
* 方法自己调用自己,等于1的时候输出,否则一直执行
* 在方法中调用,输出方法*/
public class DiGuiJieCheng {
    public static void main(String[] args) {
        System.out.println(f(5));//输出方法
    }
    public static  int f(int n){
        if (n==1){//当n==1的时候就输出
            return 1;
        }else{//否则一直进行调用n*n-1知道等于1
            return n*f(n-1);
        }
    }
}

• 输出斐波那契数列或者不死神兔

class RecursionPractice02{
    //斐波那契数列：前两个数为1，从第三个数开始，这个数等于前两个数之和 
    //将该问题拆分为第三十项元素为第29项元素加第28项元素，第29项元素为第28加第27项元素，依此类推，直至拆分到第一项和第二项。返回合并
    public static void main(String[] args){
        int num=fabonacci(30);//斐波那契数列第30项元素
        System.out.println("斐波那契数列第30项元素为："+num);
    }
    public static int fabonacci(int a){
        if(a==1|a==2){
            return 1;
        }else{
            return fabonacci(a-1)+fabonacci(a-2);
        }
    }
}
运行结果：斐波那契数列第30项元素为：832040

一维数组

1概念

• 数组是存储同一种数据类型多个元素的集合。可以将数组看成是一个容器。
• 数组既可以存储基本数据类型，也可以存储引用数据类型。

2.定义格式及数组的初始化

class ArrayPractice01{
    public static void main(String[] args){
        int[] arr1=new int[3];//动态初始化：只定义数组的长度，由系统赋默认值。数组创建好后，由系统分配索引脚标，从0开始到数组长度-1.
        int num=arr1[2];//取出数组中的元素/注意打印和取出的区别。
        System.out.println("数组arr1中索引脚标为2的元素为"+arr1[2]);//打印数组中索引脚标为2的元素
        int[] arr2={1,2,3,4,5};//静态初始化：为数组赋值，由系统计算数组长度。
        int length=arr2.length;//数组的长度属性
        System.out.println("数组arr2的长度是"+length);
        }
}
运行结果：数组arr1中索引脚标为2的元素为0
		数组arr2的长度是5

• 一维数组登录系统

package day03.review;

import com.sun.deploy.util.SyncAccess;

import java.util.Scanner;

/*
数组登录系统
数组初始化定义好
对比键盘录入的是否一样,字符串类型比较的时候用.equals不是==
* */
public class ArrayDengLu {
    public static void main(String[] args) {

        String[] userof=new String[3];//数组初始化定义好
        userof[0]="123456";
        userof[1]="123456";
        userof[2]="你真的很棒";

        Scanner sc=new Scanner(System.in);//键盘录入
        System.out.print("请输入用户名:");
        String username = sc.next();
        System.out.print("请输入密码:");
        String passworld = sc.next();
        if (username.equals(userof[0])&&passworld.equals(userof[1])){//字符串进行比较的时候用equals
            System.out.println(userof[2]);
            System.out.println("登陆成功!!");
        }else{
            System.out.println("登录失败!");
        }

    }
}

• 数组定义在方法中,用增强for代替for.length

package day03.review;
/*
* 普通for循环和增强FOR循环
* 增强FOR就是把数组中的值显示出来*/
public class ArrayFor {
    public static void main(String[] args) {
    int[] arrs=new int[5];

        for (int i = 0; i < arrs.length; i++) {//给数组自动赋值
            arrs[i]=i;
        }
    arr(arrs);
    }
    public static void arr(int[] arr){//方法中写一个增强for,把数组当做返回值
        for (int a:arr) {
            System.out.println(a);
        }
    }
}

• 常见数组异常
• a.空指针异常（原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。）

	class ArrayPractice02{
    public static void main(String[] args){
        int[] arr={10,20};
        arr=null;//人为置空
        int length=arr.length;
        System.out.println(length);
    }
}
运行结果：NullPointerException （翻译：空指针异常）

• b.数组脚标越界异常（原因：你访问了不存在的索引。）

class ArrayPractice03{
    public static void main(String[] args){
        int[] arr=new int[5];
        int num=arr[arr.length];//数组中的最后一个元素索引=数组长度-1，因此该程序会报错
        System.out,println(num);
    }
}
运行结果：ArrayIndexOutOfBoundsException 数组角标越界异常

3.Java中的内存分配以及栈和堆的区别

• 栈：存放局部变量。（局部变量：在方法定义中或者方法声明上的变量都是局部变量）

• 堆：存放所有new出来的东西

a.每一个new出的东西都会在堆中分配到一个地址值

b.不同类型的变量都有对应的默认值
byte/short/int/long ------- 0
float/double ------- 0.0
char ------- ‘\u0000’
boolean ------- false
引用数据类型 ------- null

c.地址值和使用完毕后就变成了垃圾，等待Java的回收算法对其回收

• 方法区：（面向对象部分讲解）

• 本地方法区：（和系统相关）

• 寄存器（CPU使用）

• 由三个数组只引用两个地址值的程序为例，具体说明内存分配过程：

class ArrayPractice04{//1.方法区生成ArrayPractice04.class文件
    public static void main(String[] args){//2.栈开始执行main{}
        int[] arr1=new int[3];//3.由于new了一个新数组，因此堆为arr1分配内存空间，为数组赋默认值0，并返回地址值，如0x0001。
        arr1[0]=10;//4a.根据地址值，对arr1[0]重新赋值，将默认值覆盖。
        arr1[1]=20;//4b.根据地址值，对arr1[1]重新赋值，将默认值覆盖。
        int[] arr2=new int[3];//5.由于new了一个新数组，因此堆为arr2重新分配内存空间，为数组赋默认值0，并返回地址值，如0x0002。
        arr2[1]=34;//5a.根据地址值，对arr2[1]重新赋值，将默认值覆盖。
        arr2[2]=89;//5b.根据地址值，对arr2[2]重新赋值，将默认值覆盖。
        int[] arr3=arr1;//6.没有new，因此堆不会重新分配内存空间，将数组arr1的地址值赋值给数组arr3，此时arr3与arr1元素相同。
        arr3[0]=78;//7.由于arr3和arr1引用同一个地址值，对arr3[0]重新赋值会将arr1[0]原先的值覆盖掉，因此导致arr1[0]的值也发生改变。
        arr3[1]=28;//同理，arr3[1]的重新赋值会导致arr1[1]发生改变。
        arr3[2]=99;//同理，arr3[2]的重新赋值会导致arr1[2]发生改变。
        System.out.println("arr1[0]="+arr1[0]);//78
        System.out.println("arr1[1]="+arr1[1]);//28
        System.out.println("arr1[2]="+arr1[2]);//99
        System.out.println("arr2[0]="+arr2[0]);//0
        System.out.println("arr2[1]="+arr2[1]);//34
        System.out.println("arr2[2]="+arr2[2]);//89
        System.out.println("arr3[0]="+arr3[0]);//78
        System.out.println("arr3[1]="+arr3[1]);//28
        System.out.println("arr3[2]="+arr3[2]);//99
    }
}
运行结果：	     arr1[0]=78
				arr1[1]=28
				arr1[2]=99
                arr2[0]=0
                arr2[1]=34
                arr2[2]=89
                arr3[0]=78
                arr3[1]=28
                arr3[2]=99

4.数组的操作

01 遍历（依次输出数组中的每个元素）

class ArrayPractice05{
    public static void main(String[] args){
        int[] arr={10,20,30,40,50};
        System.out.println("------正向遍历------");
        for(int i=0;i<=arr.length-1;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out,println();
        System.out.println("------反向遍历------");
        for(int j=arr.length-1;j>=0;j--){
            System.out.print(arr[j]+"\t");
        }
    }
}
运行结果：---------- 运行 ----------
			------正向遍历------
			10	20	30	40	50	
			------反向遍历------
			50	40	30	20	10	
		输出完成 (耗时 0 秒) - 正常终止

升序降序输出一个数组

/*
* 冒泡排序法*/
public class ArrayBianLI {
    public static void main(String[] args) {
        int[] num={4,3,7,9,2,1,5,7,6,3,1,9};//定义一个以为数组

        System.out.print("输出原来的数组:");//输出原来的数组
        shuchu(num);//调用自己写的输出方法

        System.out.println();
        System.out.print("输出升序的数组:");//输出升序的数组
        testUp(num);//调用升序方法
        shuchu(num);//调用自己写的输出方法

        System.out.println();
        System.out.print("输出降序的数组:");
        testDown(num);
        shuchu(num);

    }
    static void testUp(int[] arr){//建立无返回值的升序方法
        for (int j = 0; j < arr.length; j++) {//输出数组的值
            for (int i = 1; i < arr.length; i++) {//需要循环几次,第一个是0 -1==-1

               if(arr[i-1]>arr[i]) {//前后两个数进行比较,发的往后
                   int temp;//进行两个值之间的转换,采用中间变量的方法
                   temp = arr[i - 1];
                   arr[i-1] = arr[i ];
                   arr[i ] = temp;
               }
            }
        }
    }
    static void testDown(int[] arr){
        for (int j = 0; j < arr.length; j++) {
            for (int i = 1; i < arr.length; i++) {//需要循环几次,第一个是0 -1==-1
                //交换两个值
                if(arr[i-1]<arr[i]) {
                    int temp;
                    temp = arr[i - 1];
                    arr[i-1] = arr[i ];
                    arr[i ] = temp;
                }
            }
        }
    }
  static void shuchu(int[] arr){//建立一个输出方法
        for (int i = 0; i < arr.length; i++) {//输出数组的值
            if (i==0){
                System.out.print("[");
                System.out.print(arr[i]+",");
            }
            if (i>0 && i<arr.length-1){//要记得最后的一个数要-1
                System.out.print(arr[i]+",");
            }
            if (i== arr.length-1){
                System.out.print(arr[i]);
                System.out.print("]");
            }
        }


    }
}

02 获取最值

/*
采用自己写输出条件
数组长度和循环次数,以及两个数采用中间变量的转换
*/
class ArrayPractice06{
    public static void main(String[] args){
        int[] arr={32,45,87,23,65};
        int max=arr[0];
        for(int i=1;i<=arr.length-1;i++){
            max=max>arr[i]?max:arr[i];
        }
        System.out.println("数组arr中最大的元素是"+max);
    }
}
运行结果：数组arr中最大的元素是87

03 数组元素反转（将数组中的元素进行对调，按倒序输出）

04 查表法

a.根据索引查元素

import java.util.Scanner;
class ArrayPractice08{
    public static void main(String[] args){
       String[] str={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
        Scanner sc=new Scanner(System.in);
        System.out.println("请在1---7之间选择你想输入的索引");
        int index=sc.nextInt();
        String weekname=getWeekname(index,str);
        System.out.println(weekname);
    }
    public static String getWeekname(int index,String str[]){
        if(1<=index&&index>=7){
            String weekname=str[index-1];
			return weekname;
        }else{
            return "输入的索引有误";
        }
    }
}

b.根据元素查索引

import java.util.Scanner;

public class ArrayDemo10 {
    public static void main(String[] args){
        String[] str={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
        Scanner Wname=new Scanner(System.in);
        System.out.println("请输入关键字/例：星期一");
        String name=Wname.nextLine();//String类型数据的录入程序格式
        int index = getIndex(name, str);
        System.out.println("您查找的索引号为："+index);
    }
    public static int getIndex(String name,String[] str){//注意返回值类型要与方法中定义的返回值类型保持一致
        for(int i=0;i<=str.length-1;i++){
            if(name.equals(str[i])){//String类型数据之间比较相等的语句**.equals(***)
                return i;
            }
        }
        return -1;//通常用-1表示未查找到
    }
}