Java核心技术精讲-优快云博客

本文深入讲解Java中的文件操作、异常处理及设计模式等核心概念。详细介绍File类的使用方法，包括构造方法、创建与删除文件及目录等功能；探讨Java异常体系结构及处理方案，如try-catch-finally和throws关键字的运用；并介绍单例、工厂和抽象工厂三种设计模式的原理与实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java学习之文件、异常、设计模式

主要内容为文件File,异常Exception，设计模式的学习心得。

文件：File，文件和目录（文件夹）路径名的抽象表示形式。
异常：Exception，即程序出现的不正常的情况
设计模式：主要介绍一下单例设计模式、工厂设计模式以及抽象工厂设计模式

File

- File的构造方法

    File(String pathname):把一个路径名称封装成File对象
    File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
    File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象

- File的创建功能

    A:创建文件
        public boolean createNewFile():如果文件不存在，就创建。否则，不创建。
    B:创建目录
        public boolean mkdir():如果目录不存在，就创建。否则，不创建。
        public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
                                即时父目录不存在，也可以连父目录一起创建。

- File的删除功能

    public boolean delete():既可以删除文件，又可以删除目录。

- File的判断功能

    public boolean isDirectory():是否是目录
    public boolean isFile():是否是文件
    public boolean exists():是否存在
    public boolean canRead():是否可读
    public boolean canWrite():是否可写
    public boolean isHidden():是否隐藏

- File的获取功能

    public String getAbsolutePath():获取绝对路径
    public String getPath():获取相对路径
    public String getName():获取名称

下面是针对文件的一些操作代码。


package com.wy.file;

import java.io.File;
import java.io.IOException;

public class FileTest {
    public static void main(String[] args) throws IOException {

        //File(String pathname):把一个路径名称封装成File对象
        File f = new File("F://wy.txt");
        //创建文件
        System.out.println(f.createNewFile());

        //File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
        File f1 = new File("F://test");
        System.out.println(f1.mkdir());

        //File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
        File f2 = new File(f1,"a.txt");
        System.out.println(f2.createNewFile());

        File f3 = new File("F://aaa//bbb//ccc");
        System.out.println(f3.mkdirs());

        //public boolean delete():既可以删除文件，又可以删除目录。
        //只能删除目录下没有文件的目录
        //System.out.println(f3.delete());

        //删除文件
        //System.out.println(f.delete());

        System.out.println("-----进行判断功能-----");
        System.out.println("文件的判断");
        System.out.println(f.isFile());
        System.out.println(f.isDirectory());
        System.out.println(f.isHidden());
        System.out.println("目录的判断");
        System.out.println(f3.isFile());
        System.out.println(f3.isDirectory());
        System.out.println(f3.isHidden());

        File f4 = new File("a.txt");
        System.out.println(f4.createNewFile());
        System.out.println("------文件获取功能------");
        //文件的绝对路径和相对路径只有在本项目中才会体现出来
        System.out.println(f4.getAbsolutePath());
        System.out.println(f4.getPath());
        System.out.println(f4.getName());


    }
}

运行结果为

Exception

- Exception的体系结构

Throwable：
    Error：
    Exception：
        非RuntimeException：编译时期异常
        RuntimeException：运行时期异常

异常：程序出现不正常的情况
分为Error和Exception
错误Error：这是非常严重的问题，一般我们处理不了,一般在这里指的是硬件问题。
异常Exception：又分为编译期异常和运行期异常
编译时期异常：开始就必须要处理的，如果不处理，后面就走不了。
运行时期异常：开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序。

- 针对Exception的处理方案

主要分为两种：
1.try…catch…finally

 * try...catch...finally:
 *      try{
 *          可能出现异常的代码
 *      }catch(异常类名 变量名) {
 *          针对异常的代码处理
 *      }finally {
 *          释放资源的地方
 *      }

示例代码如下：

package com.wy.exception;

public class TryCatchTest {
    public static void main(String[] args) {
        //在try中进行有可能会出现异常的处理
        try{
            //进行此操作，有可能出现数组越界异常
            int[] arr = {1,2,3,4,5,6};
            System.out.println(arr[100]);

            //有可能出现除数为零的情况
            int a = 1;
            int b = 0;
            System.out.println(a/b);

        }catch(ArithmeticException e){//在catch中捕获异常
            System.out.println("除数为0啦");
        }catch (IndexOutOfBoundsException e) {
            System.out.println("数组越界啦");
        }
        finally{
            System.out.println("只要jvm没有退出，我一定会被执行");
        }
    }
}

2.throws

编译期异常与运行期异常的区别，Throw与Throws的区别

编译时期异常：
Java程序必须显示处理，否则程序就会发生错误，无法通过编译
FileNotFoundException（文件未找到异常）

运行时期异常：
无需显示处理，也可以和编译时异常一样处理
ArithmeticException

实例代码如下：

package com.wy.exception;

public class ThrowsTest {
    public static void main(String[] args) throws ArithmeticException,IndexOutOfBoundsException{
        //ArithmeticException是运行时期异常，在编译期不进行抛出可以运行
        int a = 1;
        int b = 0;
        System.out.println(a/b);

        //数组越界，直接抛出，谁调用谁负责异常的处理，这里只是把可能出现的运行时期异常给抛出去
        int[] arr = {1,2,3,4,5,6};
        System.out.println(arr[100]);
        //这里文件未找到异常时编译期异常，必须要显式处理才能运行，如果不处理，则编译不通过。
    }
}

Throw与Throws的区别
throws:

        用在方法声明后面，跟的是异常类名
        可以跟多个异常类名，用逗号隔开
        表示抛出异常，由该方法的调用者来处理
        throws表示出现异常的一种可能性，并不一定会发生这些异常

throw:

    用在方法体内，跟的是异常对象名
    只能抛出一个异常对象名
    表示抛出异常，由方法体内的语句处理
    throw则是抛出了异常，执行throw则一定抛出了某种异常?

Throw与throws的代码示例：

package com.wy.exception;

public class ThrowTest {
    public static void main(String[] args) throws IndexOutOfBoundsException{
        try{
            int a = 1;
            int b = 0;
            System.out.println(a/b);

            //数组越界，直接抛出，谁调用谁负责异常的处理，这里只是把可能出现的运行时期异常给抛出去
        }catch(ArithmeticException e){
            System.out.println("在遇到异常的时候，我没有解决，只是简单的把异常抛出去");
            throw e;

        }
    }
}

设计模式

- 设计模式的概述

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使    用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性以及代码的结构更加清晰.

- 设计模式的分类

1.创建型模式(创建对象的): 单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
2.行为型模式(对象的功能): 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3.结构型模式(对象的组成): 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、
解释器模式、状态模式、策略模式、职责链模式、访问者模式。

单例设计模式
思想：保证类在内存中只有一个对象
实现：如何实现类在内存中只有一个对象呢?
构造私有
本身提供一个对象
通过公共的方法让外界访问

单例设计模式代码示例：

package com.wy.singlepattern1;

/*
 * 饿汉式：当这个类一被加载，就在内存中创建了一个对象
 */
class Student {

    // 保证内存中只有一个对象(构造私有)
    private Student() {
    }

    // 在本类中创建一个该类的对象
    private static Student instance = new Student();

    // 创建一个公共的访问方式给外界获取该对象
    public static Student getInstance() {
        return instance;
    }
}

//////////////////////////////////////////

// 单例模式之懒汉式，需要的时候才去创建对象，不需要的时候不创建
class Student_2 {

    // 将构造函数声明为私有，外界无法创建对象
    private Student_2() {
    }

    private static Student_2 instance = null;

    // 用户需要的时候才去创建对象，不需要的时候不创建
    public static Student_2 getInstance() {
        if (instance == null) {
            instance = new Student_2();
        }
        return instance;
    }

}

//////////////////////////////////////////

public class SinglePatternTest {
    public static void main(String[] args) {
        Student s1 = Student.getInstance();
        Student s2 = Student.getInstance();
        System.out.println(s1 ==s2);
        Student_2 s3 = Student_2.getInstance();
        Student_2 s4 = Student_2.getInstance();
        System.out.println(s3 ==s4);
    }
}

运行结果都为true，说明在内存中只有一个对象存在。

- 工厂设计模式

思想：又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
实现：

package com.wy.factorypattern;

abstract class Animal {

    public abstract void eat();

}

///////////////////////////////////////////////////

class AnimalFactory {
     /*
      * 这个类主要负责生产对象
      * 使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻辑，可以决定什么时候创建哪一个产品的实例，
      * 而客户端则免去直接创建产品的责任，而仅仅是消费产品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。
      * 明确了类的职责
      */
    //这里将父类引用指向子类对象
    public static Animal creatAnimal(String type){
        //如果这个工厂要生产其他的对象，则需要修改这里的代码。
        if(type == "dog"){
            return new Dog();
        }
        else if(type == "cat"){
            return new Cat();
        }
        else{
            return null;
        }

    }
 }

///////////////////////////////////////////////////

 class Cat extends Animal{

    public Cat(){}

    @Override
    public void eat() {
        System.out.println("cat eat mouse.");
    }

}

///////////////////////////////////////////////////

  class Dog extends Animal{

        public Dog(){}

        @Override
        public void eat() {
            // TODO Auto-generated method stub
            System.out.println("dog eat meat"); 
        }
    }

///////////////////////////////////////////////////

public class FactoryTest {
    public static void main(String[] args) {
        //通过类创建狗对象
        Animal d = AnimalFactory.creatAnimal("dog");
        d.eat();
    }
}

缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

- 抽象工厂设计模式

思想：工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继    承抽象工厂的具体类实现。
客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。
缺点：需要额外的编写代码，增加了工作量。

package com.wy.abstractpattern1;

//
abstract class Fruit {
    //得到水果口味
    public abstract void getTaste();
}

///////////////////////////////////////
abstract class FruitFactory {

    public abstract Fruit creatFruit();

}

///////////////////////////////////////
class Apple extends Fruit {

    @Override
    public void getTaste() {
        System.out.println("Apple is sweet.");
    }
}

///////////////////////////////////////

class AppleFactory extends FruitFactory {

    @Override
    public Fruit creatFruit() {
        return new Apple();
    }
}

///////////////////////////////////////

public class AbstractPatternTest {
    public static void main(String[] args) {
        //得到一个苹果对象

        FruitFactory ff = new AppleFactory();
        Fruit apple = ff.creatFruit();
        apple.getTaste();
    }
}