JAVA_SE_笔记整理(基础四)

Java基础四

1、跳转控制语句

break中断

break的使用场景：

在选择结构switch中；

循环语句中；

离开使用场景的存在是没有意义的。

break的作用：

跳出单层循环

跳出多层循环：带标签的break；

 

continue 继续

使用场景：

在循环体语句中；

离开使用场景的存在是没有意义的。

作用：

单层的continue

 

多层的continue

 

return 返回

return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。

 

java 方法

1、为什么要有方法：

代码中有很多事情都是相同的，那么代码就没有必要重复填写。而这些相同代码就可以被程序中定义为一个方法。这样的话每次开枪只需调用方法，不需要再粘贴大量代码。

2、方法说明：

在很多语言里面都有函数的定义

函数在Java中被称为方法

3、格式：

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {

方法体;

return 返回值;

     }

方法格式解释：

修饰符：修饰方法的状态；目前只需要用public static

返回值类型：用于限定返回值类型，byte short int long·····

方法名：一个名字，为了方法调用方法。

参数列表：

参数类型：限定调用方法时，传入数据的类型

参数名：是一个变量，接收调用方法时传入的参数。

方法体

完成功能的代码

return：结束方法以及返回方法指定的值

返回值：程序被return带回的结果，返回给调用者。

 

4、注意事项：

方法不调用，不执行。

方法与方法之间是平级关系，不能嵌套定义。

方法定义的时候参数之间用逗号间隔。

方法调用的时候不用传递数据类型

如果方法有明确的返回值，一定要有return 带回一个值。

5、没有返回值的方法定义

修饰符 void 方法名(参数类型 参数名1，参数类型 参数名2…) {

方法体;

// 如果写return，后面直接跟“;”，如果不写，也是可以的。

// return ;

    }

 

6、重载

概述：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

重载的特点：

与返回值类型无关，只看方法名和参数列表

在调用时，虚拟机通过参数列表的不同来区分同名方法

例如：求和

 

java 数组

1、概述

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

2、数组的定义格式

格式1、数据类型[] 数组名;

格式2、数据类型 数组名[];

注意：这两种定义做完了，数组中是没有元素值的。

3、数组元素初始化

数组初始化概述：

Java中的数组必须先初始化,然后才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组初始化的方式：

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

动态初始化

初始化时只指定数组长度，由系统为数组分配初始值。

格式：

数据类型[] 数组名 = new 数据类型[数组长度];

数组长度其实就是数组中的元素个数。

举例：

int[] array = new int[3];

解释：定义了一个int类型的数组，这个数组可以存放3个int类型的数据。

 

4、内存分配：

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈 存储局部变量

堆 存储new出来的东西

方法区 (面向对象部分讲)

  寄存器 (给CPU使用)

 

局部变量：在方法定义中或方法声明上的变量都称为局部变量

每一个new出来的东西都有地址值

每一个变量都有默认值

byte，short，int，long，0

float，double， 0.0

char ‘\u0000’

Boolean false

引用类型 null

使用完毕就变成垃圾，但是并没有立即回收，会在垃圾回收器空闲的时候回收。

5、数组的静态初始：初始化时指定每个数组元素的初始值，由系统决定数组长度。

格式：数据类型[] 数组名 = new 数据类型[]{元素1、元素2、元素…};

举例：

int[] arr = new int[]{1, 2, 3};

解释：定义了一个int类型的数组，这个数组中可以存放3个int‘类型的值，并赋值为1,2,3,

其实这种写法还有一种简化写法

int[] arr = {1, 2, 3};

 

6、数组的属性

数组的length 数组的长度，属于数组对象

7、数组中可能遇见异常

ArrayIndexOutOfBoundsException 数组下标越界

NullPointerException 空指针异常

二维数组

1、二维数组概述

其实二维数组其实就是每一个数组元素为一维数组的数组

2、定义格式一

数据类型[][] 变量名 = new 数据类型[m][n]

m代表这个二维数组有多少个一维数组

n 代表每一个一维数组的元素个数。

 

举例：

int[][] array = new int[3][2];

定义了一个二维数组array

3这个二维数组有3个一维数组，名称是array[0]、array[1]、array[2]

2 每一个一维数组有2个元素，可以通过array[m][n]来获取。array[0][1]

表示获取第m+1个一维数组的第n+1个元素。

3、定义格式二

数据类型[][] 变量名 = new 数据类型[m][];

m表示这个二维数组有多少个一维数组

这一次没有直接给出一维数组的元素个数。可以动态给出。

 

举例：

int[][] array = new int[3][];

array[0] = new int[2];

array[1] = new int[5];

array[2] = new int[4];

4、定义格式三 

静态初始化

数据类型[][] 变量名称 = new 数据类型[][] {

{元素1， 元素2，….},

{元素…},

{元素..}

};

简化版格式：

数据类型[][] 变量名称 = {

{元素1， 元素2，….},

{元素…},

{元素..}

};

 

举例：

int[][] arr = {

{1, 2, 3},

{3, 6},

{123, 345, 678}

};

排序：

http://blog.csdn.net/hguisu/article/details/7776068（八种排序方式，自行学习）

冒泡排序：

基本概述：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

for(int i = 0; i < array.length; i++) {

for(int j = 0; j < array.length - i - 1; j++) {

if(array[j] < array[j + 1]) {

int temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

}

}

插入排序：

每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

public static void insertsort(int arr[]){                

        for(int i = 1;i < arr.length; i++){

//注意[0,i-1]都是有序的。如果待插入元素比arr[i-1]还大则无需再与[i-1]前面的元素进行比较了，反之则进入if语句

            if(arr[i-1] > arr[i]){

                int temp = arr[i];

                int j;

                for(j = i-1; j >= 0 && arr[j] > temp; j --){                

                        arr[j+1] = arr[j];//把比temp大或相等的元素全部往后移动一个位置            

                }

                arr[j+1] = temp;//把待排序的元素temp插入腾出位置的(j+1)

            }            

        }

        

    }

插入和冒泡排序的区别：

例如：45 12     342   2

对于插入排序来说，进行一趟排序之后就有：   12   45   342 2

而对于冒泡排序，进行一趟排序之后有：       12    45    2  342   

 

杨辉三角：

 

int triangle[][]=new int[20][];// 创建二维数组

// 遍历二维数组的第一层

for (int i = 0; i < triangle.length; i++) {

    triangle[i]=new int[i+1];// 初始化第二层数组的大小

    // 遍历第二层数组

    for(int j=0;j<=i;j++){

        // 将两侧的数组元素赋值为1

        if(i==0||j==0||j==i){

            triangle[i][j]=1;

        }else{// 其他数值通过公式计算

            triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1];

        }

        System.out.print(triangle[i][j]+"\t");         // 输出数组元素

    }

    System.out.println();               //换行

}

 

阶乘：!n == n*!(n-1);

public static int jc (int n) {

if(n ==1 ){

return 1;

}else{

return n * jc(n-1);

}

}

 

 

斐波那契数列：F[n]=F[n-1]+F[n-2] (n>=2,F[1]=1,F[2]=1)

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

 

public static int fibonacci(int n){

    if(n<=1)

return 1;

   return fibonacci(n-1)+fibonacci(n-2);

    }

 

排序：

http://blog.csdn.net/hguisu/article/details/7776068（八种排序方式，自行学习）

冒泡排序：

基本概述：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

for(int i = 0; i < array.length; i++) {

for(int j = 0; j < array.length - i - 1; j++) {

if(array[j] < array[j + 1]) {

int temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

}

}

插入排序：

每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

public static void insertsort(int arr[]){                

        for(int i = 1;i < arr.length; i++){

//注意[0,i-1]都是有序的。如果待插入元素比arr[i-1]还大则无需再与[i-1]前面的元素进行比较了，反之则进入if语句

            if(arr[i-1] > arr[i]){

                int temp = arr[i];

                int j;

                for(j = i-1; j >= 0 && arr[j] > temp; j --){                

                        arr[j+1] = arr[j];//把比temp大或相等的元素全部往后移动一个位置            

                }

                arr[j+1] = temp;//把待排序的元素temp插入腾出位置的(j+1)

            }            

        }

        

    }

插入和冒泡排序的区别：

例如：45 12     342   2

对于插入排序来说，进行一趟排序之后就有：   12   45   342 2

而对于冒泡排序，进行一趟排序之后有：       12    45    2  342   

 

杨辉三角：

 

int triangle[][]=new int[20][];// 创建二维数组

// 遍历二维数组的第一层

for (int i = 0; i < triangle.length; i++) {

    triangle[i]=new int[i+1];// 初始化第二层数组的大小

    // 遍历第二层数组

    for(int j=0;j<=i;j++){

        // 将两侧的数组元素赋值为1

        if(i==0||j==0||j==i){

            triangle[i][j]=1;

        }else{// 其他数值通过公式计算

            triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1];

        }

        System.out.print(triangle[i][j]+"\t");         // 输出数组元素

    }

    System.out.println();               //换行

}

 

阶乘：!n == n*!(n-1);

public static int jc (int n) {

if(n ==1 ){

return 1;

}else{

return n * jc(n-1);

}

}

 

 

斐波那契数列：F[n]=F[n-1]+F[n-2] (n>=2,F[1]=1,F[2]=1)

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

 

public static int fibonacci(int n){

    if(n<=1)

return 1;

   return fibonacci(n-1)+fibonacci(n-2);

    }