【JavaSE】之单例模式与异常体系

最新推荐文章于 2022-10-21 20:34:58 发布
最新推荐文章于 2022-10-21 20:34:58 发布
阅读量272 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gx123456sh/article/details/86750982
版权

目录

1.包的定义及使用、访问控制权限

2.单例设计模式与多例设计模式

3.Java异常与捕获

1.包的定义及使用

1.1包的本质实际上就是文件夹

定义用：package

package www.bit.java;

一旦程序出现包名称，那么*.class必须存在相应目录下。在JDK编译的时候使用配置参数。

打开包编译命令：javac -d . 类名.java

-d表示生成目录，根据package定义生成

“.”：表示当前所在目录生成子目录

        按照此种方式编译完成后就会发现，自动会在当前目录下生成相应的文件夹以及相应的*.class文件。一旦程序类上出现了包名称，那么在执行的时候就需要带上包名称，即使用完整类名称“包.类”。

java www.bit.java.类名

1.2包的导入（import）

例：编写简单Java类，本类需要被其他程序类所使用

package www.bit.java.util;

public class Message {
    public void print(){
        System.out.println("Hello world");
    }
}

导入包：

package www.bit.java;
import www.bit.java.util.Message;

public class Test2{
    public static void main(String[] args){
        Message message = new Message();
        message.print();
    }
}

         从正常的角度看，Test2类引用的Message类，那么首先编译的应该是Message类，而后才是Test类。那如果在引用多个包的情况下就得编译多个类，所以最好的方法是让java自己去匹配编译顺序，最常用的打包编译命令是：

javac -d . ./*.java

注意：类使用class和public class的区别：

1.public class：文件名称必须与类名称保持一致，如果希望一个类被其他包访问，则必须定义为public class

2.class：文件名称可以与类名称不一致，在一个*.java中可以定义多个class，但是这个类不允许被其他包所访问。

1.3系统常用包

1.3.1 java.long：系统常用基础类（String、Object、包装类），JDK1.1之后自动导入

1.3.2 java.util：Java提供的工具程序包（集合类、ArrayList 、HashMap），需要手工导入

1.3.3 juc：java.util.concurrent：并发程序包

1.4访问控制权限

private < default (包访问权限，仅供在同一包下访问) < protected(继承访问权限，仅供子类使用) < public

例：观察protected访问权限

package father;
public class Father {
    // 此时定义的是protected权限
    protected String msg = "www.bit.java" ;
}

定义另外一个包进行该类继承

package child;
import father.Father; // 不同包

public class Child extends Father{
    public void print() {
        System.out.println(super.msg); // 父类中protected权限
    }
}

定义测试类

package test;
import child.Child;

public class TestProtected {
    public static void main(String[] args) {
        Child child = new Child() ;
        child.print();
    }
}

在不同包中，只有子类能访问父类中的protected权限。

2.单例设计模式与多例设计模式

2.1单例设计模式

定义：一个类只允许产生一个实例化对象

a.对象如何产生？ 通过类的构造方法

b.怎么限制对象的产生？ 通过构造方法限制

饿汉式单例：上来就new

特点：不管是否使用Singleton类的对象，只要类加载了，那么一定会自动创建好一个公共的SINGLETON对象。

//饿汉式单例
class Singleton{
    //类内部产生实例化对象，只在类加载的时候产生一个
    //声明成常量，因为不会再改变，要改变就是将SINGLETON的地址改变，但是在外部改变不了
    private static final Singleton SINGLETON = new Singleton();
    //构造方法私有化，类外部无法产生实例化对象
    private Singleton(){}
    //通过类名调用
    public static Singleton getSingleton(){
       return SINGLETON;
    }
    public void test(){
        System.out.println(this);
    }
}
public class Test {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getSingleton();
        Singleton singleton1 = Singleton.getSingleton();
        singleton.test();
        singleton1.test();
    }
}

懒汉式单例：用时在new（双重加锁单例模式），可能会出现线程安全问题

特点：当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作

//懒汉式单例
class Singleton{
       //类内部产生实例化对象
    private static Singleton SINGLETON;
       //构造方法私有化，类外部无法产生实例化对象
    private Singleton(){}
       //通过类名调用
    public static Singleton getSingleton(){
        if(SINGLETON == null){
           SINGLETON = new Singleton();
        }
        return SINGLETON;
    }
    public void test(){
        System.out.println(this);
    }
}
public class Test {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getSingleton();
        Singleton singleton1 = Singleton.getSingleton();
        singleton.test();
        singleton1.test();
    }
}

总结单例模式特点：

  • 构造方法私有化，来控制对象的个数
  • 类的内部提供一个对象，并且是静态属性
  • 提供一个静态方法，将对象返回

2.2多例模式-有限个数对象

所谓的多例只是比单例多了一些实例化对象而已

//描述性别类
class Sex{
    private String title;
    public static final int MALE_FLAG = 1;
    public static final int FEMALE_FLAG = 2;
    private static final Sex MALE = new Sex("男");
    private static final Sex FEMALE = new Sex("女");
    private Sex(String title){
        this.title = title;
    }
    public static Sex getInstance(int flag){
        switch(flag){
            case MALE_FLAG:
                return MALE;
            case FEMALE_FLAG:
                return FEMALE;
            default:
                return MALE;
        }
    }

    @Override
    public String toString() {
        return this.title;
    }
}

public class Test{
    public static void main(String[] args) {
        Sex male = Sex.getInstance(Sex.MALE_FLAG);
        Sex female = Sex.getInstance(Sex.FEMALE_FLAG);
        System.out.println(male);
        System.out.println(female);
    }
}

不管多例还是单例都有共同的特点：

1.构造方法私有化

2.类内部一定会提供一个static方法用于取得实例化对象。

3.Java异常与捕获

我们先来看一下异常的继承类结构：

Error（栈溢出异常）：Error类描述Java运行时内部错误与资源耗尽错误。应用程序不抛出此类异常，这种内部错误一旦出现，除了告知用户并使程序安全终止以外，别无他法。

以Error结尾的类为自己及其子类。

例：

public class Test{
    public static void main(String[] args) {
        digui(10);
    }
    public static int digui(int num){
        return digui(num);
    }
}

RuntimeException（运行时异常）：由于程序错误导致的异常。

IOException：程序本身没有问题，但由于出现I/O问题导致的异常（例如：打开一个并不存在的文件）

非受查异常：继承于Error与RuntimeException类的所有异常子类称为非受查异常（不强制用户进行异常处理）

受查异常：Exception以及IOException子类属于受查异常（强制用户进行异常处理）

例：产生异常

public class Test{
    public static void main(String[] args) {
        System.out.println("1.数学计算开始前...");
        System.out.println("2.数学计算中"+(10/0));
        System.out.println("3.数学计算完成");
    }
}

程序之中产生异常后，异常语句产生之前的语句可以正常执行完毕，而异常产生之后程序直接进行了结束。为了保证程序出现异常后还可以继续向下执行，就需要进行异常处理。

3.1异常处理格式

为了保证程序出现异常后也能正常执行下去，需要进行异常处理

语法如下：

try{
    //有可能出现异常的语句
}[catch(异常类    对象)......]{
    //出现异常后的解决方案
}[finally]{
    //异常出口，无论是否产生异常，均会执行finally代码块
    //即便try、catch中存在return 语句，也会在return之前执行finally代码块，执行的是finally的return语句，但是如果finally不存在return语句，该走哪个return就走哪个return
}

对于三个关键字，还可以出现的三种组合：

try...catch...

try...finally...

try...catch...finally...

例：对异常进行处理 

public class Test{
    public static void main(String[] args) {
        System.out.println("1.数学计算开始前...");
        try {
            System.out.println("2.数学计算中"+(10/0));
        } catch (ArithmeticException e) {
            System.out.println("出现异常，除数有误");
        }finally {
            System.out.println("4.finally代码块无论如何都会执行");
        }
        System.out.println("3.数学计算完成");
    }
}

例：即便try、catch中存在return 语句，也会在return之前执行finally代码块，执行的是finally的return语句，但是如果finally不存在return语句，该走哪个return就走哪个return 

public class Test{
    public static void main(String[] args) {
        System.out.println(test(0));
    }
    public static int test(int num){
        try {
            System.out.println(10/num);
            System.out.println("1.***********");
            return 1;
        } catch (Exception e) {
            System.out.println("2.###########");
            return 2;
        }finally {
            System.out.println("3.$$$$$$$$$$$");
            return 3;
        }
    }
}

 

public class Test{
    public static void main(String[] args) {
        System.out.println("1.数学计算开始前...");
        try {
            int num1 = Integer.parseInt(args[0]);
            int num2 = Integer.parseInt(args[1]);
            System.out.println("2.数学计算中"+(10/0));
        } catch (ArithmeticException e) {
            System.out.println("出现异常，除数有误");
        }
        System.out.println("3.数学计算完成");
    }
}

 

通过以上代码发现，通过catch捕获异常的时候如果没有捕获指定异常，程序依然无法进行处理 。如果使用多个catch块，那么我们就得清楚程序中可能出现的异常。

例：直接捕获父类异常

public class Test1{
    public static void main(String[] args) {
        System.out.println("1.数学计算开始前...");
        try {
            int num1 = Integer.parseInt(args[0]);
            int num2 = Integer.parseInt(args[1]);
            System.out.println("2.数学计算中"+(10/0));
        } catch (RuntimeException e) {  //直接向上转型
            e.printStackTrace();  //打印错误堆栈
        }
        System.out.println("3.数学计算完成");
    }
}

3.2throws-用在方法上，明确表示此方法可能会产生异常但是方法内部不处理，将异常抛回给调用处

如果用throws将异常扔回的话，产生异常的语句以后的代码将不再执行，因为此时已经不再此方法上。

例：使用throws定义方法

public class Test2{
    public static void main(String[] args){
        try {
            System.out.println(div(10, 0));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static int div(int x, int y) throws Exception{
        return x/y;
    }
}

主方法本身也属于一个方法，所以主方法上也可以使用throws进行异常抛出，这个时候如果产生异常就会交给JVM处理。

例：主方法抛出异常

public class Test2{
    public static void main(String[] args) throws Exception {
        System.out.println(div(10, 0));
    }
    public static int div(int x, int y) throws Exception{
        return x/y;
    }
}

3.3throw-用在方法中。由用户产生异常类而非JVM产生。一般与自定义异常类搭配使用。

例：使用throw产生异常类对象

public class Test2{
    public static void main(String[] args) throws Exception {
        try {
            throw new Exception("抛个异常玩玩");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

throw和throws的区别：

1.throw用于方法内部，主要表示手工异常抛出

2.throws主要在方法声明上使用，明确告诉用户本方法可能产生异常，同时该方法可能不处理此异常。

解释Exception与RuntimeException的区别：

1.使用Exception是RuntimeException的父类，使用Exception定义的异常都要求必须使用异常处理，而使用RuntimeException定义的异常可以由用户选择性的来进行异常处理。

2.常见的RuntimeException：ClassCastException（类型转换异常）、NullPointerException（空指针异常）等。

3.4自定义异常类

例：在进行加法运算时，如果发现两个数相加内容为50，那么就应当抛出一个异常。这种异常Java不会提供，所以就必须定义一个属于自己的异常类。

自定义异常类可以继承两种父类：Exception、RuntimeException。

class AddException extends Exception{
    public AddException(String msg){
        super(msg);
    }
}
public class Test2{
    public static void main(String[] args) throws Exception {
        int num1 = 20;
        int num2 = 30;
        if(num1 + num2 == 50){
            throw new AddException("错误的相加操作");
        }
    }
}

 

 

 

 

gx1500291
关注
专栏目录
单例模式&异常处理（5.26）
安静的美男子
05-26 1091
1.数据类型   1.基本数据类型   2.引用数据类型 2.类，父类，子类，抽象类，内部类，匿名内部类，接口 3.类的结构   属性   行为   构造方法   语句块   内部类 4.类和类之间的关系   1.继承关系   2.包含关系 5.对象   实例化对象   new A();  1.申请内存  2.调用构造，初始化属性  
javase2021最强学习线路没有之一
LSFZ88888的博客
09-02 698
从事Java开发已多年，在这整理了一些有关Java的知识体系，这不是最终版，没有最好只有更好，我会不定期的更新。 Java知识体系主要包括基础知识，工具，并发编程，数据结构与算法，数据库，JVM，架构设计，应用框架，中间件，微服务架构，分布式架构等等 注意：学习编程没有捷径 少年易老学难成，一寸光阴不可轻。未觉池塘春草梦，阶前梧叶已秋声 。—朱熹《劝学诗》 勤奋才是改变你命运的唯一捷径。 一、JavaSE基础体系： 第一步：学习JAVA的开发环境配置、开发第一个Java程序。也建议大
JavaSE—单例模式
萧无义的武功秘籍
09-08 124
1、单例模式 package 单例模式; public class Earth { //1、声明全局静态对象 public static Earth i=new Earth(); //2、将构造方法权限设置为private private Earth() {} //实例方法，输出地球上所有的国家的名字 void showCountry() { System.out.p...
10.14.Java - 枚举、单例模式、异常
goodgods_的博客
10-21 116
应enum关键字定义枚举类枚举类默认继承java.util.Enum类枚举类的构造方法只能使用private修饰符，如果构造方法省略修饰符，则默认使用private枚举类的所有对象（实例）必须在枚举中显式列出，否则这个枚举类将永远不能创建实例对象枚举类的所有对象，系统会自动添加public static final修饰符final的作用是内存地址不变，枚举类中对象的常量可以用get/set方法修改。
Java异常处理简单实例
qq_42304949的博客
05-12 4597
Java异常处理 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。 异常发生的原因有很多，通常包含以下几大...
JAVA学习篇13——单例模式、异常、断言
frankDuanh的博客
11-05 340
 单例模式(一种设计模式)：                 在获取当前类的实例化对象，是同一个对象                 当前对象操作的时候成员变量确保一致                 内存效率高          饿汉模式                  static SingletonDemo sing = new SingletonDemo();          懒汉模式...
JavaSE——访问控制权限、jar、单例和异常
LiLiLiLaLa的博客
07-22 314
1.包的定义及使用 包的本质实际上就属于一个文件夹，在项目开发中很难避免类名称重复的问题，如果所有的java文件都放在一个文件夹中，就有可能存在覆盖问题 1.1.包的导入 开发中使用包的定义之后，相当于把一个大的项目分别按照一定要求保存在了不同的包之中，但是这些程序类一定会发生互相调用的情况，这个时候就需要包的导入 类使用class和public class的区别： public class: ...
JAVASE知识脑图
12-03
12. **设计模式**：了解常见的设计模式，如单例模式、工厂模式、观察者模式等，它们是解决常见编程问题的通用解决方案。 13. **JNI（Java Native Interface）**：允许Java代码和其他语言写的代码进行交互，通常用于...
javaSE个人笔记
12-29
面向对象的设计模式，如工厂模式、单例模式、观察者模式等，也可能在笔记中有详细阐述。 接着，异常处理是Java程序健壮性的重要组成部分。JavaSE中的try-catch-finally语句块、异常的分类和抛出，以及自定义异常，...
javase全套笔记
07-12
13. **集合高级特性和设计模式**：深入探讨集合类的高级特性，如并发容器（ConcurrentHashMap、CopyOnWriteArrayList）以及常用的设计模式（单例、工厂、装饰器、代理等）。 14. **网络编程**：讲解套接字编程，...
JAVA自定义异常
weixin_42843651的博客
07-31 1897
try{ } catch(异常类 对象名){ 异常处理 e.getMessage(); e.printStackTrace(); } finally{ 一定要执行的代码，如果遇到return,先执行finally,再执行return; 如果遇到System.exit(1);直接退出程序，不执行finally } throws:声明异常，写在方法声明后，表示此方法会有异常产生 ...
【Java】单例模式UncaughtExceptionHandler类实现捕获全局未处理异常
ccystewart的博客
04-13 173
UncaughtExceptionHandler类：method invoked when the given thread terminates due to the given uncaught exception. 当线程由于未捕获异常终止时调用的处理接口。 简单说就是实现该类后，Override该接口的uncaughtException方法，可以捕获到全局未捕获（没有抛出或catch）的异...
【Java异常】概念+体系+分类+练习
qq_44682003的博客
12-02 318
Java异常第一章 异常1.1 异常概念 第一章 异常 1.1 异常概念 通俗点，异常
java Exception异常的理解
小白菜
07-16 6512
首先看下结构图 Throwable是所有异常的根，java.lang.Throwable Error是错误，java.lang.Error Exception是异常，java.lang.Exception 二、异常Exception分为两大类型：检查异常与运行时异常。 检查异常：按照我自己的理解就是编译的时候会报错的异常。 比如： Java.lang.ClassNotFoundExc...
一个JAVA单例模式的典型错误应用的分析和解决方法
老紫竹的专栏
09-28 6967
问题来自论坛，http://topic.csdn.net/u/20090927/23/497372f4-af98-4b7b-8489-3eb3a8de43b5.html 其代码如下：import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import
单例模式 异常抛出
Contributor -> Committer
10-20 1668
public class FileUtil { private static class SingleFileUtill{ private static FileSystem fs = null; static{ fs = SingleFileUtill.getInstance(); } private st
java单例——反射破坏和防止破坏
专注写bug
08-31 742
单例是什么 单例：个人理解为，每次操作都是一个实例化对象，在程序有效的前体下，堆内存中实例化对象的地址不变。 下面看一个单例的栗子： public class SingleVo { public static int times; // 单例，对外不能暴露创建实例化对象的方法 private SingleVo() { System.out.println("单例调用次数"+(++times)); } // 采取 饿汉式，加载至jvm时就创建对象 private final stati
java中如何创建一个不会被反射破坏的单例
ForteScarlet's Blog
06-15 1034
前言 单例相信各位都不陌生，从学习java开始就会经常接触到这个概念，首先先来回忆一下什么是单例： 单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去...
spring单例在高并发下可能出现的错误
哎哟哟
05-25 3600
原文地址:http://www.cnblogs.com/atwanli/articles/4740184.html spring单例在高并发下可能出现的错误： 首先，只有当注入的对象是无状态的幂等的才可以保证执行前后不被修改，否则执行一次之后单例对象就会发生改变，在下次执行有肯能造成结果不一样，当在高并发的情况下就会出现，这个线程刚使用单例对象进行属性设置，还未使用的情况下，另一个进程已
JavaSE学习笔记：核心概念与单例模式解析
"这是一篇关于JavaSE学习的心得体会，作者郑晓辉分享了他在学习Java时的一些思考和理解，涵盖了Java的不同版本、核心概念以及设计模式中的单例模式。同时，他也提到了对象的toString()和equals()方法的特殊性，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gx1500291

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值