方法(函数)：
格式：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
详细解释：
修饰符：例如 public static。后面我们再详细的讲解其他的修饰符。
返回值类型：就是功能结果的数据类型。
方法名：符合命名规则即可。方便我们的调用。
参数：
实际参数：就是实际参与运算的。
形式参数；就是方法定义上的，用于接收实际参数的。
参数类型：就是参数的数据类型
参数名：就是变量名
方法体语句：就是完成功能的代码。
return：结束方法的。
返回值：就是功能的结果，由return带给调用者。
调用方法：
public class scanner { public static void main(String[] args){ int a = 3; int b =4; //第一种方法：单独调用 sum(a,b); //第二种方法：赋值调用 int result = sum(a,b); //第三种方法：输出调用 } public static int sum(int a ,int b){ int c = a+b; return c; } }
在void类型的返回值的方法调用：(void表示没有返回值)
只能进行单独调用
方法的重载：
java允许方法使用一个名字，用传入的参数识别这些方法：
例如：
//在下面这个例子中，如果我们不写int的sum方法，他会直接调用float的方法进行使用，会根据大小向下找。
public static void main(String[] args) { //jvm会根据不同的参数去调用不同的功能
//在下面这个例子中，如果我们不写int的sum方法，他会直接调用float的方法进行使用
System.out.println(sum(10,20)); System.out.println(sum(10,20,30)); System.out.println(sum(10,20,30,40)); System.out.println(sum(10.5f,20f)); } //需求1:求两个数的和 public static int sum(int a,int b) { System.out.println("int"); return a + b; } //需求2:求三数的和 /* public static int sum1(int a,int b,int c) { return a + b + c; } */ public static int sum(int a,int b,int c) { return a + b + c; } //需求3:求四个数的和 /* public static int sum2(int a,int b,int c,int d) { return a + b + c + d; } */ public static int sum(int a,int b,int c,int d) { return a + b + c + d; } public static float sum(float a,float b) { System.out.println("float"); return a + b; }
java中的内存分配：
java程序为了提高程序的效率，就对数据进行了不同空间的分配。
具体的是划分为了5个内存空间
1.栈：存放的是局部变量
2.堆：存放的是所有new出来的东西
3.方法区：面向对象有关
4本地方法区：和系统相关
5.寄存器：CPU使用
栈的内存特点：
存储的是一个变量名，当有初始化操作的时候，就会将变量名和堆中的内存地址绑定，
并且在栈内存的数据用完就释放掉。
堆的内存特点：
1.每一个new出来的东西都有地址值
2.每个变量都有默认值
byte,short,int,long 0
float,double 0.0
char “\u0000” (空值)
boolean false
引用类型 null
3.使用完毕就变成了垃圾，但是没有立即回收。会在垃圾回收器空闲的时候回收
String的地址比较和内容比较：
==：地址值比较
equals()方法：内容比较
System.out.println(ss.equals(str));//比较的是字符串的内容
数组：
数组是存储多个变量的地方，但是这些变量的数据类型要一致。
当多个变量指向一个数组的时候，任意一个变量的操作，对数组都生效，
有点像python的可变类型的列表，
定义格式：
A:数据类型[] 数组名;
B:数据类型 数组名[];
注意：数组只有初始化之后才能进行使用
两种初始化方式的区别：
a:动态初始化 只指定长度，由系统给出初始化值
b:静态初始化 给出初始化值，由系统决定长度(用的较多)
动态初始化数组：
public static void main(String[] args){ //动态数组的定义 int [] arr_d = new int[3]; System.out.println(arr_d); System.out.println(arr_d[0]); System.out.println(arr_d[1]); System.out.println(arr_d[2]); /* [I@1b6d3586 0 0 0 */ }
静态初始化数组：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式： 数据类型[] 数组名 = {元素1,元素2,…};
public static void main(String[] args) { //定义数组 int[] arr = {1,2,3}; System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); }
数组的逆序
public static void reverse2(int[] arr) { for(int start=0,end=arr.length-1; start<=end; start++,end--) { int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } }
二维数组：
就是数组中的元素还是数组的形式
动态初始化：
int[][] arr = new int[3][2]
静态初始化：
基本格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
简化版格式：
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
例如：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};
二维数组的内存绑定：
在堆中将2层数组的地址赋值给第一层数组，
然后栈中的变量在和堆中的一层数组的地址进行绑定
打印杨辉三角练习：
import java.util.Scanner; public class java_start { //打印杨辉三角 public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入一个数字(1-9):"); int n = sc.nextInt(); int [][] sanjiao = new int[n][n]; for (int i=0;i<sanjiao.length;i++){ sanjiao[i][0] =1; sanjiao[i][i] = 1; if (i>1){ for (int j=1;j<i;j++){ sanjiao[i][j] = sanjiao[i-1][j-1]+sanjiao[i-1][j]; } } } for(int i=0;i<sanjiao.length;i++){ for (int j=0;j<=i;j++){ System.out.print(sanjiao[i][j]); } System.out.println(" "); } } }
Java中的参数传递问题：
基本类型：
类比python的不可变类型
形式参数的改变对实际参数没有影响。
引用类型：
数组，一个位置改变了数组，他就变了，类比python的可变类型
形式参数的改变直接影响实际参数。
可变参数：
public static int connInt(int ...is){//可变长参数，数组的扩容 int sum=0; for (int i = 0; i < is.length; i++) { sum+=is[i]; } return sum; } //Object ： public static String connString(Object ...o){ String s=""; for (int i = 0; i < o.length; i++) { s+=o[i]; } return s; }
