第6天----二维数组，类

知识总结

• 1.函数后半部分
  • 局部变量和全局变量
  • 重载
  • 函数在内存中的体现
• 2.数组
  • 一维数组
  • 数组的作用
  • 数组的组成
  • 数组的内存展示
  • 数组的赋值取值
  • 数组的遍历
  • 数组的址传递和址传递

二维数组

• 一维数组：内部直接存储是数组
• 二维数组： 内部存储的是多个一维数组的地址（二维数组的元素就是多个一维数组）
• 二维数组:
• 数据类型+[]+[]
• = 后面的构成：new + 数据类型+[一位数组的个数]+[一维数组中元素的个数]
• 注意：第一个[]中必须填，第二个可以填，在这个值如果填了，是一个建议值；
• 二维数组的元素默认值是null

public static void main(String[] args) {
		/*
		 * 一维数组：内部直接存储是数组
		 * 二维数组：	内部存储的是多个一维数组的地址（二维数组的元素就是多个一维数组）
		 * 
		 * 
		 * 	 
		 */
		
		//一维数组
		int[] arr1 = {3,4};
		
		//二维数组:
		//数据类型+[]+[]
		//= 后面的构成：new + 数据类型+[一位数组的个数]+[一维数组中元素的个数]
		//注意：第一个[]中必须填，第二个可以填，在这个值如果填了，是一个建议值；
		//二维数组的元素默认值是null
		//赋值取值
		int[][] arr2 = new int[2][];
		arr2[0] = new int[] {3,4};
		arr2[1] = new int[]{3,4,5};
		
		//取值
		System.out.println(arr2[0][0]);
		//遍历
		for(int i = 0;i < arr2.length;i++) {
			for(int j = 0;j < arr2[i].length;j++) {
				System.out.print(arr2[i][j]);
			}
			System.out.println();
		}
		//其他的创建二维数组的方式
		int[][] arr3 = {{3,4},{5,7},{3,4,5,6}};
	}

增强for循环

• 通过增强for循环遍历二维数组
• for(数组中的元素：数组){循环体}
• 工作原理：开始循环后先从数组中取出第一个元素，放入：前面的变量中，当次循环使用的就是这个值，第一次循环结束
• 会自动从数组中取出第二个元素，再次放入：前面的变量中，依次进行，直到所有的元素遍历完，结束遍历

		for (int[] is : arr2) {
			for (int i : is) {
				System.out.print(i);
			}
			System.out.println();
		}

数组常用的方法

• 排序
  • 冒泡排序，选择排序
• 查找：
  • 二分查找
  • 冒泡排序

	public static void bubbleSort(int[] arr) {
		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]) {
					arr[j]=arr[j]^arr[j+1];
					arr[j+1]=arr[j]^arr[j+1];
					arr[j]=arr[j]^arr[j+1];
				}
			}
		}
	}

• 选择排序

public static void SelectSort(int[] arr) {
		for(int i = 0;i<arr.length-1;i++) {//确定的整体的次数，比较的次数比元素少一
			for(int j = i;j<arr.length-1;j++) {//确定一个元素的时候需要比较的次数
				//当前面的数比后面的数大，交换两个数的值
				if(arr[i] > arr[j+1]) {
					arr[j+1]=arr[j+1]^arr[i];
					arr[i]=arr[j+1]^arr[i];
					arr[j+1]=arr[j+1]^arr[i];
				}
			}
		}
	}

• 查找：
  • 注意点：
  • 1.查到值时----返回值的下标
  • 2.未查到值时----返回负一
  • 3.当有相同的值出现时，按照当前查找方法返回查到的第一个值得下标，结束查找
• 二分查找
• 二分查找进行时必须保证数组是有序的

	public static int erFenSearch(int[] arr,int key) {
		int h = arr.length-1;
		int l = 0;	
		while(l <= h) {
			int m = (h+l)/2;
			if(arr[m]==key) {
				return m;
			}else if(arr[m] >key) {
				h = m-1;
			}else if(arr[m] < key) {
				l = m+1;
			}
		}
		return -1;//没有找到值
	}

• 1.普通查找

	public static  int search(int[] arr,int key) {
		for(int i = 0;i <arr.length;i++) {
			if(arr[i] ==key) {
				return i;
			}
		}
		return -1;
	}

类

创建类

• 设计一个类–需要遵守规则
• 名字：大驼峰原则
• 属性：小驼峰原则
• 行为：小驼峰原则
• 实例：人
• 名字：Person-------必须写
• 属性：姓名：name 年龄：age -----可以省略
• 行为：跑：run 吃：eat 打电话：callPhone（String number）-----可以省略

class Person{
	//属性-----成员变量（全局变量）
	String name;
	int age;
	//行为--成员方法（函数）
	public void run() {
		System.out.println("run");
	}
	public void eat() {
		System.out.println("eat");
	}
	public void callPhone(String number) {//成员变量可以在方法中直接使用
		System.out.println(name+"给"+number+"打电话");
	}
}

创建类的对象

• 创建Person类型的对象
• 对象也是被放在堆里，对象也是通过new创建出来的
• 对象的构成：new+类名+()，其实类名+（）是一个整体，是一个方法，叫做构建方法
• 作用：new：1.开辟空间 2.将对象的地址返回
• 构造方法的作用：用来对对象的属性进行初始化，是简单数据类型初始化成0或false，如果是引用数据类型，初始化成null
• 当我们创建一个类出来，就相当于创建了一个新的类型
• =后面是对象的实体，=前面是引用数据类型，保存着对象的地址

	public static void main(String[] args) {
		Person p  = new Person();
		//给属性复制，调用方法---java的，语法实现
		p.age = 40;
		p.name = "bingning";
		p.eat();
		p.run();
		p.callPhone("110");
		
		//说明一个类可以创建多个对象，对象之家没有任何关系，互不影响
		Person p1  = new Person();
		p1.name = "chenchen";
		p1.callPhone("119");

类与类之间的关系：组合

• 创建一个房子类
• 房子里面有耗子，床，人
• 当两个类之间产生拥有的关系-----组合；是否可以用谁拥有谁描述

    public static void main(String[] args) {
   	//测试
   	House house = new House();
   	house.name = "海景房";
   	house.mouse = new Mouse();
   	house. mouse.name= "家鼠";
   	
   	Bed bed = new Bed();
   	bed.name ="席梦思";
   	house.bed = bed;
   	System.out.println(house.bed);
   	
   }

class House{
   String name;
   Mouse mouse;
   Bed bed;
   Person1 person1;
}
   
class Mouse{
   String name;
}
class Bed{
   String name;
}
class Person1{
   String name;
}