/*


1.定义一个函数，函数功能是动态提取int[]中元素的最大值。

2.定义一个函数，从数组中查询指定的元素首次出现的位置。

3.定义函数，完成冒泡排序，大数下沉。

4.折半查找。

5.阐述

6.定义一个函数，实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。

7.遍历三维组数，横向输出三维数组的每一个层。

8.定义一个类:Dog 有名称 color age cry();

9.阐述出来堆区，栈区，何时出现溢出，如何解决。

10.oop


------------------------------------------------------------------


*/

1.定义一个函数，函数功能是动态提取int[]中元素的最大值。


class GetArrayMax

{

//打印函数

public static void sop(String str)

{

System.out.println(str);

}

public static void main(String[] args)

{

sop("数组中的最大值为"+getMax(new int[]{1,2,9,3,7}));

}

//1、获取int[]中元素最大值

public static int getMax(int[] arr)

{

if(arr==null||arr.length==0)

{

System.out.println("数组输入异常");

return -1;

}

int temp = arr[0];

for(int i=1;i<arr.length;i++)

{

if(arr[i]>temp)

temp=arr[i];

}

return temp;

}

}



2.定义一个函数，从数组中查询指定的元素首次出现的位置。

class GetArrayIndex

{

//打印函数

public static void sop(String str)

{

System.out.println(str);

}

public static void main(String[] args)

{

sop("指定元素在数组中的角标位置为"+getIndex(new int[]{1,2,9,3,7},7));

}

public static int getIndex(int[] arr,int key)

{

for(int i=0;i<arr.length; i++)

if(arr[i]==key)

return i;

return -1;

}

}



3.定义函数，完成冒泡排序，大数下沉。

class BubbleSort

{

//打印函数

public static void sop(String str)

{

System.out.println(str);

}

//打印一维数组

public static void printArray(int[] arr)

{

System.out.print("[");

for(int i=0;i<arr.length;i++)

{

if(i==arr.length-1)

System.out.print(arr[i]+"]");

else

System.out.print(arr[i]+",");

}

System.out.println();

}

public static void main(String[] args)

{

int[] arr =bubbleSort(new int[]{1,2,9,3,7});

sop("排序后数组如下：");

printArray(arr);

}

public static int[] bubbleSort(int[] arr)

{

for(int i=0;i<arr.length-1;i++)

{

for(int j=0;j<arr.length-i-1;j++)

{

int temp=0;

if(arr[j]>arr[j+1])

{

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

return arr;

}

}


4、折半查找

/*

思路：定义min,max，mid三个数组角标变量，每次二分，将key与arr[mid]处值比较

key>arr[mid],则key的角标在[mid+1,max]之间

key<arr[mid],则key的角标在[min,mid-1]之间

key=arr[mid],返回mid角标，

循环条件为min<max，当min>max时，max-min=负数，说明二分后没有找到该元素。

*/

class HalfSearch

{

//打印函数

public static void sop(String str)

{

System.out.println(str);

}

public static void main(String[] args)

{

sop("折半查找出指定元素位置为："+halfSearch(new int[]{1,2,9,3,7},9));


}

public static int halfSearch(int[] arr,int key)

{

int mid,min=0,max=arr.length-1;

while(min<=max)

{

mid=(min+max)/2;

if(arr[mid]==key)

{

return mid;

}

else if(arr[mid]<key)

{

min=mid+1;

}

else

{

max=mid-1;

}

}

return -1;

}

}


5、阐述：（各个题目的思路已经注释在代码中，这里借鉴老师的，系统复习下）

1) 获取数组的最大值,解决方法:遍历整个数组,通过if条件判断比较出最大值

2) 查询数组中某个值,解决方法:遍历整个数组,if条件判断,查找到这个值时,跳出循环

3) 冒泡排序:将最小/最大的数,依次沉到数组的最后完成排序.

外层循环需要进行array.length-1次,内层循环需要比较array.length-i-1次.

4) 二分查找法:要求有序数组,通过比较中间值和查找值,确定查找值所在位置(中间值的左或右),进行多次循环查找找到值的真正所在.

5) 矩阵转置问题:涉及矩阵初始化,赋值操作,转置操作注意只需对左下正三角的值进行对位交换array[i][j]=array[j][i].

6) 三位数组:抽象为魔方,分为层,每层的每行,每层的每行的每列.通过循环控制,可以横向以及纵向打印每层.具体参见代码.

7)面相对象:涉及面相对象类的定义,对象的生成,构造函数,修饰符,javabean技巧,对封装的理解.




6.定义一个函数，实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。

/*

思路:矩阵在计算机当中其实是一个二维数组arr[i][j]

i表示矩阵的行，j表示矩阵的列。

转置操作的原理是将矩阵各个位置上的元素的行列角标互换

我们知道，对角线上的数行列互换相等，

*/

class TransMatrix

{

//打印函数

public static void sop(String str)

{

System.out.println(str);


}

//打印二维数组

public static void printArray(int[][] arr)

{

for(int i=0;i<arr.length;i++)

{

for(int j=0;j<arr[i].length;j++)

{

System.out.print(arr[i][j]+"  ");

}

System.out.println();

}

}

public static void main(String[] args)

{

int[][] arr1 = new int[][] {{1,2,3},{4,5,6},{7,8,9}};

printArray(arr1);

transMatrix(arr1);

sop("--------------转置后如下----------------");

printArray(arr1);

}

public static int[][] transMatrix(int[][] arr)

{

for(int i=0;i<arr.length-1;i++)

{

for(int j=i+1;j<arr[i].length;j++)

{

int temp = arr[i][j];

arr[i][j]= arr[j][i];

arr[j][i]= temp;

}

}

return arr;

}

}


7.遍历三维组数，横向输出三维数组的每一个层。


/*

思路：三维数组arr[i][j][k]由多个二维数组组成，二维数组由多个一维数组构成。

对应的角标i,j,k可以看成数学上的空间直角坐标系的z轴，x轴，y轴，

我们需要横向输出三维数组的每一个层，也就是说打印第一层的的第一行所有列元素后，

继续打印第二层的第一行元素，而不是打印第一层的第二行元素，接着打印第三层的第一行元素。

第二行元素和第三行元素打印同理。

arr[i][j][k]中i控制层数，j控制每层的行，k控制每层的列。

所以行数j控制外层循环，i控制第二层循环（因为打印一行元素后需要换层），

k控制最内层循环输出具体位置上元素。

从矩阵的角度来理解就更容易了，三维数组其实就是并列的三个二维矩阵。

横向打印三维数组其实就是逐次打印三个矩阵的第一行，第二行，第三行。



*/

class ThreeArray

{

public static void main(String[] args)

{

int[][][] arr = new int[][][]

{

{{1,2,3},{4,5,6},{7,8,9}},

{{1,2,3},{4,5,6},{7,8,9}},

{{1,2,3},{4,5,6},{7,8,9}}

};

printThreeArray(arr);

}

public static void printThreeArray(int[][][] arr)

{

for(int i=0; i<arr[0].length;i++)    //注意：这里不能写arr[i].length

{

for(int j=0;j<arr.length;j++)

{

for(int k=0;k<arr[i][j].length;k++)

{

System.out.print(arr[i][j][k]+"  ");

}

System.out.print(" | ");

}

System.out.println();

}

}

}





8.定义一个类:Dog 有名称 color age cry();

//8.定义一个类:Dog 有名称 color age cry();

class DogDemo

{

public static void main(String[] args)

{

Dog dog = new Dog("lucy",2);

dog.setColor("黑色");

System.out.println(dog.getName()+"是一条"+dog.getAge()+"岁的，"+dog.getColor()+"的狗");

dog.cry();

dog.setName("judy");

dog.setAge(3);

System.out.println(dog.getName()+"是一条"+dog.getAge()+"岁的，"+dog.getColor()+"的狗");

}

}

class Dog

{

private String name;

private String color;

private int age;

public Dog(String name,int age)

{

this.name=name;

this.age=age;

}

public void cry()

{

System.out.println("Dog会哭的功能！");

}

public void setName(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

public void setColor(String color)

{

this.color = color;

}

public String getColor()

{

return color;

}

public void setAge(int age)

{

this.age = age;

}

public int getAge()

{

return age;

}

}


9.阐述出来堆区，栈区，何时出现溢出，如何解决。

答：

堆区:保存对象以及成员变量

栈区:保存方法以及局部变量

溢出条件:产生过多或者占用内存很大的对象函数递归调用自身可能出现栈区溢出

如何解决:1.尽可能不产生不必要的对象或成员变量1.递归操作要小心

2.设置JAVA虚拟机堆大小(java -Xms<size>) 2.采用非递归手段

10 oop

面向对象:是相对面向过程而言的一种编程方式,将问题简单化.是对客观事物的抽象，使编程更加符合人的思维模式。


类:是对象的共性的抽象.比如汽车图纸

对象:是类的具体实现.比如具体的宝马汽车

实例:就是对象.通过new关键字来创建

成员变量:对象的属性变量.

成员函数:对象的方法.

public:用于修饰成员变量或者成员函数,表示公有,供其他类调用.

private:用于修饰成员变量或者成员函数,表示私有,用于封装,提高数据安全性,可通过set,get方法进行属性的改变,获取

构造函数: 用于初始化对象.函数没有返回值.

this:是对象的成员变量,指向当前的对象,用于类中方法引用当前对象.

super:是父类对象的成员变量，指向父类对象，用于类中引用父类的成员

static:静态的,修饰成员变量,同类对象所共有,类也可以引用静态成员,静态方法只能访问静态成员.静态成员可以通过类名直接调用

由于static修饰的成员是同类对象所共有，因此通常修饰共享数据，但是static修饰的变量生命周期较长，谨慎使用。

比如在多线程技术中使用同步来解决共享数据安全的问题。