【笔记】小小白的java从0开始,第四节

战之都

提前祝大家中秋节快乐
                       奋斗的人儿永远最幸福
                                         加油!!!!!!!

                                                                                             

发帖的时候这个排版问题 我真的是有点研究不透
第一次点击发帖总是堆在一起没有换行
改一次少一点 改一次少一点  稍微有点难受
我尽力了 还有什么问题你们就当没看到 没看到
这时间一直在研究SSM有点乏力  稍微有点转不过弯来
今天实在学不下去了 来更一下下笔记


数组概述
1 定义
用来存放同一种数据类型的集合，存到数组中的每个数据称为元素，他们都有下标从0开始，我们可以通过下标操作对应的元素
2 好处
可以存储多个数据而且有下标从0开始，方便操作这些元素，我们可以通过length属性获取数组长度
3 特点
1）可以存储任意类型的数据
2）数组大小一旦确定就无法改变
3）可以通过下标获取数据
4 声明
4.1 动态声明
格式：数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
案例：
int[] arr = new int[5];
说明：声明一个数组用来存放int类型的数据，可以存储5个
4.2 静态声明
格式：数据类型[] 数组名 = new 数据类型[]{元素，元素，……};
案例1：
int[] arr = new int[]{3,5,1,7};
案例2：
int[] arr = {3,5,1,7};
说明：以上两种写法都相同，下边的是简写方式
4.3 区别
当我们确定要存出哪些数据时可以使用静态声明因为比较方便，如果我们不确定要存储哪些具体的数据，需要使用动态声明后期赋值。当然静态声明方式也是可以修改值的
数组常见操作
1 创建
1.1 动态声明

[Java] 纯文本查看 复制代码

        public static void main(String[] args) {
                //声明一个长度为5,类型为int的数组
                int[] ages = new int[5];
                //给数组中的元素赋值
                ages[0] = 20;
                ages[1] = 30;
                ages[2] = 25;
                ages[3] = 26;
                ages[4] = 53;
                //获取数组中的数据,通过下标获取
                //获取元素的格式:数组名[元素的下标]
                System.out.println(ages[0]);
                System.out.println(ages[1]);
                System.out.println(ages[2]);
                System.out.println(ages[3]);
                System.out.println(ages[4]);
                //数组下标从0开始 至 数组长度-1
                
        }

  1.2 静态声明

[Java] 纯文本查看 复制代码

        public static void main(String[] args) {
                //声明一个长度为5,类型为int的数组
                int[] ages = {20,30,25,26,53};
                //需要获取数组的长度,可以通过length属性获取数组的长度
                //length属性是数组的唯一一个属性
                int i = ages.length;
                System.out.println("数组ages的长度是"+i);
        }

2 遍历
2.1 普通循环遍历

[Java] 纯文本查看 复制代码

        public static void main(String[] args) {
                //声明数组
                int[] arrs = {1,2,3,4,5,6,7,8};
                //通过for循环获取数组数据
                //变量i记录的是数组的下标
                for (int i = 0; i < arrs.length; i++) {
                        System.out.println(arrs[i]);
                }
        }

2.2 增强for循环遍历

[Java] 纯文本查看 复制代码

        public static void main(String[] args) {
                //声明数组
                int[] arrs = {1,2,3,4,5,6,7,8};
                //通过增强for循环获取数组数据(foreach)
//                语法:
//                        for (遍历目标的数据类型 变量名 : 遍历目标的变量名) {
//                                可以通过变量名操作元素
//                                System.out.println(变量名);
//                        }
//                
                for (int arrlist : arrs) {
                        System.out.println(arrlist);
                }
        }

  2.3 两者区别
增强for循环操作起来比较方便，但是不能通过下标操作元素，所以仅当需要遍历时可以使用增强for循环，如果要操作元素还是需要使用普通的循环，通过下标操作元素
3 将数组中的奇数换成0

[Java] 纯文本查看 复制代码

public static void m2() {                int[] is = { 4, 2, 5, 3, 6, 8, 3, 7, 0, 3, 1 };
                for (int i = 0; i < is.length; i++) {
                        if (is[i] % 2 == 1) {
                                is[i] = 0;
                        }
                }
                for (int i : is) {
                        System.out.println(i);
                }
        }

4 排序
1 选择排序

[Java] 纯文本查看 复制代码

        //选择排序
        public static void main(String[] args) {
                int[] is = { 7, 9, 5, 3, 6, 8, 2 };
                int temp ;
                for (int i = 0; i < is.length - 1; i++) {
                        int minIndex = i;//把每次的行数i赋给变量
                        for (int j = minIndex+1; j < is.length; j++) {
                                if (is[minIndex] > is[j] ) {
                                        minIndex = j;
                                }
                        }
                        temp = is[minIndex];
                        is[minIndex] = is[i];
                        is[i] = temp;        
                }
                System.out.println(Arrays.toString(is));
        }

2 冒泡排序

[Java] 纯文本查看 复制代码

// 冒泡排序
        public static void m1() {
                int[] is = { 7, 9, 5, 3, 6, 8, 2 };
                // 0 ~ 5 长度为6
                int temp;
                for (int i = 0; i < is.length-1; i++) {
                        for (int j = 0; j < is.length-1-i; j++) {
                                if (is[j+1] < is[j]) {
                                        temp = is[j+1];
                                        is[j+1] = is[j];
                                        is[j] = temp;
                                }
                        }
                }
                System.out.println(Arrays.toString(is));
        }

5 二维数组
5.1 静态声明

[Java] 纯文本查看 复制代码

// 数据类型 [][] 数组名 = {{数组1},{数组2},....};
        // 数据类型 数组名 [][] = {{数组1},{数组2},....};
        //以上两种方式是一样的
        public static void m1() {
                int is[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
                for (int i = 0; i < is.length; i++) {
                        for (int j = 0; j < is[i].length; j++) {
                                System.out.println(is[i][j]);
                        }
                }
        }

5.2 动态声明

[Java] 纯文本查看 复制代码

        // 数据类型 [][] 数组名 = new 数据类型[一维数组的个数][每一个一维数组中元素的个数]
        public static void m3() {
                int[][] is = new int[3][4];
                for (int i = 0; i < is.length; i++) {
                        for (int j = 0; j < is[i].length; j++) {
                                is[i][j] = j;
                                System.out.println(is[i][j]);
                        }
                }
        }

数组常见异常
1 角标越界异常

[Java] 纯文本查看 复制代码

public static void main(String[] args) {
int[] x = { 1, 2, 3 };System.out.println(x[3]);
//异常：java.lang.ArrayIndexOutOfBoundsException}

说明：当操作了不存在的角标时会出现角标越界异常
解决：我们可以通过数组的length属性控制循环时的角标，防止越界。

2 空指针异常

[Java] 纯文本查看 复制代码

public static void main(String[] args) {
int[] x = { 1, 2, 3 };x = null;System.out.println(x[1]);
//空指针异常： java.lang.NullPointerException}

说明：因为数组时引用数据类型所有有一个特殊的值是null，如果值为（引用）为null再去使用该变量时就会出现空指针异常。
Arrays类（参考API）
1 概述
Java提供的专门用来操作数据的类，可以对数组进行排序，查询，拷贝等操作
(文件有点大 放不进来 我放一个链接有需要就自己去下载吧 :
  文档：jdk api 1.8.CHM 链接：http://note.youdao.com/noteshare?id=fb71183896b8da0c86a4ada2d00cfc79&sub=4BBD53B85C6A4329BB305A923516A99C


方法
1 方法概述
定义在类中具备一定功能的代码块
2 方法的好处1）提高代码的复用性
2）将程序进行封装，提高程序的安全性
3 方法语法
3.1 格式

访问修饰符 返回值类型 方法名([数据类型 变量1,数据类型 变量2,...]){要执行的代码;return 返回值;}

[Java] 纯文本查看 复制代码

        //声明一个方法,计算两个数组的和
        public static int add(int num1, int num2){
                int sum = num1 + num2;
                return sum;
        }
        
        public static void main(String[] args) {
                //方法调用方式
                int sum = add(3, 2);
                System.out.println(sum);
                
        }

8.3.2 详解
0.访问修饰符：控制方法的访问权限，现阶段都写成public static
1.返回值类型：
1.有返回值，返回值类型与返回值的类型一致
2.没有返回值，返回值类型使用void表示
2.方法名：自己定义的名字，符合规范并且有意义(顾名思义)
3.参数列表：
数据类型：该方法接收的参数的数据类型变量
1：自定义的变量名，有意义
4.要执行的代码：该方法所要完成的功能
5.return两个作用：
1.将方法的返回值返回给调用者
2.结束方法
6.返回值：
方法运算完之后的结果，可以通过return关键字返回给调用者，交由调用者处理

8.4 方法分类
1.有参数有返回值
2.有参数没有返回值
3.没有参数有返回值
4.没有参数没有返回值

[Java] 纯文本查看 复制代码

// 1.有参数有返回值，方法返回一个用户传进来的字符串
        public static String methodl(String str){
                return str;
        }
        
        //2.有参数没有返回值，将用户传进来的参数打印
        public static void method2(String str){
                System.out.println(str);
                return;//结束方法
        }
        
        //3.没有参数有返回值，返回自定义内容
        public static String method3(){
                return "没有参数有返回值";
        }
        
        // 4.没有参数没有返回值
        public static void method4(){
                System.out.println ("没有参数没有返回值");
        }

[Java] 纯文本查看 复制代码

public static void main(String[] args){
                //调用有参数有返回值
                String str=methodl("有参数有返回值");
                System.out.println(str);                //调用有参数无返回值
                method2("有参数无返回值");                //无参数有返回值
                String str2=method3();
                System.out.println(str2);                //无参数无返回值
                method4();
        }

5 方法传递参数

[Java] 纯文本查看 复制代码

  
      // 基本数据类型
        public static int methodl(int i) {
                i = 3;
                return i;
        }        // 引用数据类型  
      public static int[] method2(int[] arr) {
                Arrays.fill(arr, 100);
                return arr;
        }        public static void main(String[] args){
        //调用基本数据类型
        int i=10;
        int value=methodl(i);
        //i=10,valiue=3；i的值没有变化
        System.out.println(i+"==---->"+value);
        //调用引用数据类型
        int[]arr={1,2,3,4,5,6};
        int[]arr2=method2(arr);
        //arr:
        //arr2：
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("arr2:"+Arrays.toString(arr2));
        }

5.1 总结
1）传递基本数据类型：相当与一个值拷贝的的过程，会在栈内存中开辟一块空间保存新的变量，操作的是新变量而原先的值并不发生变化。
2）传递引用数据类型：会将堆内存中的地址传递给新变量，操作时操作的是同一块内存中的数据，所以原数据会发生变化。


6 方法特点
0.方法只能定义在类中
1.方法中只能调用方法，不能定义方法
2.方法只有被调用才执行，不调用就不执行
3.方法的返回值返回给调用者，将结果交给调用者处理


7 如何定义好一个方法
1.如果有未知数参与运算就需要在定义方法时定义参数列表，明确参数类型就是数据类型， 明确有几个未知数参与运算就是明确有几个形式参数
2.明确方法运算完之后如果调用者需要结果则明确返回值类型，否则返回值类型就是用void来写  如果调用者需要返回值，返回值类型就根据返回值来写

8参数分类
形式参数：方法定义上声明的变量实际参数：方法调用时传递的具体的数据


9 方法重载
概念：在同一个类中，方法名相同，但是参数列表不同，与返回值类型无关，
与参数的顺序有关案例：
计算两个数的和，计算三个数的和好处：有些方法它们的功能相同，但是实现的方式不同，为了让方法名更有意义，java提供了一个机制，叫做方法的重载什么时候使用：当一个类中有部分方法他们的功能是相同的但是实现方式不同就可以将这写方法的方法名定义成一样的   

luokack

很深奥的感觉。。。