Java基础（五）

Java设计模式–单例模式

• 单例模式，是一种常用的软件设计模式。
• 在它的核心结构中只包含一个被称为单例的特殊类。
• 通过单例模式可以保证系统中，应用该模式的类，
• 一个类只有一个实例。即一个类无论如何创建都只有一个对象实例。
• 单例模式的几个要点
  • 私有化构造函数
  • 提供一个静态的私有该对象的的属性
  • 提供被public修饰的静态方法
• 单例模式下的线程安全
  • 懒汉模式（需有同步代码块）
    • 线程安全，调用效率不高，但是能延时加载
  • 饿汉模式
    • 线程安全，调用效率高，但是不能延时加载
  • Double CheckLock （双检锁模式–两判断1.null判断2.class判断 ）
    • 由于JVM底层模型原因，偶尔会出问题，不建议使用
  • 静态内部类实现模式
    • 线程安全，调用效率高，可以延时加载
  • 枚举类
    • 线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用
• 单例模式的两种方式
  • 懒汉模式
    • 单例模式之懒汉单例模式
    • 线程不安全—同步代码块来解决
    • 用时间换空间–效率低

public class Demo01{
	public static void main(String[] args){
		Bggl L01=Bggl.getIntence();
	}
}
class Bggl{
	//1、实例化构造函数
	private  Bggl(){};
	//2、提供一个本类的私有静态对象
	private  static Bggl L01=null;
	//3、提供一个公开的静态的可以创建对象的方法
	public  static Bggl getIntence(){
			if(L01==NULL)
				L01=new Bggl();
			return L01;
	}

}

• 单例模式之二
  • 饿汉模式
    • 线程安全
    • 饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存
    • 但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

public class Demo01{
	public static void main(String[] args){
		Bggl L02=Bggl.getIntence();
	}
}
class Bggl{
	//1、私有化构造方法
	private  Bggl(){}
	//2、私有化静态的本类对象
	private static Bggl L02=new Bggl();
	
	//3、创建一个公共的静态的可被实例化的方法
	public static Bggl getIntecne(){
		retrun L02;
	}

}

异常

Java 是采用面向对象的方式来处理异常，处理过程

• 定义
  • 异常是指java程序在运行过程中出现的错误

异常类的父类–Throwable

• Throwable子类类中有Error和Exception

编译异常与运行时异常的区别

• 编译异常必须要try…catch/throws
• 运行时异常则不需要try…catch/throws

异常的处理方案

• throws

• 把问题向上抛出，抛给它的调用者去处理

• try{…} catch{…}

  • 可嵌套

  • 捕捉多个异常

    • 一行代码可能产生多个不同的异常，我们需要针对具体的错误进行补救
    • 所以需要捕捉不同的异常，添加补救的代码
    • 父类的异常放在下面

• try{…}catch{…}finally{…}//不论是否抛出异常与否，finally内的代码最后都会执行。

try-catch-finally中，如果在catch中return了，finally中的代码还会执行么，原理是什么？

代码一：catch中有return，finally中无retrun

/*
 * java面试题20--如果catch里面有return语句，finally里面的代码还会执行吗？
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        System.out.println(getInt());
    }

    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a;
        } finally {
            a = 40;
        }
            /*
             * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
             * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
             * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
             
             
             **归纳**  
             *异常->catch { a=30 ，准备return 30时，发现有finally} 故 
                            ->finally a=40;(但这里无return) 
             	            ->返回catch的return 位置。
             	  故a=30，输出结果30
             */
        return a;
    }
}

代码二：catch中有return，finally中有retrun

package com.java_02;
 
public class FinallyDemo2 {
    public static void main(String[] args) {
        System.out.println(getInt());
    }
 
    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a;
  
        } finally {
            a = 40;
            return a; //如果这样，就又重新形成了一条返回路径，由于只能通过1个return返回，所以这里直接返回40
        }
 		**归纳**  
             *异常->catch { a=30 ，准备return 30时，发现有finally} 故 
                            ->finally a=40;(但这里有return) 
             	            ->直接return 40。
             	  故a=40，输出结果40
             */
//      return a;
    }
}

自定义异常

• 定义
  • 自己定义的异常
• 自定义异常方法
  • 继承Exception 必须抛出,需要在编译前处理
  • 继承RuntimeException 不需要抛出，编译前不需要处理

常见异常

• java.lang.ArithmeticException //数学类型异常
• StringIndexOutOfBoundsException//字符串下标越界
  • [String s = “h”;s.charAt(10)]
• ArrayIndexOutOfBoundsException//数组下标越界
• classCastException//类强转异常
• NullPointerException//空指针异常
  • String s = null;s.length()
• java.text.ParseException// 解析异常

数组和二维数组的初始化

String[] a= new String[5];

String[] a={"b01","b02"};
//初始化时，“2”的位置必须确定
String[][] names = new String[2][];
//整行赋值
s[0]=new String[]{"1","2","3","4"};

下列数组的声明有哪些是对的？错的应该怎么修改？
A.int[]a;     T  int a[]    T
B.inta[]=newint[3];   T
C.int[]a;a={1,2,3,4,5}; F
D.int[]a=newint[3]{1,2,3}; F;

数组在内存中的分配图

• 数组的引用在栈内存
• 数组的对象在堆内存

### 对象数组的概述和使用

Stu[] stus = new Stu[5];
stus[0] = new Stu("Lily", 22);
stus[1] = new Stu("Lucy", 25);
stus[2] = new Stu("Luck", 26);
stus[3] = new Stu("Lala", 28);
stus[4] = new Stu("Lida", 21);