10.JavaSE_单例模式_多例模式、异常（受查异常、非受查异常）、断言异常

一、单例模式

定义：一个类只允许产生一个实例化对象。

1、饿汉式单例：上来就new。面试中最好写这个。

class Singleton{
	//类内部提供实例化对象
	private static final Singleton SINGLETON = new Singleton();//上来就new
	//构造方法私有化，类外部无法产生实例化对象
	private Singleton(){}
	public void test(){
		System.out.println(this);
	}
	//对象方法
	public static Singleton getSingleton(){
		return SINGLETON;
	}
}

2、懒汉式单例：用时再new，存在线程安全问题（双重加锁单例模式）

class Singleton{
	//类内部提供实例化对象
	private static Singleton SINGLETON;
	
	private Singleton(){}//构造方法私有化，类外部无法产生实例化对象
	
	public void test(){
		System.out.println(this);
	}
	//对象方法
	public static Singleton getSingleton(){
		if(SINGLETON == null){
			SINGLETON = new Singleton();//用时再new
		}
		return SINGLETON;
	}
}

注意：
a.对象如何产生？ 通过类的构造方法。
b.要想限制对象的产生？ 通过 构造方法（私有化） 限制。
//方法私有化，类外部无法产生实例化对象。
因此，在类内部提供实例化对象。类内部提供静态方法。
c.提供静态方法返回唯一对象。

二、多例模式（了解概念即可,该概念已被枚举所取代）–有限个数的对象

所谓的多例只是比单例多了一些实例化对象而已。

定义一个表示性别的多例类：

class Sex{
  private String title;
  public static final int MALE_FLAG = 1;
  public static final int FEMALE_FLAG = 2;
  private static final Sex MALE = new Sex("男");
  private static final Sex FEMALE = new Sex("女");
  private Sex(String title){
  	this.title = title;
  }
  public static Sex getInstance(int flag){
  	switch(flag){
  		case MALE_FLAG:
  			return MALE;
  		case FEMALE_FLAG:
  			return FEMALE;
  		default:
  			return null;
  	}
  }
  public String toString(){
  	return this.title;
  }
}
public class MultitonTest{
  public static void main(String[] args){
  	Sex male = Sex.getInstance(Sex.MALE_FLAG);
  	System.out.println(male);
  }
}

多例和单例的共同特点：
①构造方法私有化。
②类内部一定会提供一个static方法用于取得实例化对象。

三、异常

1、Error（栈溢出异常）：Error类描述Java运行时内部错误与资源耗尽错误。应用程序不抛出此类异常，这种内部错误一旦出现，除了告知用户并使程序安全终止之外，别无他法。

2、RuntimeException（运行时异常）：由于程序错误导致的异常。

IOException：程序本身没有问题，但由于出现I/O问题导致的异常（例如：打开一个并不存在的文件）。

• 非受查异常：继承于Error与RuntimeException类的所有异常子类称为非受查异常（不强制用户进行异常处理）。
• 受查异常：Exception以及IOException子类属于受查异常（强制用户进行异常处理）。

3、异常处理格式：

为了保证程序出现异常后也能正常执行下去，需要进行异常处理。
语法如下：

  try{
  	//有可能出现异常的语句
  }[catch(异常类 对象)……]{
  	//异常出现后的解决方案
  }[finally]{
  	//异常出口，无论是否产生异常，均会执行finally代码块
  	//即便try、catch存在return语句，也会在return之前执行finally代码块
  }
  try...catch...
  try...finally...
  try...catch...finally...

4、throws：用在方法上，明确表示此方法可能会产生异常但是方法内部不处理，将异常抛回给调用处。

5、throw：用在方法中。由用户产生异常类对象，而非JVM产生。一般与自定义异常类搭配使用。

6、断言异常（了解）：

默认关闭断言，断言需开启。assert 布尔表达式 : “返回false执行的代码块”

public class Test0123{
    public static void main(String[] args) {
        int num = 10;
        assert num == 55 : "错误：num应当为55";
        System.out.println(num);
        //结果为10，此时断言没有生效。要想生效需使用-ea的参数启动断言。（IEDA中run->Edit Configurations->Configuration->VM options填写-ea  ->OK）
    }
}

运行结果Exception in thread “main” java.lang.AssertionError: 错误：num应当为55
at 异常与捕获.Test0123.main(Test0123.java:158)

当断言返回false时会抛出断言异常。
Java断言开启参数（JVM参数）为 -ea，默认断言关闭。

7、自定义异常类：可以继承两种父类Exception、RuntimeException

实现自定义异常类：

package test;
class AddException extends Exception{
	public AddException(String msg){
		super(msg);
	}
}
public class Test{
	public static void main(String[] args) throws Exception{
		int num1 = 20;
		int num2 = 30;
		if(num1 + num2 == 50){
			throw new AddException("错误的相加操作");
		}
	}
}

运行结果：

Exception in thread “main” 异常与捕获.AddException: 错误的相加操作
at 异常与捕获.Test0123.main(Test0123.java:174)