原文地址：https://www.cloudcrossing.xyz/post/34/
1 方法
1.1 方法的概述
方法，简单的说就是完成特定功能的代码块（注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法）。
格式：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句; return 返回值;
}格式解释：
修饰符：目前就用 public static，后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便调用该方法
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
实参：实际参与运算的数据
形参：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者
注意：
要明确返回值类型：结果的数据类型
方法与方法是平级关系，不能嵌套定义
参数列表：参数的个数及对应的数据类型，参数之间用逗号隔开
如果方法有明确的返回值，一定要有return带回一个值
方法的调用：
class FunctionDemo { public static void main(String[] args) { int x = 10; int y = 20;
//方式1：单独调用，没有意义（void类型的方法可以单独调用）
//sum(x,y);
//方式2：输出调用（void类型会报错：此处不允许使用 '空' 类型）
//System.out.println(sum(x,y));
//System.out.println(30);
//方式3：赋值调用（void类型会报错：非法的表达式开始）
int result = sum(x,y); //result在这里可以进行操作
System.out.println(result);
}
public static int sum(int a,int b) { //int c = a + b;
//return c;
return a + b;
}
}1.2 方法重载
在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
参数列表不同：
A：参数个数不同
B：参数类型不同
class FunctionDemo { public static void main(String[] args) { //jvm会根据不同的参数去调用不同的功能
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 sum(int a,int b,int c) { return a + b + c;
}
//需求3:求四个数的和
public static int sum(int a,int b,int c,int d) { return a + b + c + d;
}
//需求3:求两个浮点数的和
public static float sum(float a,float b) {
System.out.println("float"); return a + b;
}
}2 数组
2.1 数组概述
数组是存储同一种数据类型的多个元素的容器。每一个元素都有索引，从0开始，最大索引是长度-1。
数组既可以存储基本数据类型，也可以存储引用数据类型。
定义格式：
A：
数据类型[] 数组名;（推荐）B：
数据类型 数组名[];
java中的数组必须先初始化然后才能使用。所谓的初始化即为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化：
java中的数组必须先初始化然后才能使用
A：动态初始化。只给长度，系统给出默认值
举例：
int[] arr = new int[3];B：静态初始化。给出值，系统决定长度
举例：
int[] arr = new int[]{1,2,3};或者int[] arr = {1,2,3};
2.2 数组内存分配
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
A：栈，通常保存方法中的参数，局部变量。每一个线程包含一个栈区，只保存基本数据类型的对象和自定义对象的引用（不是对象），对象都存放在共享堆中；每个栈中的数据（基本数据类型和对象引用）都是私有的，其他栈不能访问；
B：堆，存储所有new出来的，即存储的全部是对象。每个对象都包含一个与之对应的class的信息（class的目的是得到操作指令）。jvm只有一个堆区，被所有线程共享，不存放基本类型和对象引用，只存放对象本身。
C：方法区(面向对象部分详细讲解)，又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。方法区中包含的都是在程序中永远的唯一的元素
D：本地方法区(系统相关)
E：寄存器(CPU使用)
注意：
a：局部变量 在方法定义中或者方法声明上定义的变量
b：栈内存和堆内存的区别
byte,short,int,long——0
float,double——0.0
char——'\u0000'
boolean——false
引用类型——null
栈：数据使用完毕，就消失。比如局部变量
堆：每一个new出来的东西都有地址，每一个变量都有默认值
C：数据使用完毕后，在垃圾回收器空闲的时候回收
（1）定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
定义一个数组的内存图
（2）定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
定义两个数组的内存图
（3）定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。
三个数组(两个栈变量指向同一个堆内存)
2.3 数组常用操作
（1）遍历
public static void printArray(int[] arr) { for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}注意：数组提供了一个属性length，用于获取数组的长度。格式：数组名.length。
（2）最值
public static int getMax(int[] arr) { //从数组中任意的找一个元素作为参照物
int max = arr[0]; //然后遍历其他的元素
for(int x=1; x<arr.length; x++) { //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
if(arr[x] > max) {
max = arr[x];
}
} //最后参照物里面保存的就是最大值。
return max;
}
public static int getMin(int[] arr) { //从数组中任意的找一个元素作为参照物
int min = arr[0]; //然后遍历其他的元素
for(int x=1; x<arr.length; x++) { //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。
if(arr[x] < min) {
min = arr[x];
}
} //最后参照物里面保存的就是最小值。
return min;
}（3）逆序
方式1：public static void reverse(int[] arr) { for(int x=0; x<arr.length/2; x++) { int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
}
方式2：public static void reverse(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;
}
}（4）查表
public static String getString(String[] strArray,int index) { return strArray[index];
}（5）基本查找
方式1：public static int getIndex(int[] arr,int value) { for(int x=0; x<arr.length; x++) { if(arr[x] == value) { return x;
}
} return -1;
}
方式2：public static int getIndex(int[] arr,int value) { int index = -1; for(int x=0; x<arr.length; x++) { if(arr[x] == value) {
index = x; break;
}
} return index;
}2.4 二维数组
二维数组是一个元素是一位数组的数组。
格式：
A：
数据类型[][] 数组名 = new 数据类型[m][n];B：
数据类型[][] 数组名 = new 数据类型[m][];C：
数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};D：
数据类型[][] 数组名 = {{...},{...},{...}};
PS：m表示这个二维数组有多少个一维数组。n表示每一个一维数组的元素有多少个。
二维数组格式A的内存图解
二维数组格式B的内存图解
二维数组格式D的内存图解
二维数组的遍历：外循环控制的是二维数组的长度，其实就是一维数组的个数。内循环控制的是一维数组的长度。
class Array2 { public static void main(String[] args) { int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; //arr[0]就是第一个数组，arr[0] = {1,2,3};
printArray2(arr);
System.out.println("--------------"); int[][] arr2 = {{1,2,3},{4,5},{6}};
printArray2(arr2);
}
public static void printArray2(int[][] arr) { for(int x=0; x<arr.length; x++) { for(int y=0; y<arr[x].length; y++) { //arr[x]就是第x-1个数组
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}举个二维数组的应用例子
/*
需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
分析：看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
*/import java.util.Scanner;class Array2Test { public static void main(String[] args) { //创建键盘录入对象
Scanner sc = new Scanner(System.in);
//这个n的数据来自于键盘录入。
System.out.println("请输入一个数据："); int n = sc.nextInt();
//定义二维数组
int[][] arr = new int[n][n];
//给这个二维数组任何一行的第一列和最后一列赋值为1
for(int x=0; x<arr.length; x++) {
arr[x][0] = 1; //任何一行第1列
arr[x][x] = 1; //任何一行的最后1列
}
//按照规律给其他元素赋值
//从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
for(int x=2; x<arr.length; x++) { //这里如果y<=x是有个小问题的，就是最后一列的问题
//所以这里要减去1
//并且y也应该从1开始，因为第一列也是有值了
for(int y=1; y<=x-1; y++) { //每一个数据是它上一行的前一列和它上一行的本列之和。
arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
}
}
//遍历这个二维数组。
for(int x=0; x<arr.length; x++) { for(int y=0; y<=x; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}3 参数传递问题
Java中的参数传递问题：
基本类型：形式参数的改变对实际参数没有影响
引用类型：形式参数的改变直接影响实际参数
class ArgsDemo { public static void main(String[] args) { int a = 10; int b = 20;
System.out.println("a:"+a+",b:"+b); //输出：a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b); //输出：a:10,b:20
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //输出：4
} public static void change(int a,int b) { //a=10,b=20
System.out.println("a:"+a+",b:"+b); //a:10,b:20
a = b; //a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a:20,b:40
} public static void change(int[] arr) { //arr={1,2,3,4,5};
for(int x=0; x<arr.length; x++) { if(arr[x]%2==0) {
arr[x]*=2;
}
} //arr={1,4,3,8,5};
}
}#运行结果：a:10,b:20a:10,b:20a:20,b:40a:10,b:204
4 语言基础综合练习
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来。
题目要求：
A:数据是小于8位的整数
定义一个int类型的数据 int number = 123456;
B:加密规则
a:首先将数据倒序
结果 654321
b:然后将每位数字都加上5，再用和除以10的余数代替该数字
结果 109876
c:最后将第一位和最后一位数字交换
结果 609871
C:把加密后的结果输出在控制台
通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。
不是直接写成这个样子的： int[] arr = {1,2,3,4,5,6};
如何把数据转成数组呢?
A:定义一个数据 int number = 123456;
B:定义一个数组,这个时候问题就来了，数组的长度是多少呢? int[] arr = new int[8]; //不可能超过8
在赋值的时候，我用一个变量记录索引的变化。
定义一个索引值是0
int index = 0;
C:获取每一个数据 int ge = number%10
int shi = number/10%10
int bai = number/10/10%10
arr[index] = ge;
index++;
arr[index] = shi;
index++;
arr[index] = bai;
...import java.util.Scanner;class JiaMiDemo2 { public static void main(String[] args) { //创建键盘录入对象
Scanner sc = new Scanner(System.in);
//请输入一个数据
System.out.println("请输入一个数据(小于8位)："); int number = sc.nextInt();
//写功能实现把number进行加密
//调用
String result = jiaMi(number);
System.out.println("加密后的结果是："+result);
}
/*
需求：写一个功能，把数据number实现加密。
两个明确：
返回值类型：String 做一个字符串的拼接。
参数列表：int number
*/
public static String jiaMi(int number) { //定义数组
int[] arr = new int[8];
//定义索引
int index = 0;
//把number中的数据想办法放到数组中
while(number > 0) {
arr[index] = number%10;
index++;
number /= 10;
}
//把每个数据加5，然后对10取得余数
for(int x=0; x<index; x++) {
arr[x] += 5;
arr[x] %= 10;
}
//把第一位和最后一位交换
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;
//把数组的元素拼接成一个字符串返回
//定义一个空内容字符串
String s = "";
for(int x=0; x<index; x++) {
s += arr[x];
}
return s;
}
}
作者：苍云横渡
链接：https://www.jianshu.com/p/b7d0963dee78
來源：简书