4.25

最新推荐文章于 2024-10-31 17:37:36 发布

Pisces1996

最新推荐文章于 2024-10-31 17:37:36 发布

阅读量249

点赞数

本文链接：https://blog.csdn.net/Pisces1996/article/details/70685775

版权

JAVA

标号语句

break 和 continue 语句既可以是有标号，也可以是没有标号的。但是实际开发中，没有标号的break 和 continue 语句更常用。

标号语句一般只有在嵌套的循环中才会用到，这样 break 语句将跳出标号的循环体

break [label];

这个语句相当于C++语言中 goto 语句

public class BreakContinue2 {
        public static void main(String[] args) {
                outer:for(int i=0;i<=10;i++) {
                       //当i等于偶数时进入下一次循环
                       for(int j=0;i<2;i++) {
                              if(i==2) {
                                   break outer;
                              }
                              //否则打印i的值
                              System.out.println("i="+i);
                        }
                }
                System.out.println("跳出循环体");
        }
}

当i==2时，跳到outer标记处继续执行，得到如下结果：

F:\gz\JAVA\lckz>java BreakContinue2
i=0
i=1
跳出循环体

Continue 语句的语法格式如下

continue [label];

当没有label 标号时，continue 语句用于结束当前循环，然后执行循环语句中结束条件的判断继续下一次循环。当使用 label 标号时，continue 可以跳转到 label 标号所指明的外层循环

public class BreakContinue3 {
        public static void main(String[] args) {
                outer:for(int i=0;i<=10;i++) {
                        //当i等于2时进入下一次循环
                        if(i==2) {
                             continue;
                        }
                        //当i等于3时跳出循环
                        if(i==3) {
                             continue outer;
                        }
                        //否则打印i的值
                        System.out.println("i="+i);
                }
                System.out.println("跳出循环体");
        }
}

当i 等于2时直接进入下一次循环，当i 等于3时跳到 outer 标记处，运行结果：

F:\gz\JAVA\lckz>java BreakContinue3
i=0
i=1
i=4
i=5
i=6
i=7
i=8
i=9
i=10
跳出循环体

异常处理

异常的层次结构

在Java 语言中，所有的异常类都扩展自java.lang.Exception 类，而这个异常类又是Throwable类的子类

此处需要了解异常的层次结构，从属关系

java.lang.Exception和 java.lang.Erro 两个类都扩展自Throwable类，Throwable类是Java 异常处理的总跟类，它继承自Object类

try-catch 处理异常

import java.io.*;
public class Try {
        public static void main(String args[]) {
               try {
                     File f=new File("");
                     f.getCanonicalFile();
                } catch (IOException nfe) {
                      nfe.printStackTrace();
                } catch (Exception e) {
                      e.printStackTrace();
                }
        }
}

f.getCanonicalFile(); 语句将抛出IOException 捕获异常，异常被抛出后，程序将转移到 catch 子句中执行，从而调用 printStackTrace() 方法打印异常的跟踪

使用 finally

程序在执行过程中一旦抛出异常，就会跳出try 语句块，进入异常处理的代码执行，而这时的程序可能还连接着数据库。这将对系统资源造成很大的浪费，所以应该在程序抛出异常时仍然保证将这些占用的资源都关闭。

public class FinallyTest {
        public static void main(String args[]) {
                try {
                      System.out.println("try语句块执行! ") ;
                      //程序返回
                      return;
                } catch (Exception e) {
                      //打印异常信息
                      e.printStackTrace();
                } finally {
                      System.out.println("finally语句块执行! ");
                }
        }
}

程序在执行一次打印后从方法返回，得到如下结果：

F:\gz\JAVA\lckz>java FinallyTest
try语句块执行!
finally语句块执行!

可以看出，即使在程序中使用了 return 语句从方法返回， finally 语句块也同样会执行

import java.io.*;
public class FinallyTest1 {
        public static void main(String args[]) {
                FileInputStream fis=null;
                try {
                      File f=new File("F:\\cmd.txt");
                      fis=new FileInputStream(f);
                      fis.read();
                } catch (IOException e) {
                      e.printStackTrace();
                } finally {
                      //关闭输入流
                      try {
                            fis.close();
                      } catch (IOException e) {
                            e.printStackTrace();
                      }
                      System.out.println("finally语句块执行! ");
                }
        }
}

以上代码的作用是读取F盘根目录下的cmd.txt 文件：

F:\gz\JAVA\lckz>java FinallyTest1
finally语句块执行!

异常的匹配

在一个程序中，可能会同时抛出多个异常。如果这些异常或者其中一部分有继承关系或者是在同一个继承树上该怎么处理呢，这就是异常的匹配。

当抛出一个异常的时候，Java 首先回去找为这个异常编写的 catch 子句，如果没有找到则搜索该异常类子类的处理程序，以此沿着调用向下传播该异常

在实际开发中，需要将更具体的异常处理程序放在最前面：

import java.io.*;
public class ExceptionTest {
        public static void main(String args[]) {
                FileInputStream fis=null;
                try {
                      File f=new File("F:\\cmd.txt");
                      fis=new FileInputStream(f);
                      fis.read();
                } catch (FileNotFoundException fnfe) {
                      fnfe.printStackTrace();
                } catch (IOException ie) {
                      ie.printStackTrace();
                } catch (Exception e) {
                      e.printStackTrace();
                } finally {
                     //关闭输入流
                     try {
                           fis.close();
                     } catch (IOException e) {
                           e.printStackTrace();
                     }
                }
        }
}

FileNotFoundException 是 IOException 的子类，而 IOException 又是 Exception 的子类

除了可以使用系统提供的异常处理类之外，也可以自己开发自己的异常类，只要继承 Throwable 类即可：

public class MyException extends Throwable {
        public String msg;
        //无参构造函数
        public MyException() {
        }
        //有参构造函数
        public MyException(String msg) {
                //调用父类有参构造函数
                super(msg);
        }
}

MyException 为自己定义的异常类，这样就可以在自己的应用程序中使用自定义的异常处理类：

class MainClass1 {
        public static void main(String args[]) {
                try {
                      throw new MyException("MyException");
                } catch (MyException me) {
                      me.printStackTrace();
                }
        }
}

throw new MyException("MyException") 是异常的再抛出:

F:\gz\JAVA\lckz>java MainClass1
MyException: MyException
at MainClass1.main(MainClass1.java:4)

LINUX

useradd 建立用户

newgrp 转换组，用来转换用户的当前组到指定的组账户，用户必须属于该组才能执行

pwck 检测用户账号信息的完整性

grpck 检测用户组账号信息的完整性

tar 备份文件，用来建立，还原备份文件的工具程序，可以加入，解开备份文件内的文件

dump 备份文件系统，作为备份工具程序，可将目录或整个文件系统备份至指定的设备，或备份成一个大文件

restore 还原备份下来的文件或整个文件系统

unzip 解压缩zip 文件

gizp 压缩文件