Java的参数传递

最新推荐文章于 2024-09-22 22:20:33 发布

少年的云和月(^～^)

最新推荐文章于 2024-09-22 22:20:33 发布

阅读量406

点赞数

文章标签：开发语言 java

本文链接：https://blog.csdn.net/m0_70054514/article/details/133026264

版权

1.常量池在哪里：

在Java编程语言中，常量池是Java虚拟机（JVM）中的一部分，用于存储类文件中的常量数据，包括字符串常量、数字常量、符号引用等。每个类文件都有一个常量池，用于存储该类的常量数据。在运行时，Java虚拟机会从常量池中加载常量数据供程序使用。

2.参数传递：

在Java中，参数传递有两种方式：按值传递（Pass by Value）和按引用传递（Pass by Reference）。

按值传递（Pass by Value）： 在按值传递中，方法接收的是实际参数的副本，而不是原始参数本身。这意味着如果在方法内部修改参数的值，不会影响原始参数的值。

public class PassByValueExample {
    public static void main(String[] args) {
        int x = 10;
        modifyValue(x);
        System.out.println(x); // 输出仍然是 10，因为方法内的修改不会影响原始值
    }

    public static void modifyValue(int value) {
        value = 20;
    }
}

按引用传递（Pass by Reference）： Java不支持按引用传递，虽然你可以将对象传递给方法，但方法接收的是对象引用的副本，因此在方法内部修改对象的内容会影响原始对象。

public class PassByReferenceExample {
    public static void main(String[] args) {
        StringBuilder str = new StringBuilder("Hello");
        modifyStringBuilder(str);
        System.out.println(str); // 输出 "Hello World"，因为方法内的修改会影响原始对象
    }

    public static void modifyStringBuilder(StringBuilder s) {
        s.append(" World");
    }
}

需要注意的是，虽然在对象传递时，看起来好像是按引用传递，但实际上仍然是按值传递，只不过传递的值是对象引用的副本，这意味着你可以修改对象的状态，但不能修改对象引用本身。如果将新的对象赋值给方法内的参数，原始引用不会受到影响。

public class PassByReferenceExample {
    public static void main(String[] args) {
        StringBuilder str = new StringBuilder("Hello");
        reassignStringBuilder(str);
        System.out.println(str); // 输出 "Hello"，因为重新分配了一个新的对象给参数
    }

    public static void reassignStringBuilder(StringBuilder s) {
        s = new StringBuilder("New Value");
    }
}

总之，Java中的参数传递始终是按值传递，但在对象传递时，传递的是对象引用的副本，这可以让你修改对象的内容，但不能修改对象引用本身。

3.如果有个user对象，a方法中传入user对象，a中在new 一个对象并赋给user，外部的user会变吗?

在Java中，如果在一个方法中传入一个对象，并在该方法内部创建一个新的对象并将其赋值给该参数，不会影响外部的对象。这是因为方法参数是按值传递的，传递的是对象引用的副本，而不是对象本身。

public class User {
    private String name;

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

    public String getName() {
        return name;
    }

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

public class Main {
    public static void main(String[] args) {
        User user = new User("Alice");
        modifyUser(user);
        System.out.println(user.getName()); // 输出 "Alice"，外部的user对象未被修改
    }

    public static void modifyUser(User user) {
        user = new User("Bob"); // 在方法内部创建了一个新的User对象并赋值给参数user
    }
}

在上面的示例中，虽然在modifyUser方法内部创建了一个新的User对象并将其赋值给参数user，但这不会影响外部的user对象。外部的user对象仍然保持其原始值，即"Alice"。

这是因为在方法内部重新分配对象给参数，只会影响方法内部的引用，不会影响外部的引用。如果要修改外部对象的状态，可以直接调用该对象的方法或访问其属性。

4.讲一下线程安全与线程不安全

线程安全和线程不安全是关于多线程编程中的概念，它们描述了在多线程环境下共享数据的行为。下面对这两个概念进行详细解释：

线程安全（Thread-Safe）：
- 定义： 线程安全是指在多线程环境下，共享数据的操作能够正确地被多个线程同时进行而不会导致数据损坏或不一致的情况。一个线程安全的程序在多线程环境下可以正常运行，不会出现竞态条件或数据竞争的问题。
- 实现： 实现线程安全通常需要采用一些同步机制，例如互斥锁（Mutex）、信号量（Semaphore）、读写锁（ReadWrite Lock）、原子操作等。这些机制可以确保在任何时刻只有一个线程能够访问共享数据，或者在适当情况下确保数据的一致性。
- 示例： 使用synchronized关键字或java.util.concurrent包中的类来管理共享资源，如使用ConcurrentHashMap而不是HashMap，都可以实现线程安全。
线程不安全（Thread-Unsafe）：
- 定义： 线程不安全是指在多线程环境下，共享数据的操作可能会导致数据损坏、不一致或程序崩溃的情况。线程不安全的程序可能会在多线程并发访问时产生竞态条件（Race Condition）或数据竞争（Data Race）。
- 原因： 线程不安全通常发生在没有适当的同步机制的情况下，多个线程同时修改共享数据，导致数据的状态不受控制。
- 示例： 使用普通的非线程安全集合类，如ArrayList或HashMap，在多线程环境下操作这些集合可能导致数据不一致或崩溃。
- ```
// 线程不安全的示例
public class ThreadUnsafeExample {
    private static int count = 0;

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 多个线程同时访问并修改count，可能导致不一致
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + count); // 输出的结果可能不是2000
    }
}
```
  在上述示例中，两个线程同时访问并修改count变量，由于没有同步机制，因此结果可能是不一致的。为了确保线程安全，可以使用 synchronized关键字或AtomicInteger等线程安全的数据结构来保护共享资源。
  
  总之，线程安全和线程不安全是多线程编程中的重要概念。编写线程安全的代码需要使用适当的同步机制，以确保在多线程环境下数据的一致性和可靠性。否则，线程不安全的代码可能会导致难以追踪和修复的问题。

5.线程池了解过吗，讲一下核心参数

这些核心参数的选择需要根据具体应用程序的需求和系统资源来进行调优。合理配置这些参数可以确保线程池在高并发情况下能够提供高性能且稳定的服务。不同的线程池实现（如ThreadPoolExecutor）可以根据这些参数来创建线程池对象，以满足不同的需求。

6.@Autowired怎么实现自动注入bean

@Autowired 是Spring框架中用于实现依赖注入的注解之一，它可以自动将匹配的Bean注入到目标对象中。要使用@Autowired来实现自动注入Bean，需要遵循以下步骤：

核心线程数（Core Pool Size）： 这是线程池中一直保持活动的最小线程数量。即使线程处于空闲状态，它们也会一直存在，等待任务到来。核心线程数通常根据系统资源和应用程序需求来配置。
最大线程数（Maximum Pool Size）： 这是线程池中允许的最大线程数量。当任务提交给线程池超过核心线程数并且工作队列也满时，线程池会创建新的线程，直到达到最大线程数。如果达到最大线程数后仍然有新任务到来，根据线程池的策略（后面会提到），可能会采取不同的操作，如拒绝任务或将任务放入等待队列。
工作队列（Work Queue）： 工作队列用于存储等待执行的任务。当线程池中的线程都在忙碌处理任务时，新的任务将被放入工作队列中等待执行。工作队列可以是不同类型的队列，如无界队列（Unbounded Queue）或有界队列（Bounded Queue），如ArrayBlockingQueu

或LinkedBlockingQueue等。
线程存活时间（Thread Keep-Alive Time）： 当线程池中的线程数量超过核心线程数时，多余的线程在一定时间内如果没有执行任务会被终止（销毁），以减少资源消耗。这个时间称为线程的存活时间。一般设置为一定的时间，例如60秒。
拒绝策略（Rejected Execution Handler）： 当工作队列已满且线程池中的线程数量达到最大线程数时，新任务的处理方式由拒绝策略决定。常见的拒绝策略包括丢弃任务、抛出异常、在调用者线程中执行等。

配置Spring容器： 首先，确保你已经配置了Spring容器，通常是通过XML配置文件或Java配置类来完成。Spring容器会负责管理和创建Bean对象。

创建目标类： 创建需要依赖注入的目标类。这个类可以使用@Autowired注解来标记需要注入的成员变量、构造函数、方法等。

7.介绍下spring和springboot

Spring和Spring Boot都是Java领域中非常流行的开发框架，用于简化企业级应用程序的开发。它们之间存在一些关键区别和共同点，下面分别介绍Spring和Spring Boot：

- 配置Bean： 确保你已经在Spring容器中配置了要注入的Bean对象。这可以通过在XML配置文件或Java配置类中定义Bean来完成。
- 自动注入Bean： 在目标类中使用@Autowired注解来标记需要注入的属性或构造函数参数。
```
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component // 声明这是一个Spring托管的Bean
public class MyService {
    private MyRepository repository;

    @Autowired // 使用@Autowired注解进行自动注入
    public MyService(MyRepository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        // 使用注入的repository对象执行操作
        repository.saveData();
    }
}

@Component // 声明这是一个Spring托管的Bean
public class MyRepository {
    public void saveData() {
        // 数据保存逻辑
    }
}
```
  在上述示例中，MyService类中的构造函数使用@Autowired注解来注入MyRepository对象。Spring容器会自动查找一个匹配的MyRepository Bean并将其注入到MyService中。
  
  要使@Autowired生效，确保以下条件成立：
- Spring容器已正确配置，可以扫描到带有@Component或其他相关注解的类。
- 目标类（如MyService）需要被Spring管理，通常也需要使用@Component或其他相关注解。
要注入的Bean（如MyRepository）已经被Spring容器正确配置。

Spring框架：

定义： Spring是一个轻量级的开源框架，用于构建企业级Java应用程序。它提供了一组模块和库，用于处理各种常见的企业应用程序需求，如依赖注入、AOP（面向切面编程）、事务管理、数据访问、Web应用程序开发等。

特点：

Spring提供了强大的控制反转（IoC）容器，可以管理和组装Java对象的生命周期和依赖关系。
Spring支持AOP，可以用于处理横切关注点（如日志、事务等）的代码。
Spring提供了多种数据访问技术，包括JDBC、ORM（例如Hibernate、JPA）等。
Spring支持构建Web应用程序，包括Spring MVC用于处理Web请求。

配置： Spring框架通常需要手动配置，开发人员需要编写XML配置文件或Java配置类，以定义Bean、依赖关系和各种配置选项。

Spring Boot：

共同点：

总之，Spring框架提供了广泛的功能和灵活性，适用于各种类型的应用程序，而Spring Boot则专注于简化Spring应用程序的开发过程，提供了快速开发和自动配置的能力，适用于构建快速启动和部署的微服务和独立应用程序。选择使用哪个取决于项目的需求和开发团队的偏好。

8.怎么让spring管理第三方jar包中的类

要让Spring管理第三方JAR包中的类，你可以使用Spring的@ComponentScan注解来扫描并注册这些类，以便让Spring容器管理它们。以下是具体的步骤：

定义： Spring Boot是构建在Spring框架之上的项目，旨在简化Spring应用程序的开发和部署。它提供了一种快速开发和自动化配置的方式，使得开发人员可以更轻松地创建独立的、可运行的Spring应用程序。
特点：
- Spring Boot提供了自动配置机制，根据项目的依赖和需要，自动配置Spring应用程序。
- Spring Boot集成了嵌入式Web服务器（如Tomcat、Jetty），使得构建Web应用程序更加简便。
- Spring Boot支持快速开发，可以通过Spring Initializr快速生成项目骨架。
- Spring Boot通过"starter"依赖简化了项目的依赖管理。
Spring Boot是基于Spring框架构建的，因此它继承了Spring框架的核心功能和理念。
两者都支持依赖注入和AOP等关键特性，使得应用程序更加模块化和可维护。
- 配置： Spring Boot鼓励约定优于配置的原则，它提供了默认的配置选项，开发人员可以根据需要进行覆盖。通常，只需要少量配置即可创建一个可运行的Spring Boot应用程序。
创建Spring配置类： 创建一个Spring配置类，通常使用Java配置类或XML配置文件来定义Spring容器的配置。
- 如果使用Java配置类，确保在配置类上使用@ComponentScan注解，并指定要扫描的包。这将告诉Spring在指定的包及其子包中查找带有Spring注解的类。
```
@Configuration
@ComponentScan(basePackages = "com.example.thirdparty")
public class AppConfig {
    // 其他配置
}
```
  ` 如果使用XML配置文件，可以使用<context:component-scan>元素来指定要扫描的包。
```
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.example.thirdparty" />
    
    
    
</beans>
```
  2.使用Spring注解： 在第三方JAR包中的类上使用适当的Spring注解，例如@Component、@Service、@Repository等，以标记这些类为Spring组件，从而使它们可以被Spring管理。
```
package com.example.thirdparty;

import org.springframework.stereotype.Component;

@Component
public class ThirdPartyComponent {
    // 类的实现
}
```
  3.加载配置：确保在Spring应用程序中加载你的Spring配置类，不论是通过XML配置文件还是通过Java配置类如果使用XML配置文件，确保在应用程序上下文中引用配置文件
```
<context:annotation-config />
<import resource="classpath:application-config.xml" />
```
  如果使用Java配置类，确保在Spring应用程序中注册配置类。
```
public class MainApp {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        // 使用Spring容器中的Bean
        ThirdPartyComponent component = context.getBean(ThirdPartyComponent.class);
        // ...
        
        context.close();
    }
}
```
  jvm参数用过吗，jstack，jps等：
- JVM（Java虚拟机）参数以及相关的工具（如jstack和jps）是在Java开发和性能调优中经常使用的工具和技术。以下是一些常见的JVM参数和工具：
  - JVM参数：
    - -Xmx: 用于设置堆内存的最大大小。
    - -Xms: 用于设置堆内存的初始大小。
    - -Xss: 用于设置每个线程的栈大小。
    - -XX:MaxPermSize（在Java 7之前）或-XX:MaxMetaspaceSize（Java 8及以后）：用于设置永久代或元空间的最大大小。
    - -XX:+UseG1GC、-XX:+UseConcMarkSweepGC等：用于选择不同的垃圾回收器。
    - -XX:PrintGCDetails、-XX:PrintGCDateStamps等：用于打印垃圾回收信息。
    - -Dproperty=value：用于设置Java系统属性。
  - jstack：jstack是一个用于生成Java线程转储信息的命令行工具。它可以用于查看Java应用程序中所有线程的堆栈跟踪，以帮助识别线程死锁和性能问题。
  - jps：jps是Java进程状态工具，用于列出正在运行的Java进程的进程ID（PID）。它通常与其他工具一起使用，例如jstack，以查看和诊断Java应用程序的状态。
  - 这些工具和参数对于Java开发人员和系统管理员来说都非常有用，可以用于监视和调优Java应用程序的性能、诊断问题以及进行线程分析。不过需要注意的是，具体的参数和工具使用可能会根据JVM版本和应用程序的需求而有所不同。因此，在使用它们之前，建议查阅相关文档以获取更多信息。