Java day 04
Java day04
1.方法的定义
语句定义格式：
修饰符 返回值类型 方法名（参数类型 参数名，…）{
方法实现逻辑代码；
return 返回值
}
名词解释：
修饰符：public static （暂时只需要记住固定写法）
返回值类型：将来调用者调用完方法后所得到的内容
方法名：符合标识符的命名规则，将来通过方法名来确定调用方法类型
参数：形式参数【形参】：指的是在方法定义的小括号中的参数名
实际参数【实参】：指的是将来实际调用方法时所传入的具体的值
方法实现逻辑代码：调用方法要干的事情
return：用于结束整个方法，将结果返回给调用者
返回值：将来方法调用完，需要返回给调用者的值
需求：定义一个求两个数之和的方法
package com.shujia.day04;
/*
方法的定义：
语句定义格式：
修饰符 返回值类型 方法名(参数类型 参数名,...){
方法实现逻辑代码;
return 返回值;
}
名词解释：
修饰符：public static 这两天只需要记住一个固定写法即可，后面学习过程中会改变这个修饰符
返回值类型：将来调用者调用完方法后所得到的内容
方法名：符合标识符的命名规则，将来通过方法名来确定调用的方法类型
参数：
形式参数【形参】：指的是在方法定义的小括号中的参数名
实际参数【实参】：指的是将来实际调用方法时所传入的具体的值
方法实现逻辑代码：调用方法要干的事情
return：用于结束整个方法，将结果返回给调用者。
返回值：将来方法调用完，需要返回给调用者的值。
需求：定义一个求两个int类型的数之和的方法
注意：
1、方法和方法之间是平级关系，方法不能嵌套定义
2、方法不调用不执行
3、方法调用的时候，只需要传值就可以，不需要写数据类型
4、若方法有返回值的话，需要使用变量接受该返回值，或直接使用
5、如果方法有明确的返回值，一定要有return带回一个值，且类型和定义时返回值类型保持一致【或父子关系】
*/
public class FunctionDemo1 {
public static void main(String[] args) {
// int res = sum(3,4);
// System.out.println(res);
// System.out.println(res+1);
//
// System.out.println(sum(5,9));
int a = 3;
int b = 4;
System.out.println(sum(a,b));
}
public static int sum(int a,int b){
int c = a+b;
return c;
}
}
注意：
1.方法与方法之间是平级关系，方法不能嵌套定义
2.方法不调用不执行
3.方法调用的时候，只需要传值就可以，不需要写数据类型
4.若方法有返回值的话需要使用变量接收该返回值或直接使用
5.如果方法有明确的返回值，一定要有return带回一个值，9:31（补充）
6.Java针对没有返回值类型的方法——提供了一个关键字代表没有返回值void7.若方法没有返回值直接调用即可，不需要东西接收
8.当一个类中，方法名相同，只是方法的参数列表【参数类型 ，参数个数】不一样，这个现象叫做方法的重载，与返回值无关
将来调用时候，jvm会根据方法名和参数列表一起定位到需要调用的方法
pubilc class functiondemo1{new*
public static void main(String[] args){ new*
int res = sum(a:3,b:4);//调用、接收
System.out.println(res);
System,out.println(res +1);
}
public statuc int sum(int a,int b){//形参
int c=a+b;
return c;
}
}
键盘录入行数列数，输出对应的星形
Scanner sc =new Scanner(System.in);//9:49
需求1:求两个数之和
public static void sum(int x,int y,int z){
System.out.println(x+y+z);
2.数组
1)数组的概念
是一块连续固定大小的内存空间，有着索引的概念
数组长度固定：数组一旦被创建，它的大小是固定的，不能动态调整。
数组类型一致：数组中的所有元素必须是相同的数据类型。
2)定义数组语句格式
数据类型[] 数组名——更推荐
数据类型 数组名[]；
如果只是定义一个数组的话，没有给初始化值，相当于一个变量没有值，是不能够直接使用的
3.如何对一个数组初始化
1.动态初始化
我们自己给定数组大小，数组中默认值由JVM来赋值
定义格式：
数据类型[] 数组名 = new 数据类型[元素的个数]
我们自己给元素值，由JVM根据我们给定值数量来设置数组大小
引用数据类型
//定义一个存储int类型元素的数组
pubilc class Aarraydemo1{new*
public static void main(String[] args){
//数据类型 变量名 =初始化值
int[] arr= new int[3];//引用数据类型
/*
左边：
int：表示该数组中元素的数据类型，需要一致
[]：表示一个一维数组
arr:是数组名，符合标识符变量的命名规则
右边：
new：将来看到new，表示在堆内存中开辟一个空间
int：表示该数组中元素的数据类型，需要一致
[]：表示一个一维数组
3:表示该数组最大只能储存3个int类型的元素
*/
System.out.println(arr);//I@4554617c地址值【16进制】——只要引用数据类型才有地址值
//数组有索引概念，从左向右，索引下标从0开始编号，我们可以通过这个索引下标来定位到具体位置的元素
//语法格式：数组名[索引]
//获取数组中的第一个元素
int i = arr[0];
System.out.println(i);
//获取数组中的第二,三个元素
System.out.println(arr[1]);
SYstem.out.println(arr[2]);
//结果都是0，这个和数据类型有关系，如果说double的话，结果就不一样了
}
我们以后使用数组的时候，肯定是希望将我们自己的元素放在数组中
将数据第一个元素值进行修改
arr[0] = 100;
System.out.println(arr[1]);
//这样打印下来的就是100而不是0了
引用数据类型（第二天的坑）
4.java中的内存分配
对空间进行的划分
1) 栈 存储局部变量——基本上所有方法调用都是在栈中执行的
先将main方法加载到栈中执行
特点：先进后出
局部变量：在方法定义上或者方法内部定义的变量都称之为局部变量
2)堆 存储new出来的东西
默认值
在堆内存中的变量，系统会赋予默认值，不同的数据类型，会有不同的默认值。
整数的默认值byte,short,int,long:0
小数默认值 float，double：0.0
boolean默认值：false
char：’\u0000’
引用数据类型：null
3)方法区（面向对象部分讲）
4)本地方法区（和系统相关）
5)寄存器（给cpu使用）
pubilc class Aarraydemo1{new*
public static void main(String[] args){
int[]arr1 = new int[3];
arr1[0]=11;
arr1[1]=22;
arr1[2]=33;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println("------------------------");
int[] arr2=arr2;
arr2[1]=100;
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
静态初始化2点25（困了乏没哭）
我们上一个案例中，学习了数组的定义以及数组的动态初始化，
但是有一个地方不太方便，如果我们想要赋值自己的元素在数组中的话，动态初始化需要我们先将数组创建出来
然后再一个一个复制，其实很麻烦，能不能在初始化是将元素赋值进去？
数组的静态初始化；
数据类型[] 数组名 = new 数据类型[]{元素1…元素n}；
int[] arr1 = new int[]{11,22,33,44,55};
//arrayIndexOutOfNoundaEXception —— 数组越界异常
简化写法：
数据类型[] 数组名 = {元素1….元素2…..}；
数组的遍历
2点37
pubilc class Aarraydemo1{
public static void main(String[] args){
//定义一个数组并初始化
int[] arr = {1,2,3,4,5,6,7,8,};
//使用for循环
// for(int i = 0;i<8;i++){
// System.out.println(arr[i]);
//}
//虽然用for循环，范围是人为数出来的，元素多是，就很难写对
//java的数组有一个属性，length属性，我们可以直接获取数组的该属性得到数组的长度【元素的个数】
//语句格式：数组名.length
//System.out.ptintln("数组长度为："arr.length)
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
获取数组的最值
/*
分析：14点40
1.创建一个数组，赋值
2.默认第一个元素为最大值或最小值
3.从第二个元素开始循环，依次比较出较大的值和较小的值
*/
pubilc class Aarraydemo1{
public static void main(String[] args){
int[] arr = {23,44,66,73,78,45,34,3,33};
int maxNumber = arr[0];
int maxNumber = arr[0];
for (int i=1;i<arr.length;i+){
if(arr[i])
}
}
}
数组元素逆序
14点47，16点
/*
分析
1.交换的次数少长度/2的整除
2.交换时，需要使用到临时变量
*/
pubilc class Aarraydemo1{
public static void main(String[] args){
int[] arr ={1,2,3,4,5,6,7};
//第一次交换，将第一个元素与最后一个元素交换
int tmp1= arr[arr.length-1]
arr[arr.length-1 ]= arr[0];
arr[0]=tmp1
3.二维数组
元素是一维数组的数组是二维数组
格式1
数据类型[] [] 数组名 = new 数据类型[m] [n];
举例：int[] [] arr = new int [2] [3];
表示创建了一个元素是int类型的二维数组，其中二维数组中有两个一维数组，每一个一维数组中的元素个数是3
16点13（补充）
格式2
语句定义格式2：
数据类型[][] 数组名 = new 数据类型[m][];
举例：int[][] arr = new int[2][];
arr[0] = new int[]{11,22,33,44};
arr[1] = new int[]{100,200};
格式3
语句定义格式3：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,...},{元素1,...},...};
举例：int[][] arr = new int[][]{{11,22,33,44},{100,200}};
简化写法：数据类型[][] 数组名 = {{元素1,元素2,...},{元素1,...},...};
举例：int[][] arr = {{11,22,33,44},{100,200}};
今后可能会遇见的写法
1、int[] arr[] = {{11,22,33,44},{100,200}}; √
2、int arr[][] = {{11,22,33,44},{100,200}}; √
3、int [] [] arr = {{11,22,33,44},{100,200}}; √
4、int[][] arr = new int[][]{{11,22,33,44},{100,200}}; √【规范写法】
5、int[][] arr = new int[2][]{{11,22,33,44},{100,200}}; ×
public class Array2Demo4 {
public static void main(String[] args) {
int[][] arr = new int[2][3];
System.out.println(arr); // 二维数组的地址值
System.out.println(arr[0]); // 二维数组中第一个一维数组的地址值
System.out.println(arr[1]); // 二维数组中第二个一维数组的地址值
System.out.println(arr[0][0]); // 二维数组中第一个一维数组的第1个元素值
}
}
