java的重修之路

一、内存管理

java里的声明分引用与基本数据类型。

数组：

java里new一个对象数组为  person[] A; A = new person[4];  person[0] = new person();

第一句声明了1个A数组引用变量，指向为null。第二句让A指向一个长度为4的数组内存，数组元素类型是person引用类型，值为null，此时并没有分配内存。所以才有第三句，第三句是真正意义上的分配内存。

java里new多维数组为 int[][] a; a = new int[4][];  a[0] = new int[4];

第一句声明了1个二维数组引用变量，指向为null。第二句声明让a指向一个长度为4的数组内存，数组元素是一维数组引用类型，值为null，此时并没有分配内存。第三句分配了一个长度为4的一维数组，因为数组元素是int，所以变量自动填补为0。(如果把int改为person，则到这里还不够，还需要继续new，为每个person分配内存)。

实例变量与类变量：

被static修饰的是类变量。每个类中有一份类变量，类变量一开始就有内存。所以static方法可以访问static变量，但访问普通变量必须先new，因为普通变量没有分配内存。

对于类变量，系统首先为其分配内存空间，并将基本数据类型赋值为0或null；之后再根据初始化顺序依次初始化。

父子实例的内存控制：方法会覆盖，变量不不会被覆盖。这里就牵扯到多态问题了。一个父类引用指向一个子类时，当用该引用调用方法 引用.方法()，调用的是实际类型的方法（子类方法）；当用该引用调用变量时 引用.变量，调用的是声明类型的变量（父类变量）。

final修饰符：

很多情况下，final修饰的变量会被当做宏替换处理。子类若能访问到父类的final方法，则不能对final方法进行重写。

final的用途：

• 锁定方法，防止被继承类修改。
• 写出可以在运行时被确定的代码，从而可以内嵌调用。

 内部类：成员内部类、静态内部(嵌套)类、方法内部类、匿名内部类 。

成员内部类：

class Outer {

class Inner{}

}

编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。

 

方法内部类：

把类放在方法中。

(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

(2)、方法内部类对象不能使用该内部类所在方法的非final 局部变量。

class Outer {

public void doSomething(){

final int a =10;

class Inner{

public void seeOuter(){

System.out.println(a);

}

}

Inner in = new Inner();

in.seeOuter();

}

public static void main(String[] args) {

Outer out = new Outer();

out.doSomething();

}

}

匿名内部类：

当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。匿名内部类的声明格式如下：

new ParentName（）{

...// 内部类的定义

}

很方便，直接在new的时候实现一个接口或一个类。

静态内部类：

静态内部类中可以定义静态或者非静态的成员。

静态的含义是该内部类可以像其他 静态成员一样， 没有外部类对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。

class Outer{

static class Inner{}

}

class Test {

public static void main(String[] args){

Outer.Inner n = new Outer.Inner();

}

}

在静态方法中定义的内部类也是StaticNested Class，这时候不能在类前面加static关键字，静态方法中的StaticNested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。

 

 

@Override的用法：

编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错。

 

二、异常

JAVA里的异常机制是，程序执行过程中遇到异常，则该方法向上级方法传递异常，直到main方法。

异常分为捕获异常与未捕获异常。所谓捕获异常即必须处理的异常，若某代码段可能 出现某捕获异常必须处理，未出现必须不处理。不能在一个正常的代码段后catch一个捕获异常。否则无法通过编译。（至于哪些是捕获异常，编译的时候编译器会提醒你，否则会无法通过编译）

try..catch..finally，catch与finally不能都省略。finally一般情况下在try和catch执行后都会得到执行（即使在try或catch中有return语句也会得到执行）。

关于抛出异常：声明的时候是throws ...，代码里是throw ...，可向上级方法传递异常。刚才说了，某代码段可能出现某 捕获异常则必须处理，可以以try..catch..finally的方式处理（自己处理），也可以直接在函数声明处一以void f() throws ...{}处理（上级处理）。

throws关键字的最大好处是： 在方法中不处理任何的异常，而交给被调用处处理。

声明的时候有捕获异常，则必须用以上用以上两种方法处理，throws或try...catch...finally...

声明的时候 throws xx，代码里可以没有 throw xx，遇到xx异常，则隐式抛出异常，有throw xx，则显示抛出异常。

关于异常的博客资料：http://taohui.iteye.com/blog/1222431

转载于:https://www.cnblogs.com/dirge/p/5572972.html