java对象

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量117 收藏
点赞数
文章标签： java 多态 封装 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sw_eet/article/details/103691320
版权

面向对象编程

  • java的核心思想oop

初识面向对象

  • 面向过程思想
    • 步骤清晰简单，第一步做什么，第二步做什么……
    • 面向过程适合处理一些较为简单的问题
  • 面向对象思想
    • 物以类聚，分类的思维模式，思考问题首先思考要解决的问题有哪些分类，然后对这些分类进行单独思考。最后，在对某个分类下的细节进行面向过程的思索。
    • 面向对象适合复杂的问题，适合处理需要多人协作的问题
  • 对于描述复杂的事物，为了从宏观上把握、从整体上分析，我们需要使用面向对象思路来分析整个系统。但是，到微观操作，任然需要面向过程的的思路处理。
  • 面向过程编程的本质：以类的方式组织代码，以对象的方式组织（封装）数据
  • 抽象
  • 三大特性
    • 封装
    • 继承
    • 多态
  • 从认识的角度考虑，先有对象后有类。对象是具体的事物，类是抽象的，是对类的抽象
  • 从代码的运行角度考虑先有类后有对象，类是对象的模板

回顾方法的定义

  • 方法的定义

    • 修饰符

      含有static为静态，否则为非静态。静态可以直接调用，非静态需要定义使用

    • 返回值类型

      可以有返回值也可以没有，数组也可以是返回值

    • break，跳出switch、结束循环。return，代表方法结束

    • 方法名

      注意规范（驼峰原则），见名知意

    • 参数列表

      参数类型，参数名（可变长参数，需要放在最后）

    • 异常的抛出

  • 方法的调用-----（递归）

    • 静态方法

      有static，使用时、类名.方法名、就可以使用，自己可以调用自己，但不能与非静态混调

    • 非静态方法

      无static，使用时需要先进性new一个对象，在使用，自己可以调用自己，但不能与静态混调

    • 形参和实参

      方法中传入的参数，表明需要接收什么类型的值，要接收多少，太多同类型的，或同类型不知道有多少个数的，可以使用可变长参数，但一个方法只能有一个，而且需要放在最后

    • 值传递和引用传递

      java只有值传递，引用传递 给对象，本质是值传递。值传递不改变原值，引用传递直接在原值上改动。

    • this关键字

类与对象的关系

  • 类是一个抽象的数据类型，它是对某一事物的整体描述、定义，但不能代表某一具体事物
  • 对象是抽象概念的具体事例

创建与初始化对象

  • 使用new关键字
  • 使用new关键字创建时，除了分配内存空间之外。还会给创建好的对象进行默认的初始化及对类中构造器的调用
  • 类中的构造器也称为构造方法，是在进行创建对象时必须调用的。构造器有以下两个特点
    • 必须和类名相同
    • 必须没有返回类型，也不能写void
package oop.demo02;

//一个项目只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //把类实例化为一个对象
        //类是抽象的，需要实例化
        //类实例化后，会返回一个自己的对象
        //studentd对象是Student类的一个具体实例
        Student agaio = new Student();
        Student laoba = new Student();

        agaio.name="小阿giao";
        agaio.age=3;
        System.out.println(agaio.name);
        System.out.println(agaio.age+"岁");
        agaio.agiao();

        System.out.println("==============================");
        laoba.name="老八";
        laoba.age=4;
        System.out.println(laoba.name);
        System.out.println(laoba.age+"岁");
        laoba.laoba();
    }
}

package oop.demo02;

public class Student {

    //属性 字段
    String name;
    int age;

    //方法
    public void agiao(){
        System.out.println(this.name+"------>一给我的giao");
    }

    public void laoba(){
        System.out.println(this.name+"------>只有你们想不到的，没有我老八做不到的");
    }
}

/*
结果
小阿giao
3
小阿giao------>一给我的giao
==============================
老八
4
老八------>只有你们想不到的，没有我老八做不到的

Process finished with exit code 0
*/

构造器详解

  • 构造器必须理解
  • 和类名相同没有返回值
  • 作用，new的本质是在调用构造方法，还可以初始化值
  • 定义构造器后，如果想使用无参构造器，必须显示定义一个无参构造
  • 即使你的方法里什么都没写，但是会自动生成一个无参构造器
  • 生成构造器快捷键Alt+Insert
package oop.demo02;

//java------------>class、、、、out文件夹查看
public class Person {
//即使一个类里，什么都没写也会存在一个方法，看class文件
    //显示的定义构造器
    //可以给实例化对象一些初始值
    String name;
    //使用new关键字，必须要有构造器
    //构造器一般用来初始化值
    public Person(){
        //this.name="小阿giao";
    }
    //有参构造，一旦定义了有参构造，就必须写无参构造
    public Person(String name){
        this.name=name;
    }
    //方法重载
    //alt+insert-------------》自动生成构造器
}

/*
 public static void main(String[] args) {

        //mew一个实例化的对象
        Person person = new Person("小阿giao");
        System.out.println(person.name);

    }
 */

创建对象内存分析

内存分析

package oop.demo03;

public class Pet {

    public String name;
    public int age;

    public void shout(){
        System.out.println(this.name+"叫了一声");
    }
}

/*
public static void main(String[] args) {

        Pet dog = new Pet();
        Pet cat = new Pet();

        dog.name="123";
        cat.name="456";
    }
 */

对象小结

  1. 类与对象

    类是一个模板是抽象的，是一种有相似框架的事物的框架。对象是具体的实例（实物）

  2. 方法

    定义、调用

  3. 对象的引用

    引用类型，基本类型（8种）

    对象是通过引用来操作的，栈--------->堆

  4. 属性，字段field 成员变量

    默认初始化

    整数 0 0.0

    char u0000

    boolean false

    引用类型 null

  5. 对象的创建和使用

    必须使用new关键字，创建对象，无参构造器

    对象的属性 dog.name

    对象的方法 dog.shout()

  6. 类

    静态的属性 属性

    动态的行为 方法

封装

  • 该露的露，该藏的藏
    • 我们的程序设计要追求，“高内聚，低耦合”。高内聚是类的内部操作细节自己完成，不允许外部干涉。低耦合，仅暴露少量方法供外部使用
  • 数据的隐藏（封装）
    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
  • 记住这句话，属性私有、get、set
  • 提高程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 系统的可维护性增加
package oop.demo04;

public class Student {

    //属性  私有
    private String name;//姓名
    private int id;//学号
    private char sex;//性别
    private int age;

    //提供一些可以操作这些类的方法
    //提供一些pubilc 的 set get 方法

    //get 获取这些数据
    public String getName() {
        return this.name;
    }

    //set  给这个数据设置数据
    public void setName(String name){
        this.name=name;
    }

    //Alt+Insert

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(0<=age&&age<=120) {
            this.age = id;
        }else{
            this.age=3;
        }
    }
}

/*
//提高程序的安全性，保护数据
//隐藏代码的实现细节
//统一接口
//系统的可维护性增加
public static void main(String[] args) {

        Student s1 = new Student();
        s1.setName("小阿gaio");

        System.out.println(s1.getName());

        s1.setAge(9999);
        System.out.println(s1.getAge());
    }
 */

继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界的建模
  • extends的意思“扩展”，子类是父类的扩展
  • java中类只有单继承，没有多继承。一个儿子只能有一个爸爸，一个爸爸有横多儿子。
  • 继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
  • 子类和父类之间的关系，从意义上讲有“is a”的关系
package oop;

import oop.demo05.Student;

//一个项目只存在一个main方法
public abstract class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();
    }

}
/*
package oop.demo05;

//在java中所有的类都默认直接或间接继承object类
//人      父类
public class Person {

    public int moneg;
    public void say(){
        System.out.println("一给我的giao");
    }

    public int getMoneg() {
        return moneg;
    }

    public void setMoneg(int moneg) {
        this.moneg = moneg;
    }
}


package oop.demo05;

//老师     派生类  子类
public class Tacher extends Person{
}


package oop.demo05;

//学生     派生类  子类
//子类继承了父类，就会拥有父类的全部方法
//Ctrl+h   打开继承树
public class Student extends Person{


}

 */

Super详解

  • 私有的东西，无法被继承
  • 调用子类的无参构造，父类的会先与子类无参构造之前被调用，相当于在子类的代码前加了一句，super();
  • super();若要显示的写出来，那么必须在子类构造器的第一行
  • 注意点
    • super调用父类方法，必须在构造方法的第一行
    • super只能出现在子类的方法或构造方法之中
    • super和this不能同时调用构造方法
  • 与this比较
    • this表示调用者这个对象
    • super代表父类对象的引用
    • this在没有继承是也可以使用
    • super只能在继承条件下使用
    • this默认调用本类的构造方法
    • super，调用父类的构造

方法重写

  • 前提需要有继承关系，子类重写父类的方法

  • 重写是方法的重写，与属性无关

  • 父类的引用指向了子类

  • 静态方法的调用之和左边有关，定义了数据类型有关

  • 非静态方法才算重写

  • @override重写的注解（有功能的注释）

  • 重写的关键词只能是public

  • 子类的方法与父类的一致，方法体不同

  • 快捷键，Alt+Insert选择override

  1. 方法名必须相同
  2. 参数列表必须相同（没有继承关系，重载）
  3. 修饰符，范围可以扩大，但不能缩小，public>protected>default>private
  4. 抛出的异常可以被缩小但不能扩大

为什么需要重写

  1. 父类的功能子类不一定需要，或者不一定满足

多态

  • 类型，动态编译，可扩展性更强

  • 即同一方法可以可以根据发送对象的不同而采用不同的行为方式

  • 一个类的实际类型是确定的，但可以指向的对象的引用类型有很多

  • 多态存在的条件

    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象

  • 注意，多态是方法的多态，属性没有多态

  • instanceof

  • 子类重写了父类的方法，则执行子类中的方法

  • 注意事项

    • 多态是方法的多态，属性没有多态

    • 父类和子类，有联系，ClassCastException（类型转换异常）

    • 多态存在的条件，继承关系，方法重写，父类对象指向子类，Father f1=new Son();

    • static方法属于类，不属于实例不能重写

    • final，常量不能重重写

    • private方法也不能重写

package oop;

import oop.demo06.Person;
import oop.demo06.Student;

//一个项目只存在一个main方法
public abstract class Application {
    public static void main(String[] args) {

        //父类引用指向子类，引用类型不确定
        //对象能执行哪些方法，主要看对象左边的类型，和左边关系不大
        //Student能调用的方法，都是自己的或者继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();//子类重写了父类的方法，则执行子类中的方法
        s1.run();
        //((Student) s2).eat();      强制转换
    }

}

/*
package oop.demo06;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son");

    }
    public void eat(){
        System.out.println("eat");
    }
}

package oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }
}
 */

instanceof和类型转换（引用类型判断一个对象是什么类型）

  • 父类的引用指向子类的对象
  • 把子类转换为父类，向上转型，不用强制转换，自动就可以转换
  • 把父类转换为子类，向下转型，用强制转换，可能会丢失一些方法
  • 方便方法的调用，减少重复的代码
package oop;

import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;

public abstract class Application {

    public static void main(String[] args) {

        //父类转化为子类需要强转，子类转化为父类自动转化
        //
        Student s1 = new Student();
        s1.go();

        System.out.println("========================================");
        //Student将这个对象转换为Student，就能使用Student方法了
        Person obj = new Student();
        Student s2=(Student)obj;
        s2.go();
        //以上简短写法
        //((Student)obj).go();
        System.out.println("========================================");
        //把Student变成Person类型,person类型不能使用go()方法
        //因此可知当进行低转高时会出现方法不能使用的现象
        //子类转换为父类可能会失去一些自己的方法
        Person s3= s1;

    }
}

/*
  Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("========================================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译报错
        System.out.println("========================================");



        package oop.demo06;

public class Student extends Person {

    public void go(){
        System.out.println("go");
    }
}



package oop.demo06;

public class Teacher extends Person{

}


package oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }
}

 */

static关键字

package oop.demo07;

//import java.lang.Math;    使用后可以直接调用Math类中的方法
//System.out.println(random());//随机数产生

//import static java.lang.Math.random;    静态导入包
//被final修饰不能被继承
public class Test {

    public static void main(String[] args) {

        System.out.println(Math.random());//随机数产生
    }
}


package oop.demo07;

public class Person {

    {
        //第2执行，与对象同时产生，可用于赋初始值
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }


    static{
        //第1执行，且只执行一次
        //静态代码块
        System.out.println("静态代码块");
    }

    public Person(){
        //第3执行
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=================");
        Person person2 = new Person();//输出时静态代码块没有了


    }
}


package oop.demo07;

public class Student {

    //static 用在类就是，静态类，用在方法就是静态方法
    private static int age=1;          //静态变量             多线程
    private double score=0.1;         //非静态变量

    public static void run(){

    }
    public static void go(){

    }
    public static void main(String[] args) {
        /*
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println("====================");
       // System.out.println(Student.score);报错
        System.out.println(s1.score);
        */

        Student student = new Student();
        student.go();
        //上面的简写，new Student().go();
        Student.run();
        //静态方法可以调用静态方法
        run();

    }
}

抽象类

  • abstract修饰符可以用来修饰方法也可以用来修饰类。如果修饰方法，那么该方法是抽象方法。如果修饰类，那么该方法是抽象类。
  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要申明为抽象类
  • 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
  • 抽象方法，只有方法的申明，没有方法的实现，他是让子类来实现的
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要申明为抽象类
package oop.demo08;

//abstract抽象类
public abstract class Action {

    //约束----有人帮你实现
    //抽象abstract方法，只有方法的名字，没有方法的实现，无方法体
    public abstract void doSomething();
}

/*
package oop.demo08;

//抽象类的所有方法，继承他的子类，都必须要实现他的方法，除非子类也是抽象类，那就有子子类实现
//extends          单继承
//接口              多继承

public class A extends Action{
    @Override
    public void doSomething() {

    }

    //抽象的抽象，约束
    //不能new抽象类，只能让子类去实现它
    //抽象方法必须在抽象类中
    //抽象类里可以写普通方法
    public void go(){
        System.out.println("");
    }

}
//思考
//抽象类不能new，存在构造器吗
//抽象类存在的意义
 */

  • 抽象类不能new，存在构造器吗

    有构造器

  • 抽象类存在的意义

    1. 例如，兔子，老鼠，都是哺乳动物，可以用抽象类来规定他们的相同点（属性）哺乳等
    2. 现在要加入西安的哺乳动物人，直接继承哺乳动物类就好了，再添加自己特有的方法即可
    3. 还是不太懂------------------------------------

接口

  • 对比
    • 普通类，只有具体实现
    • 抽象类，具体实现和规范（抽象方法）都有
    • 接口只有规范，约束和实现分离
  • 接口就是规范，定义了一些规则，体现了现实世界中，“如果你是……则必有……”的意思，例，如果你是哺乳动物，则必有你需要喝奶
  • 接口本质是契约，就像人类的法律，制定好后就必须遵守
  • 面向对象的精髓，就是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都是讨论具备抽象能力的语言（c++、java、C#等），就是因为设计模式所研究的就是如何合理的去抽象
  • 声明接口的关键字，interface
  • 作用
    1. java的接口是约束
    2. 定义一些方法，让不同的类实现
    3. public abstract，定义方法是默认的修饰
    4. public static final，定义常量的默认修饰（一般不在接口里写）
    5. 接口不能被实例化，没有构造方法
    6. implements可以实现多个接口的方法的实现，必须要实现接口中的方法（否则报错）
package oop.demo09;

//定义的关键字interf
//接口都需要有实现类
public interface UserServi {

    //接口中的所有定义都是抽象的    public
    //public abstract显示灰色，可以不写
    //public abstract void run();

    //接口中常量的修饰为,public static final
    int AGE=99;                    //常量的定义，用大写

    void add(String name);
    void delete(String name);
    void uodate(String name);
    void query(String name);
}


/*
package oop.demo09;

public interface TimeService {
    void timer();
}

package oop.demo09;

//类可以实现接口，用，implements
//实现接口的类，就必须重写接口的方法
//利用借口来实现，多继承
public class UserServImpl implements UserServi,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void uodate(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

 */

内部类

package oop;

import oop.demo10.Outer;

public abstract class Application {

    public static void main(String[] args) {

        Outer outer = new Outer();
        outer.out();

        System.out.println("========================");
        //内部类通过外部类来实例化
        //对象的类型叫 Outer.Inner
        Outer.Inner inner = outer.new Inner();
        inner.in();
        System.out.println("========================");
        inner.getId();

    }
}

/*
package oop.demo10;

public class Outer {


}
//一个java文件中只能有一个public类，但可以有多各类
class a{

}

/*
package oop.demo10;

public class Outer {
    private int id=1;
    public void out(){
        System.out.println("这是外部类的方法" );
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类");
        }

        //可以获取外部类的私有属性,私有方法
        public void getId(){
            System.out.println(id);
        }
    }
}

 */
 */

/*
package oop.demo10;

import oop.demo08.A;

public class Test {
    public static void main(String[] args) {

        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        new UserService(){
            @Override
            public void hello() {

            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}
interface UserService{
    void hello();
}
 */
sw_eet
关注
java对象转JSONObject
小小鸭脖的博客
12-21 4万+
首先导包 两个 import com.alibaba.fastjson.JSONObject; import com.google.gson.Gson; Gson g = new Gson(); Notice notice = g.fromJson(s, Notice.class); //json字符串转java对象 需要的是Gson /*这里需要强转一下 默认是Obje...
JAVA 对象转换为JSON
u200814342A的博客
08-15 2万+
cfg.setExcludes(new String[] {“待过滤属性1”, “待过滤属性2”, ..., “待过滤属性n”});使用jsonConfig对象的setExcludes()方法，传入参数为待过滤属性组成的数组。//过滤List集合中的Customer对象的id属性不生成JSON。//过滤Customer对象的id属性不生成JSON。//包含多个对象的List集合转换为JSON格式。1、Java对象列表转换为JSON对象数组，并转为字符串。3、过滤不需要转换为JSON格式的属性。
Java对象转Map
m0_67392126的博客
04-19 4725
使用org.apache.commons.beanutils包下的BeanUtils.describe()方法可以将Java对象按属性转为Map。 import org.apache.commons.beanutils.BeanUtils; class CommonUtils{ public static Map<String, Object> convertToMap(Object obj) { try { if (obj instanceof Map) { ret
Java 对象拷贝工具类
小白一个
07-19 1万+
我们在Java编码中，有时候可能会经常遇到对象拷贝的场景。比如（1）当我们更新一个对象的时候，如果要记录对象属性的前后变化，那么在更新对象之前，我们应该首先将对象拷贝暂存起来，且这个时候的拷贝一定是深拷贝（内存地址不同的两个对象），因为Java存在对象引用，将一个对象赋值给另外一个对象，他是浅拷贝的（两个不同变量名，但实际内存地址一样的两个对象）的话，也就是说当我们去更新完成属性值的时候，其实是设置的同一个对象，那么这个时候就会导致更新前后无变化的情况。............
如何将 Java 对象转换为 JSON？
allway2的博客
03-20 7万+
要将 Java 对象或 POJO（普通旧 Java 对象）转换为 JSON，我们可以使用JSONObject将对象作为参数的构造函数之一。在下面的示例中，我们将StudentPOJO 转换为 JSON 字符串。Student类必须提供 getter 方法，JSONObject通过调用这些方法创建 JSON 字符串。 在此代码段中，我们执行以下操作： 使用 setter 方法创建Student对象并设置其属性。 创建JSONObject调用object并将Student对象用作其构造函数的参数。 J.
java对象之间赋值
dawnStart的博客
12-20 3251
第一种：使用org.apache.commons.beanutils.PropertyUtils.copyProperties()拷贝一个bean中的属性到另一个bean中,第一个参数是目标bean,第二个参数是源bean。 特点： 1.它的性能问题相当差 2.PropertyUtils有自动类型转换功能，而java.util.Date恰恰是其不支持的类型 3.PropertyUtils支持为null的场景； public static void copyProperties(Object dest, Ob
Java对象初始化
小虎哥的技术博客
07-27 3427
Java对象初始化，对象初始化流程: 加载字节码(只加载一次)->初始化字段->父类构造方法->自身构造方法。
java对象写入文件_将Java对象写入文件中
weixin_28807463的博客
02-20 3521
Java对象序列化首先介绍一下对象序列化的目标：对象序列化的目标是将对象保存到磁盘中，或允许在网络中直接传输对象。一、序列化的含义和意义：序列化机制使得对象可以脱离程序的运行而独立存在。对象的序列化指将一个Java对象写入IO流中，与此对应的反是，对象的反序列化则指从IO流中恢复该Java对象。如果需要需要让某个对象支持序列化机制，则必须让它的类是可序列化的(serializable)。为了让某个...
java对象结构
zqz_zqz的博客
04-19 3万+
先转载一篇文章作为开头，因为讲的非常详细，我就简单加工下放到这里： 对象结构 在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。下图是普通对象实例与数组对象实例的数据结构： 对象头 HotSpot虚拟机的对象头包括两部分信息： markword 第一部分markwo...
java对象和JSONObject相互转换
qq_28796037的博客
06-14 1万+
java对象和JSONObject相互转换
java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容
04-07
java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的容纳，java 对象的...
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
热门推荐
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
Java对象的实例化过程是怎样的？
流楚丶格念的博客
08-22 3017
但如果Java堆中的内存并不是规整的，已被使用的内存和空闲的内存相互交错在一起，那就没有办法简单地进行指针碰撞了，虚拟机就必须维护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录，这种分配方式称为“除如何划分可用空间之外，还有另外一个需要考虑的问题：对象创建在虚拟机中是非常频繁的行为，即使仅仅修改一个指针所指向的位置，在并发情况下也并不是线程安全的，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况。
阿里jsonobject转java对象_java对象与json对象间的相互转换
weixin_39599654的博客
02-25 4344
工程中所需的jar包,因为在网上不太好找，所以我将它放到我的网盘里了，如有需要随便下载。1.简单的解析json字符串首先将json字符串转换为json对象，然后再解析json对象，过程如下。JSONObject jsonObject = JSONObject.fromObject(jsonStr);根据json中的键得到它的值String name = jsonObject.getString("...
工厂模式的介绍及实现
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 177
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 824
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 223
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 500
Android的系统结构的设计混合了分层设计和分块设计。
使用JakartaCommonsPool优化Java对象池化技术
"深入理解Java对象池化技术及Jakarta Commons Pool的使用" Java对象池化技术是一种优化资源管理的方法，它通过复用已创建的对象来减少频繁创建和销毁对象带来的性能开销。对象池化的核心思想是预先创建一组对象，当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值