1.定义一个函数，函数功能是动态提取int[]中元素的最大值。
2.定义一个函数，从数组中查询指定的元素首次出现的位置。
3.定义函数，完成冒泡排序，大数下沉。
4.折半查找。
5.阐述
6.定义一个函数，实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。
7.遍历三维组数，横向输出三维数组的每一个层。
8.定义一个类:Dog 有名称 color age cry();
9.阐述出来堆区，栈区，何时出现溢出，如何解决。
10.oop
---------------------------------------------------
解答：获取数组中最大值
class ArrayMax {
public static void main(String[] args){
System.out.println(arraymax(new int[]{1,2,3,6,33,76,23}));
}
public static int arraymax(int[] arr){
if(arr ==null){
System.out.println("数组不存在");
return -1;
}
int temp =arr[0];
for(int i=0;i
if(temp
temp=arr[i];
}
}
return temp;
}
}
2.从数组中查询指定的元素首次出现的位置
class SearchArray{
public static void main(String[] args){
//System.out.println("第一次位置是第"+(searchArray(5,new int[]{1,2,4,5,7,8})+1)+"个数");
searchArray(5,new int[] {1,2,4,5,7,8});
}
public static void searchArray(int num,int[] arr){
// int a=-1;
for(int i=0;i
if(arr[i]==num){
System.out.println("这个数第一次位置是第"+(i+1)+"个数");
}
}
}
}
3.定义函数，完成冒泡排序，大数下沉。
/*
冒泡排序，大数下沉
*/
class BubbleSort{
public static void main(String[] args){
//outArray(getSort(new int[]{9,5,4,5,1,7}));
outArray(getSort(new int[]{55,8,7,9,3,1,4,11,15,6,50,45,33,30}));
}
//定义一个冒泡排序方法
public static int[] getSort(int[] arr){
//外层循环决定排序几次
for(int i=0;i
//内层循环决定大数下沉走几步
for(int j=0;j
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
//定义一个输出数组的方法
public static void outArray(int[] arr){
for(int i=0;i
System.out.print(arr[i]+" ");
}
}
}
4.折半查找。
class BinarySelect{
public static void main(String[] args){
System.out.println(getValue(new int[]{1,2,3,4,5,6,7,8},6));
}
public static int getValue(int[] arr,int x){
int a=0;
int b=arr.length-1;
int m=0;
//int minindex=0;
while(a<=b){
int minindex=(a+b)/2;
m=arr[minindex];
if(m==x){
return minindex;
}
else if(m>x){
b=minindex-1;
}
else {
a=minindex+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)面相对象:oriented object program 面向对象编程 一切皆对象
涉及面相对象类的定义,对象的生成,构造函数,修饰符,javabean技巧,对封装的理解.
6.定义一个函数，实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。
//转置数组
class ArrayTransDemo{
public static void main(String[] args){
transDemo(new int[][] {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25}});
}
public static void transDemo(int[][] arr){
for(int i=0;i
for(int j=i+1;j
int a=arr[i][j];
arr[i][j]=arr[j][i];
arr[j][i]=a;
}
}
//输出数组
for(int i=0;i
for(int j=0;j
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
7.遍历三维组数，横向输出三维数组的每一个层
/*
*遍历三维组数，横向输出三维数组的每一个层
*/
class MagicArray{
public static void main(String[] args){
int[][][] arry=new int[][][]{{{1,2,3},{4,5,6},{7,8,9}},{{10,11,12},{13,14,15},{16,17,18}},{{19,20,21},{22,23,24},{25,26,27}}};
magicCube1(arry);
}
//纵向输出三维数组
public static void magicCube(int[][][] arr){
for( int i=0; i
for( int j=0; j
for( int k=0; k
System.out.print(arr[i][j][k] +" ");
}
System.out.println();
}
System.out.println("------------------------------");
}
}
//横向输出三维数组方法
public static void magicCube1(int[][][] arr){
for( int i=0; i
for( int j=0; j
for( int k=0; k
System.out.print(arr[j][i][k] +" ");
}
System.out.print("\t"+"|"+"\t");
}
System.out.println();
}
}
}
8.定义一个类:Dog 有名称 color age cry();
class DogDemo{
public static void main(String[] args){
Dog d=new Dog();
d.cry();
//new Dog().cry();
System.out.println(d.getName());
d.setName("hetao");
//System.out.println(d.name);
System.out.println(d.getName());
}
}
class Dog{
private String color="black";
private int age=3;
private String name="xiaobai";
//构造方法
public void Dog(String name){
//name="n";
this.name=name;
}
public void setName(String name){
this.name=name;
//name="n";
}
public String getName(){
return this.name;
}
//属性私有化 不能用静态方法调用
public void cry(){
System.out.println(name +" "+ age+" "+"wawa");
}
}
9.阐述出来堆区，栈区，何时出现溢出，如何解决。
答：
堆区:保存对象以及成员变量
栈区:保存方法以及局部变量
溢出条件:产生过多或者占用内存很大的对象函数递归调用自身可能出现栈区溢出
如何解决:1.尽可能不产生不必要的对象或成员变量1.递归操作要小心
2.设置JAVA虚拟机堆大小(java -Xms) 2.采用非递归手段
栈空间不足：java -Xss stacksize
堆空间不足：java -Xms
举例：
堆溢出 byte[][] arr = new byte[1024 * 1024][1024 * 5];
栈溢出：
while(true){
out();
}
}
catch(Exception e){
System.out.println(count);
}
10.oop
答：
面相对象:是相对面向过程而言的一种编程方式,将问题简单化.
类:是对象的抽象.
对象:是类的具体实现.
实例:就是对象.
成员变量:对象的属性变量.
成员函数:对象的方法.
public:用于修饰成员变量或者成员函数,表示公有,供其他类调用.
private:用于修饰成员变量或者成员函数,表示私有,用于封装,提高数据安全性,可通过set,get方法进行属性的改变,获取
构造函数:用于初始化对象.函数没有返回值.
this:是对象的成员变量,指向当前的对象,用于类中方法引用当前对象.
static:静态的,修饰成员变量,同类对象所共有,类也可以引用静态成员,静态方法只能访问静态成员.
面向对象是相对面向过程而言，将功能封装进对象，强调具备了功能的对象。
类是对象的抽象，对象跟实例概念差不多
面向对象的特征：
1.封装
把属性都隐藏，提供set() get()方法
private ：
用于修饰成员变量和成员函数
被私有化成员只在本类中有效
对外提供set get方法
2.继承
3.多态
类的属性也叫成员变量
类的方法也叫成员函数
成员变量：
定义在类中，随着对象的建立而建立，存在于对象所在的堆内存中，成员变量有默认初始化。
局部变量：
定义在局部范围内，存在于栈内存，作用范围结束，变量空间释放，没有默认初始化
构造函数
--------------------------
给对象进行初始化 可以有多个构造函数 重载
1.没有返回值 连void也不能有
2.函数名和类名相同
3.用构造函数创建对象 默认的构造函数时calssname
匿名对象
-----------------------------------
匿名对象是对象的简化形式
匿名对象使用情况:
1.当对对象方法仅进行一次调用的时候
2.匿名对象可以作为实际参数进行传递
Car car=new Car();
outCarColor(Car c);
匿名： outCarColor(new Car());
或者 new Car().run;
this :是关键字 对象内部指向内部的一个指针
static 静态
用于修饰 成员变量和成员函数
修饰的成员：随着类的加载而加载 优于对象存在 被所有对象所共享 可以直接被类名调用
静态方法只能访问静态成员 静态方法中不可以写this super关键字 主函数是静态的
-高级优化)
