Java基础03（java基础案例教程第二版）

创包com.grammer.day3，创建class ArrayTest001.java

Java数组

package com.grammer.day3;
/*
 * 数组
 * 1、引用数据类型：数组类型、接口类型、类类型、String类型；
 * 2、数组
 * 		是存储同种数据类型、固定大小的容器。
 * 		数据类型：基本数据类型和引用数据类型都可以存储。
 * 		数组分为一维数组、二维数组、三维....多维数组。
 * 	3、声明
 * 		数据类型[]  数组名；
 * 		说明：上面这种格式是java的，建议这么写；	"数据类型  数组名[]；"这种格式是c语言的，也可以写、编译；
 * 			还是建议用java的形式写。
 *
 *
 * 	4、创建一个数组
 * 		4.1创建一个空数组（没有等号右边的值，只有数组类型和数组名）
 * 			数据类型[]  数组名;
 * 			   int[]   a;
 * 		4.2创建一个固定个数的数组
 * 			数据类型[]  数组名 = new  数据类型[数组个数];
 * 			   int[]  a    = new     int[4];  ->创建可以存放4个int类型数据的数组a。
 * 		4.3创建一个数组直接赋值
 * 			数据类型[]  数组名  = {值1，值2，值3....值n};
 * 			  int[]   a    = {1,2,3,4};
 *
 * 	5、访问数组元素      数组名[索引数]
 * 		数组的元素通过索引(角标)来调用的。索引从0开始一直到‘数组个数-1’;
 * 		定义：int[] a = { 1, 2, 3, 4 };
 * 		访问：a[0]
 *
 *
 * 	6、遍历数组
 * 		遍历：沿着某种形式挨个的访问；
 * 		遍历数组：挨个取数组里的每个值；
 */

public class ArrayTest001 {

    public static void main(String[] args) {
        // 声明了一个数组a，数组的类型是int类型，数组里面存储的数据得是int类型的。
        // 数组没有赋值，所以是个空数组。
        // int[] a;
        // // 4.2创建一个固定个数的数组
        // int[] b = new int[4];
        // System.out.println(b[0]);
        // System.out.println(b[1]);
        // System.out.println(b[2]);
        // System.out.println(b[3]);
        //
        // // 4.3创建一个数组直接赋值
        // int[] c = { 1, 2, 3, 4 };
        // System.out.println("c[0]的值是：" + c[0]);
        // System.out.println("c[1]的值是：" + c[1]);
        // System.out.println("c[2]的值是：" + c[2]);
        // System.out.println("c[3]的值是：" + c[3]);
        //
        // String[] d = new String[5];
        // System.out.println(d[0]);
        // System.out.println(d[1]);
        // System.out.println(d[3]);

        // 6、遍历数组
        int[] a = { 1, 2, 3, 4, 5, 6 };
        // 获取数组a的长度（数组里数据的个数）
        System.out.println("数组a里总共有" + a.length + "个数。");

        for (int i = 0; i < a.length; i++) {
            System.out.println("第" + (i + 1) + "个数是" + a[i]);// 第1个数是1；
        }
    }

}

创建class ArrayTest002.java

冒泡排序

package com.grammer.day3;

public class ArrayTest002 {
    public static void main(String[] args) {
        // int[] a = { 4, 3, 2, 1 };

        // for (int j = 1; j < 4; j++) {
        // for (int i = 0; i < 3; i++) {
        // if (a[i] > a[i + 1]) {
        // int c = a[i];
        // a[i] = a[i + 1];
        // a[i + 1] = c;
        // }
        // }
        // }

        // 优化代码1
        /*
         * int[] a = { 6, 5, 4, 3, 2, 1 };
         *
         * for (int j = 1; j < a.length - 1; j++) { 
         * for (int i = 0; i < a.length- 1; i++) { 
         * if (a[i] > a[i + 1]) { 
         * int c = a[i]; 
         * a[i] = a[i + 1]; 
         * a[i+ 1] = c; } } }
         */
        // 优化代码2
        int[] a = { 6, 5, 4, 3, 2, 1 };

        for (int j = a.length - 1; j > 0; j--) { // j的作用只要有次数就行 3 2 1
            for (int i = 0; i < j; i++) {// 每个轮次，两两交换的次数 3 2 1
                if (a[i] > a[i + 1]) {
                    int c = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = c;
                }
            }

            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i] + " ");
            }
            System.out.println();

        }

    }
}

创建class MethodTest001.java

Java方法定义

package com.grammer.day3;

/*
 * 1、方法
 * 		为了完成某个特定的功能，可以重复使用的代码段。
 * 		这样编程可以提高代码的复用性，减少代码冗余.
 * 		方法是写到类体（class）里面的，可以写多个方法，方法里面不能有方法.
 *
 * 2、定义语法
 * 		修饰符    返回值类型     方法名（形式参数列表）{
 * 				方法体；
 * 				return   返回值（返回值的类型要和方法名左边的“返回值类型对应”）；
 *		 }
 * 3、调用语法
 * 		类名.方法名(实际参数列表)；
 * 		方法不调用，就不执行；
 *
 */
public class MethodTest001 {
    // 修饰符(public :修饰的这个方法可以别任何程序调用。
    // static ：在没有创建对象的时候就可以调用次方法。
    // 返回值类型 (void)：空的意思，代表这个方法没有返回值，也就是说return语句不用写。
    // 方法名(main):起名用小驼峰法。
    // （形式参数列表）String[] args：简称形参，在调用此方法时候，要按照参数的类型、顺序、个数进行传入参数值。
    // 如果不需要传参，就不写。
    // 方法体：这个方法里面执行的代码段；
    // return 返回值：当调用此方法时，返回一个值给调用者。
    public static void main(String[] args) {
        // 类名.方法名(实际参数列表)；
        // 如果形参没写，那么实参就不用写。
        MethodTest001.helloWorld();// 调用方法
        // 调用nihao方法时，因为有“形参”，要传入“实参”就是传入实际的数据
        // 要按照参数的类型、顺序、个数进行传入值;
        MethodTest001.niHao("Tom");
    }

    // 定义了一个方法helloWorld；
    public static void helloWorld() {
        System.out.println("hello world");
    }

    public static void niHao(String name) {// 此处叫形参；形式上有这个数据要参与到运算中；
        System.out.println("你好，" + name);
    }

}

创建class MethodTest002.java

Java方法

package com.grammer.day3;

//方法的定义位置一定是在类里面，但是方法的顺序不限制；
//方法的调用语句，写在主方法或者自定义方法都可以；

public class MethodTest002 {
    // 自定义方法
    public static void demoB() {
        System.out.println("这是B方法~~~~~");
    }

    // 自定义方法demoC，有返回值name；
    // 由于name的类型是String，返回值类型要和name类型一致，所以定义demoC时，前面写String。
    public static String demoC() {
        String name = "demoC";
        return name;
    }

    // 主方法
    public static void main(String[] args) {
        // 调用方法
        MethodTest002.demoA();
        // 调用有返回值的方法
        // 此时，需要有个跟返回值相同类型的变量来接收调用方法返回的值。
        String nString = MethodTest002.demoC();
        System.out.println("有返回值的方法的名字是：" + nString);
    }

    // 自定义方法
    public static void demoA() {
        System.out.println("这是A方法");
        MethodTest002.demoB();
    }

}

创建class MrthodTest003.java

Java方法的参数

package com.grammer.day3;

/*
 * 参返组合
 * 利用有没有参数和有没有返回值，来看常用的代码编写模式；
 *
 * 无参无返
 * 无参有返
 * 有参无返
 * 有参有返
 *
 */
public class MethodTest003 {

    public static void main(String[] args) {
        // 1--> 无参无返 的调用
        MethodTest003.sumInt();

        // 2--> 无参有返 的调用
        int r = MethodTest003.sumInt2();
        System.out.println("无参有返 的求和结果-->" + r);

        // 3-->有参无返 的调用
        MethodTest003.sumInt3(3, 5);

        // 4-->有参有返 的调用
        int s = MethodTest003.sumInt4(6, 5);
        System.out.println("有参有返 的求和结果-->" + s);
    }

    // 4-->有参有返 的方法
    public static int sumInt4(int a, int b) {
        int c = a + b;
        return c;
    }

    // 3-->有参无返 的方法
    public static void sumInt3(int a, int b) {
        int c = a + b;
        System.out.println("有参无返 的求和结果-->" + c);
    }

    // 2--> 无参有返 的方法
    public static int sumInt2() {
        int a = 2;
        int b = 2;
        int c = a + b;
        return c;
    }

    // 1--> 无参无返 的方法
    public static void sumInt() {
        int a = 1;
        int b = 2;
        int c = a + b;
        System.out.println("无参无返 的求和结果-->" + c);
    }
}