JAVA入门学习（一）——基本数据类型
JAVA入门学习（二）——进制以及进制的转换、数据类型隐式转换的优先级、变量
JAVA入门学习（三）——Scanner、语句类型
内存：堆、栈、方法区、本地方法栈、寄存器
详细信息
一、数组
🔺1.定义：存储相同数据类型的容器
🔺2.特点：相同数据类型，有序的（下标从0开始），长度是不可变的（可通过属性length获得长度）
🔺3.声明数组：
数据元素的数据类型【】 数组名；
例如： int[] nums; 或者 int nums [];
🔺4.创建数组（申请 内存）
数组名 = new 数据元素的类型【长度】；
例如：nums = new int【10】；
🔺5.存放数据:
num[0] = 1; num[1] = 2; num[9] = 10;
🔺6.使用数组
<1.syso(nums[0]);
<2. for(int i = 1; i<nums.length; i++){ syso(nums[i]);}
<3. 增强for循环 即foreach循环
for(int i : nums){ syso(i);}
<4. Arrays.toString(nums);
<4.定义数组常用的三种方式：
int[] nums = new int[10];
int[] nums1 = {1, 3, 4, 6};
int[] nums2 = new int[] {1, 2, 3};
<5.mian方法中args数组的使用
public static void main(String[] args) {
int sum = 0;
for (String string : args) {
sum += Integer.parseInt(string);
}
System.out.println(sum);
//System.out.println(Arrays.toString(args));
}
⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆ Program arguments里的数据用空格隔开就ok
<6.数组的拷贝：
/**
* 数组的拷贝
*/
int a[] = {1,2,3,4,5};
int[] b = new int[10];
/**
* System.arraycopy(src, srcPos, dest, destPos, length);
* 第一个参数：原数组
* 第二个参数：原数组的起始位置
* 第三个参数：目标数组
* 第四个参数：目标数组的起始位置
* 第五个参数：拷贝原数组到目标数组的 原数组长度(不能超过原数组的长度，否则报错 java.lang.ArrayIndexOutOfBoundsException)
*/
System.arraycopy(a, 0, b, 0, 5);
System.out.println(Arrays.toString(b)); //输出: b={1,2,0,0,0,0,0,0,0,0}
<7.copyof()方法：
实现数组的扩容（假象，数组长度是不可变的，原理就是使用arrraycopy（）方法把原数组数据存到一个新的数组里面,这个新的创建的数组容量要大）
/**
* Arrays.copyOf(T[] original, int newLength)
* 第一个参数：原数组
* 第二个参数：扩容后的长度
*/
String[] a = {"张三"};
System.out.println(Arrays.toString(a));
a = Arrays.copyOf(a, 2);
a[1] = "李四";
System.out.println(Arrays.toString(a));
/**
* 运行结果 ：
* [张三]
[张三, 李四]
*/
🔺7.数据元素的排序：
7.1冒泡排序法：两两比较，大的沉下去，小的浮上来，即为较大的数慢慢往后排，较小的数慢慢往前排。最终排序结果从小到大。
public static void test01() {
/**
* 冒泡排序
*/
int[] a = new int[] {7, 2, 6, 4, 10};
/**
* 7 2 6 4 10
* 2 6 4 7
* 2 4 6
* 2 4
*/
// Arrays.sort(a);
// System.out.println(Arrays.toString(a));
//表示总体要循环的次数 n-1
for(int i = 0; i < a.length - 1; i++ ) {
//每次循环序列，两两比较数值，大的放后面，小的放前面
for(int j = 0; j < a.length - 1 - i; j++) {
if(a[j] > a[j+1]) {
a[j] = a[j] ^ a[j+1];
a[j+1] = a[j] ^ a[j+1];
a[j] = a[j] ^ a[j+1];
}
}
System.out.println(Arrays.toString(a));
}
}
7.2 选择排序：选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
/**
* 选择排序法
* 10,7,8,3,6,9
* --------------
* 10 7 8 3 6 9 1 5
* 9 8 3 6 7 2 4
* 8 3 6 7 3 3
* 7 6 3 4 2
* 6 3 5 1
* @param args
*/
public static void main(String[] args) {
int[] num = {10,7,8,3,6,9};
for(int i=0; i<num.length-1; i++) {
//定义 maxIndex为最大的下标
int maxIndex = i;
for(int j=i+1; j<num.length; j++) {
if(num[maxIndex] < num[j]) {
maxIndex = j;
}
}
int temp = num[maxIndex];
num[maxIndex] = num[i];
num[i] = temp;
System.out.println(Arrays.toString(num));
}
}
🔺8.二维数组
二维数组的声明：
int[][] arrays;
int[] arrays[];
int arrays[][];
创建：
arrays = int[2][3]; //2行3列
赋值：
array[0][2] = 1;
0 0 1
0 0 0
使用数组元素，使用嵌套循环
public static void test02() {
//声明二维数组
int[][] num;
//创建
num = new int[3][2];
//赋值
num[1][1] = 1;
//输出
for(int i = 0; i<num.length; i++) {
for(int j = 0; j<num[i].length; j++) {
System.out.print(num[i][j]);
}
System.out.println();
}
}
🔺小测试：
/**
* 对角线求和
1 2 3 1 [0][0] 3 [0][2]
1 2 2 2 [1][1] 2 [1][1]
3 2 2 2 [2][2] 3 [2][0]
* @author 陶沅玱
*
*/
public class Test03 {
public static void main(String[] args) {
int[][] num = new int[][] {{1,2,3},{1,2,2},{3,2,2}};
int sum = 0;
for(int i=0; i<num.length-1; i++) {
for(int j=0; j<num[0].length-1; j++) {
if(i==j || i+j==2) {
sum += num[i][j];
}
}
}
System.out.println(sum);
}
}
/**
* 矩阵转置
1 2 3 [0][0] [0][1] [0][2]
4 5 6 [1][0] [1][1] [1][2]
1 4 [0][0] [0][1]
2 5 [1][0] [1][1]
3 6 [2][0] [2][1]
* @author 陶沅玱
*
*/
public class Test04 {
public static void main(String[] args) {
int[][] num = new int[][] {{1, 2, 3}, {4, 5, 6}};
int[][] a = new int[3][2];
for(int i=0; i<num.length; i++) {
for(int j=0; j<num[0].length; j++) {
a[j][i] = num[i][j];
}
}
//输出二维数组
for(int i=0; i<a.length; i++) {
System.out.println(Arrays.toString(a[i]));
}
}
}
/**
* 杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
特点：每一行的开始和结束都是1；其余位置的元素是计算：
arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
输入一个数字n表示行数，输出对应的前n行
* @author 陶沅玱
*
*/
public class Test05 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入您想看到的杨辉三角第几层: " );
int a = input.nextInt();
int[][] num = new int[a][a];
for(int i=0; i<num.length; i++) {
for(int j=0; j<=i; j++) {
if(i == j || j == 0) {
num[i][j] = 1;
}
else {
num[i][j] = num[i-1][j] + num[i-1][j-1];
}
}
}
//输出
for(int i = 0; i<num.length; i++) {
for(int j = 0; j<num[0].length; j++) {
if(i >= j) {
System.out.print(num[i][j] + "\t");
}
}
System.out.println();
}
}
}
二、方法
顺便提一下，java中代码书写方法时，特别要注意的一点：
java中方法只能平级书写，方法不能嵌套方法。
🔺1.方法的定义：
访问修饰符 方法的返回类型 方法名 （形参列表）{
方法体;
}
▲访问修饰符：
▲返回类型：无返回值void，有返回值的——任何数据类型
无返回值void，return可有可无:
public void test(){
syso("aa");
return ; //表示方法结束，可有可无
}
有返回值（任何数据类型，Object）,必须有返回值
public double test(){
syso("aaa");
return 1.0 + 2;
}
▲方法名：同变量命名规则相同
▲形参列表：同变量定义规则，多个形参之间用“，”隔开
public int test(int x, int y){
return x+y;
}
▲方法体：就是方法完成的功能代码
🔺2.方法的调用
方法名（实参列表)
🔺3.方法的重载
（1）方法重载是让类以统一的方法处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数（类型）。重载Override是一个类中多态性的一种表现。
（2）java的方法重载，就是在类中可以创建多个方法，他们具有相同的名字，但具有不同参数和不同的定义。调用方法时通过传递给他们不同的参数个数和参数类型来决定具体使用那个方法，这就是多态性。
（3）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不同。无法以返回类型来作为重载函数的区分标准。
> 注意：
>
> 1.重载不能以返回值作为区分标准；
>
> 2.重载不能以形参的不同名称（例如形参int a和形参int b无法区分）作为区分标准。
🔺4.方法的重写（覆盖）
注意：方法的重写只能发生在继承关系的基础上
（1）父类与子类的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写。 在java中，子类可继承父类的方法，则不需要重新编写相同的方法。但有时子类并不想原封不动继承父类的方法，而是想做一定的修改，这就采用方法重写。方法重写又称方法覆盖。
（2）若子类中的方法与父类的中的某一方法具有相同的方法名、返回类型和参数表，则新方法覆盖原有的方法。如需要父类的原有方法，可以使用super关键字，该关键字引用房钱类的父类。
（3）子类函数访问权限大于父类。
🔺5.值传递
如果基本数据类型，方法内改变，原值不变。
如果是地址（数组），地址不变，数据发生变化，原值也发生变化
251
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
