Java的基础知识1.2

数组的知识

int [ ] number=new int [10];

在数组中通过下标来存储元素，也可以通过下标输出元素
ArrayIndexoutofboundsException数组下标越界异常
type mismatch cannot convert from string to int 类型不匹配 不能从字符串类型转换成整型
数组的长度 数组的变量名字number.length
数组中的元素个数：数组的长度-1；number.length-1;
数组的最值问题：找出数组的最大值或者是最小值，只用一个for循环就ok
数组的冒牌排序：
用两个for循环，外层循环控制的是循环轮数
内层循环控制比较次数 ：两个元素之间相互比较的次数
优化之后的循环 外层循环是(i=0;i<array.length-1;i++)
内层循环是(j=0;j<array.length-1-i;j++);后面的-i的原因是：主要是随着程序的执行，后面的数字已经慢慢的排序好了，所以就不用浪费时间再去执行了。
数组的选择排序：
还是两个for循环，外层循环是来控制比较几次（数组的长度-1次），内层循环是假定一个元素是最值，然后和其他的元素逐一比较，符合条件的就结束这次内层循环，然后相互换了位置。
数组的冒牌排序和数组的选择排序，基本都是类似的，他们之间的区别就是效率的问题。选择排序比冒牌排序效率高。
在数组中学习到知识和相关的例子：
1.数组的最值（最大值和最小值）
最大值：
public static void main(String[] args) {
int[] arr = { 12, 15, 65, 23, 35, 18, 92 };
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
System.out.println(“这个数组的最大值是：” + max);
}
最小值：
public static void main(String[] args) {
int[] arr = { 12, 15, 65, 23, 35, 18, 92 };
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if (min > arr[i]) {
min = arr[i];
}
}
System.out.println(min);
}
2.冒泡排序（升序）
import java.util.Arrays;
public static void main(String[] args) {
int[] arr = {12, 15, 65, 23, 35, 18, 92 };
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1; j++) {
if (arr[j]>arr[j+1]) {
int tem=arr[j+1];
arr[j+1]=arr[j];
arr[j]=tem;
}
}
}
System.out.println(Arrays.toString(arr));
}
降序：
import java.util.Arrays;
public static void main(String[] args) {
int[] arr = { 12, 15, 65, 23, 35, 18, 92 };
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j]<arr[j+1]){
int tem=arr[j+1];
arr[j+1]=arr[j];
arr[j]=tem;
}
}
}
System.out.println(Arrays.toString(arr));
}
3.九九乘法表
public static void main(String[] args) {
for (int i = 1; i <=9; i++) {
for (int j = 1; j <=i;j++) {
System.out.print(j+""+i+"="+ij+"\t");
}
System.out.println();
}
}
4.选择排序（升序和降序）：
升序：
import java.util.Arrays;
public static void main(String[] args) {
int[] arr = { 12, 15, 65, 23, 35, 18, 92 };
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j <arr.length; j++) {
if (arr[i]>arr[j]) {
int tem=arr[i];
arr[i]=arr[j];
arr[j]=tem;
}
}
}
System.out.println(Arrays.toString(arr));
}
降序：
import java.util.Arrays;
public static void main(String[] args) {
int[] arr = { 12, 15, 65, 23, 35, 18, 92 };
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j <arr.length; j++) {
if (arr[i]<arr[j]) {
int tem=arr[i];
arr[i]=arr[j];
arr[j]=tem;
}
}
}
System.out.println(Arrays.toString(arr));
}

类和对象的理解

类：具有相同属性和方法的一组对象的集合；
类和对象的关系：类是对象的抽象，对象是类具体化的实例；
成员变量和局部变量的区别：
1.在类中的位置不同
成员变量：在类中方法外；
局部变量：在方法中或者代码块中，或者是在方法的声明上（即在参数列表中）
2.在内存中的位置不同
成员变量：在堆中（方法中的静态区）
局部变量：在栈中
3.生命周期不同
成员变量：随着类的创建而存在，对着类的消失而消失
局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失
4.初始值不同
成员变量：有默认的初始值；(可以在声明的时候不赋值)
局部变量：没有默认的初始值，使用之前需要先赋值，否则编译器会报错（The local variable xxx may not have been initialized（初始值））；
this 关键字(表示调用对象本身),这个关键字用于访问成员变量

方法：
1.无参方法
2.有参方法
3.无返回值方法
4.有返回值方法
有返回值的方法

参数的传递：
1.基本数据类型的参数传递
基本数据类传递的是值，两个变量相互不影响

2.引用数据类型的参数传递
引用数据类型传递的是内存的地址(引用)，两个变量引用的是同一个对象；通过一个变量改变对象的值。通过另外一个变量查看对象的值，发现值也被改变了。
Student stu=new Student();
new Student()；此方法会创建出一个对象，放在内存的堆中
stu是一个变量(对象名)，放在栈中
既然stu是一个变量(对象名)，那么存放的是对象的内存地址(在栈中)；
stu.age=18; 通过变量stu 找到内存中的地址值，通过地址值找到对象本身，对象里面有age属性，可以赋值给age为18

对象是保存在堆内存，变量(对象名)是保存在栈中，变量中放的是地址值，通过地址值找到对象，对象里面有保存的其属性。

数据作为参数传递的时候：
成员变量是在类中 方法外
局部变量是在方法中或是在代码块中或者是在方法的参数列表中
成员变量和局部变量的区别：

1. 它们在类中的位置不一样
   局部变量是在方法中或者是在代码块中或者是在方法的参数列表中；成员变量是在类中 方法外。
   2.它们在内存中的位置不一样
   成员变量是保存在堆中的； 局部变量是在栈中保存的
   3.它们的生命周期是不一样的
   局部变量是随着方法，代码块，参数列表的执行而执行，随着他们的消失而消失；成员变量是随着类的执行而执行，随着类的结束而结束
   4.初始化
   局部变量中的变量必须是先声明，使用的时候必须是赋值的，不然会报错，没有默认的初始值； 成员变量是先声明，使用的不赋值的话使用其默认值。
   成员变量是保存在堆中的，局部变量是保存在栈中的；
   基本数据类型和引用数据类型的参数传递的问题：
   基本数据类型作为参数的传递，传递的是值
   引用数据类型作为参数传递，传递的也是值(地址值)，然 后通过地址值引用堆中的对象
   在java中数据类型作为参数传递，传递的一直是值
   在做不管是基本数据类型还是引用数据类型当作参数传递的问题的时候：
   1.时刻分析变量是局部还是成员，思考一下它们的作用域；
   2.尤其是分析引用数据类型的时候要注意，结束方法之后，里面的变量也就消失了，但是造成了什么后果，改变了什么；
   3.注意String类 它是被final修饰的 是赋值后不可改变的

三级目录数组的定义：数组是一个变量，存储同一种数据类型的一组数据。