韩顺平java教程个人笔记 代码块和单例设计模式

已于 2023-12-08 16:46:49 修改
阅读量373 收藏 8
点赞数 8
分类专栏： 韩顺平Java笔记 文章标签： java 笔记
于 2023-12-08 16:43:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52804277/article/details/134882486
版权

代码块

基本介绍

  1. 代码块又称为初始化块，属于类的一部分。
  2. 和方法不同的是，没有方法名、返回值和参数，只有方法体，而且通过加载类或创建对象时隐式调用，不用显示调用。
  3. 相当于另一种形式的构造，可以做初始化的操作。当多个构造器中需要用到重复的语句，可以将这些语句抽取到初始化块中，简洁代码。
  4. 不管调用哪个构造器，都会先调用代码块。

基本语法

[修饰符]{

​ 代码内容

}

注：

  1. 修饰符可选，但只有static可选

  2. 有static修饰的叫做静态代码块，没有的叫做普通代码块

  3. 大括号里可以写任何逻辑语句（输入、输出、调用、循环、判断）

  4. ; 号可以写也可以省略，看个人习惯

//CodeBlock01.java
public class CodeBlock01 {
    public static void main(String[] args) {
        //主函数中分别调用不同的构造器
        Movie movie1 = new Movie("1");
        Movie movie2 = new Movie("2",100);
        Movie movie3 = new Movie("3",200,"张三");

    }
}

class Movie{
    private String name;
    private double price;
    private String director;

    //假设有三个重载的构造器，都要输出一个开场信息
    //可以将这个开场信息放在代码块中，这样构造器会直接调用

    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始");
        System.out.println("电影正式开始");

    }
    public Movie(String name) {
        System.out.println("调用了构造器1\n");
        this.name = name;
    }

    public Movie(String name, double price) {
        System.out.println("调用了构造器2\n");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("调用了构造器3\n");

        this.name = name;
        this.price = price;
        this.director = director;
    }
}

输出结果

电影屏幕打开...
广告开始
电影正式开始
调用了构造器1

电影屏幕打开...
广告开始
电影正式开始
调用了构造器2

电影屏幕打开...
广告开始
电影正式开始
调用了构造器3

注意事项

  1. static 代码块作用就是对类进行初始化，随着类的加载而执行，且只会执行一次。但如果是普通代码块，每创建一个对象就执行一次。

  2. 类什么时候被加载：

    • 创建对象实例时
    • 创建子类对象实例，父类也会被调用一次。父类先加载。
    • 使用类的静态成员时

  3. 普通代码块在创建对象实例时被隐式调用，被创建一次就会调用一次。

  4. 如果只使用类的静态成员，普通代码块并不会被执行

//CodeBlockDetail.java

//以下最好分开运行查看效果（把另一点创建实例注释掉）。
public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //被加载的三种情况
        //1. 创建对象实例时被加载
        AA a = new AA();

        //2. 创建子类对象实例，父类也会被加载一次
        BB bb = new BB();

        //3. 使用类的静态成员时也会被加载
        System.out.println(CC.n1);

        //普通代码块和静态代码块被调用的情况
        DD dd = new DD();
        DD dd1 = new DD();

        //直接调用静态成员而不创建对象
        System.out.println(DD.n1);
    }
}


class AA{
    //静态代码块
    static {
        System.out.println("AA 的静态代码块被执行");
    }
}

class BB extends AA{
    static {
        System.out.println("BB 的静态代码块被执行");
    }
}

class CC {
    public static int n1 = 999;//静态属性
    static {
        System.out.println("CC 的静态代码块被执行");
    }
}

class DD{
    public static int n1 = 8888;//静态属性
    static {//静态代码块
        System.out.println("DD的静态代码块被执行");
    }
    {//普通代码块只有创建对象时才会调用
        System.out.println("DD的普通代码块被执行");
    }
}

输出结果:

// AA a = new AA();
AA 的静态代码块被执行
    
// BB bb = new BB();
AA 的静态代码块被执行
BB 的静态代码块被执行

//同时运行 AA a = new AA();BB bb = new BB();
//因为每个类只会加载一次，不把第1点注释掉而同时运行第1、2点的话，由于BB继承于AA，在调用第2点时AA已经加载过了，只会输出2条结果
AA 的静态代码块被执行
BB 的静态代码块被执行
    
// System.out.println(CC.n1);
CC 的静态代码块被执行
999
    
// DD dd = new DD(); DD dd1 = new DD();
//静态代码块只被调用一次，普通代码块每创建一次就被调用一次
DD的静态代码块被执行
DD的普通代码块被执行
DD的普通代码块被执行
    
// System.out.println(DD.n1);
// DD中的普通代码块未被调用
DD的静态代码块被执行
8888
  1. 创建对象时在一个类内调用的优先级是：

静态 > 普通 > 构造器

注：静态代码块和静态属性之间优先级相同，有多个则按照定义顺序调用。普通代码块和普通属性也是如此。

下面这个例子中，如果只定义了变量（没有=号），则不会调用getN1或者getN2方法。但这里在类内初始化了，因此一定会调用getN1或getN2。

//CodeBlockDetail02.java

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}

class A{
    private static int n1 = getN1();
    private int n2 = getN2();

    static {//静态代码块
        System.out.println("静态代码块");
    }
    public static int getN1(){//静态方法
        System.out.println("静态方法getN1被调用");
        return 100;
    }

    {//普通代码块
        System.out.println("普通代码块");
    }
    public int getN2(){//普通方法
        System.out.println("普通方法getN2被调用");
        return 200;
    }
    public A(){//无参构造器
        System.out.println("A()的无参构造器");
    }
}

输出结果（被调用的顺序）

静态方法getN1被调用
静态代码块
普通方法getN2被调用
普通代码块
A()的无参构造器

  1. 构造器隐含的内容：

    • super()
    • 调用普通代码块的机制

这些内容即使未显式声明也会调用，且类之间拥有继承关系时，调用优先级如下：

父类静态 > 子类静态 > 父类普通 > 父类构造器 > 子类普通 > 子类构造器

其中“静态”包含静态代码块和静态属性，“普通”包含普通代码块和普通属性

//CodeBlockDetail03.java

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        BBB bbb = new BBB();

    }

}

class AAA{
    {
        System.out.println("AAA的普通代码块");
    }
    static {
        System.out.println("AAA的静态代码块");
    }

    public AAA(){
        //super();
        //调用本类普通代码块
        System.out.println("AAA的构造器");
    }
}

class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块");
    }
    static {
        System.out.println("BBB的静态代码块");
    }

    public BBB() {
        //super();
        //调用本类普通代码块
        System.out.println("BBB的构造器");
    }
}

输出结果

AAA的静态代码块
BBB的静态代码块
AAA的普通代码块
AAA的构造器
BBB的普通代码块
BBB的构造器
  1. 静态代码块只能调用静态成员，普通代码块可以调用任意成员

单例设计模式

设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、变成风格以及解决问题的思考方式，免得我们自己再思考和摸索。

单例模式是什么

  1. 采取一定的方法保证在整个的软件系统重对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
  2. 两种形式：饿汉式和懒汉式

步骤

  1. 构造器私有化：防止用户之间创建对象
  2. 类内创建对象
  3. 向外提供一个静态的公共方法，如getInstance

说明

  1. 为什么叫饿汉式：未使用就已经在类内初始化好了一个对象（显得很着急）

  2. 为什么叫懒汉式：你不用就不创建，避免资源浪费

  3. 两种设计模式区别：

    • 饿汉式在类加载时就创建了对象实例，懒汉式在使用时才创建

    • 饿汉式不存在线程安全问题，懒汉式则存在

    • 饿汉式可能浪费资源。因为程序员有可能并不创建对象实例。

  4. javaSE标准类中的java.lang.Runtime就是一个经典的单例模式

//singleTon01.java

public class singleTon01 {
    public static void main(String[] args) {
        girlFriend instance = girlFriend.getInstance();
        System.out.println(instance);
    }
}

class girlFriend{
    //单例模式-饿汉式：

    private String name;

    //1. 构造器私有化：防止用户之间创建对象
    private girlFriend(String name){
        this.name = name;
    }
    //2. 类内创建对象
    //为了能接收静态方法返回的参数，也需要用static修饰
    private static girlFriend gf = new girlFriend("小红");
    //3. 向外提供一个静态的公共方法，如`getInstance
    //为了不创建实例就能调用，需要用static修饰
    public static girlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "girlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

输出结果：

girlFriend{name='小红'}

//singleTon2.java

public class singleTon02 {
    public static void main(String[] args) {
        //第一次，未存在，开始创建
        Cat instance = Cat.getInstance();
        System.out.println(instance);

        //第二次，已存在，开始返回
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);
    }
}
class Cat{
    //单例模式-懒汉式
    private String name;
    public static int n1 = 999;

    //1. 构造器私有化
    private Cat(String name){
        System.out.println("构造器调用");
        this.name = name;
    }
    //2. 定义一个static 静态对象
    private static Cat cat; //默认值null

    //3. 提供一个public static方法返回Cat对象
    // 没有才新建，否则直接返回
    public static Cat getInstance(){
        if (cat == null) {
            cat = new Cat("小可爱");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

输出结果

构造器调用
Cat{name='小可爱'}
Cat{name='小可爱'}
★梦之蓝★
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韩顺平_Java设计模式笔记.docx
05-20
韩顺平_Java设计模式笔记.docx
java设计模式笔记
fingers_xwk的博客
07-05 144
（一）静态代理1.真实角色2.代理角色，包含真实角色的引用3.两者实现相同的接口interface Merry{//接口 merry(); } class You implements Merry{//真是角色 public void merry(){ System.out.println("你和小仙女结婚了！"); } } class WeddingC...
基于韩顺平视频的Java学习笔记
m0_63932157的博客
12-25 735
基于韩顺平视频的Java学习笔记
java设计模式整理笔记
11-13
该文档为java设计模式的整理笔记，有助于大家更详细了解java设计模式
韩顺平图解Java设计模式
嘟爷java超神学堂
08-27 2932
今天分享一部设计模式相关的视频，好好复习帮助还是很大的。课程介绍1) 优秀的程序应该是这样的：阅读时，感觉很优雅；新增功能时，感觉很轻松；运行时，感觉很快速,这就需要设计...
韩顺平_java设计模式笔记
11-07
23中java设计模式结合生活中用例进行讲解以及spring源码中存在的设计模式才知道原来设计模式如此重要，视频教程链接如下：https://study.163.com/course/courseMain.htm?courseId=1209569921，或者直接在网易云搜索...
韩顺平java笔记完整版.zip（无笔记，只是代码）
10-10
韩顺平java笔记完整版 这是韩顺平老师java教学视频的全部笔记，所有代码都有的！（无笔记，只是代码）
韩顺平java视频教程源代码和笔记
08-16
韩顺平java从入门到精通视频教程源代码和笔记,分享给大家
韩顺平老师所有课程笔记
04-13
本文档包含韩顺平老师的linux，Java，Oracle，PHP，struts,j2ee,javascript课程笔记
韩顺平java代码
03-18
韩顺平java教程里的代码（前10讲），全部为本人亲自输入的，后面的会陆续发布
韩顺平java笔记完整版
09-07
java课件PPT、java基础，适合初次接触java的朋友，可以下载看看，ppt。大家最好还要看视频教程学习，一起对着看就可以。
韩顺平老师java视频全套
09-23
解压压缩包会有一个种子文件。直接迅雷下载即可，包含了韩顺平老师的java入门视频，jdbc,jsp,servlet,oracle,hibermate,spring,SHH框架，struct,linux,等十套视频，并且还包含了配套的源码。迅雷下载速度很快。20兆的宽带下载速度大概是2.3MB/s，没有开会员。
韩顺平java se视频教程
02-28
韩老师的java se视频教程 很好的教程
韩顺平java从入门到精通1-32课源码笔记
08-20
韩顺平老师讲解java从入门到精通，1-32讲代码笔记完整版
韩顺平Java教程个人笔记 接口
最新发布
qq_52804277的博客
12-10 386
接口就是给出一些没有实现的方法封装到一起，到某个类要使用的时候再根据情况把这些方法写出来。interface 接口名 {​//属性​//方法class 类名 implements 接口{​自己的属性;​自己的方法;​实现接口的抽象方法;注意事项：在jdk7.0以前接口的所有方法都没有方法体，jdk8以后接口类可以有静态方法和默认方法。接口中的抽象方法默认为修饰的，因此可以省略关键字abstract和public，如果加大括号“实现”，则里面 只能写静态方法 或 用default。
【韩顺平】Java线程（基础）知识点总结
m0_66908465的博客
03-16 1862
此篇文章总结自韩顺平老师所讲解的Java线程内容，我将会在引用韩老师原文的基础上增加自己的一些解读，以加深各位小伙伴对于Java线程的理解。希望能为各位学习Java的小伙伴带来帮助。
韩顺平Java基础-第一阶段(建立编程思想)
m0_60694716的博客
09-23 2829
Java韩顺平笔记
JAVA 代码块（韩顺平）
wztmds的博客
04-10 308
一.基本介绍 代码块属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来 但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用 二.基本语法 修饰符 { 代码}； 说明注意： 1.修饰符可写可不写，要写的话，也只能写static 2.若使用static修饰叫做静态代码块，若没有static修饰的叫做普通代码块 3逻辑语句可以为任何逻辑语句（输入输出，方法调用，循环等） 4；号可以写上，也可以省略 三

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值