数组
数组指一种容器，可以存储同种类型的多个值
1.数组的定义格式和静态初始化
数据类型 [] 数值名
int [] arr
静态初始化：
初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
格式：
数据类型[] 数值名 = {元素1，元素2，元素3.....}；
int [] arr = {11, 22, 33, 44, 55};
1.1数值遍历操作
数组遍历：依次访问数组中的每一个元素
public static void main (String [] args){
for(int i = 0; i < arr.lenght; i++){
}
}
1.2案例求偶数和
package com.itheima.test;
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr1 = {-11, -22, -33, -44, -55};
int[] arr2 = {66, 77, 88, 99, 100};
int sum = getSum(arr2);
System.out.println("偶数和为:" + sum);
}
public static int getSum(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
// arr[i] : 每一个元素
// i : 代表索引
if (arr[i] % 2 == 0) {
sum += arr[i];
}
}
return sum;
}
}
1.3案例求最大值
package com.itheima.test;
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr1 = {5, 44, 33, 55, 22};
int max = getMax(arr1);
System.out.println("最大值为:" + max);
}
public static int getMax(int[] arr) {
// 1. 假设数组中第一个元素为最大值
int max = arr[0];
// 2. 遍历数组, 取出剩余的每一个元素
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
// 4. 找到更大的元素, 改变max变量的值
max = arr[i];
}
}
return max;
}
}
1.4案例数值反转操作 ***
需求：
已知一个数组 arr = {11, 22, 33, 44, 55}; 用程序实现把数组中的元素值交换，
交换后的数组 arr = {55, 44, 33, 22, 11}; 并在控制台输出交换后的数组元素。
package com.itheima.test;
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr1 = {11, 22, 33, 44, 55};
reverseArray(arr1);
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
}
public static void swap() {
int[] arr = {11, 22, 33, 44, 55};
// 第一个元素 arr[0]
// 最后一个元素 arr[arr.length-1]
int temp = arr[0];
arr[0] = arr[arr.length - 1];
arr[arr.length - 1] = temp;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//需求: 对数组中的元素反转
public static void reverseArray(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;
}
}
}
2.数组的动态初始化
int[]arr = new int[n]
// 创建有N个坑位的数组，长度为n
// 数据类型[] 数组名 = new 数据类型[数组长度]
2.1两种数组的区别
1.明确了数组长度就用静态初始化，没有明确数组长度就用动态初始化
2.静态初始化需要手动指定元素，动态初始化有系统默认值
2.2案例评委打分
//由6个评委打分，分数0-100，
//选手最后得分为：去掉一个最高分和一个最低分的4个评委的平均值
package com.itheima.test;
import java.util.Scanner;
public class ArrayTest3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入6个评委的分数: ");
int[] arr = new int[6];
for (int i = 0; i < arr.length; i++) {
System.out.println("第" + (i + 1) + "个: ");
arr[i] = sc.nextInt();
}
// 1. 找出最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 2. 找出最小值
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
// 3. 求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
// 4. 计算最终得分
double avg = (sum - max - min) / 4.0;
System.out.println("平均值为:" + avg);
}
}
3.方法参数传递
//方法参数为基本数据类型，传递的是数据值
public class ArgsTest1 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前:" + number); // 100
change(number);
System.out.println("调用change方法后:" + number); // 100
}
public static void change(int number) {
number = 200;
}
}
为什么两次输出都是 100？
因为：
- 方法改的是传进去的数值副本（复印件）
- 原来的变量（原件）丝毫没有被修改
超简记忆口诀
基本类型传参数，传的只是一个值；方法里面随便改，外面原值不动摇。
//方法参数为引用数据类型，传递的是地址值
public class ArgsTest2 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
System.out.println("调用change方法之前:" + arr[0]); // 11
change(arr);
System.out.println("调用change方法之后:" + arr[0]); // 66
}
public static void change(int[] arr) {
arr[0] = 66;
}
}
3.1数组常见问题
3.1.1数组索引越界异常
package com.itheima.exception;
public class IndexOutOfBoundsExceptionDemo {
/*
数组索引越界异常: IndexOutOfBoundsException 访问了数组中不存在的索引
*/
public static void main(String[] args) {
int[] arr = {11, 22, 33};
System.out.println(arr[10]);
for(int i = 0; i <= arr.length; i++){
// i = 0 1 2 3
System.out.println(arr[i]);
}
}
}
3.1.2空指针异常
package com.itheima.exception;
public class NullPointerExceptionDemo {
/*
空指针异常: NullPointerException
当引用数据类型变量被赋值为 null 之后, 地址的指向被切断, 还继续访问堆内存数据, 就会引发空指针异常
*/
public static void main(String[] args) {
int[] arr = {11, 22, 33};
arr = null;
System.out.println(arr[0]);
}
}
4.二维数组
int[][] arr =new int [][] {{元素1，元素2}，{元素1，元素2}}
int[][] arr = {{1，2}，{3，4}}
public static void main(String[] args) {
int[][] arr = {
{11, 22, 33},
{44, 55, 66}
};
4.1二维数组遍历
package com.itheima.test;
public class ArrayTest4 {
public static void main(String[] args) {
int[][] arr = {
{11, 22, 33},
{44, 55, 66}
};
// 外循环: 遍历二维数组, 取出每一个一维数组
for (int i = 0; i < arr.length; i++) {
// arr[i] : 每一个一维数组
// 内循环: 继续遍历一维数组, 取出每一个元素
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
面向对象基础
1.类和对象
1.1类和对象的关系
- 依赖关系：需要根据类创建对象
- 数量关系：一个类可以创建出多个对象
1.2类的组成
属性：成员变量，放在方法外面的
public static Student(){
String name；
int age；
}
行为：成员方法，和之前方法的格式一样，去掉static关键字
public void study(){
sout()
}
1.3对象的创建和使用
类名 对象名 = new 类名()
Student st = new Student()
2.对象内存图
超级精简总结
- new 时才在堆里创建对象
- 对象名存在栈里，保存的是地址
- 真正的数据存在堆里
- 方法传对象，传的是地址，所以能修改堆里的值
3.成员变量和局部变量的区别
1.初始化值不同： 成员变量: 有默认初始化值 局部变量: 没有，使用之前必须完成赋值
2.内存位置不同： 成员变量：堆内存 局部变量：栈内存 3.生命周期不同： 成员变量：随着对象的创建而存在，随着对象的消失而消失 局部变量：随着方法的调用而存在，随着方法的运行结束而消失
4.作用域：都在自己所归属的 {} 中有效
