11【Java基础】jvm内存解析、Arrays工具类、局部变量和成员变量（属性）的区别

一、数组基本知识

a.声明和初始化

//声明：

String[] names; //建议使用这种声明类型

int ages[]; //c语言声明的特点

//初始化：分为静态和动态

///静态：意为初始化和赋值同时进行。
names = new String[]{"小a", "小b"};
int[] score = {1,20,9};

//下面这种方式不对，不能分开写。
int[] score;
socre = {1,20,9};//容易造成误解，不清楚score是啥

///动态：初始化和赋值分开进行，只分配空间。
///注意: 不赋值，也是有默认值的。
age = new int[5];//5 is the length of the array age[];指定数组长度，分配内存空间。

1. 数组是引用数据类型（类、接口、数组）
2. 数组中的元素可以是基本数据类型，也可以是引用数据类型

b.获取数组中的元素——通过下标 0~length-1

方法：

int[] age = new int[5];
int len = age.length;// len = 5

c.数组元素的默认值

byte[] b = new byte[2];
System.out.println(b[0]);//默认为0

//int类型也是默认为0；Boolean类型默认为false

总结：

1. byte，short，int，long 默认为0；
2. float，double 默认为 0.0；
3. char默认为 \u0000，长得像空格，但不是空格，只是一片空白；
4. 引用数据类型（类、接口、数组）默认为 null

二、一维数组的内存解析

1. jvm内存解析

   jvm即翻译，像一个小型计算机，我们 new 的对象，jvm负责找地方来存储，也就是在内存条里找地方存着。

2. 数组内存解析

   String[] names = new String[3];
   //上面这行代码，new的一个string类型的数组，存放在堆里，names是一个局部变量（只存在于main函数里），即存放在栈中。
   

三、数组的复制和反转

a.数组复制

int[] numbers = new int[5]; //声明并动态初始化
int[] copyNumbers = new int[numbers.length];
for(int i = 0; i < numbers.length; i++){
    copyNumbers[i] = numbers[i];
}

// output the elements of the array——返回数组中的所有元素，并输出字符串。
System.out.println(Array.toString(numbers));
//Array 是操作数组的一个工具类，下节会讲到，不用循环i输出，会直接输出整个数组的所有值。

如果修改了 copyNumbers 中的数据，numbers中的数据不会发生改变。

b.数组的反转

public class ArrayTest{
    public static void main(String[] args){
        int[] num = {1,2,3,4,5};
        int[] reverseNum = new int[num.length];
        for(int i = revesreNum.length-1; i>0; i--){
            reverseNum[i] = num[num.length - i];
        }
        
        //对换
        for(int i = 0, j = num.length-1; i < num.length/2; i++,j--){
            int temp = num[i];
            num[i] = num[j];
            num[j] = temp;
        }
    }
}

//static
ps = new String[][]{{1,wang},{2,sun},…{3,li}};

String[][] persons = {{1,wang},{2,sun},…{3,li}};

//dynamic
ps2 = new String[1][2];//数组长度为1，元素的长度为2

ps3 = new String[2][];
ps3[0] = new String[2];
ps3[1] = new String[3];///这种方式声明的数组，不同元素的长度也不同！一个2，一个3

四、二维数组（默认值为null）（但二维数组元素的元素的默认值，和一维数组元素的默认值是一样的）

a.声明和初始化

String[][] ps;//建议使用
String ps1[][];
String[] ps2[];

初始化：

//static
ps = new String[][]{{1,wang},{2,sun},...{3,li}};

String[][] persons = {{1,wang},{2,sun},...{3,li}};

//dynamic
ps2 = new String[1][2];//数组长度为1，元素的长度为2

ps3 = new String[2][];
ps3[0] = new String[2];
ps3[1] = new String[3];///这种方式声明的数组，不同元素的长度也不同！一个2，一个3

b.遍历

for(int i = 0; i < ps.length; i++){
	for(int j = 0; j < ps[0].length; j++){
        System.out.println(ps[i][j] + " ");
    }
    System.out.println();//输出换行
}

五、Arrays工具类（四个常用方法

public class ArraysTest{
    public static void main(String[] args){
        int[] n = {1,2,3,40,5};
        int[] n2 = {1,2,3,4,5};
        
     //Arrays.equals(int[] a, int[] b)方法用来比较：两个数组是否相等（数组的内容、个数、顺序）
        boolean equals = Arrays.equals(n, n2);
        
     //void fill(int[] a, int[] val);讲指定值填充到数组中。也就是覆盖新的值。
        Arrays.fill(n2, 100);
        
     //void sort(int[] a);
        Arrays.sort(n);
        
     //二分法查找：一定要先排序！！！！如果找不到，返回负数（不一定是 -1）
        int index = Arrays.binarySearch(n, 5);//前提是要排好序的数组，此时返回值为3
        
    }
}

六、数组中常见异常

1.下角标越界：ArrayIndexOutOfBoundsException

public class ArrayExceptionTest{
    public static void main(String[] args){
        //下标越界，访问越界内存
        int[] numbers = new int[2];
        int ans = numbers[2];//此时报错，[2]不存在这个地址
        //编译错误：超出了索引值的范围
    }
}

2.空指针异常：NullPointerException

原因：只要调用属性和方法的那个值为 null 就会发生空指针异常

public class ArrayExceptionTest{
    public static void main(String[] args){
        String str = "aaa";
        System.out.println(str.toUpperCase());//这个函数的意思是，将str转化为大写输出
        //output：AAA
        
        str = null;//此时报错，空指针异常——因为str的内容为null
        
        String[][] ps = new String[2][3];
        System.out.println(ps[0][0].toUpperCase());//此时也报错，因为ps[0][0]为null，调用null的方法，编译错误
        
        String[][] ps1 = new String[2][];//二维数组元素默认值为null
        System.out.println(ps1[0][0]);//这时是因为 ps1[0] 为null，调用属性失败，编译错误
        
        //综上，因为动态初始化（没有赋值，默认为null） 或 赋值为null值 —— 这种情况就是空指针异常。
    }
}

七、面向对象oop

a.学习主线

1. Java类和类的成员：属性、方法、构造器、代码块、内部类
2. oop三大特征：封装性、继承性、多态性
3. 其他关键字：this，super，static，final。。。。。。

b.oop\pop

1. 面向对象：强调具备功能的对象，以类、对象为最小单位
2. 面向过程：强调的是功能行为，以函数为最小单位

c.类和对象

1. 类：是一类事物的描述，是抽象的、概念上的定义

2. 对象：是实际存在的该类食物的每个个体，也成为实例 instance

   对象是由类派生出来的（new 出来的）

d. 类的成员：属性和方法

1. 属性：类中的成员变量（Field）
2. 方法：类中的成员方法（函数）

e. 面向对象的落地实现：

1. 创建一个类并提供必要的属性和方法；
2. 通过该类创建对象（new
3. 调用属性和方法。。。

class Person{
    //属性
    String name;//成员变量
    int age;
    
    //方法
    public void show(){
        int a;//局部变量/
        System.out.println(a);//报错，因为没有初始化
        
        System.out.println("I am" + name);
    }
}
public class oop{
    public static void main(String[][] args){
        
        //创建对象并接收，p为对象的名字
        Person p = new Person();
        
        //调用属性和方法：p.xxx
        p.name = Dora;
        p.show();
        
        //属性（成员变量）的有默认值，如下：
        System.out.println(p.age);//输出结果为 0 ，默认值为0
        
        //类中的局部变量
        int b;
        System.out.println(b);//报错，因为没有初始化
        
        //main方法中，局部变量作用域是确定的，不能使用权限修饰符来修饰
        public int c;//这样会报错
    }
    
    //oop类中的成员变量可以由四种修饰符来修饰
    private int d = 3;
}

八. 局部变量和成员变量（属性）的不同点：

1. 位置

   1. 属性：在类中方法等结构外
   2. 局部变量：在方法中的方法的形参、构造器中，构造器的形参、代码块中；

2. 默认值：

   1. 属性：

      基本数据类型：

      ​ byte，short，int，long：0

      ​ float，double：0.0

      ​ char：\u0000

      ​ boolean：false

      引用数据类型：类、接口、数组：null

   2. 局部变量：没有默认值——所以必须（动态、静态）初始化

3. 权限修饰符

   属性：private public protected 缺省的

   成员变量：不能使用权限修饰符

4. 内存

   属性：在堆中的对象中

   局部变量：在栈中