目录
一. 二维数组
1. 声明
2. 初始化
3. 取值 赋值
4. 遍历
5. 一些细节
二. 方法
1. 方法的定义
1.1 无返回值方法
1.2 有返回值方法
2. 方法的调用
3. 动态参数
4. Overload 方法重载
一. 二维数组
二维数组的本质其实就是一维数组，只不过每个元素又是一个一维数组
存储:
int[][] arr = {{1,2},{3,4}};
1. 声明
●数据类型[][] 数组名;
int[][] ns1;●数据类型[] 数组名[];
int[] ns2[];●数据类型 数组名[][];
int ns3[][];●多个数组声明
//多个数组的声明 int[] a,b[];//声明一维数组a, b是int类型的二维数组
2. 初始化
●动态初始化:
数据类型[][] 数组名 = new 数据类型[长度][];
//动态: 数据类型[][] 数组名 = new 数据类型[长度][]; int[][] ns =new int[3][];●静态初始化:
数组类型[][] 数组名=new 数据类型[][]{{},{},{}};
// 静态: 数据类型[][] 数组名=new 数据类型[][]{{},{},{}}; int[][] ns1 = new int[][] { { 4, 5, 6 }, { 7, 8 } };●静态省略初始化:
数组类型[][] 数组名={{},{},{}};
// 静态省略: 数据类型[][] 数组名={{},{},{}}; int[][] ns2 = { { 4, 5, 6 }, { 7, 8 } };
3. 取值 赋值
取值:
数组名[i][j];int[][] ns =new int[3][]; //取值 System.out.println(ns[0]);//null System.out.println(ns[1]);//null System.out.println(ns[2]);//null赋值:
//赋值 ns[0] = new int[] {1,2,3}; int[] newArray = {4,5,6}; ns[1] = newArray; ns[2] =new int[] {7,8}; //打印内容 System.out.println(Arrays.toString(ns[0])); System.out.println(Arrays.toString(ns[1])); System.out.println(Arrays.toString(ns[2]));
4. 遍历
for循环遍历:
//1.for循环遍历 for (int i = 0; i < ns.length; i++) { for (int j = 0; j < ns[i].length; j++) { System.out.print(ns[i][j]+" "); } System.out.println(); } System.out.println("=============");foreach进行元素遍历:
//2.foreach进行元素遍历 for (int[] is : ns) { for (int is2 : is) { System.out.print(is2+" "); } System.out.println(); } System.out.println("================");Arrays工具类快速打印内容:
需要导包
import java.util.Arrays;//3.Arrays工具类快速打印内容 System.out.println(Arrays.deepToString(ns));运行结果:
5. 一些细节
int[][] ns1 = new int[3][]; int[][] ns2 = new int[3][4]; // System.out.println(Arrays.deepToString(ns1)); // System.out.println(Arrays.deepToString(ns2)); int[] ns = new int[] { 2, 3 }; ns1[0] = ns; ns2[0] = ns; System.out.println(Arrays.deepToString(ns1)); System.out.println(Arrays.deepToString(ns2)); ns1[0][1] = 666; System.out.println(Arrays.toString(ns));
二. 方法
方法是具有一定功能的代码段，我们通过这个来解决问题，是一段代码的集合。
1. 方法的定义
方法定义的位置:
类内,其他方法的外面方法定义语法规则:
修饰符 返回值类型 方法名(参数类型 参数名){ 方法体 return值; }●修饰符:public static
●返回值类型:任意的数据类型均可以，无返回值-void
●方法名:标识符:变量命名规范
●参数类型:数据类型 参数名:所有数据类型均可,有多个参数,之间用逗号来分隔●方法体:如果有返回值,呢一定要返回数据
分类:
有无返回值 参数
无 无
无 有
有 无
有 无
1.1 无返回值方法
定义:
无返回值 无参数:
//无返回值 无参数 public static void sum() { int a = 5; int b = 10; int c = a + b; System.out.println(c); }无返回值 有参数:
//无返回值 有参数的方法1 public static void add(int a, int b) { int c = a + b; System.out.println(c); } //无返回值 有参数的方法2 public static void user(String name, int age) { System.out.println(name + "的年龄为" + age); }
调用:
无参返回值方法的调用: 方法名();
//无参无返回值的方法调用 方法名(); sum();有参无返回值的方法调用: 方法名(值)
//有参无返回值的方法调用 方法名(值) //方法进行调用的时候参数值的个数，顺序，类型要和方法定义的保持一致 add(5, 100); user("zkt", 21);
1.2 有返回值方法
定义:
有返回值 无参数:
// 有返回值无参 public static int add() { int a = 5; int b = 6; int c = a + b; return c; }有返回值 有参数:
// 有返回值有参 public static double sum(double a, int b) { return a + b; }
调用:
有返回值无参: 数组类型 变量名 = 方法名()
// 有返回值无参 // 数组类型 变量名 = 方法名() int result = add(); System.out.println(result);//11有返回值有参: 数组类型 变量名 = 方法名(值)
// 有返回值有参 // 数组类型 变量名 = 方法名(值) double d = sum(10.0, 10); System.out.println(d);//20.0
[注]
●方法定义好后不会自动执行，只有方法进行调用的时候才会执行---调用次数和执行的次数
●方法调用完会回到原位置
●方法进行调用的时候参数值的个数，顺序，类型要和方法定义的保持一致
2. 方法的调用
●直接调用(不推荐)
方法名(参数);●赋值调用(推荐使用)
方法返回值的数据类型变量名=方法名(参数);●打印调用(测试可用)
system. out.println(方法名(参数）);调用方法 有返回值的方法 无返回值的方法
直接 可以(不推荐) 可以
打印 可以(测试) x
赋值调用 强烈推荐 x
1请编写方法signOf，如果接收的int型参数的值n为负，则返回-1；如果为0，则返回0；如果值n为正，则返回1。 public static void main(String[] args) { test1(); System.out.println("======"); System.out.println(signOf(-7)); } public static void test1() { test(); } public static void test() { System.out.println("还想继续考研"); return; } public static int signOf(int n) { if (n < 0) { return -1; } else if (n > 0) { return 1; } else { return 0; } }
[注]
●方法调用和方法的定义的顺序无关
●方法不能嵌套定义
●不调用不执行
●如果方法有返回值，return必须要有
●如果方法没有放回值，可以写return ; ,也可以省略
3. 动态参数
从JDK 1.5 开始，Java支持传递同类型的一组值，做为参数，传递给方法中的一个参数，该参数为成为动态参数。
●一个方法中只能有一个参数的动态参数
●动态参数必须是方法的最后一个参数
●动态参数在方法中，可做为一个数组使用
语法格式:
修饰符 返回值类型 方法名(参数类型 参数1，参数类型 参数2，参数类型...参数3){ 方法体 return值; }代码演示:
/* *动态参数写在参数的最后,最多只能有1个动态参数 *动态参数在进行使用的时候可以作为数组使用 *含动态参数的方法在进行调用的时候，可以不用动态参数 */ int a = 10; int b = 20; int[] c = { 1, 2, 3, 4, 5 }; int sum = add(a, b, c); System.out.println(sum);//45 int sum1 = add(a, b); System.out.println(sum1);//30 int sum3 = add(a, b, 1, 2, 3, 4, 5, 6); System.out.println(sum3);//51 } /** * 定义了一个含动态参数的方法,add--求参数的和 * * @param a 整型变量 * @param b 整型变量 * @param c 动态参数,数据类型int * @return 求所有的参数和 */ public static int add(int a, int b, int... c) { int sum = a + b; for (int i = 0; i < c.length; i++) { sum += c[i]; } return sum; }
4. Overload 方法重载
在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，JavaOOP的语法允许把这一组方法名定义为同名方法。
●方法的重载:在同一个类中，方法名相同，参数项不同(类型，个数，顺序)
●和返回值无关,发生在编译期
//方法的重载:在同一个类中，方法相同，参数项不同(类型，个数，顺序) //和返回值无关,发生在编译器 double a = add(10.0, 20); System.out.println(a);//30.0 } public static int add(int a, int b) { return a + b; } public static double add(int a, double b) { return a + b; } public static double add(double a, int b) { return a + b; } public static double add(double a, double b) { return a + b; }
