Java常用类和异常

常用类

内部类

• 成员内部类

• 静态内部类

• 局部内部类

• 匿名内部类

• 概念：在一个类的内部在定义一个完整的类

• 特点：

  • 编译之后可生成独立的字节码文件
  • 内部类可直接访问外部类的私有成员，而不破坏封装
  • 可为外部类提供必要的内部功能组件。

成员内部类

外部类的访问修饰符只能是public或默认.

实例属性就是类内的普通属性，实例方法时普通方法

• 再类的内部定义**，与实例变量，实例方法同级别的类**
• 外部类的一个实力部分，创建内部类对象是，必须依赖外部类对象。
  • 1.Outer out=new Outer();
  • Outer.Inner in =out.new Inner();
  • 2.Outer.Inner inner=new Outer().new Inner();
• 当外部类，内部类存在重名属性时，会优先访问内部类属性。
• 特点：
  • 1.成员内部类可以使用任意访问修饰符。
  • 2.成员内部类可以直接访问外部类的属性和方法。(Outer.this.name)
  • 3.当成员内部类中属性和外部类的属性同名是，使用外部类名，使用外部类名.this访问外部类的属性。
  • 成员内部类中不能包含静态成员。可以包含静态常量。

静态内部类

• 静态内部类：级别和外部类一样，为外部类提供功能。

  • Outer.Inner inner=new Outer.Inner();
  • Inner inner=new Inner(); 需要导包。

• 不依赖外部对象，可直接创建或通过类名访问，可声明静态成员。

• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）

  • Outer.Inner=new Outer.Inner();
  • Outer.Inner.show();

• 静态内部类特点：

  • 1.静态内部类可以使用任何访问修饰符。
  • 2.静态内部类不能直接访问外部类的实例属性和方法，可以直接访问外部类静态属性和方法。(Outer.name)
  • 3.静态内部类可以包含静态成员。

• 总结static用法

  • 1.修饰属性
  • 2.修饰方法
  • 3.静态代码块 只能放代码块.
  • 4.静态内部类
  • 5.静态导入 import static java.lang.System.out;

• 注意静态方法访问同一个类下的静态属性不能加this.直接调用。

• 访问静态内部类，通过外部类名.静态内部类名.属性。

局部内部类

• 定义在外部类方法中，作用范围和对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因为无法保证变量的生命周期与自身相同，变量默认修饰为final.
• 限制类的适用范围。
• 局部内部类级别和局部变量相同，适用范围只能当前方法中使用。
• 特点：
  • 1.不能使用任何访问修饰符。
  • 2.如果局部内部类所在方法是非静态方法，那么可以访问外部类的实例属性和方法（Outer.this.name)。如果局部内部类所在方法是静态方法，只能访问外部类的静态属性和方法。(Outer.name)
  • 局部内部类可以访问局部变量，但是局部变量不许是final,JDK1.8 final可以被省略。(因为怕你在局部内部类中使用，局部变量。)
  • 局部内部类也不能声明静态成员，可以使用静态常量。（因为静态成员是属于类，但是内部类属于外部类，所以有问题）。

匿名内部类。

• 没有类名的***局部内部类***（一切特征都与局部内部类相同）。
• 必须继承一个父类或者实现一个接口
• 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象。
• 优点：减少代码量
• 缺点：可读性比较差。

USB mouse=new USB(){
    @Override
    public void service(){
        Sytme.out.println("mouse is service..")
    }
}
//lambda
Usb luoji=()->{
    System.out.println("mouse is service...")
}
Usb luoji=()->System.out.println("mouse is service..")

• 特点
  • 1.创建匿名内部类可以使用接口，抽象类，普通类，必须实现接口或抽象方法中的抽象方法
  • 2.匿名内部类不能手动添加构造方法，也不能包含静态成员。（静态成员需要类名访问）
  • 3.匿名内部类中一般不包含特有的方法，不能直接访问，可以通过可访问方法访问或内部对象访问。
  • 4.匿名内部类生成的class文件：类名&编号.class

Object类

• 超类，基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写extends显示继承某个类，都默认直接Object类，否则为间接继承。
• Object类中所定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。
  • 作为参数，可接受任何对象。
  • 作为返回值，可接受任何对象。
• 本地方法也没有方法体native

Java中创建对象有四种方式

• new 关键字创建
• 反射
• 反序列化
• 克隆

getClass()方法

• public final Class <?> getClass(){}
• 返回引用中存储的实际对象类型。
• 应用：通常用于判断两个引用中实际存储对象类型是否一致

		 Student student1 = new Student();
        Student student2 = new Student();
        System.out.println(student1.getClass() == student2.getClass());
        System.out.println(student1.getClass().getName());
        System.out.println(student1.getClass().getSimpleName());
        System.out.println(student1.getClass().getPackage().getName());
   

hashCode()方法

• public int hashCode(){}
• 返回该对象的十进制的哈希码值
• 哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值。
• 哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码。

 System.out.println(student1.hashCode());
        System.out.println(student2.hashCode());
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

toString()方法

• public String toString(){}
• 返回该对象的字符串表示（表现形式）
• 可以根据程序需求覆盖该方法，如：展示对象的各个属性值

System.out.println(student1.toString());
        System.out.println(student2.toString());
        System.out.println(student1);
        System.out.println(student2);

equals()方法覆盖步骤

• 比较两个引用是否指向同一个对象。
• 判断obj是否为null
• 判断两个引用指向的实际对象类型是否一致
• 强制类型转换
• 依次比较个属性值是否相同。

equals()方法

• public boolean equals (Object obj){}
• 默认实现为（this==obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。

@Override
    public boolean equals(Object obj) {
        //1.判断obj是否为空
        if(obj==null){
            return false;
        }
        //2.比较两个对象同一个
        if(this==obj){
            return true;
        }
        //3.判断是不是Student类型
        if(obj instanceof Student){
            //4.强转换，判断属性。
            Student student=(Student)obj;
            if(this.getName().equals(student.getName())){
                return true;
            }
            return false;
        }
        return false;
    }

finalize()方法

• 当对象被判定为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存消耗，一次性回收所有垃圾对象。
• 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

 @Override
    protected void finalize() throws Throwable {
        System.out.println("回收了"+this.name);
    }

new Student("dmeodong",12,"phase after the girl,"male);

包装类

• 基本数据类型所对应的引用数据类型。
  • byte–>Byte ;short->Short;int->Integer;long->Long;float->Float;double->Double;char->Character;boolean->Boolean
• Object可统一的所以数据，包装类的默认值是null

类型转换与拆箱，装箱。

• 8中包装类提供不同类型间的转换方式：
  • Number父类提供的6个共性方法。
  • parseXXX()静态方法，（除Character).
  • valueOf()静态方法
• JDK5.0之后，自动装箱，拆箱，基本数据类型和包装类自动转换。

Integer integer=new Integer(10);
//装箱
int num=10;
Integer integer1=new Integer(num);

System.out.println(num1==integer1);//true


//拆箱
int num2=integer2.intValue();
System.out.println(num2==integer2);

//自动拆箱装箱
int age=30;
Integer integer3=age;
Integer integer4=Integer.valueOf(age);


int number =integer4;
int age2=integer4.intValue();

面试题案例

Integer integer1=new Integer(100);
Integer integer2=new Integer(100);
System.out.println(integer1==integer2);//false

Integer integer3=100;
Integer integer4=100;
System.out.println(integer3==integer4);//true

Integer integer9=200;
Integer integer10=200;
System.out.println(integer9==integer10);//false
//new 堆中开辟空间，
//自动装箱后，如果在-128--127范围内利用的是valueOf,返回的是IntegerCache数组，返回的是同一个地址，所以是true。超过的话返回Integer(i)，返回的是对象地址。false

• 基本类型和字符串之间的转换

int n1=500;
String s1=n1+"";
String s2=String.valueOf(n1);
String s3=Integer.toString(n1);

• 字符串转成基本类型

String s4="200";
int n2=Integer.parseInt(s4);
int n3=Integer.parseInt(s4,16);//按16进制
String s5="f";
int n4=Integer.parseInt(s5,16);

• 特殊boolean,boolean类型的字符串转成基本类型。

boolean b=Boolean.parseBoolean("true");//只能是"true","false"

String 类

• Java程序中所有的字符串文本都是此类的实例。

• 字符串字面值是常量，创建之后不可改变。

• 常用创建方式：

  • String str1=“Hello”
  • String str2=new String(“Wold”);

• 字符串使用方式，直接字面量赋值

//字符串使用方式，直接字面量赋值
String name="zhangsan";//字符串常量存在方法去中常量池中，
name="lisi";//zhangsan变为垃圾
//方法区，虚拟机名字:Hotspot.
//常量池在jdk1.6之前在永久代。jdk1.7之后跑到堆中。

• 字符串使用方法，使用构造方法

String name2=new String("zhangsan");//zhangsan其实是一个char数组放到方法区,在堆中存着数组地址，name2存着堆里面保存着数组的地址的变量的地址
String name3="zhangsan";//zhangsan放在常量区，name3保存着常量区zhangsan的地址，所以是同一个zhangsan,但是存放的地址不同
System.out.println(name3==name2);//false
//验证name3name2是同一个.
Class<String>stringClass=String.class;
Field field=stringClass.getDeclaredField("value");
field.setAccesssible(true);
char[]v=field.get(name2);
v[5]='n';
System.out.println(name3);

       String name3="zhangsan"; //放在常量区
        String name2=new String("zhangsan");//放在堆

        System.out.println(name2==name3);//false

String 常用方法

• public char charAt(int index):根据下标获取字符

• public boolean contains(String str);

• public char[]toCharArray();

• public int indexOf(String str):

• public int length();

• public String trim()

• public String toUpperCase():

• public boolean endsWith(String str)

• public String replace(char oldChar,char newChar);

• public String[]split(String str)

• public String subString(int beginIndex,int endIndex)

• compare()比较字符串位置大小

String name1="abc";
String name2="xyz";
//abc
//abcdef

可变字符串

• 概念个：可在内存中创建可变的缓冲空间，存储频繁改变的字符串
• 常用方法：
  • public StringBuilder append(String str);追加数据
  • insert()插入。
  • replace()
  • reverse()反转.
  • delete
  • delete(0,sb.length());
• StringBuilder:可变长字符串JDK5.0提供，运行效率快，线程不安全
• StringBuffer:可变长字符串JDK1.0提供，运行效率慢，线程安全。

面试题

		 String s1="abc";//常量区没有，abc，开辟空间，初始一个abc放在常量区
        String s2="xyz";
        String s3=s1+s2;//程序中产生的放到堆中  在底层使用的是StringBuilder_>  使用的是new String放在堆中。
        String s4="abc"+"xyz";//在常量区产生abcxyz   
        String s5="abcxyz";//常量区上面已经产生。所以和s4一样.
        System.out.println(s3==s4); //false
        System.out.println(s5==s4);//true

• 方法区包括.class文件常量池2.运行常量池。(jdk1.7之前常量池在方法区，1.8之后常量池在堆里面)

String.intern()

• String.intern()方法如果常量池中没有，则把对象复制一份放到常量池中，返回常量中的对象，如果常量池中存在，则直接返回。jdk1.7之前是复制一份赋到常量池，JDK1.8.把对象引用到常量池。

  		String s1 = "abc";
          String s2 = "xyz";
          String s3 = s1 + s2;//abcxyz   常量池中
          String s4 = s3.intern();// 堆中abcxyz把地址放到常量池中，地址返回给s4
          String s5 = "abcxyz"; //常量池中有abcxyz地址，吧地址给了s5所以相同
          System.out.println(s3 == s4);
          System.out.println(s5 == s4);
  

      //常量池中默认有java
          String str1="pub"; //常量池
          String str2="lic";//常量池
          String str3=str1+str2;//堆中
          String str4=str3.intern();//发现常量池中有，就不给常量池地址。
          System.out.println(str3==str4);
  

正则表达式(Regular Expression)

• 正则表达式就是一个验证字符串格式是否满足要求的字符串，使用一个字符串匹配一组字符串，这个字符串就是正则表达式
• 正则表达式的用途
  • 匹配
  • 拆分
  • 查找
  • 替换

元字符

• 正则表达式中通常包含一些具有特殊含义的字符

字符	解释
a	匹配字符a
[abc]	匹配a或b或c
[^abc]	任何符，除了a,b或c（否定)
[a-d[m-p]]	a到d或m到p:[a-dm-p]
[a-zA-Z]	a到z或A到Z,两头的字母包括在内
[a-z&&[def]]	d,e或f（交集)
[a-z&&[^bc]]	a到z，除了b和c：ad-z
[a-z&&[^m-p]]	a到z，而非m到p：[a-lq-z]减去

其他字符

• 预定义字符：

  字符	解释
  .	任意字符（与行借书符可能匹配也可能不匹配）
  \d	数字:[0-9] digit
  \w	单词字符[a-zA-Z_0-9] word

• 边界匹配：

  字符	解释
  ^	表示行开始
  $	表示行结束

• 其他字符

  • 数量：

    字符	解释
    X?	一次或0次
    X*	0次或多次（包括1次）
    X+	一次或多次
    X{n}	恰好n次
    X{N,}	至少n次
    X{n,m}	至少n次，不超过m次

正则表达式应用

• 匹配

  String reg="1[2578]\\d{9}";
  String regex="^[1-9][0]9{5,12}@[qQ][.][cC][oO][mM]$";
  String email="[e-mail]";
  boolean boo=email.matches(regex);
  

• 拆分

  String regex="[,]";
  String str="Hello I am LiLEI,welcome to china";
  String[]str=str.split(regex);
  System.out.println(Arrays.toString(strs));
  

正则表达式应用

• Patter类：正则表达式编译类

• Matcher类：匹配器

• 获取和替换

  String string="我爱java，java是世界上最好的语言，java真香";
  Pattern p2=Patter.compile("[jJ]ava");
  Matcher matcher2=p2.matcher(string);   
  while(matcher2.find()){
      String s=matcher2.group();
      System.out.println(s);
  }
  
  String s3=string.replaceAll("[jJ]ava","JAVA");
  System.out.println(s3);
  

          Pattern pattern = Pattern.compile("^a*b");
          //Matcher:匹配器
          Matcher matcher = pattern.matcher("aaaaaaab");
          //调用matchs方法
          boolean matches = matcher.matches();
          System.out.println(matches);//true.
  

        //扩展叠词处理
          String hi3 = "我..我..喜喜喜喜喜喜喜喜喜欢.....JJJJJava";
          String hi4 = hi3.replaceAll("[.]", "");
          System.out.println(hi4);
          String hi5 = hi4.replaceAll("(.)\\1+", "$1");// ()表示分组 \1表示引用前面的字符,和()里面的分组相同.加上+就表示2个以上  $1表示引用前面的
  
          System.out.println(hi5);
  

BigDecimal

• 位置：java.math包中。
• 作用：精确计算浮点数。
• 创建方式:BigDecimal bd=new BigDecimal(“1.0”);
• 方法：
  • BigDecimal add(BigDecimal bd)
  • BigDecimal subtract(BigDecimal bd)
  • BidDecimal multiply(BigDecimal bd)
  • BigDecimal divide(BigDcimal bd）
• 触发：divide
• 参数mode:
  • 指定小数部分的取舍模式，通常采用四舍五入的模式
  • 取值为BigDecimal.ROUD_HELP_UP.

        //减法，除法
        BigDecimal bigDecimal = new BigDecimal("1.4");//字符串精确
        BigDecimal bigDecimal1 = new BigDecimal("0.5");
        BigDecimal bigDecimal2 = new BigDecimal("0.9");
        BigDecimal divide = bigDecimal.subtract(bigDecimal1).divide(bigDecimal2);
        System.out.println(divide.toString());
        System.out.println(divide.doubleValue());

        //加法
        BigDecimal add = bigDecimal.add(bigDecimal2);
        System.out.println(add.toString());
        //乘法
        BigDecimal multiply = bigDecimal.multiply(bigDecimal2);
        System.out.println(multiply.toString());

        //除不尽
        BigDecimal divide1 = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_HALF_UP);
//        System.out.println(divide1.toString());
        System.out.println(divide1);

Date

• Date 表示特定的瞬间，精确到毫秒
• Date类中的大部分方法都已经被Calendar类中的方法所取代
• 时间单位
  • 1秒=1000毫秒
  • 1毫秒=1000微秒
  • 1微秒=1000纳秒

        //创建当前时间
        Date date = new Date();
        System.out.println(date.toString());

        System.out.println(date.toLocaleString());

        //前一天时间
        Date date1 = new Date(date.getTime() - 24 * 60 * 60 * 1000);
        System.out.println(date1.toLocaleString());

        //after  before
        boolean after = date.after(date1);
        System.out.println(after);
        boolean before = date1.before(date);
        System.out.println(before);

        //compareTo
        int i = date.compareTo(date1);
        System.out.println(i);

Calendar

• Calendar提供了获取或设置各种日历字段的方法

• Protected Calendar()构造方法为protected修饰，无法直接创建改对象。

• 其他方法

  方法名	说明
  static Calendar getInstance()	使用默认时区或区域获取日历
  void set(int year,int month,int date,int hourofday,int minute,int second)	设置日历的年月日时分秒
  int get(int field)	返回给定日历字段的值，字段比如年月日等
  void setTime(Date date)	用给定的Date 设置此日历的时间 Date -Calendar
  Date getTime()	返回一个Date表示此日历的时间Calendar-Date
  void add(int field ,int amount)	按照日历的规则，给指定字段添加或减少时间量
  long getTimeInMillis()	毫秒为单位返回该日历的时间值

        //Calendar
        //创建一个现在日历
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH) + 1);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.HOUR_OF_DAY));
        System.out.println(calendar.get(Calendar.MINUTE));
        System.out.println(calendar.get(Calendar.SECOND));


        //昨天
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(2020, 6, 29);
        calendar1.add(Calendar.DAY_OF_MONTH,-1)
        System.out.println(calendar1.getTime().toLocaleString());

        //after before
        System.out.println(calendar.after(calendar1));
        System.out.println(calendar1.before(calendar));

        //获取这个月的最大天数
        System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.getActualMinimum(Calendar.DAY_OF_MONTH));

        //获取月的最大天数
        System.out.println(calendar.getMaximum(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.getMinimum(Calendar.DAY_OF_MONTH));
        
        //转换
        //date----calendar
        Date date= new Date();
       Calendar calendar2= Calendar.getInstance();
       calendar2.setTime(new Date());
       
       //calendar ---date
        Date date1 =calendar2.getTime();

SimpleDateFormat

• SimpelDateFormat 是以语言环境有关的方式来格式化和解析日期的类

• 进行格式化（日期-》文本），解析（文本-》日期）

• 常用的时间模式格式

  字母	日期或时间
  y	年year
  M	年中月份month
  d	月中天数(day)
  H	小时数(hour)
  m	分钟(minute)
  s	秒(second)
  S	毫秒(mills)

        //日期---》字符串
        Date date = new Date();
        System.out.println(date.toString());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        String format = simpleDateFormat.format(date);
        System.out.println(format);


        //字符串--->日期
        SimpleDateFormat simpleDateFormat1=new SimpleDateFormat("yyyy-MM-dd");
        String string = "2020-07-30";
        Date parse = simpleDateFormat1.parse(string);
        System.out.println(parse);

Math

• Math类包含用于执行基本数学运算的方法

  方法名	说明
  static int abs(int a)	复制数组
  static double pow(double a ,double b)	返回第一个参数的第二个参数次幂的值
  static double random	返回带正好的double值[0,1)
  static long round(double a)	返回最接近参数的Long
  static double cbrt(double a)	返回double值的立方根

        System.out.println(Math.abs(100)); //100   absolute root
        System.out.println(Math.abs(-100));//100
        System.out.println(Math.ceil(3.9));//4.0  ceil天花板
        System.out.println(Math.floor(3.9));//3.0   floor地板
        System.out.println(Math.pow(2, 10));//1024
        System.out.println(Math.round(3.5));//3
        System.out.println((int)( Math.random() * 10));
        //100-999
        System.out.println((int)(Math.random()*900)+100);
        //50 100
        System.out.println((int)(Math.random()*51)+50);
        //平方根
        System.out.println(Math.sqrt(4));//2.0  square root
        System.out.println(Math.cbrt(27));//cube root

Random

• 此类的实例用于生成伪随机数流

• 此类使用48位的种子，使用线性同余公式（linear congruential form)对其进行修改所得

  方法名	说明
  int nextInt	返回下一个伪随机数
  double nextDouble	返回0.0和1.0之间均匀分布的double值

• 若long种子确定，则在不同程序中，相同次数产生的伪随机数是相同的。

        Random random = new Random();
        System.out.println(random.nextInt());
        System.out.println(random.nextDouble());
        System.out.println(random.nextInt(100));//1-99

        Random random1 = new Random(100);
        Random random2 = new Random(100);
        System.out.println(random1.nextInt() == random2.nextInt());

System

• System系统类，主要用于获取系统的属性数值和其他操作

  方法名	说明
  static void arraycopy()	赋值数组
  static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
  static void gc()	建议JVM，如果参数是0表示正常退出JVM,非0表示异常退出JVM

          int[] nums = {12, 3, 63, 3, 5};
          int[] nums1 = new int[10];
          System.arraycopy(nums, 0, nums1, 0, nums.length);
          System.out.println(Arrays.toString(nums1));
  
  
          long start = System.currentTimeMillis();
          long start1=System.nanoTime();
          StringBuilder stringBuilder = new StringBuilder();
          for (int i = 0; i < 99999; i++) {
              stringBuilder.append(i + " ");
          }
          long end = System.currentTimeMillis();
          long end1=System.nanoTime();
          System.out.println(end - start);
          System.out.println((end1-start1)/Math.pow(10,9));
          
          //退出jvm  status 0正常退出  非0非正常退出
          System.exit(0);
          System.out.println("end...");
  

  Runtime类

  • 每个Java应用程序都有一个Runtime类实例，使应用程序能够与运行的环境相连接，可以通过getRuntime()方法获取当前运行时

  方法名	说明
  Process exec(String command)	在单独的进程中执行指定的字符串命令。
  void exit(int status)	终止当前正在运行的Java虚拟机
  void gc()	建议JVM赶快启动垃圾回收器回收垃圾
  long totalMemory()	返回Java虚拟机中的总内存总量。
  long freeMemory()	返回Java虚拟机中的空闲内存量
  maxMemory()	返回Java虚拟机试图使用的最大内存量。

  • 修改JVM运行内存
    • 修改堆初始内存大小-Xms300m
    • 修改栈最大内存大小-Xmx4000m
    • 修改栈空间大小：Xss2m jdk1.5之前256k jdk1.5之后1m

        //Runtime类：运行时类，只能通过getRuntime()获取实例
        Runtime runtime=Runtime.getRuntime();
        //1.exec()；在单独进程中执行命令
        Process notepad = runtime.exec("notepad");
        Process calc = runtime.exec("calc");
        Process control = runtime.exec("control");
        Thread.sleep(3000);
        //关闭
        notepad.destroy();
        calc.destroy();
        control.destroy();
        Thread.sleep(10000);

//        System.exit(0);
//        runtime.gc();
//        System.gc();//使用的runtime.gc()

        System.out.println(runtime.totalMemory()/1024/1024);
        System.out.println(runtime.freeMemory()/1024/1024);
        System.out.println(runtime.maxMemory()/1024/1024);

异常

• 概念：程序在运行过程中出现的特殊情况。
• 异常处理的必要性：任何程序都可能存在大量的未知问题，错误，如果不对这些进行正确处理，则可能导致程序的中断，造成不必要的损失。

异常的分类

• Throwable:可抛出的，一切错误或异常的父类，位于java.lang包中，
  • Error.:JVM，硬件，执行逻辑错误，不能手动处理。
  • Exception.：程序在运行和配置中产生的问题，可处理
    • RuntimeException:运行时异常，可处理，可不处理
    • CheckedException：检查时异常，必须处理。

类型	说明
NullPointerException	空指针异常
ArrayIndeOutOfBoundsException	数组越界异常
ClassCastException	类型类型转换异常
NumberFormatException	数字格式化异常
ArithmeticException	算术异常

异常的产生

• 自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常。
• 手动抛出异常：语法：throw new 异常类型（“实际参数”）；
• 产生异常结果：相当于遇到return 语句，导致程序因异常而终止。

异常的传递

• 异常的传递：按照方法的调用链反向传递，如时钟没有处理异常，最终会由JVM进行默认中断，异常处理（打印堆栈跟踪信息）
• 检查时异常：throws声明异常，修饰在方法参数列表后端。
• 运行时异常：因可处理可不处理

异常的处理

try{
    //可能出现异常的代码
}catch(Exception){
    //处理异常
}finally{
    //
}

常见异常处理结构

• try{}catch{}

• try{}catch{}catch{}…

• try{}catch{}finally{}

• try{}catch{}catch{}finally{}

• try{}finally{}

• 从小到大原则,子类异常在前面。

• try…finally…不能捕获异常，仅仅用来当发生异常时，用来释放资源

• 一般用在底层代码，只释放资源不做异常处理，把异常向上抛出

        //ctrl+alt+t
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.println("Please input a number");
            int num1 = scanner.nextInt();
            System.out.println("Please input other number");
            int num2 = scanner.nextInt();
            System.out.println(num1 / num2);
        } catch (Exception e) {
//            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();
        }

        int result = 0;
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("Please input a number");
            int number1 = scanner.nextInt();
            System.out.println("Please input a number");
            int number2 = scanner.nextInt();
            result = number1 / number2;
        } catch (InputMismatchException e) {
            e.printStackTrace();
        }catch (ArithmeticException e){
            e.printStackTrace();
        } catch (Exception e){
            System.out.println("位置异常");
        }
        System.out.println(result);

抛出异常

• 除了系统自动抛出异常外，有些问题需要程序员自行抛出异常
• throw关键字，抛出异常
• 语法：throw异常对象。

抛出异常和捕获异常的区别

• 抛出异常：如果出现异常，没有办法将具体的异常打印出，不做任何处理
• 捕获异常：如果出现异常，就能详细打印出什么原因导致了异常并能处理，显示出详细的Log.

try{},catch{},finally{}中是否可以有retrun;？

• 三个语句中都可以写return;但是一般finally{}不写return,因为会造成返回结果有问题

如果try中有return,那么finally里面的代码会不会执行。

• 一定会执行。

public static void print(){
    int num=10;
    try{
        return num++;
    }finally{
        retrun num++;
    }
} //int result=print()=11;

int num=10;
try{
    return num++;
}catch(Exception e){
    return num++;
}finally{
    num++;
} //int result=print()=10;

• 运行时异常，也就是extends RuntimeException的异常编译时不用try{}catch(){}和throws

• 编译时异常，也就是extends Exception 的异常需要在调用时try{}catch(){}或throws*

自定义异常

• 概念：需继承Exception或Exception的子类，代表特定问题。

方法重写

带有异常声明的方法重写：

• 方法名、参数列表、返回值类型必须和父类相同。
• 子类的访问修饰符合父类相同或是比父类更宽。
• 子类中的方法，不能抛出比父类更多、更宽的检查时异常

本文地址：https://blog.csdn.net/DemoD_/article/details/107675324