JavaSE-内存分析、内存控制、异常机制、注解

内存分析

// Student.java
public class Pet{
	String name;
	int age;
	public static void shout(){
		System.out.print("它叫"+this.name+'，年龄:'+this.age);
	}
}
// Main.java
public class Main{
	public static void main(String[] args){
		// 实例化对象
		Pet dog = new Pet();
		dog.name = "旺财";
		dog.age = 3;
		dog.shout();

		Pet cat = new Pet();
		cat.name = "ketty";
		cat.age = 1;
		cat.shout();
	}
}

java堆、栈、常量池

1. 堆：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）对象

2. 栈：存放所有new出来的对象。对象指针

3. 方法区：存放静态成员（static定义的）static 定义的

4. 常量池：存放字符串常量和基本类型常量（public static final）常量值

对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

String s1 = "china";  
String s2 = "china";  
String s3 = "china";  
String ss1 = new String("china");  
String ss2 = new String("china");  
String ss3 = new String("china"); 

这里解释一下黄色这3个箭头，对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。这也就是有道面试题：String s = new String(“xyz”);产生几个对象？一个或两个，如果常量池中原来没有”xyz”,就是两个。

对于基础类型的变量和常量：变量和引用存储在栈中，常量存储在常量池中。

int i1 = 9;  
int i2 = 9;  
int i3 = 9;   
public static final int INT1 = 9;  
public static final int INT2 = 9;  
public static final int INT3 = 9;  

对于成员变量和局部变量：成员变量就是方法外部，类的内部定义的变量；局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。

形式参数是局部变量，局部变量的数据存在于栈内存中。栈内存中的局部变量随着方法的消失而消失。成员变量存储在堆中的对象里面，由垃圾回收器负责回收。

class BirthDate {  
    private int day;  
    private int month;  
    private int year;      
    public BirthDate(int d, int m, int y) {  
        day = d;   
        month = m;   
        year = y;  
    }  
    省略get,set方法………  
}  
  
public class Test{  
    public static void main(String args[]){  
        int date = 9;  
        Test test = new Test();        
        test.change(date);   
        BirthDate d1= new BirthDate(7,7,1970);         
    }    
  
    public void change1(int i){  
        i = 1234;  
    }
} 

对于以上这段代码，date为局部变量，i,d,m,y都是形参为局部变量，day，month，year为成员变量。下面分析一下代码执行时候的变化：

1. main方法开始执行：int date = 9;

date局部变量，基础类型，引用和值都存在栈中。

2. Test test = new Test();

test为对象引用，存在栈中，对象(new Test())存在堆中。

3. test.change(date);

i为局部变量，引用和值存在栈中。当方法change执行完成后，i就会从栈中消失。

4. BirthDate d1= new BirthDate(7,7,1970);

d1为对象引用，存在栈中，对象(new BirthDate())存在堆中，其中d，m，y为局部变量存储在栈中，且它们的类型为基础类型，因此它们的数据也存储在栈中。day,month,year为成员变量，它们存储在堆中(new BirthDate()里面)。当BirthDate构造方法执行完之后，d,m,y将从栈中消失。

5. main方法执行完之后，date变量，test，d1引用将从栈中消失，new Test(),new BirthDate()将等待垃圾回收。

异常机制

存在异常

1. 检查性异常

2. 运行时异常

• ArrayIndexOutOfBoundsException（数组下标越界）

• NullPointerException（空指针异常）

• ArithmeticException（算数异常）

• MissingResourceException（丢失资源）

• ClassNotFoundException（找不到类异常）

• StackOverflowError（栈溢出异常）

3. 错误

异常捕获

1. try{}catch(){}

// 执行时被动捕获异常
try{
	// 监控区域
}catch(Error[type] err){
	// 其中type为异常类型
}catch(Exception err){
	// 最高Throwable捕获异常
}catch(Throwable err){
	// 支持多种类型的异常捕获
}finally{
	// 善后工作
}

快捷键：选中 ctrl + alt + t

2. throw

// 执行时主动抛出异常
throw new [type]();

3. throws

注解

什么是注解

Annotation 是从JDK 5.0开始引入的新技术

Annotation 的作用：

1. 不是程序本身，可以对程序做出解释这一点，和注释没什么区别

2. 可以被其他程序比如编译器读取

Annotation 的格式：@注释名(value=[参数])

使用位置：

1. package

2. class

3. method

4. field

相当于给他们添加了额外的信息，我们可以通过反射机制变成实现这些元数据的访问。

// 注释
/*注释*/
/*
注释
*/
public class Demo extends Object{
	@Override  // 注解
	public String toString(){
		return super.toString();
	}
}

内置注解

1. @Override：定义在java.lang.Override中，此注解只适用于方法的修饰，表示一个方法声明打算重写超类中另一个声明的方法。

2. @Deprecated：定义在java.lang.Deprecated中，此注解可以修饰方法，属性，类，表示不鼓励程序员使用这样的元素、方法。通常因为它很危险或者存在更好的选择。

3. @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，需要添加参数比如：

   • @SuppressWarning(“unchecked”)

   • @SuppressWarning(“all”) 抑制全部警告

   • @SuppressWarning(value={“unchecked”,“deprecated”})

4. …

元注解

元注解：负责注解其他注解。

1. @Target：用于描述注解的使用范围，需要添加参数。

@MyAnnotation
public class Demo{
    @MyAnnotation
    public void test(){

    }
}
// 自定义注解
//@Target(ElementType.METHOD)
@Target(value = {ElementType.METHOD,ElementType.TYPE})
/**
 * ElementType.METHOD 方法上
 * ElementType.TYPE 类、枚举上
 * ElementType.FIELD 元素上
 * ElementType.CONSTRUCTOR 构造器上
 * ElementType....
 */
@interface MyAnnotation{

}

2. @Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期。生命周期 RUNTINE>CLASS>SOURCE。

@MyAnnotation
public class Demo {
    @MyAnnotation
    public void test() {

    }
}

// 自定义注解
//@Retention(RetentionPolicy.RUNTIME)
@Retention(value = RetentionPolicy.RUNTIME)
/**
 * RetentionPolicy.SOURCE 源码
 * RetentionPolicy.CLASS 类
 * RetentionPolicy.RUNTIME 运行时
 */
@interface MyAnnotation {

}

3. @Document：说明注解是否将被包含在javadoc中

4. @Inherited：说明子类可以继承父类中的该注解

@MyAnnotation
public class Demo {
    @MyAnnotation
    public static String name;
    @MyAnnotation
    public void test() {

    }
    @MyAnnotation
    public Demo(){}
}

// 自定义注解
@Documented
@Inherited
@interface MyAnnotation {

}

自定义注解

使用@interface 自定义注解，自动继承java.lang.annotation.Annotation 接口

格式：public @interface 注解名{定义内容}

1. 其中定义的方法实际上是声明了一个配置参数。

2. 方法名就是参数名

3. 返回值的类型就是参数的类型（返回值只能是基本数据类型、Class、String、enum）

4. 可以通过default来声明参数的默认值

5. 如果只有一个参数成员，一般参数名为value

6. 注解元素必须有值，我们定义注解元素时，经常使用空字符串，0作为默认值。

public class Demo {
    @MyAnnotation(value="参数名")
//    @MyAnnotation
    public void test() {

    }
}

// 自定义注解
@Target(value={ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
// 注解的参数格式：数据类型 参数名() [default ...];
    String value();
//    String value() default "";
}

注意：

---