学习内容:

1、数组,存放同一种类型数据的集合,容器,元素从0角标开始编号。

定义格式 

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

元素类型[] 数组名 = new 元素类型[]{元素,元素,……};

元素类型[] 数组名 = {元素,元素,……};

数组常用操作

获取最值

public static int getMax(int[] arr) {

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

System.out.println("数组不存在!");

return -1;

}

int temp = Integer.MIN_VALUE;

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

if (temp < arr[i]) {

temp = arr[i];

}

}

return temp;

}

排序,选择排序、冒泡排序(大数、小数下沉)

public static int[] sort(int[] array) {

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

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

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

int temp = 0;

if (array[j] > array[j+1]) {

temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

}

}

return array;

}

折半查找,前提是数组有序

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

{

int max,min,mid;

min = 0;

max = arr.length-1;

mid = (max+min)/2;

//进行多次二分查找

while(arr[mid]!=key)

{

   if(key>arr[mid])

min = mid + 1;

   else if(key<arr[mid])

max = mid - 1;

   if(max<min)

return -1;

   mid = (max+min)/2;

}

return mid;

}

常见数组操作异常(运行时异常)

数组角标越界异常 ArrayIndexOutOfBoundsException 

int[] arr = new int[2];

System.out.println(arr[3]);

访问到了数组中的不存在的脚标时发生。

空指针异常 NullPointerExcepiton

int[] arr = null;

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

arr引用没有指向实体,却在操作实体中的元素时。

2、内存结构

栈内存(stack),方法栈 (层帧)

用于存储局部变量,当数据使用完后所占空间会自动释放,先进后出,

push stack: 压栈

pop stack:弹栈

stack overflow:栈溢出

堆内存(heap),对象堆

数组和对象,通过new建立的实例都存放在堆内存中

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不在被使用,会在不确定的时间内被垃圾回收器回收

heap overflow: 堆溢出

注意:Java没有指针是指没有显式的指针操作,引用就是指针,也就是说有指针(变量的名称,引用)


3、多维数组

数组中嵌套数组,嵌套的数组可以是不等宽数组。

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

public static int[][] trans(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;

}

//遍历三维组数,横向输出三维数组的每一个层。

public static void outHor(int[][][] arr) {

//抽象为魔方,分为层,每层的每行,每层的每行的每列.通过循环控制,可以横向以及纵向打印每层

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

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

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

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

}

System.out.print(" | ");

}

System.out.println();

}

}

4、面向对象(oop),oriented object program. 基于面向过程(只见树木不见森林)

思维模式的转变,讲功能行为封装进对象,强调具备了功能的对象,

将复杂的事情简单化,从执行者的角度转换成指挥者,掌控了设计权;

开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情。

设计的过程:其实就是在管理和维护对象之间的关系。

类与对象的关系

class  : 类,类是对象的抽象, 对现实世界的事物的软件抽象。

Object : 对象,对象是类的实例。new 类名

instance : 实例. 就是对象

面向对象的特征:

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

Java中用类class来描述事物的属性和行为

属性:对应类中的成员变量

行为:对应类中的成员函数

成员变量

成员变量定义在类中,在整个类中都可以被访问。

成员变量随着对象的建立而建立,存在于对象所在的堆内存中。

成员变量有默认初始化值。

局部变量:

局部变量只定义在局部范围内,如:函数内,语句内等。

局部变量存在于栈内存中。

作用的范围结束,变量空间会自动释放。

局部变量没有默认初始化值。

构造函数:给对象进行初始化,多个构造函数是以重载的形式存在的

1.没有返回值

2.函数名和类名相同

3.默认的构造函数是 类名()

匿名对象

没有引用变量指向,是对象的简化形式

当对对象方法仅进行一次调用的时候

匿名对象可以作为实际参数进行传递

封装

隐藏对象的属性和实现细节,仅对外提供公共访问方式。

好处:

将变化隔离。

便于使用。

提高重用性。

提高安全性。

封装原则:

将不需要对外提供的内容都隐藏起来。

把属性都隐藏,提供公共方法对其访问。

private(私有)关键字

权限修饰符,可用于修饰成员变量和成员函数,被私有化的成员只在本类中有效

将成员变量私有化,对外提供对应的set ,get方法对其进行访问。提高对数据访问的安全性

this关键字

代表本类对象的引用,对象内部指向自身的一个指针

当在函数内需要用到调用该函数的对象时,就用this

static(静态)关键字

用于修饰成员(成员变量和成员函数)

被修饰后的成员具备以下特点:

随着类的加载而加载

优先于对象存在

被所有对象所共享

可以直接被类名调用

使用注意

静态方法只能访问静态成员

静态方法中不可以写this,super关键字

主函数是静态的


5、JVM堆栈大小的调整

java -X 获取相应参数帮助说明

-Xms<size>        设置初始 Java 堆大小

-Xmx<size>        设置最大 Java 堆大小 memory max

-Xss<size>        设置 Java 线程堆栈大小    stackSize

示例:java -Xmx8000m 类名

阐述出来堆区,栈区,何时出现溢出,如何解决。

答:堆区:保存对象以及成员变量; 栈区:保存方法以及局部变量

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

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

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


遇到的问题:

  


需要帮助的问题: