一方法

1.1 何谓方法？

• java方法是语句的集合，他们在一起执行一个功能。
  • 方法是解决一类问题的步骤的有序组合。
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用。

1.2 设计方法的原则：

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，有利于后期的拓展。

1.3 命名规则【回顾】：

1.4 方法的定义：

• Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义
  一个方法包含以下语法：
  方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

1. 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型
2. 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void
3. 方法名：是方法的实际名称。方法名和参数表共同构成方法签名
4. 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数
   • 形式参数：在方法被调用时用于接收外界输入的数据
   • 实参：调用方法时实际传给方法的数据
5. 方法体：方法体包含具体的语句，定义该方法的功能

修饰符 返回值类型 方法名(参数类型 参数名) {
	方法体
}
rerturn 返回值;
1
2
3
4

1.5方法的调用

调用方法：对象名.方法名(实参列表)
Java支持两种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，方法调用通常被当作一个值

int larger=max(666,888);
1

如果方法返回值是void，方法调用一定是一条语句。

System.out.println("酸梅汤小王子");
1

java中使用的是值传递

1.6 案例：输入两个整数，输出较大值

public static void main(String[] args) {
        int a=0,b=0;
        System.out.println("请输入两个整数：");
        Scanner scanner=new Scanner(System.in);
            if(scanner.hasNextInt()) {
                a= scanner.nextInt();
                b= scanner.nextInt();
            }
        scanner.close();
        int larger=max(a,b);
        System.out.println("较大值是："+larger);
    }

    public static int max(int a,int b) {
        int larger=0;
        return larger=a>b?a:b;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.7 方法的重载

• 重载是在一个类中，有相同的函数名称，但形参不同的函数。
  方法的重载的规则：
  • 方法名称必须相同
  • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
  • 方法的返回类型可以相同也可以不相同
  • 仅仅返回类型不同不足以成为方法的重载
    实现理论：
  • 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

1.8 可变参数

JDK1.5开始，JAVA支持传递同类型的可变参数的一个方法。
在方法生命中，在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数都必须在它之前声明

举例

public static void main(String[] args) {
        printMax(666.666,888.888,999.999);
    }

    public static void printMax(double...numbers) {
        double result=numbers[0];
        if(numbers.length==0) {
            System.out.println("无数据输入！");
        }
        else {
            for(double i:numbers) {
                if(result<i) {
                    result=i;
                }
            }
        }
        System.out.println("最大值是："+result);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.9 递归

• 通俗讲：自己调用自己
• 利用通归可以用简重的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
  递归结构包括两个部分：
  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
  • 递归体：什么时候需要调用自身方法
    

举例：求阶乘

 public static void main(String[] args) {
        int n=0;
        System.out.println("请输入您要求的阶乘的整数：");
        Scanner scanner=new Scanner(System.in);
        if(scanner.hasNextInt()) {
            n= scanner.nextInt();
        }
        scanner.close();
        System.out.println(f(n));
    }
    public static int f(int n) {
        if(n==1) {
            return 1;
        }
        else {
            return n*f(n-1);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二 数组

2.1 数组的定义

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

2.2 数组的声明创建

首先必须声明数组变量，才能在程序中使用数组。语法如下：

dataType[] arrayReVar;//首选
或者
dataType arrayReVar[];//效果相同，但不是首选
1
2
3

使用new操作符来创建数组，语法如下：

dataType[] arrayReVar=new dataType[arraySize];
1

2.3 三种初始化

静态初始化

int]a={1,2,3};
Man[]mans={newMan(1,1)，newMan(2,2）;
1
2

动态初始化

int]a=newint[2];
a[o]=1;
a[1]=2;
1
2
3

数组的默认初始化:
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

2.4 数组边界

下标的合法区间：[0.length-11，如果越界就会报错；
ArraylndexOutOfBoundsException：数组下标越界异常！
小结：

• 数组是相同数据类型（数据类型可以为任意类型）的有序集合
• 数组也是对象，数组元素相当于对象的成员变量
• 数组长度的确定的，不可变的。如果越界，则报：ArraylndexOutOfBounds

2.5 数组的四个基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
• 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型
• 数组对象本身是在堆中的

数组翻转

public static void main(String[] args) {
        int [] arrays={1,2,3,4,5,6,7};
        int [] reverse=reverse(arrays);
        printArray(reverse);
    }
    public static int[] reverse(int[] arrays) {
        int [] result =new int[arrays.length];
        for(int i=0,j=result.length-1;i<arrays.length;i++,j--) {
            result[j]=arrays[i];
        }
        return result;
    }

    public static  void printArray(int[] arrays) {
        System.out.println("翻转后的数组为：");
        for(int i:arrays) {
            System.out.print(i+" ");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.6 Arrays类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们便
用，从而可以对数据对象进行一些基本的操作。
查看JDK帮助文栏
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不
用”使用对象采调用（注意：是不用”而不是“不能”）
具有以下常用功能：

• 给数组赋值：通过初方法
• 对数组排序：通过sort万法按升序
• 比较数组：通过equals方法比较数组中元素值是否相等
• 查找数组元素：通过binarysearch方法能对排序好的数组进行二分查找法操作

2.7 稀疏数组

2.7.1 稀疏数组的介绍

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
如下图：左边是原始数组，右边是稀疏数组

public static void main(String[] args) {
    //1 创建一个二维数组 11*11 0：没有棋子 1：黑子 2：白子
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        System.out.println("输出原始的数组：");
        for(int [] ints:array1) {
            for(int anInt:ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum=0;
        for(int i=0;i<11;i++)
        {
            for(int j=0;j<11;j++) {
                if(array1[i][j]!=0)
                {
                    sum++;
                }
            }
        }

        System.out.println("有效值的个数："+sum);

        //2 创建一个稀疏数组的数组
        int [][] array2=new int[sum+1][3];

        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        //遍历二维数组,将非零的值，存放稀疏数组中
        int count=0;
        for(int i=0;i<array1.length;i++) {
            for(int j=0;j<array1[i].length;j++) {
                if(array1[i][j]!=0) {
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }

        //输出稀疏数组
        /*for(int i=0;i< array2.length;i++) {
            System.out.println(array2[i][0]+"\t"
                                +array2[i][1]+"\t"
                                +array2[i][2]+"\t");
        }*/
        for(int[] ints:array2) {
            for(int intX:ints) {
                System.out.print(intX+"\t");
            }
            System.out.println();
        }

        //还原数组
        System.out.println("还原数组：");
        //1. 读取稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        //2. 给其中的元素还原它的值
        for(int i=1;i<array2.length;i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //打印
        for(int[] intS:array3) {
            for(int intX:intS) {
                System.out.print(intX+"\t");
            }
            System.out.println();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

2.8 冒泡排序【稍有优化】

冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！
冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知
我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0（n2）。

public static void main(String[] args) {
      int [] a={1,15,14,88,99,75,65,999};
      int[] sort=sort(a);
      System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int [] array) {
        int temp;
        //外层循环，判断要走多少次
        for(int i=0;i<array.length-1;i++) {
            boolean flag=false;//通过flag标识位减少没有意义的比较
            //内层循环，比较判断两个数的值
            for(int j=0;j< array.length-1-i;j++) {
                if(array[j]>array[j+1]) {
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
                if(!flag) {
                    break;
                }
            }
        }
        return array;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25