数组和面向对象01

数组：相同数据类型数据的有序集合
一维数组
1、数组的创建
(1)动态创建，先声明后赋值，须指定数组长度
数据类型[] 变量名=new 数据类型[长度]；

int[] arr3=new int[3];

(2)静态创建1
数据类型[] 变量名=new 数据类型[]{数据1,数据2,…}；

int[] arr1=new int[]{1,2,3,4};

(3)静态创建2
数据类型[] 变量名={数据1,数据2,…}；
int[] arr2={5,6,7};
注意：静态创建2情况数组不可改变
2、为数组进行赋值 =

int[] arr3=new int[3];
arr3[0]=90;
arr3[1]=0;
arr3[2]=9;

3、使用下标获取数组中的数据

//声明数组
int[] arr3=new int[3];
//为数组赋值
arr3[0]=90;
arr3[1]=0;
arr3[2]=9;
//获取并输出数组的第一个数据
System.out.println(arr3[0]);

4、遍历数组

//增强for遍历数组
for(int aa:arr3){
	System.out.println(aa);
 }
//普通for遍历
for(int i=0;i<arr3.length;i++){
	System.out.println(arr3[i]);
}

二维数组
1、数组的创建
（1）动态创建
数据类型[][] 变量名=new 数据类型[外层数组长度][内层数组长度]；
注意：内存数组长度在声明时可以不指定，外层数组长度必须指定

int[][] arr1 = new int[2][2];
int[][] arr2 = new int[2][];

（2）静态创建
数据类型[][] 变量名=new 数据类型[][]{{数据1，数据2…},{数据1，数据2…},{数据1，数据2…}…}；

char[][] arr3= new char[][]{{'1','2'},{'2','3','4'},{'4','5','6'}};

数据类型[][] 变量名={数据1，数据2…},{数据1，数据2…},{数据1，数据2…}…}；

char[][] arr3= {{'1','2'},{'2','3','4'},{'4','5','6'}};

2、二维数组的赋值

int[][] arr1 = new int[2][2];
arr1[0][0]=31;
arr1[0][1]=32;
arr1[1][0]=33;
arr1[1][1]=34;        

3、二维数组的取值

System.out.println(arr1[0][0]);

4、二维数组的遍历：双重for循环

//普通for嵌套增强for
int[][] arr1=new int[][]{{1,111,3},{3,14,5},{122,33,4}};
for(int i=0;i<arr1.length;i++){
   for(int aa:arr1[i]){
     System.out.println(aa);
   }
 }

//普通for嵌套普通for
for(int i=0;i<arr1.length;i++){
    for(int j=0;j<arr1[i].length;j++){
        System.out.println(arr1[i][j]);
    }
}

//增强for嵌套增强for
for(int[] a1:arr1){
    for(int aa:a1){
        System.out.println(aa);
    }
}

//增强for嵌套普通for
for(int[] a1:arr1){
	for(int i=0;i<a1.length;i++){
        System.out.println(a1[i]);
     }
}

Arrays工具类简单使用
1、一维数组的比较
Arrays.equals(数组1, 数组2)

//equals比较的是内容 == 比较的是对象
int[] a= {1,2,3};
int[] a1= {1,2,3};
System.out.println(Arrays.equals(a, a1));//true
System.out.println(a==a1);//false

2、一维数组的输出
Arrays.toString(数组)

System.out.println(Arrays.toString(a));//[1, 2, 3]
System.out.println(a.toString());//[I@15db9742

3、多维数组的比较
Arrays.deepEquals(数组1, 数组2)
4、多维数组的输出
Arrays.deepToString(数组)

int[][] aa= {{1,2,3,4},{2,3,4},{32,2,3}};
char[][] aa1= {{'q','w'},{'s','d'},{'e'}};
char[][] aa2= {{'q','w'},{'s','d'},{'e'}};
System.out.println(Arrays.deepEquals(aa1, aa2));
System.out.println(Arrays.deepToString(aa));

5、数组的拷贝
（1）Arrays.copyOf(原数组, 新数组长度)

int[] a3= {11,2,3,34,5,44};
System.out.println(Arrays.toString(Arrays.copyOf(a3, 6)));//新旧数组长度一致:拷贝
System.out.println(Arrays.toString(Arrays.copyOf(a3, 3)));//新数组长度<旧数组长度:截取
System.out.println(Arrays.toString(Arrays.copyOf(a3, 9)));//新数组长度>旧数组长度:填充

（2）Arrays.copyOfRange(原数组, 起始位置，结束位置)

int[] a3= {11,2,3,34,5,44};
System.out.println(Arrays.toString(Arrays.copyOfRange(a3, 1, 4)));

6、数组排序
Arrays.sort(a3数组)

int[] a3= {11,2,3,34,5,44};
Arrays.sort(a3);

7、二分查找
Arrays.binarySearch(数组, 查找的数据)
注意：在数据中找到该数据返回‘数据的下标’，否则返回‘负的插入点-1’

int[] a3= {11,2,3,34,5,44};
System.out.println(Arrays.binarySearch(a3, 2));
System.out.println(Arrays.binarySearch(a3, 12));

结果：

面向对象
1、类和对象：类使对象的模型，对象是类的具体实现
2、创建对象：使用关键字new

Baby baby = new Baby();

3、获取成员变量，调用成员方法：
对象.成员变量;

baby.name；

对象.成员方法();

baby.cry();

类与对象的实现：

public class Baby {
	//成员变量
	public String name;
	//成员方法
	public void cry() {
		System.out.println("baby一饿就哭，哇哇大哭");
	}
	public void sleep() {
		System.out.println("baby每天大部分时间都在睡觉");
	}
}
//测试类
public class TestObj {
	public static void main(String[] args) {
	//创建Baby对象
	Baby baby = new Baby();
	//为变量赋值
	baby.name="bubu";
	//调用成员方法
	baby.cry();
	baby.sleep();
	System.out.println(baby.name+"今天很乖哦");
	}
}