Java学废之路03——类

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量176 收藏
点赞数
分类专栏： Java学废之路 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjxBayern/article/details/120921409
版权

03 JAVA类

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。

  • 继承的出现减少了代码冗余，提高了代码的复用性
  • 继承的出现，更有利于功能的扩展
  • 继承的出现让类与类之间产生了关系，提供了多态的前提

3.1 概述

在 Java 中，没有类就无法做任何事情。要想使用对象，就必须首先构造对象，并指定其初始状态，然后对对象应用方法。

3.1.1 概述

类是构造对象的模板或蓝图。由类构造对象的过程称为创建类的实例。

封装是将数据与行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。对象中的数据称为实例域，操纵数据的过程称为方法。实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域，只能调用其他类提供的接口。

3.1.2 类之间关系

依赖、聚合（关联）、继承等

  • 继承：is-a关系，一种用于表示特殊与一般的关系。在UML术语中，描述继承的关系称为泛化

  • 实现：实现表示面向对象编程中类的接口实现

  • 依赖：uses-a关系，一个类的方法操纵另一个类的对象，即为一个类依赖于另一个类。开发中应该尽量减少类之间的依赖关系，即降低类之间的耦合度；（方法内有一个其他类的对象）

  • 关联：表示两个实体之间的关系。有两种类型的关联：组合与聚合

    • 聚合：has-a关系，聚合关系意味着一个类的对象包含有另一个类的对象（类中含有一个其他类的对象）
    • 组合：一个类是另一个类的组成部分

    组合与聚合的区别：

    聚合是一个类在逻辑上包含另一个类，但是所包含的类的实例是可以独立于第一个类在其上下文之外生存的，即它是可以被其他类引用的。如部门与员工

    组合则是当主类不再存在时，依赖类也不再存在。如房子与房间

关系UML连接符解释
继承（泛化）image-20200726145655909箭头指向父类
接口实现image-20200726145732746箭头指向接口
依赖image-20200726150318844箭头指向被包含的对象
关联image-20200726151250292箭头指向被关联的对象
聚合image-20200726150359987菱形指向整体
组合image-20200726151307112菱形指向整体

3.2 继承

已存在的类称为超类、基类或父类；新派生出来的类称为子类、派生类。

  • 子类继承了父类，就继承了父类的方法和属性
  • 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法
3.2.1 super()方法

子类含有与父类一样的方法，但是子类不能直接访问父类的私有域，必须要借助于公有的接口，如get*()方法。同时在调用时，要使用super关键字来进行调用。在 Java 类中使用super来调用父类中的指定操作：

  • super可用于访问父类中定义的属性
  • super可用于调用父类中定义的成员方法
  • super可用于在子类构造器中调用父类的构造器
  • super的追溯不仅限于直接父类
  • super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

super不是一个对象的引用，不能将super赋予一个对象变量，它只是一个指示编译器调用超类方法的特殊关键字。

3.2.2 子类构造器

由于子类继承了父类的属性和方法，所以在对子类对象进行初始化的时候，必须要对父类中的属性进行初始化操作。但是由于子类不能访问父类的私有域，就必须要调用父类的构造器对父类的私有域进行初始化，可以使用super实现对超类构造器的调用。使用super调用构造器的语句必须是子类构造器的第一条语句。

如果子类的构造器没有显式的调用超类构造器，则将自动地调用超类默认的无参数的构造器。所以对于父类来说，必须要有一个无参数的构造器。

image-20201020110624543

3.2.3 final类

不允许扩展的类称为final类，即该类不能再被其他类继承，其内部的方法无法被覆盖。当一个类被声明为final时，其内部的方法也会自动成为final方法，但是不包括域。

将方法或类声明为final的目的是：确保他们不会在子类中改变语义。

3.2.4 抽象类

包含一个或多个抽象方法的类本身必须要被声明为抽象的。

抽象类本身除了抽象方法外，还可以包含具体的数据与具体的方法；同时，类即使不含有抽象方法，也可以声明为抽象类。

抽象类不能被实例化，即不能创建抽象类的对象。但是可以定义一个抽象类的对象变量，该变量的引用必须是非抽象子类的对象。

3.3 多态

多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。就是**用父类的引用指向子类的对象。**

子类的每个对象也是超类的对象。即一个父类对象变量可以引用一个父类对象，也可以引用一个子类对象，如：

//从超类的角度看，体现了多态性
Parent parent = new Parent();
Parent parent = new Children();

//但是不能将一个超类的引用赋给子类变量
//Children child = new Parent();
3.3.1 概述
（1）特点

对象的多态——在 Java 中，子类的对象可以替代父类的对象使用。

  • 一个变量只能有一种确定的数据类型

  • 一个引用类型变量可能指向(引用)多种不同类型的对象

    Person p = new Student();
Object o = new Person();	//Object类型的变量o， 指向Person类型的对象
o = new Student(); 			//Object类型的变量o， 指向Student类型的对象

  • 子类可看做是特殊的父类， 所以父类类型的引用可以指向子类的对象：向上转型(upcasting)

  • 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问在子类中添加的属性和方法

    Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量

    属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误

（2）虚拟方法调用

  • 正常的方法调用

    Person e = new Person();	// getInfo方法是父类中定义的共有方法
e.getInfo();				// 调用的是父类中的getInfo方法
Student e = new Student();
e.getInfo();				// 调用的是子类中的getInfo方法

  • 虚拟方法调用

    多态情况下，子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

    Person e = new Student();	// 父类类型的引用指向一个子类的对象，编译时确定（静态绑定）
e.getInfo(); 			// 父类调用子类Student类的getInfo()方法，运行时确定（动态绑定）

    编译时类型和运行时类型：

    编译时的类型是父类，而方法的调用是在运行时确定的，所以调用的是其中某一个子类重写的一个共有方法——动态绑定

3.3.2 重载与重写

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

image-20201007165155388
（1）重载

重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重载对返回类型没有特殊的要求，只对方法名和参数列表有要求。

  • 必须保证方法名相同
  • 参数列表不相同【参数类型与个数，与参数名无关】
  • 对返回类型不做要求，前提是参数列表也要不同

image-20210517105018284

（2）重写
  • 子类的重写方法首先要保证与父类的方法声明一致
  • 子类重写方法的参数列表要与父类的参数列表一致。一旦子类中方法的参数列表改变了，那么该方法将会被视为该子类的成员方法
  • 若返回类型是基本数据类型，那么子类中的返回类型必须与父类中的保持一致；若返回类型是引用类型，那么子类重写方法的数据类型可以与父类中的不相同，子类方法中的返回类型可以设置为父类返回类型的派生类

image-20210521225325006

image-20210521225632955

image-20210521225825314

image-20210521230057856

  • 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected
  • 父类的成员方法只能被它的子类重写
  • 声明为 final 的方法不能被重写
  • 声明为 static 的方法不能被重写，但是能够被再次声明
  • 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法
  • 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法
  • 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以
  • 构造方法不能被重写
  • 如果不能继承一个类，则不能重写该类的方法
（3）总结

重写与重载都对方法的声明与参数列表有要求，而返回类型是根据参数列表的异同来确定是否有要求的。

  • 重载：
    • 参数列表相同时，编译出错
    • 参数列表必须不相同，对返回类型不做要求
  • 重写：
    • 参数列表必须相同。若返回类型是基本数据类型，那么必须相同；若为引用数据类型，那么返回类型可以不同，但是子类中的返回类型必须是父类返回类型的派生类
    • 参数列表不同，那么该方法将被视为子类的成员方法

3.4 Object类

3.4.1 概述

  • Object类是所有 Java 类的根父类

  • 如果在类的声明中未使用extends关键字指明其父类， 则默认父类为java.lang.Object类

    public class Person {
	...
}
等价于：
public class Person extends Object {
	...
}
3.4.2 主要方法

image-20210805230027752

（1）toString()

toString()方法在Object类中定义， 其返回值是String类型， 返回类名和它的引用地址。

  • 在进行String与其它类型数据的连接操作时，自动调用toString()方法

    Date now=new Date();
System.out.println(“now=”+now); 
// 相当于
System.out.println(“now=”+now.toString());

  • 可以根据需要在用户自定义类型中重写toString()方法。如 String 类重写了toString()方法，就会返回字符串的字面值，如果某一个类没有默认重写toString()方法，那么就会返回它的类名与引用地址。

    // 未重写toString()方法的自定义类型Person，返回类名@引用地址
Person p5 = new Person("zoip", 888);
System.out.println(p5);		//com.zdp.learn.studyCollection.Person@32a1bec0

// 重写toString()方法的自定义类型Person，返回对象的内容
Person p5 = new Person("zoip", 888);
System.out.println(p5);		//Person{name='zoip', age=888}

// String默认重写了toString()方法
s1=“hello”;
System.out.println(s1);		//返回hello，相当于System.out.println(s1.toString());

  • 基本类型数据转换为String类型时， 调用了对应包装类的toString()方法

    int a=10; 
System.out.println(“a=”+a);  

// 数组是引用数据类型
public void test() {
    char[] arr = new char[] { 'a', 'b', 'c' };
    System.out.println(arr);                        // abc
    int[] arr1 = new int[] { 1, 2, 3 };
    System.out.println(arr1);                       // [I@1d8d30f7
    double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
    System.out.println(arr2);                       // [D@3e57cd70
}
（2）equals()

…

（3）类生命周期相关方法

  • getClass()

  • finalize()

（4）线程通信相关方法
  • notify()
  • notifyAll()
  • wait()

3.5 包装类

Java 是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作， Java 为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从 Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

3.5.1 对象包装

Java 是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。比如：将基本数据类型存储到Object[]数组或集合中的操作等等。

为了解决这个不足， Java 在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。包装类均位于java.lang包。

这些对象包装器类有：Integer,Long,Double,Byte,Character,Void,Boolean。对象包装器类是final的，不能定义他们的子类，即不可被继承。

image-20200727101156486

//尖括号内必须为引用类型
ArrayList<Integer> list = new ArrayList<>();
//但是由于每个值都是被包装在对象中的，所以像这种情况，ArrayList的效率是远远低于int[]的效率
3.5.2 装箱与拆箱
//自动装箱
Integer total = 99;

//自动拆箱
int totalprim = total;

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

3.5.3 过程分析

以Integer为例：

public class Main {
    public static void main(String[] args) {
        //自动装箱
        Integer total = 99;

        //自动拆箱
        int totalprim = total;
    }
}

其内部具体的调用过程如下：

（1）调用函数

调用valueOf()，将int包装为Integer

  • Integer total = 99;
    执行上面那句代码的时候，系统为我们执行了： Integer total = Integer.valueOf(99);

调用intValue()，将Integer拆箱为int

  • int totalprim = total;
    执行上面那句代码的时候，系统为我们执行了： int totalprim = total.intValue();
（2）valueOf()函数

image-20201019160928928

缓存：包装器内部预先保存有[-128,127]共256个数，是为了防止多次创建：

public static Integer valueOf(int i) {
    //首先判断i的大小：
    //如果i小于-128或者大于等于128，就创建一个Integer对象（使用构造器）
    //否则执行SMALL_VALUES[i + 128]
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
（3）Integer()构造函数
private final int value;

public Integer(int value) {
    this.value = value;
}

public Integer(String string) throws NumberFormatException {
    this(parseInt(string));
}

定义了一个value变量，创建一个Integer对象，就会给这个变量初始化。第二个传入的是一个String变量，它会先把它转换成一个int值，然后进行初始化。

（4）SMALL_VALUES[]
private static final Integer[] SMALL_VALUES = new Integer[256];

它是一个静态的Integer数组对象，且已经被创建好了，其容量为256。

包装类的缓存问题：

因为对于Integer，在[-128,128)之间只有固定的256个值，所以为了避免多次创建对象，我们事先就创建好一个大小为256的Integer数组SMALL_VALUES[]，所以如果值在这个范围内，就可以直接返回我们事先创建好的integer对象。

（5）缓存池

new Integer(123) 与 Integer.valueOf(123) 的区别在于：

  • new Integer(123) 每次都会新建一个对象；
  • Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
Integer x = new Integer(123);
Integer y = new Integer(123);
// 对象做相等操作，比较的是地址
System.out.println(x == y);    // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k);   // true

valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在 Java 8 中，Integer 缓存池的大小默认为 -128~127。

static final int low = -128;
static final int high;
static final Integer cache[];

static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
        try {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        } catch( NumberFormatException nfe) {
            // If the property cannot be parsed into an int, ignore it.
        }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
        cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
}

编译器会在自动装箱过程调用 valueOf() 方法，因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建，那么就会引用相同的对象。

Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true

基本类型对应的缓冲池如下：

  • Boolean values true and false
  • all byte values
  • short values between -128 and 127
  • int values between -128 and 127
  • char in the range \u0000 to \u007F

在使用这些基本类型对应的包装类型时，如果该数值范围在缓冲池范围内，就可以直接使用缓冲池中的对象。

在 jdk 1.8 所有的数值类缓冲池中，Integer 的缓冲池 IntegerCache 很特殊，这个缓冲池的下界是 - 128，上界默认是 127，但是这个上界是可调的，在启动 jvm 的时候，通过 -XX:AutoBoxCacheMax=<size> 来指定这个缓冲池的大小，该选项在 JVM 初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界。

（6）综述

在Integer的构造函数中，它分两种情况：

  • i >= 128 || i < -128 => new Integer(i) ：每次执行后，即使是相同数值的数所指向的对象也不一样
  • i < 128 && i >= -128 => SMALL_VALUES[i + 128]（数组 下标为0-255）：每次执行后，相同数值的数所指向的对象一样
public class Main {
    public static void main(String[] args) {

        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;

        System.out.println(i1==i2);  //true
        System.out.println(i3==i4);  //false
    }
}
/* i1和i2会进行自动装箱，执行了valueOf函数，它们的值在(-128,128]这个范围内，它们会拿到SMALL_VALUES数组里面的同一个对象SMALL_VALUES[228]，它们引用到了同一个Integer对象，所以它们肯定是相等的。
*/

/* i3和i4也会进行自动装箱，执行了valueOf函数，它们的值大于128，所以会执行new Integer(200)，也就是说它们会分别创建两个不同的对象，所以它们肯定不等。
*/

但是，对于浮点数而言，每次的结果都是不一样的。因为浮点数在这个范围内数的个数是无限的。所以对于浮点数的操作就很直接：

//每次都是新创建一个Double对象
public static Double valueOf(double d) {
    return new Double(d);
}
  • Integer派别：Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
  • Double派别：Double、Float的valueOf方法的实现是类似的。每次都返回不同的对象。

image-20200727104741452

我姓弓长那个张
关注
专栏目录
JAVA学习——聚合与组合
sinat_41895919的博客
11-12 407
一、聚合的定义 当一个类的实例作为另一个类的属性，称之为“ 对象聚合 ”。 假设 B 类中的实例 b 作为 A 类的一个属性，在创建 A 类的时候并不会同步创建 B 类对象，当且仅当外部对象传入时才创建，换句话说，B 类对象并不是由 A 类对象的创建的。 因此，A 类与 B 类之间并不是“命运共同体”的关系，而是一种“亲戚”关系，B 类不会因为 A 类的消亡而消亡。 ...
Java学废之路10——Java8新特性
我姓弓长那个张的博客
11-07 234
JAVA8新特性 速度更快 代码更少——Lambda 强大的Stream API 便于并行 最大化减少空指针异常——optional 零、速度更快 速度更快指的是hashMap的结构增加了红黑树。 在之前的hashmap结构中，jdk采用的是数组+链表的方式进行。当发生碰撞时，会极大地降低查找的效率。所以在jdk1.8中，采用了数组+链表+红黑树的方式，前提是当发生碰撞的个数大于8时且总容量大于64时，才会将链表结构转换为红黑树，此时会造成添加元素的效率降低，但是查找和删除等的效率会大大提高： 一、
Java中的聚合与组合
weixin_43865096的博客
11-12 404
聚合（Aggregation） 如果一个类的实例作为另一个类的属性，则称之为聚合，这两个类之间存在has a"的关系。 在聚合中，部分与整体之间的关系比较松散，如：一个学院由许多老师组成，缺少一个老师，这个学院依然存在,老师离开了学院依旧是一个老师。这意味着聚合中的两种类（或实体）是可以单独存在的，不会相互影响。 在UML类图设计中，聚合关系以空心菱形加实线箭头表示： class Studen...
Java学废之路01——基础
我姓弓长那个张的博客
10-23 286
Java基础 面向对象的特征： 抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。通过继承，子类可以使用父类中的一些成员变量与方法，从而提高代码的复用性，提高开发效率。新类继承了原始类的特性，新类称为原
Java学废之路07——IO流
我姓弓长那个张的博客
10-28 335
七、IO流 对于任何程序设计语言而言，输入输出(Input/Output)系统都是非常核心的功能。程序运行需要数据，数据的获取往往需要跟外部系统进行通信，外部系统可能是文件、数据库、其他程序、网络、IO设备等等。外部系统比较复杂多变，那么我们有必要通过某种手段进行抽象、屏蔽外部的差异，从而实现更加便捷的编程。 I/O 问题是任何编程语言都无法回避的问题，可以说 I/O 问题是整个人机交互的核心问题，因为 I/O 是机器获取和交换信息的主要渠道。在当今这个数据大爆炸时代，I/O 问题尤其突出，很容易成为一个性
Java学废之路02——对象
我姓弓长那个张的博客
10-23 167
02JAVA对象 2.1 概述 对象的特性： 行为——可以对对象施加哪些操作？对象的行为是用可调用的方法定义的。 状态——当施加了方法时，对象如何响应？对象状态的改变必须通过调用方法实现。 标识——如何辨别具有相同行为与状态的不同对象？每个对象都有一个唯一的标识。 2.1.1 对象与对象变量 在 Java 中使用构造器构造新实例。构造器是一种特殊的方法，用来构造并初始化对象。 //1 对象变量 Date deadline; //2 对象 //该句构造了一个Date类型的对象，并且它的值是对新
Java学废之路04——接口与内部类
我姓弓长那个张的博客
10-23 136
04 JAVA接口与内部类 4.1 接口 4.1.1 接口与抽象类 抽象类：声明方法的存在但不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不在该类中实现这些方法。 抽象类中可以没有抽象方法；接口中的方法必须是抽象方法（1.8中的增强接口除外） 抽象类中可以有普通的成员变量；接口中的变量必须被初始化 抽象类只能被单继承，一个类可以实现多个接口 抽象类不可被实例化，即不可直接new一个抽象类。但是，可以声明一个变量为抽象
Java学废之路08——反射与代理
我姓弓长那个张的博客
11-01 198
八、反射与代理 8.1 反射机制 当使用字符串的形式给出一个类名时，依靠什么机制来获取他的类型呢？ JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用对象的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 8.1.1 简介 在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时就可以利用Java的反射机制来获取所需的成员变量或是方法（public或pri
Java学废之路06——泛型与集合
我姓弓长那个张的博客
10-27 345
六、泛型与集合 6.1 泛型 为了能够更好的学习容器，我们首先要先来学习一个概念：泛型。 泛型是JDK1.5以后增加的，它可以帮助我们建立类型安全的集合。在使用了泛型的集合中，遍历时不必进行强制类型转换。JDK提供了支持泛型的编译器，将运行时的类型检查提前到了编译时执行，提高了代码可读性和安全性。 泛型的本质就是“数据类型的参数化”。泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。使用泛型编写的代码要比那些杂乱的使用Object变量，然后再进行强制类型转换的代码具有更好的安全性，可读性。 6.
Kafka从入门到学废（六）——Spring框架下认证集群生产消息
爱清清的专栏
10-12 305
生产环境基本都是采用认证集群的方式，认证集群搭建方式参见之前的博文（认证集群搭建）。接下来基于Spring kafka编写生产消息代码 首先配置文件： kafka: producer: security: # 加密协议（和认证集群搭建时候的配置内容对应） protocol: SASL_PLAINTEXT # 加密方式（和认证集群搭建时候的配置内容对应） sasl-mechanism: SCRAM-SHA-256 # 访问用户名（和认.
Kafka从入门到学废（七）——Spring框架下认证集群消费消息（动态配置）
爱清清的专栏
10-12 2113
之前写了认证集群搭建和认证集群模式下生产消息的内容。本次将介绍认证集群模式下的消费消息。写博文的时候刚好项目涉及到同时要监听多个topic，而且不同topic有对应不同的groupid以及用户名密码的情况。所以本次实现了动态配置多组监听的场景，同理其它配置也可以修改配置多套。Talk is cheap 配置内容： kafka: consumer: # topic::groupId::账号::密码，英文逗号分割 cp: topic1::groupid1::user1::pwd1,top.
Kafka从入门到学废（五）——Kafka认证集群搭建
爱清清的专栏
09-01 342
安装包准备 下载安装包到目标目录，用tar zxvf命令解压 认证配置文件准备 进入kafka安装包根目录的config文件夹下，创建kafka_server_jaas.conf和kafka_zoo_jaas.conf两个文件 创建文件 kafka_zoo_jaas.conf Server{ org.apache.zookeeper.server.auth.DigestLoginModule required username="[YOUR NAME]"
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 142
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 817
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 881
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
基于Mysql、JavaScript、PHP、ajax开发的MBTI性格测试网站（前端+后端）
2302_79553009的博客
10-29 1443
本项目旨在构建一个基于MBTI（迈尔斯-布里格斯性格分类指标）理论的在线平台——“16Personalities”。该平台利用PHP、MySQL、JavaScript等技术栈开发，旨在帮助用户更好地理解和运用MBTI理论来评估个人性格类型，并应用于职业规划、团队建设和人际交往等多个方面。用户端功能 包括账号注册与登录、在线性格测试、性格类型浏览、团队评估及在线交友等模块。用户可以通过完成性格测试来获得详细的MBTI性格分析，并通过平台提供的功能与其他具有不同性格类型的用户互动。
SpringSession源码分析
lkr_lkr的博客
11-01 258
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java复习24（PTA)
2301_79272475的博客
10-30 410
Java复习24（PTA)：多种排序的book类*
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 289
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
Java项目使用Dozer进行实体类转换实战
"该资源主要介绍了在Java项目中如何实现实体类之间的转换，具体使用了Dozer库作为转换工具，并提供了配置文件设置和日期转换的示例。" 在Java开发中，实体类转换是一个常见的需求，特别是在处理业务逻辑时，需要在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我姓弓长那个张

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

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

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

打赏作者

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

抵扣说明：

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

余额充值