不就是Java吗之 继承

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量383 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53117341/article/details/126091452
版权

继承

一、继承

1.1 为什么需要继承

Java使用类来对现实世界进行描述，那么现实世界错综复杂，不同事务之间可能会有联系，会有共同点。比如修猫还有修狗，都能吃，都能睡，都能叫。那么我们可以用类来表示修猫和修狗

class Cat {
    public String name;
    public int age;
    public double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
    public void mew() {
        System.out.println(this.name + "正在喵喵喵!");
    }
}

class Dog {
    public String name;
    public int age;
    public double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
    public void bark() {
        System.out.println(this.name + "正在汪汪汪!");
    }
}

我们可以看到，他们都有共同的属性

public String name;
public int age;
public double weight;

也有共同的方法

public void sleep() {
    System.out.println(this.name + "正在睡觉!");
}
public void eat() {
    System.out.println(this.name + "正在吃饭!");
}

image-20220527175942386

那么我们能否把这些共同点抽取出来，然后能多次使用呢？这就需要我们的继承了

1.2 继承

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

其实继承就是：对共性的抽取，从而达到了代码的复用

image-20220527175909365

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态(后序讲)。

1.2.1 语法

修饰符 class 子类 extends 父类 {
 // ... 
}
其中，子类又叫做派生类，父类又叫做基类/超类

比如：

class Cat extends Animalc {
    // ...
}

那么我们就可以对猫类、狗类重新设计了

class Animal {
    public String name;
    public int age;
    public double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.name + "正在喵喵喵!");
    }
}

class Dog extends Animal {
    public String color;

    public void bark() {
        System.out.println(this.name + "正在汪汪汪!");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sex = "雌性";//可以对子类的属性进行赋值
        cat.name = "大傻瓜";//也可以对父类继承下来的属性进行赋值
        cat.age = 3;
        cat.weight = 16.0;
        cat.eat();//可以调用父类继承下来的方法
        cat.sleep();
        cat.mew();//也可以调用自己的方法
        System.out.println("-----------------");
        Dog dog = new Dog();
        dog.color = "黄色";
        dog.name = "大笨蛋";
        dog.age = 4;
        dog.weight = 18.8;
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

image-20220527185124506

在这里我们要注意两点：

  1. 子类会将父类当中的成员变量或者成员方法继承到子类当中
  2. 子类继承父类之后，最好要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

那么我们把访问权限改成私有呢？

class Animal {
    private String name;
    private int age;
    private double weight;

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.name + "正在喵喵喵!");
    }
}

class Dog extends Animal {
    public String color;

    public void bark() {
        System.out.println(this.name + "正在汪汪汪!");
    }
}

我们可以看到，name属性访问不了了？这难道是因为没有被继承？

image-20220528205823153

不是，是因为这几个属性被设置成私有的，在类外访问不了。我们需要编写getter setter方法，在类外才能实现

class Animal {
    private String name;
    private int age;
    private double weight;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void sleep() {
        System.out.println(this.name + "正在睡觉!");
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭!");
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.getName() + "正在喵喵喵!");
    }
}

class Dog extends Animal {
    public String color;

    public void bark() {
        System.out.println(this.getName() + "正在汪汪汪!");
    }
}

1.3 父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

1.3.1 子类访问父类的成员变量

1.3.1.1 子类和父类不存在同名成员变量
class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base {
    public int c = 3;

    public void method() {
        System.out.println(a);//访问从父类继承的a:1
        System.out.println(b);//访问从父类继承的b:2
        System.out.println(c);//访问子类自己的c:3
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

image-20220527191950847

1.3.1.2 子类和父类成员变量同名
class Base2 {
    public int a = 1;
    public int b = 2;

    public void method() {
        System.out.println("Base2::method");
    }
}

class Derived2 extends Base2 {
    public int a = 3;
    public int c = 4;

    public void method(int a) {
        System.out.println("Derived::method");
    }

    public void display() {
        System.out.println(a);//3:子类里面也有的时候，优先访问子类
        System.out.println(b);//2:子类里面没有的时候，去父类里面找
        System.out.println(c);//4：子类里面有父类里面没有的，去子类里面找
        //System.out.println(d);//子类当中也没有，父类当中也没有->报错
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived2 derived2 = new Derived2();
        derived2.display();
    }
}

在子类方法中 或者 通过子类对象访问成员时：

  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的，即：子类将父类同名成员隐藏了。成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

那么我们要访问父类的成员变量，该怎么办呢？

这时候我们就需要用一个关键字super，他的作用是在子类方法中访问父类的成员

大家都说super代表父类对象的引用，但是不太准确。super其实就是个普通的关键字，是来帮助别人或者程序员知道访问父类成员的，起到了易读的操作

所以我们就可以这样写：

public void display() {
        System.out.println("父类里面的a:" + super.a);
        System.out.println("子类里面的a:" + this.a);
        System.out.println("父类里面的b:" + super.b);
        System.out.println("父类里面的b:" + this.b);//因为父类里面有b，子类里面没有b，所以也可以用this
        System.out.println("子类里面的c:" + this.c);
    }

image-20220527194608521

image-20220527194346936

1.3.2 子类中访问父类的成员方法

1.3.2.1 成员方法名字不同

成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

class Base3 {
    public void methodA() {
        System.out.println("Base3::methodA()");
    }
}

class Derived3 extends Base3 {
    public void methodB() {
        System.out.println("Derived3::methodB()");
    }

    public void display() {
        methodA();//访问父类的A
        methodB();//访问子类的B
        //methodC();//父类子类都没有->报错
    }
}

public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.display();
    }
}
1.3.2.2 成员方法名字相同

通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用的方法所传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法的原型一致(这就是重写，后面讲)，则只能访问到子类的，父类的无法通过派生类对象直接访问到，需要借助super关键字

class Base4 {
    public void method1() {
        System.out.println("Base4::method1()");
    }

    public void method2() {
        System.out.println("Base4::method2()");
    }
}

class Derived4 extends Base4 {
    public int a = 10;

    public void method1(int a) {
        System.out.println("Derived4::method1(int a)");
    }

    public void method2() {
        System.out.println("Derived4::method2()");
    }

    public void display() {
        method1();//没有参数->调用父类的method1方法
        method1(a);//有参数->调用子类的method1方法
        super.method1();//没有参数->调用父类的method1方法,super也不好使
        method2();//没有super->调用子类的method2方法
        super.method2();//有super->调用父类的method2方法
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Derived4 derived4 = new Derived4();
        derived4.display();
    }
}

image-20220528150121592

我们要注意的是，其实这里面是发生了函数重载的。那有的同学就想起来了，函数重载不是在方法之间产生的吗，而且当初我们是在一个类里面实现的啊？在两个类里面也可以实现继承？

要在两个类里面的方法实现继承的话，必须这两个类是继承关系！！！

1.4 super关键字

super关键字的主要功能是：在子类方法中访问父类的成员(成员变量、成员方法)。

super代表父类对象的引用，其实是不准确的。它起到的作用就是：当别人看见这个关键字之后，知道我是在访问父类的成员，增加可读性

class B extends A {
    char a1;
    public void func() {
        super.a1 = 97;//并未改变a1的值
    }
}
public class TestDemo5 {
    public static void main(String[] args) {
        B b = new B();
        b.func();
        System.out.println(b.a1);//打印不出来的东西
        A a = new A();
        System.out.println(a.a1);//100

    }
}

image-20220528155412437

但是要注意：super是不能在静态方法里面使用的

public static void func() {
        System.out.println(super.a);
    }

image-20220528151054009

我们刚才也知道了super的几个用法：

  1. super.data：访问父类当中的成员变量
  2. super.func()：访问父类当中的成员方法

其实super还有一个用法：子类构造父类的时候会用上，这就是我们接下来要讲的

1.5 子类构造方法

当构造子类的时候，一定要先帮父类进行构造。

父类：

//构造方法
    public Animal(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

子类：

//构造方法
    public Cat(String name,int age,double weight,String sex) {
        //先帮助父类构造
        super(name,age,weight);
        //再帮助子类构造
        this.sex = sex;
    }

//构造方法
    public Dog(String name, int age, double weight, String color) {
        //先帮助父类构造
        super(name, age, weight);
        //再帮助子类构造
        this.color = color;
    }

注意事项：

  1. super必须放在第一行

    public Cat(String name,int age,double weight,String sex) {
        System.out.println("super不放在第一行当然是不行的");
        //先帮助父类构造
        super(name,age,weight);
        //再帮助子类构造
        this.sex = sex;
    }

    image-20220528162949217

  2. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法

    原型：

    public Cat() {
    super();
}

    这里面的super可以省略

    如果父类构造方法是带有参数的，此时编译器不会再给子类生成默认的构造方法，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

  3. super只能在构造方法中出现一次

    class Animal {
    private String name;
    private int age;
    private double weight;
    
    //构造方法
    public Animal(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    public Animal(String name) {
        this.name = name;
    }
}

class Cat extends Animal {
    public String sex;

    public void mew() {
        System.out.println(this.getName() + "正在喵喵喵!");
    }

    //构造方法
    public Cat(String name,int age,double weight,String sex) {
        //不能出现两个super
        super(name,age,weight);
        super(name);
        
        this.sex = sex;
    }
}

    image-20220528163841858

  4. super不能和this同时出现

    //构造方法
    public Cat(String name,int age,double weight,String sex) {
        //super不能和this同时出现
        super(name,age,weight);
        //this(name);
        
        this.sex = sex;
    }

    image-20220528163955064

1.6 super 和 this

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点：都是Java中的关键字

  1. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
  2. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点：

  1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成
    员的引用
  2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
  3. this是非静态成员方法的一个隐藏参数，super不是隐藏的参数
  4. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造
    方法中出现
  5. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

1.7 再谈初始化

在之前，我们讲过了实例代码块、静态代码块、构造方法。那么我们浅浅的复习一下

执行时间：静态代码块>实例代码块>构造方法

  1. 静态代码块只会执行一次，在类加载阶段执行
  2. 实例代码块只会在有对象创建的时候才执行

那么我们学习了继承，父类中可以有静态代码块、实例代码块、构造方法，子类中也可以有静态代码块、实例代码块、构造方法。那么他们执行的先后顺序也跟之前的一样吗？我们举个栗子：

class Person {
    public String name;
    public int age;

    //构造方法
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类的构造方法");
    }

    //实例代码块
    {
        System.out.println("父类的实例代码块");
    }

    //静态代码块
    static {
        System.out.println("父类的静态代码块");
    }
}

class Student extends Person {
    public int id;

    //构造方法
    public Student(String name,int age,int id) {
        super(name,age);
        this.id = id;
        System.out.println("子类的构造方法");
    }

    //实例代码块
    {
        System.out.println("子类的实例代码块");
    }

    //静态代码块
    static {
        System.out.println("子类的静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student("孙答应",56,001);
        System.out.println("-----------------");
        Student student2 = new Student("静白师太",66,002);
    }
}

运行结果：

image-20220528200308308

父类的静态代码块
子类的静态代码块
父类的实例代码块
父类的构造方法
子类的实例代码块
子类的构造方法
-----------------
父类的实例代码块
父类的构造方法
子类的实例代码块
子类的构造方法

那么我们看运行结果，我们可以归纳出：

  1. 静态代码块依然先执行，其中父类的静态代码块比子类的静态代码块先执行
  2. 然后执行父类的实例代码块和静态代码块
  3. 再然后执行子类的实例代码块和构造方法
  4. 第二次实例化对象的时候，父类和子类的静态代码块都不再执行

1.8 protect关键字

image-20220528201148867

如果产生了继承关系，子类就可以访问到父类里面被protct修饰的成员变量

举个栗子：

父类：

public class B {
    private int a;//私有的：只能在当前类中访问
    protected int b;//继承权限：产生继承关系，子类就可以访问父类protected修饰的成员变量
    public int c;//哪里都可以访问
    int d;//默认权限：在同一个包中都可以访问
}

同一个包下，产生继承关系的D类：

public class D extends B {
    public void method() {
        //super.a = 10;//编译报错：父类中a为private属性，只能在父类中使用
        super.b = 20;//父类中b为protected属性，由于B D为继承关系，父类中protected成员在子类中也可以访问
        super.c = 30;//父类中c为public属性，哪里都可以访问
        super.d = 40;//父类中d为default属性，可以在当前包中任何位置访问
    }
}

不同包下，产生继承关系的C类：

public class C extends B {
    public void method() {
        //super.a = 10;//编译报错：父类中a为private属性，只能在父类中使用
        super.b = 20;//父类中b为protected属性，由于B D为继承关系，父类中protected成员在子类中也可以访问
        super.c = 30;//父类中c为public属性，哪里都可以访问
        //super.d = 40;//编译报错：父类中d为default实行，只能在同一个包中访问
    }
}

不同包下，未产生继承关系的Test类：

public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.method();

        //System.out.println(a);//编译报错：父类中a为private属性，只能在父类中使用
        //System.out.println(b);//父类中b为protected修饰，未产生继承关系，不能访问
        System.out.println(c);//父类中public成员在不同的包不同的类中都可以访问
        //System.out.println(d);//父类中d为default修饰，在其他包中就不可以访问了
    }
}

他们的关系我已经截图标记出来了

image-20220528205656865

那么我们现在学会了好几种权限，那到底什么时候用哪一种呢？

教给大家一种最直接的办法：

所有的成员属性全部设置成private，将所有的方法设置成public

1.9 Java当中的继承方式

Java只支持以下几种继承方式：

image-20220528210332738

1.10 final关键字

final是一个关键字，可以用于修饰类，成员变量，成员方法。

特点：

  1. 它修饰的类不能被继承。

    Animal类：

    final public class Animal {
    
}

    image-20220528210809295

    Birds类：

    public class Bird extends Animal {
    
}

    image-20220528210916512

  2. 它修饰的成员变量是一个常量。被final修饰的常量名称,所有字母都大写

    final int SIZE = 10;//当前的SIZE后续就不能被修改了

  3. 它修饰的成员方法是不能被子类重写的。(后续)

1.11 继承与组合

继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物

组合表示对象之间是has-a的关系，组合就是把另一个类的类型定义的新变量作为成员，比如：汽车

那我们举个栗子：汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。

class Tire {
    
}

class Engine {
    
}

class VehicleSystem {
    
}

class Car {
    //这就叫复用
    private Tire tire;
    private Engine engine;
    private VehicleSystem vehicleSystem;
}

class Baoma extends Car {
    //宝马可以继承Car里面的所有属性
}

栗子2：

class Money {
    
}

class Student {
    public Money money;
}

class Teacher {
    public Money money;
}

class School {
    public Student[] student;
    public Teacher[] teacher;
}

加勒比海涛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java面向对象之继承练习题.doc
08-04
【Java面向对象之继承练习题】的解析与详解： 1. **类的继承**：在Java中，继承是面向对象编程的重要特性，允许一个类（子类）继承另一个类（父类）的属性和方法。例如，我们可以创建一个`Music`类作为其他音乐相关...
Java编程之继承问题代码示例
08-28
下面是一个Java继承示例，演示了交通工具类（Vehicle）、汽车类（Car）和公交车类（Bus）的继承关系： * 交通工具类（Vehicle）：定义了载客量（capacity）属性和无参构造方法、有参构造方法、getCapacity()、set...
Java语法之继承
m0_63635730的博客
11-19 4219
Java语法之继承
Java继承（超详解）
热门推荐
m0_52896041的博客
07-18 2万+
继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。继承是指在原有类的基础上，进行功能扩展，创建新的类型。继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。JAVA中类只有单继承，没有多继承!继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系。
java接口的继承是多继承吗
qq_46497604的博客
09-01 3712
​ Java接口不仅可以继承接口，还可以多继承 ​
Java 继承
南辞的博客
11-06 7753
面向对象三大特征之二：继承
java 不能继承的类_java中不能继承的类有哪些？
weixin_28813803的博客
02-12 2530
在Java中，只要是被定义为final的类，也可以说是被final修饰的类，就是不能被继承的。因为jdk的开发者认为，有一些最基本的类没要必要对开发者开放，如果用户继承时操作有误，很可能引入很多问题。为了防止用户对基本类进行相应的扩展，也体现了java设计过程中的开闭原则，最终将这些类设计成为final的。这是final的规定：当你将final用于类身上时，一个final类是无法被任何人继承的，那...
Java中static变量能继承吗
08-25
Java 中的 static 变量和方法可以被子类继承，但是它们不能被重写，无法形成多态。这个结论来自于对 Java 中 static 变量和方法的研究和实践。 在 Java 中，static 变量和方法是属于类的，而不是实例的。因此，当...
java教程之java继承示例详解
09-04
"java继承示例详解" java继承是指新定义的类从已有的类中获取属性和方法的现象。这个已有的类叫做父类，而从这个父类获取属性和方法的类叫做子类。继承的主要优点是提高了代码的重用性，让类和类之间产生了关系，为...
java为何不能多继承的原因详解
08-25
Java 为何不能多继承的原因详解 Java 语言是不能多继承的，这意味着一个子类只能继承于一个父类。这是 Java 语言设计者的一个重要决定，目的是为了避免多继承带来的问题。 多继承是一个子类从多个父类中继承属性和...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 497
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 272
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 283
1.导入hutool的maven依赖。2.直接复制一下代码运行。
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 881
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 756
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
安装ElasticSearch
diffiii
07-31 395
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
Java8新特性之FlatMap&Reduce
startqbb的博客
07-26 213
【代码】Java8新特性之FlatMap&Reduce。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 231
新建springboot项目找不到java版本8?
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 661
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
Java单继承详解与示例
本教程以经典的"单继承示例"为主题，讲解了如何在Java中实现单继承以及与之相关的概念。 单继承在Java中的实现 Java语言采用严格的单继承机制，这意味着一个类只能直接继承自一个父类。这种设计使得类的继承关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

加勒比海涛

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

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

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

打赏作者

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

抵扣说明：

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

余额充值