java 实现目录树移动 javase目录

转载

mob6454cc6e6a40 2023-09-06 15:18:57

文章标签 java 实现目录树移动 java System 数据 文章分类 Java 后端开发

javaSe基础篇

JDK的下载和安装

java 实现目录树移动 javase目录_数据

1.按照提示安装即可

2.配置环境变量

新建JAVA_HOME:

java 实现目录树移动 javase目录_System_02

配置系统path路径(也可以设置用户path,但是当系统和用户变量同时存在是,会优先选择系统环境变量)

java 实现目录树移动 javase目录_java 实现目录树移动_03

3.环境变量配置完成，检查是否配置正确，启动命令窗口：

win+R：cmd

输入java、javac、java -version：

java 实现目录树移动 javase目录_java 实现目录树移动_04

java 实现目录树移动 javase目录_java 实现目录树移动_05

java 实现目录树移动 javase目录_System_06

DOS命令概述

1.打开DOS窗口:win+R

2.查看当前目录所有文件:dir\

java 实现目录树移动 javase目录_java_07

3.切换盘符:cd /d A:

java 实现目录树移动 javase目录_数据_08

4.清除屏幕：cls

java 实现目录树移动 javase目录_数据_09

5.查看本机IP:ipconfig

java 实现目录树移动 javase目录_System_10

6.相关文件的操作：

md 创建文件夹
rd 移除文件夹
cd>a.txt 新建文件
del a.txt 删除文件

基础语法

注释

1.单行注释://

2.多行注释:/* */

3.文档注释:/** */

关键字

关键字是java里有特殊意义的标识符

如for,if,case

数据类型

1.java是强类型语言

所有变量要先定义(变量名,类型,作用域,变量值)

2.java的数据类型分为两大类

1.基本数据类型

简单类型	boolean	byte	char	short	Int	long	float	double	void
二进制位数	1	8	16	16	32	64	32	64	--
封装器类	Boolean	Byte	Character	Short	Integer	Long	Float	Double	Void

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。

short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。

int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

boolean：只有true和false两个取值。

char：16位，存储Unicode码，用单引号赋值。

2.引用数据类型(变量,对象)

3、常见的问题

银行业务的表示：
不能使用浮点数，会有舍入误差，只能说接近，因为会有精度损失
BigDecimal：数学工具类；

变量常量

public class Test01 {    public static void main(String[] args) {
        //局部变量
        int a=100;
        //常量
        final int MAX_A=100;
        Test01 test01 = new Test01();
        System.out.println(test01.id);
        System.out.println(b);
        System.out.println(MAX_A);
        System.out.println(PI);
        System.out.println(a);
    }
    //实例变量
    int id;
    String name;
    int age;
    //类变量
    static int b;
    static final double PI=3.14;

public class Demo3 {        int a;
        String b;
        boolean c;
        public static void main(String[] args)
        {
            Demo3 test = new Demo3();
            int a=test.a;
            System.out.println(a);//实例变量在创建实例时会被类加载器初始化,所以可以输出;
            System.out.println(test.b);
            System.out.println(test.c);
        }
}

类型转换

1.java中整数类型默认的int类型；小数类型默认的double；

2.String的字符串转化为char类型时，只能用char类型的数组来接收；字符串在转化成char类型是不能像int、float那样使用封装类的parseXXX方法等，但它可以转换成char类型的数组；long str1=Long.parseLong(str);

3.byte de=(byte) 128;System.out.println(de); 结果：-128 //如果数字溢出当前的数字类型，有两种方法可以阻止其出错，一种是直接强转成当前数据类型，另一种是转成其他的数据类型（较大的）**

4.String的字符串进行类型转换时，如果字符串中包含long整形的字符大写L或者小写l时，在转换成字符串时，会出现错误

例如： String str="123L"; long str1=Long.parseLong(str); System.out.println(str1);//结果：错误

String的字符串是float、double浮点型时，字符串可以加f、F、D、d等，在进行基本类型转换时不会出错

例如： String f1="12.34f";

float f2=Float.parseFloat(f1); System.out.println(f2);//结果：12.34,；d、D也一样

5.自动类型转换(也叫隐式类型转换) ，其实就是小范围的数据类型向大范围的数据类型转换，例如int类型转long

强制类型转换(也叫显式类型转换) int b = (int)(i + j);

强制类型转换在某种情况下会丢失精度

表达式的数据类型自动提升

public class Demo1 {    public static void main(String[] args) {
    int a =2;
    int b=3;
    double c=3.1415D;
    float d=3.141f;
    long e=352L;
    short f=12;
    char g='a';
    int a1=a++;
    int a2=++a;
    double h= Math.pow(2,3);

        System.out.println(g+f);
        System.out.println(a+b);
        System.out.println(a+b+c+d+e+f+g);//向上转型,类型自动提升为最大的
        System.out.println(a/b);
        System.out.println(a!=b);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(h);

    }
}

运算符

算数运算符的种类

+	-	*	/	%	++	--

注：整数相除只能得到整数，如果想得到小数，就要使用浮点数（float、double）；/是获得除法的商；%获取的是除法操作的余数（4%5=8），运算结果的符号取决于参与运算的左边的符号。

++--运算符的用法

++：自加。对原有的数据进行+1	--：自减。对原有数据进行-1
放在操作数的前面和后面效果一样
注：放在操作数的前面，先自增或者自减，然后再参与运算; 放在操作数的后面，先参与运算，再自增或者自减。

Math类

double h= Math.pow(2,3);//2^3,因为java没有幂运算,除此之外还可以移位实现

赋值运算符的种类

=	+=	-=	*=	/=	%=

赋值运算符的注意事项

基本的赋值运算符=：把=右边的数据赋值给左边。
扩展的赋值运算符+=,-=,*=,/=,%=：把左边和右边做加法，然后赋值给左边。
赋值运算符要求左边的数据必须是一个变量

关系运算符的种类

==	!=	<=	>=	>	<	instanceof

关系运算符的注意事项

无论你的操作是简单还是复杂，结果是boolean类型
"=="不能写成"="

逻辑运算符的种类

！(非)	&(与)	&&(短路与)	\|(或)	\|\|(短路或)	^(异或)

public class Demo2 {    public static void main(String[] args) {
        int c=4;
        boolean d=(c<3)&&(c++<3);
        System.out.println(d);//短路
       

    }
}

位运算符的种类

~(按位取反)	<<(左移)	&(与)	\|(或)	>>(右移)	^(异或)	>>>(无符号右移)
~:按位取反 0变1 1变0	空位补0，被移除的高位丢弃	&:有0则0	^:相同则0，不同则1	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，高位补1。	^:相同则0，不同则1	被移位二进制最高位无论是0或者是1，空缺位都用0补。

小知识:

System.out.println(2<<3);//表示2^3

三目运算符与格式

public class Demo2 {    public static void main(String[] args) {
      
        String f=2<1?"good":"false";//前为真则为good,为假则为false;
        System.out.println(f);

    }

扩展运算符

+= -= *+ /= <<=

例:a+=c 等价于a=a+c a<<=x等价于a=a<<x

此处不做过多赘述

包机制:import package;

流程控制

用户交互Scanner

import java.util.Scanner;

Scanner s=new Scanner(System.in);

next() nextLine()获取输入内容

hasNext() hasNextLine()判断是否还有输入

package JavaSe.struct;import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner src=new Scanner(System.in);
        int[] i=new int[src.nextInt()];
        for (int x:i) {
            System.out.println(x);

        }
        src.close();
    }

}

顺序结构

顺序结构：就是从头到尾依次执行每条语句的操作。

选择结构

在java中，选择结构分为if-else语句和 switch 语句。

//单选择结构if(布尔表达式){ 语句或语句块 }else{ 语句或语句块 } //多选择结构 if(布尔表达式){ 语句或语句块 }else if(布尔表达式){ 语句或语句块 }else{ 语句或语句块 }

1）if括号里表达式的值返回的必须是布尔类型

2）如果条件体内只有一条语句需要执行，那么if后面的大括号可以省略。建议不要省略！

3）如果出现有多个if一个else的情况，else子句归属于最内层的if语句。

switch(表达式){case 常量值1: 语句块; break; case 常量值2: 语句块; break; case 常量值3: 语句块; break; .. default: 语句块; break; }

1）switch中表达式的返回值只能是int，byte，char，short，枚举，字符串；

2）case子句中的值必须是常量，且不能重复；

3）default可有可无;

4）break作为某一个case代码段的结束句，使其跳出程序。

循环结构

while循环 do...while循环 for循环

public class BreakList {    public static void main(String[] args) {
        int i=0;
        while(i<10)
        {
            if (i<5) {
                System.out.println(i);
            }
            i++;
            System.out.println(i);
        }
    }
}

public class Demo4 {    public static void main(String[] args) {
        for(int j=1;j<10;j++)
        {
            for(int i=1;i<=j;i++){
                System.out.print(j+"*"+i+"="+j*i);
            }
            System.out.println();
        }

    }
}

public void test(){        int i=0;
        do {
            if (i<5) {
                System.out.println(i);
            }
            i++;
            System.out.println(i);
        }
        while (i<10);

//for循环深入//奇数和偶数的和分别是多少-100以内
public void test2(){
        int oddSum=0;
        int evenSum=0;
        for (int i = 0; i <= 100; i++) {
            if (i/2!=0){//奇数
                evenSum=evenSum+i;
            }else {//偶数
                oddSum=oddSum+i;
            }

        }
//九九乘法表
public void test3(){
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            System.out.print(i*j);
        }
        System.out.println("");
    }
}
//增强for循环
//遍历数组
public void test4(){
    int[] arry=new int[10];
    for(int x;arry){
        System.out.printl(x);
    }
}

break && continue&&return

break语句：

break语句刚刚在switch中已经见过了，是用来终止case的。实际上，break出现在while，do-while，for循环中，用于强行退出当前循环。

continue语句：

continue只能用于for，while，do-while循环语句中，用于让程序跳出本次循环，直接进入下次循环。

return语句

public void show(){        System.out.println("show---");
        return;//结束方法
    }

public static int add(int a, int b){        return a+b;//返回值
    }

三角形打印

public class Triangle {    public static void main(String[] args) {
        for (int i = 0; i <=5; i++) {
            for (int j = 5; j >=i; j--) {
                System.out.print(" ");
            }
            for(int j=0;j<=i;j++)
            {
                System.out.print("*");
            }
            for(int j=0 ;j<i;j++)
            {
                System.out.print("*");
            }
            System.out.println();

        }
    }
}

###

方法

方法的定义和调用

[修饰符] 返回值类型方法名（[参数类型参数名]，[…]）{return 值}

方法的重载

方法名必须相同
参数列表必须不同（个数不同、参数类型不同、参数列表的顺序不同）
参数的返回值类型可以不同也可以相同
仅仅返回值类不同不足以构成方法的重载

public static void main(String[] args) {        test(3,5);//调用静态方法
        Test03 test03 = new Test03();
        System.out.println(test03.test(1,2,3));//调用非静态方法
        System.out.println(test03.test(1.0,2.0));
    }
    static void test(int a, int b){
        System.out.println(a+b);
        }
    int test(int a,int b,int c){
        return a+b+c;
    }
    double test(double a,double b){
        return a+b;
    }
}

可变参数

1.在方法声明中类型后面加...

2.必须在参数列表的最后

3.储存类似于数组

int test(int... a){        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"\t");
        }
        return 0;
    }
test03.test(1,2,3,4,5);//方法的调用

递归详解

递归就是方法自己调用自己
递归分为递归头和递归体

public class Demo1 {    public static void main(String[] args) {
        System.out.println(f(3));
    }
    private static int f(int n){
        if (n==1){
            return 1;
        }else {
            return n*f(n-1);//10*9*8*7*6*5*4*3*2*1
        }
    }
}

数组

数组创建与声明

dateTyepe[] arrayNmae;或者dateTyepe[] arrayName[]

创建数组:dateType[] arrayName=new dateType[arraySize];或者 dateType[] arrayName={...};

数组一旦被创建,其大小不会改变

获取数组长度

arrays.length

内存分析

堆:存放对象及数组

栈:存放变量类型及引用对象的变量

方法区:calss static变量

二维数组

dateType arratName=new dateType[arraySize] [arraySize];或者 dateType[] arrayName={...};

冒泡排序

public class ArraysDemo2 {    public static void main(String[] args) {
        int[] array={101,5,2,1,6,7,4,9,100,99};
        System.out.println(Arrays.toString(sort(array)));

    }
    public static int[] sort(int[] array){
        int imp=0;
        for (int i = 0; i <array.length-1; i++) {   		//每轮外层比较,内层两两比较,都会把最小或最大的冒泡到最后一位
            for (int j=0;j<array.length-1-i;j++){			//,因此,每轮外层之后都可以减少一个内层最后一位
                if (array[j+1]>array[j]) {
                    imp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=imp;
                }

            }

        }
        return array;
    }
}

稀疏数组

行数	列数	非0总数
x	y	sum
非0元素.	非0元素.	非0元素.

public class ArraysDemo3 {    ArraysDemo3(){
        System.out.println("调试");
    }
    public static void main(String[] args) {
        //创建原数组
        ArraysDemo3 test=new ArraysDemo3();
        int[][] array1 = new int[10][10];
        array1[2][5] = 25;
        array1[8][7] = 26;
        array1[9][9] = 88;
        //遍历输出原数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println("");

        }
        System.out.println("==========");
        //获取非0数组元素个数
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }

            }

        }
        //根据非0元素个数觉得稀疏数组size;
        int[][] array2 = new int[sum+1][3];
        //稀疏数组头部
        array2[0][0] = 10;
        array2[0][1] = 10;
        array2[0][2]=sum;
        int sum2 = 1;
        //将原数组非0元素赋值稀疏数组
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array1[i][j] != 0) {
                    array2[sum2][0] = i;
                    array2[sum2][1] = j;
                    array2[sum2][2] = array1[i][j];
                    sum2++;
                }
            }
        }
        for (int[] anInt2:array2)
        {
            for (int anInt3:anInt2)
            {
                System.out.print(anInt3+"\t");
            }
            System.out.println("");

        }
        System.out.println("======");
        //方向逆转稀疏数组
        System.out.println("还原");
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i <array2.length; i++) {
            for (int j = 0; j <array2[i].length; j++) {
                array3[array2[i][0]][array2[i][1]]=array2[i][2];

            }

        }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println("");

        }
    }

面向对象

一切皆对象

类构造器

方法名和类名相同；
无参构造器是默认存在的；
如果自己定义了一个有参构造器，那么无参构造器必须显示定义

public class Student {    String name;
    int age;
    //alt+insert自动生成
    //无参构造器
    public Student() {
    }

    //有参构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    void study(){
        System.out.println(this.name+"\t"+this.age+"\t"+"在学习！");
    }
}


public class Application {
    public static void main(String[] args) {
        Student student1 = new Student("lscong",22);
        student1.study();
    }
}

封装

程序追求“高内聚、低耦合”，
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：尽量暴露少量的方法给外部使用；
私有属性----定义set、get方法

一句话,属性私有(get/set方法)!

继承

关键字：extends；
java中只有单继承，没有多继承；
子类拥有父类所有的东西，但是私有的东西是不能被继承的；
Object是所有类的父类，直接继承Object
super关键字：调用父类的属性及方法
重写：
需要有继承关系，子类重写父类方法名必须相同，方法体不同参数列表必须相同修饰符可以扩大：public>protected>default>private 抛出的异常：可以缩小，但是不能扩大子类重写了父类，那么对象调用的就是执行重写的方法为什么重写：
父类的功能，子类不一定需要，或者不一定能够满足
1.父类是有参构造,子类必须调用父类的有参构造2.子类加载构造器时,默认先加载父类构造器,以此类推到从父类的父类开始 3.调用父类或者自身构造器时,必须放在构造器方法的第一行 4.构造器可以有多个过载构造器(不同形参)

public class Teacher extends Person{ Teacher(){ super("name");//如果父类是有参构造,子类必须显示调用有参构造,因为子类默认构造无参构造 }

public class Person {    Person(){
        System.out.println("this is the father");
    }
    private String name;
    private String sex;
    private int age;
    public String str="这是父类常量";

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }
    public void test(){
        System.out.println("这是父类方法");
    }
    public static void test3(){
        System.out.println("这是父类静态方法");
    }
}
class Teacher extends Person{

    Teacher(){

    }
    public String str="这是子类常量";
    public void test(){
        System.out.println("这是子类方法");
    }
    public void test2(){
        System.out.println("这是子类多余方法");
    }
    public static void test3(){
        System.out.println("这是子类静态方法");
    }

    public static void main(String[] args) {
        Object teach=new Teacher();
        teach.test();
        teach.test3();
        System.out.println(teach.str);
        
        System.out.println(teach instanceof Person);
    }
}

多态

（Father f1=new Son（）；）

1.一个对象的实际类型是确定的,但指向它的引用可以不同

2.因为指向它的引用类型不同,而表现出不同的方法(因为编译时类型表现为父类,而运行时类型是子类)

3.多态的存在条件有继承关系子类重写父类的方法父类的引用类型指向对象

4.只有方法多态,而无属性多态

6.总是执行子类的重写方法,而无法执行子类的独有方法

5.instanceof用于判断两个对象之间是否存在父子关系

public static void main(String[] args) {        Person teach=new Teacher();
        teach.test();//表现为子类重写方法
        teach.test3();//表现为子类重写方法
        //teach.test2();    //无法执行子类自有方法
        System.out.println(teach.str);

        System.out.println(teach instanceof Person);//ture
    }
}

Student s1=new Student();Person s2=new Student();

Object s3=new Student();

//Object>Person>Student
//Object>Person>Teacher
//Object>String
s3 instanceof Student//true
s3 instanceof Person//true
s3 instanceof Object//true
s3 instanceof String//false
s3 instanceof Teacher//false
    
s1 instanceof Student//true
s1 instanceof Person//true
s1 instanceof Object//true
s1 instanceof String//编译错误
s1 instanceof Teacher//编译错误
    
s2 instanceof Student//true
s2 instanceof Person//true
s2 instanceof Object//true
s2 instanceof String//编译错误
s2 instanceof Teacher//false

static关键字

static修饰的方法或者是变量常量内部类都会变成类的成员变量,作为类的一部分

抽象类

abstract关键字修饰
是一种约束，抽象方法，只有方法没有具体的方法体实现
只能靠子类去实现方法
抽象类中可以存在非抽象类方法，但是非抽象类不能写抽象方法
子类继承抽象类，必须对其抽象方法进行重写

public abstract class Abstract {    Abstract(){
        System.out.println("抽象类里有构造器");
    }
    public abstract void doSomething();//抽象方法不能有方法体
    public void okk(){
        System.out.println("抽象类可以有普通方法");//抽象类可以有普通方法
    }
    //抽象方法必须在抽象类中
    //抽象类不能实例化
    //抽象类有构造器
    //抽象方法必须被子类实现
    //抽象类可以没有抽象方法

}
class Action extends Abstract{
    public void doSomething(){
        System.out.println("子类必须实现抽象方法");
    }

    public static void main(String[] args) {
        Action action=new Action();
        action.doSomething();;
        action.okk();
    }


}

接口

接口只有规范

1.implements：继承关键字

2.interface：修饰符

3.[public abstract] void run();//方法

4.接口中定义的变量均为常量：[public abstract final ] AGE=100；//接口里不允许有变量

5.接口可以实现多继承

6.只有规范，自己无法写方法

7.以后均在面向接口编程

8.子类继承接口，子类必须对其方法进行重写

public interface TimeType {    int a=1;
    public static final int b=2;//接口里面的常量默认全部用public static final修饰
    void add();
    public abstract void delete();//接口里的方法全部默认用public abstract
}

内部类

成员内部类

public class Outer{    private String name;
    private int age;
    public void outer(){
     	System.out.println("outer!");   
    }
 		public class Inner{
            public void inner(){
             	   System.out.println("inner!");   
            }
        }
}

//new
Outer outer=new Outer();//非静态内部类依赖于外部类实例而实例化
Outer.Inner inner=outer.new Inner();//非静态内部类创建实例语法 outerclassDemo.new.innerclass()
inner.inner();

静态内部类

public class StaticInner {        private String name;
        private int age;
        public void outer(){
            System.out.println("outer!");
        }
        public static class Inner{
            public void inner(){
                System.out.println("inner!");
            }
        }

    public static void main(String[] args) {
        Inner test2=new Inner();//静态内部类不需要依赖外部类实例实例化

    }

}
class Normal{
    public static void main(String[] args) {
        StaticInner.Inner test3=new StaticInner.Inner();//静态内部类创建语法 new outerclass.innerclass()
    }

package JavaSe.oop;public class Outer {
    static String name="外部类静态变量";
    String name2="外部类实例变量";
    String box="这是外部类重名变量";
    public static void test1(){
        System.out.println("这是外部静态方法");
    }
    public void test2(){
        System.out.println("这是外部实例方法");
    }
    public class Inner{
        Inner(){
            System.out.println("这是内部类的构造器");
        }
        static String innerName="这是内部类静态变量";
        String getInnerName2="这是内部类实例变量";
        String box="这是内部类重名变量";
        public static void innerTest(){
            test1();
            //test2(); //实例内部类静态方法无法访问实例外部类实例方法,即 静态无法访问实例
            System.out.println(name);
        }
        public void innerTest2() throws Exception{
            String box="这是方法局部变量";
            test1();
            test2();
            System.out.println(name2);
            System.out.println(box);
            System.out.println(this.box);
            System.out.println(Outer.this.box);
        }
    }

    public static void main(String[] args) {
        Outer outter=new Outer();
        Outer.Inner inner=outter.new Inner();  //内部类只能通过外部实例化类来实例化
        Outer.Inner.innerTest();
        //Outer.Inner.innerTest2();  //外部类实例化对象无法直接访问内部类实例方法;
        try {
            inner.innerTest2();
        }catch (Exception e){
            System.out.println(e);
        }
        inner.innerTest();

    }
}

非静态内部类依赖于外部类实例而实例化

静态内部类不需要依赖外部类实例实例化\

非静态内部类创建实例语法 outerclassDemo.new.innerclass()

静态内部类创建语法 new outerclass.innerclass()

实例内部类静态方法无法访问实例外部类实例方法,即静态无法访问实例

局部内部类

public class Outer{    private String name;
    private int age;
    public void outer(){
        public class Inner{
            private int score;
            void run(){
             	   System.out.println("run!");  
            }
        }
     	System.out.println("outer!");   
    }
}

匿名内部类

package JavaSe.oop;public interface TimeType {
    int a=1;
    public static final int b=2;//接口里面的常量默认全部用public static final修饰
    void add();
    public abstract void delete();//接口里的方法全部默认用public abstract
}
class Test{
    public static void main(String[] args) {
        new TimeType(){				//在main方法里的匿名内部类
            @Override
            public void delete() {

            }

            @Override
            public void add() {
                
            }
        };
    }
}

异常处理

java 实现目录树移动 javase目录_java_11

程序错误分为三种：1.编译错误；2.运行时错误；3.逻辑错误。（1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是大家在刚接触编程语言最常遇到的问题。（2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。（3）逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。

Throwable：有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。异常和错误的区别是：异常能被程序本身可以处理，错误是无法处理。

Thrwoable常用方法

1. 返回异常发生时的详细信息public string getMessage(); 2. 返回异常发生时的简要描述 public string toString(); 3. 返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同 public string getLocalizedMessage(); 4. 在控制台上打印Throwable对象封装的异常信息 public void printStackTrace();

异常抛出：任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。 异常捕获：捕捉异常通过try-catch语句或者try-catch-finally语句实现。总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

public class Outer {   
        public void innerTest2() throws Exception{
         
        }
    }

    public static void main(String[] args) {
        Outer outter=new Outer();
   
        try {
            outter.innerTest2();
        }catch (Exception e){
            System.out.println(e);//此处调用了异常类的toString()
        }
        finnally{
            ...
        }
    }
}

public class Except {    int a=0;
    int b=2;
    public void test(){
        try{
            if (a==0){
                throw new ArithmeticException();//主动抛出异常
            }
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println(e);
        }finally {
            System.out.println("这是一个默认处理语句,在catch不到异常时才执行");
        }
    }
}

创建自己的异常类

public class Excep extends Exception {    String myException;
    public Excep(String myException){
        this.myException="这是我自己定义的异常类";

    }
    public String toString(){
        return myException;
    }

}
class ThrowsEX {
    public void test() throws Excep{
        System.out.println("测试自己的异常类");

    }

    public static void main(String[] args) {
        try {
            new ThrowsEX().test();
        }catch (Excep e){
            System.out.println(e);

        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java 堆栈信息如何分析 java堆栈方法区思维导图

下一篇：Android 重要通知不重要通知重要通知设置

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯