数组

http://t.csdn.cn/lA6GMhttp://t.csdn.cn/lA6GM

数组的基本要素

标识符、数组元素、元素下标：从0开始、元素类型

注：数组长度固定不变，避免数组越界;数组中的所有元素必须属于相同的数据类型

如何使用数组

声明数组(告诉计算机数据类型是什么)

分配空间(告诉计算机分配几个连续空间)

赋值(向分配的格子里放数据)

处理数据

步骤（分步）

第一步：声明数组

数据类型[] 数组名；或者

数据类型 数组名[]

第二步：分配空间，告诉你声明的数组里可以存储多少个数据

数组名 = new 数据类型[数组元素个数]

第三步：给数组赋值，将数据存储到数组中

数组名[下标] = 数据；

第四步：操作数据，使用数组名[数组元素下标]来操作数据

数据类型的默认值

声明数组、分配空间合并写

 数组类型[] 数组名 = new 数据类型[数组长度];

或者 数据类型 数组名[] = new 数组类型[数组长度];

声明数组、分配空间、赋值合并写

数据类型[] 数组名 = new 数据类型[]{数据1，数据2，……，数据n} 

数据类型 数组名[] = new 数据类型[]{数据1，数据2，……，数据n}

注意：等号后面的[]里不要写数组长度，写了会报错

声明数组、分配空间、赋值合并写的简写方式，也是最常用的方式

数据类型[] 数组名={数据1，数据2，……，数据n}

数据类型 数组名[]={数据1，数据2，……，数据n}

获取数组中元素的个数：数组名.length

int size = nums.length;
System.out.println("个数为："+size);

遍历：按照元素在数组中的顺序输出

        for(int i=0;i
		System.out.print(nums[i]+" ");
		}

  遍历还可以使用增强for循环来进行遍历

for(数据类型 变量名:数组名){
 System.oout.println(变量名)
}

执行规律按照数组中元素的顺序依次将元素取出来存入到变量a中，这个时候操作变量a就相当于操作数组里面的元素

数组与内存空间的关系

栈和堆都是内存，可以想象成内存中两块不一样的区域。

栈内存 大小固定 用于存储局部 临时变量(基本数据类型)和引用变量

堆内存 大小不固定 用于存储对象

变量x的值存的时栈中的一个地址（这个地址一般是16进制），地址里面再指向一块堆的存贮空间，数组的内存空间是一块连续的空间。比如：

int[] i={1,2,3,4,5};

可以想象成再这个空间里面有五个小格，第一个格子是1，第二个格子是2……。栈内存的地址有个指向，指向了这块堆内存的首地址。即可以通过栈内存中的地址找到首地址，而要找里面的元素就要使用到下标，就可以找到数据。

---

http://t.csdn.cn/XrAcahttp://t.csdn.cn/XrAca

数组的常用操作

查:

查询数组里的某个元素
很简单，System.out.println(nums[3]);

遍历数组:按照元素在数组中的顺序，依次输出所有的元素
for(int i=0;i
System.out.print(nums[i]);
}

找出数组中的最大(小)值
以找最大值为例

思路

①假设数组中的第一个元素的最大值

②依次取出后面的元素与假设的最大值进行比较，如果后面的元素比假设的最大值大，取代它成为新的最大值，如果比假设的最大值小，不进行替换，继续向后比较

③一直比较到最后一个元素，就可以获得数组中的最大值

例：输出五位同学的分数，并输出最高分数

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double[] scores = new double[5];
        double max = scores[0];
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第" + (i + 1) + "位同学的分数");
            scores[i] = sc.nextDouble();
            if (scores[i] > max) {
                max = scores[i];
            }
        }
        System.out.println("最高分为" + max);
    }

 增

①新建一个比原来数组长度大1的数组（长度按照插入的数据个数定）

②将原来数组里的元素按照顺序，存储到新的数组中

③使用Scanner获取要增加的数据

④通过循环比较获取要插入的位置

⑤从插入位置开始及之后的元素依次往后移动

 必须是后面的元素先往后移前面的才往后移

比方说原来的数组i下标为4，新的数组j的下标就为5，J[5]在赋值的时候没有参与，所以它是默认的数值0，所以这里就是先从j[4]最先开始向后移，然后前面的依次向后移。

删

删除指定位置的元素

从删除位置之后的元素依次往前移动一位，最后一位元素值赋予对应类型的初始值

最后一位元素值赋予对应类型的初始值,只有当删除位置处于0-6之间的时候删除元素才会操作

冒泡排序

每次比较相邻两数，小的交换到前面，每轮结束后最大的数交换到最后

如这样的一个数组[11,5,80,25,62],可以发现第一轮，比较了4次，第二轮，比较了3次，第三轮，比较了2次，第四轮：比较了1次

这样就可以想到之前使用双重循环结构输出图形，外层循环控制行，内层循环控制列。在这里面是外层循环控制比较轮数，内层循环控制比较次数。
 

此外还有快速排序和直接插入法，博文的地址在这里：   冒泡排序，选择法，直接插入法

Arrays类

boolean equals(array1,array2)------比较array1和array2两个数组是否相等

sort(array)------对数组array的元素进行升序排列

String toString(array)------将一个数组array转换成一个字符串

void fill(array,val)------把数组array所有的元素都赋值为val

copyOf(array,length)---把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致

int binarySearch(array,val)----查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

二维数组

http://t.csdn.cn/5PcLFhttp://t.csdn.cn/5PcLF

多维数组

三维及以上的数组很少使用
主要使用二维数组
从语法上java支持多维数组
从内存分配原理的角度讲，只有一维数组

即数组的嵌套，数组里面的元素又是一个数组

步骤：

分步写

①、声明二维数组，数据类型[][] 数组名 ； 或者 数据类型 数组名[][]

        //声明一个int类型的二维数组
        int[][] nums;
        //声明一个String类型的二维数组
        String[][] strs;
②、分配空间(告诉你这个数组里可以存储多少个元素)  数组名 = new 数据类型[数组长度][数组长度];或者 数组名= new 数据类型[数组长度][]；

注意：二维数组在分配空间的时候第一个数组长度必须要写告诉你这个二维数组里面有多少个元素，第二个数组长度可以不写，如果写了，表示这个二维数组里的元素（一维数组）的长度,如果没有写，这个二维数组里面的元素(一维数组)长度可以不一样

③、赋值：数组名[下标][下标] = 数据;

④、操作数据:数组名[下标][下标];

二维数组的声明和分配空间合并写：

数据类型[][] 数组名 =  new 数据类型[数组长度][数组长度]或数据类型[][] 数组名 =  new 数据类型[数组长度][]

二维数组的声明、分配空间、赋值合并写：

数据类型[][] 数组名 = new 数据类型[][]{{数据1,数据2,……,数据n},{数据1,数据2,……,数据n},……,{数据1,数据2,……,数据n}}; 

注意：new后面的两个[]里都不能写长度

二维数组的声明、分配空间、赋值合并写的简写方式

数据类型[][] 数组名 = {{数据1,数据2,……,数据n},{数据1,数据2,……,数据n},……,{数据1,数据2,……,数据n}};

注意：new后面的两个[]里都不能写长度

二维数组&多维数组的遍历 

//二维数组    
public static void main(String[] args) {
		// 遍历二维数组
		int[][] nums = {{1,2,3},{44,5},{9}};
		for(int i=0;i
			//nums[i]又是一个一维数组，对这个一位数组nums[i]再次遍历，现在将nums[i]改名为number
			for (int j = 0; j < nums[i].length; j++) {
				System.out.print(nums[i][j]+"\t");
			}
			System.out.println();
		}
 
	}
//三维数组
    public static void main(String[] args) {
		//三位数组
		int[][][] nums={{{1,5,6,7},{3,2,5,6},{7,8,9,4,4}},{{12,25,60,37},{3,2,5,6},{7,82,90,40,40}},{{1,5,66,27},{3,2,55,76},{7,8,79,74,4}}};
		//遍历三维数组
		for (int i = 0; i < nums.length; i++) {
			for (int j = 0; j < nums[i].length; j++) {
				for (int k = 0; k < nums[i][j].length; k++) {
					System.out.print(nums[i][j][k]+" ");
				}
				System.out.println();
			}
			System.out.println();
		}
	}

类和对象

http://t.csdn.cn/SPqfWhttp://t.csdn.cn/SPqfW

对象

万物皆对象
对象是指现实世界中的一个事物

对象用来描述客观事物的一个实体，由一组属性和方法构成

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

面向对象是把解决的问题按照一定规则划分为多个独立的对象，然后通过调用对象的行为（方法）来解决问题,面向过程就是分析解决问题所需要的步骤。

 面对对象的三大特点：封装，继承，多态（如果是四大特点还要加一个接口）
                封装性：类是将属性和行为封装在一起，共同描述同类事物的特性的，在Java中，属性用变量来刻画，行为用方法来体现，属性是数据，方法是数据操作。
                继承性：子类可继承父的属性和行为，同时又可以增添子类独有的属性和行为。比如“人类”是“哺乳类”的子类，哺乳类描述该类共同的属性和行为，人类继承了哺乳类所有属性和行为，同时又增加了人类独有的属性和行为。
                多态性： 多态有两种，一种是操作（方法）名称多态，是指多个方法，名称相同，因接收消息不同，产生不同行为（重载）另一种是继承中的多态，不同子类对象对同一方法产生不同行为，如哺乳类“喊叫”，猫和狗是不同的（子在继承你类方法，对其进行了修改，在不同子类中产生不同的行为-重写 ）

属性

对象具有的各种特征，每个对象的每个属性都拥有特定值

定义属性：访问权限修饰符(暂时不写) 属性类型(数据类型) 属性名(变量名)

方法

对象执行的操作   
定义方法:访问权限修饰符 返回值类型 方法名(参数列表){方法体}

方法根据是否有返回值分为：无返回值的方法和有返回值的方法
   方法没有返回值，返回值类型为void
   方法有返回值，返回值是什么类型就写什么类型，返回值类型可以是基本数据类型也可以是引用数据类型，方法有返回值，需要使用return将结果返回

1.方法需要通过对象来调用
2.调用的方法没有返回值，不需要用变量接受
3.调用有返回值的方法，可以根据情况决定时候用变量来接收返回值
   方法根据有没有参数分为无参方法和有参方法
   定义无参方法

public void noParameter(){
   System.out.println("我是一个无参方法");
}

  定义有参方法

public void havaOneParameter(int num){
  System.out.println("你传进来的参数是"+num);
}

有参方法跨号中的参数仅仅只是一个变量而已，形式参数。调用方法中输出的才是实参，实际参数

类

具有相同属性和方法的一组对象的集合，类是抽象的概念

类是同一类事物的统称,具有相同特征和行为的一类事物就称为类.

类是模板，确定对象将会拥有的特征（属性）和行为（方法）

类是一种数据类型，不同于int类型：具有方法，对象是类这种类型变量。即类是用来创建对象的模板
            public class  类名 {
        //定义属性部分
        属性1的类型 属性1;
          …
        属性n的类型 属性n;
        //定义方法部分
        方法1;
        …
        方法m;
}
 class是关键字，用来定义类。“class  类名”是类的声明部分，类名必须是合法的Java标识符。两个大括号以及之间的内容是类体。 

类是对象的抽象，对象是类的具体

方法

方法的定义语句 访问权限修饰符 返回值类型 方法名（数据类型 变量名1，数据类型 变量2……数据类型 变量n）

访问权限修饰符 有四种

public（公共的）

private（受保护的）

默认的（不写修饰符）

private（私有的）

返回值类型

没有返回值的时候写void

有返回值，返回值可以是基本数据类型也可以是引用数据类型

方法名

采用小驼峰命名法

见名知意

方法的参数列表

可以有也可以没有，有参数的时候，可以有一个，也可以有多个

方法体

方法具体能干什么事情的代码

方法根据是否有返回值和参数分类
        无返回值的无参方法
        无返回值的有参方法
        有返回值的无参方法
        有返回值的有参方法

调用返回值的注意事项
        调用一个有返回值的方法，对于返回的结果，可以直接输出，也可以使用返回类型的变量去接收返回值

调用需要传递参数的有参方法注意事项
        方法需要多少个参数，你就要传递多少个参数，并且需要按照其定义的顺序传递

 综上所述：调用方法有两个原则是
        1）给什么结什么---》返回什么结果给你，你就用什么变量接收
         2）要什么给什么---》方法需要什么参数，你就给什么参数

http://t.csdn.cn/UwkIWhttp://t.csdn.cn/UwkIW

方法调用

方法之间允许相互调用，不需要知道方法的具体实现，实现重用，提高效率

有两种情况，以student类中的方法为例

①、student类的方法a(),调用student类的方法b，可以直接调用

public class Student {
//定义方法a
    public void a(){
        System.out.println("我是Student类中的方法a");
    }
    
    public void b(){
        System.out.println("我是Student类中的方法b");
        a();
    }
}

②、 student类的方法a()调用Teacher类的方法b()，先创建类对象，然后使用“.”调用

 
public class Teacher {
	//定义方法c
	public void c() {
		System.out.println("我是Teacher类里的方法c");
		//调用Student类里的方法a,不能直接调用，需要使用Student对象调用
		//a();
		Student stu = new Student();
		stu.a();
	}
}

带参方法

为什么要使用带参方法：不同对象对同一方法产生不同的行为。比如用榨汁机榨汁汁，不同的水果汁是不一样的

如何使用带参数的方法：

定义参数的方法

<访问修饰符>  返回类型  <方法名>(<形式参数列表>) {
        //方法的主体
}

调用参数的方法

对象名.方法名（参数1，参数2，……，参数n）；

 形参和实参数据类型，数量，顺序都要一致！！！

方法传参

方法中最重要的部分之一就是方法的参数，参数属于局部变量，当对象调用方法时，参数被分配内存空间，并要求调用者向参数传递值，即方法被调用时，参数变量必须有具体的值，局部变量是在调用方法时分配内存

基本数据类型和引用数据类型数据在传参时的区别

1.基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。就像a找我借数据，我觉得a不靠谱所以就拷贝一份发给他，那份文件a怎么搞都跟我电脑里的数据无关，我的数据也不会因为a的操作而改变

2.引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用。就像b又找我要数据，我觉得b靠谱，我就直接把电脑借给她操作，她的操作对我的数据是由影响的

 方法实现了一段代码的重复使用