第九周Java实验作业

最新推荐文章于 2024-11-14 14:48:14 发布
最新推荐文章于 2024-11-14 14:48:14 发布
阅读量174 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/980303CYR/p/9863442.html
版权

实验九 异常、断言与日志

实验时间 2018-10-25

1、实验目的与要求

(1) 掌握java异常处理技术；

Java的异常处理机制可以控制程序从错误产生的位置转移到能够进行错误处理的位置。

Java中的异常类可以分为两大类：

Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误。应用程序不应该捕获这一类异常，也不会抛出这类异常。

Exception类层次结构又分解为两个分支，一个分支派生于RuntimeException，另一个分支包含其他异常。

 

 

RuntimeException类为运行时异常类，一般是程序错误产生。

注意：如果出现RuntimeException异常，就一定是程序员的问题。

异常处理的两种方式：

积极处理方式：确切知道如何处理的异常应该捕获；

消极处理方式：不知道如何去处理的异常声明抛出；

(2) 了解断言的用法；

断言是程序的开发和测试阶段用于插入一些代码错误语句的工具。

语法格式：

assert 条件 

或者       

arrest   条件：表达式

注意：断言失败是致命的，不可恢复的错误

　　　断言检查仅仅用在程序开发和测试阶段。

(3) 了解日志的用途；

程序中记录日志一般有两个目的：Troubleshooting和显示程序运行状态。好的日志记录方式可以提供我们足够多定位问题的依据。

(4) 掌握程序基础调试技巧；

2、实验内容和步骤

实验1：用命令行与IDE两种环境下编辑调试运行源程序ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别。

package 小陈2;
//异常示例1

public class ExceptionDemo1 {

public static void main(String args[]) {
int a = 0;
do {
    if(a == 0) {
        System.out.println("分母为0，发生错误");
        break;
        }
    else {
        System.out.println(5 / a);
    }
    
    }while(a!=0);

}
}
异常示例1

运行结果：

//异常示例2

import java.io.*;

 

public class ExceptionDemo2 {

public static void main(String args[]) throws Exception 

     {

          FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象

          int b;

          while((b=fis.read())!=-1)

          {

              System.out.print(b);

          }

          fis.close();

      }

}
异常示例2

运行结果：

       

实验2： 导入以下示例程序，测试程序并进行代码注释。

测试程序1：

l 在elipse IDE中编辑、编译、调试运行教材281页7-1，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释；

l 掌握Throwable类的堆栈跟踪方法；

package stackTrace;//堆栈跟踪

import java.util.*;

/**
 * A program that displays a trace feature of a recursive method call.
 * 一个展示递归方法调用的跟踪特征的程序
 * @version 1.01 2004-05-10
 * @author Cay Horstmann
 */
public class StackTraceTest
{
   /**
    * Computes the factorial of a number
    * @param n a non-negative integer
    * 计算一个非负整数n的阶乘
    * @return n! = 1 * 2 * . . . * n
    */
   public static int factorial(int n)
   {
      System.out.println("factorial(" + n + "):");
      Throwable t = new Throwable();//创建一个Throwable类的数组
//      Throwable类是Java中所有异常信息的祖宗类，
//          直接已知子类有Error和Exception，已实现的接口java.io.Serializable  
      StackTraceElement[] frames = t.getStackTrace();
//    使用getStackTrace方法，得到getStackTraceElement对象的一个数组。
//    StackTraceElement类含有能够获得文件名和当前执行的代码的行号的方法。同时还含有能够获得类名和方法名的方法。
      for (StackTraceElement f : frames)
         System.out.println(f);
      int r;
      if (n <= 1) r = 1;
      else r = n * factorial(n - 1);
      System.out.println("return " + r);
      return r;
   }

   public static void main(String[] args)
   {
      Scanner in = new Scanner(System.in);
      System.out.print("Enter n: ");
      int n = in.nextInt();
      factorial(n);
   }
}
stackTrace

 运行结果：

测试程序2：

l Java语言的异常处理有积极处理方法和消极处理两种方式；

l 下列两个简答程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionalTest.java，将程序中的text文件更换为身份证号.txt，要求将文件内容读入内容，并在控制台显示；

l 掌握两种异常处理技术的特点。

package 小陈;
  //积极处理方式　　
import java.io.*; 
  public class ExceptionTest {
     public static void main (String args[])
  {
         
      try{
          
 
        FileInputStream fis=new FileInputStream("C:/身份证号.txt");
        BufferedReader in = new BufferedReader(new InputStreamReader(fis));
          try {
              String s, s2 = new String();
              while ((s = in.readLine()) != null) {
                s2 += s + "\n ";
            }
             in.close();              System.out.println(s2);
          } catch (IOException e) {
              System.out.println("学生信息文件读取错误");
              e.printStackTrace();
          }
      } catch (FileNotFoundException e) {
          System.out.println("学生信息文件找不到");
          e.printStackTrace();
      }
 
   }
 }
积极处理方式 
package 小陈;
  //消极处理方式
  
  import java.io.*;
  public class ExceptionTest {
      public static void main (String args[]) throws  IOException
        {
          FileInputStream fis=new FileInputStream("C:/身份证号.txt");
          BufferedReader in = new BufferedReader(new InputStreamReader(fis));
         String s, s2 = new String();
 
             while ((s = in.readLine()) != null) {
                 s2 += s + "\n ";
             }
             in.close();
            System.out.println(s2);
       }
 }
消极处理方式

运行结果：

 

  

 

实验3: 编程练习

练习1：

l 编制一个程序，将身份证号.txt 中的信息读入到内存中；

l 按姓名字典序输出人员信息；

l 查询最大年龄的人员信息；

l 查询最小年龄人员信息；

l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；

l 查询人员中是否有你的同乡；

l 在以上程序适当位置加入异常捕获代码。

注：以下实验课后完成

package 小陈1;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class Identity{
    private static ArrayList<Student> studentlist;
    public static void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("C:/身份证号.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                
                Scanner linescanner = new Scanner(temp);
                
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province =linescanner.nextLine();
                Student student = new Student();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);
            }
        } catch (FileNotFoundException e) {
            System.out.println("学生信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("学生信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
            System.out.println("选择你的操作，输入正确格式的选项");
            System.out.println("1.字典排序");
            System.out.println("2.输出年龄最大和年龄最小的人");
            System.out.println("3.寻找老乡");
            System.out.println("4.寻找年龄相近的人");
            System.out.println("0.退出");
            int status = scanner.nextInt();
            switch (status) {
            case 1:
                Collections.sort(studentlist);              
                System.out.println(studentlist.toString());
                break;
            case 2:
                 int max=0,min=100;
                 int j,k1 = 0,k2=0;
                 for(int i=1;i<studentlist.size();i++)
                 {
                     j=studentlist.get(i).getage();
                 if(j>max)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j<min)
                 {
                   min=j; 
                   k2=i;
                 }
                 
                 }  
                 System.out.println("年龄最大："+studentlist.get(k1));
                 System.out.println("年龄最小："+studentlist.get(k2));
                break;
            case 3:
                 System.out.println("老家?");
                 String find = scanner.next();        
                 String place=find.substring(0,3);
                 for (int i = 0; i <studentlist.size(); i++) 
                 {
                     if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                         System.out.println("老乡"+studentlist.get(i));
                 }             
                 break;
                 
            case 4:
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near=agenear(yourage);
                int value=yourage-studentlist.get(near).getage();
                System.out.println(""+studentlist.get(near));
                break;
           
                case 0:
                    status = 0;
                    System.out.println("程序已退出!");
                    break;
               default:
                   System.out.println("输入错误");
               }
             }
            }
        public static int agenear(int age) {      
        int min=53,value=0,k=0;
         for (int i = 0; i < studentlist.size(); i++)
         {
             value=studentlist.get(i).getage()-age;
             if(value<0) value=-value; 
             if (value<min) 
             {
                min=value;
                k=i;
             } 
          }    
         return k;         
      }
      
}
Identity 
package 小陈1;

public  class Student implements Comparable<Student> {
    private    String name;
    private    String number ;
    private    String sex ;
    private    int age;
    private    String province;
 
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getnumber() {
        return number;
    }
    public void setnumber(String number) {
        this.number = number;
    }
    public String getsex() {
        return sex ;
    }
    public void setsex(String sex ) {
        this.sex =sex ;
    }
    public int getage() {
        return age;
    }
    public void setage(int age ) {
        this.age=age ;
    }
    public String getprovince() {
        return province;
    }
    public void setprovince(String province) {
        this.province=province ;
    }
@Override
public int compareTo(Student other) {
    // TODO Auto-generated method stub
     return this.name.compareTo(other.getName());
}

public String toString() {
    return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
}    
}
Student

运行结果：

   

 

练习2：

l 编写一个计算器类，可以完成加、减、乘、除的操作；

l 利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；

l 将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt；

l 在以上程序适当位置加入异常捕获代码。

 

package 小陈;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;


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

        Scanner in = new Scanner(System.in);
        jieguo student=new jieguo();
        PrintWriter out = null;
        try {
            out = new PrintWriter("text.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        int sum = 0;

        
        
        for (int i = 1; i <=10; i++) {
            int a = (int) Math.round(Math.random() * 100);
            int b = (int) Math.round(Math.random() * 100);
            int c= (int) Math.round(Math.random() * 3);

            
           switch(c)
           {
           case 0:
               System.out.println(i+": "+a+"/"+b+"=");
               
               while(b==0)
               { 
                   b = (int) Math.round(Math.random() * 100);
            }
               
            int C = in.nextInt();
            out.println(a+"/"+b+"="+C);
            if (C == student.division(a, b)) {
                sum += 10;
                System.out.println("right");
            }
            else {
                System.out.println("false");
            }
            
            break;
            
           case 1:
               System.out.println(i+": "+a+"*"+b+"=");
               int D = in.nextInt();
               out.println(a+"*"+b+"="+D);
               if (D == student.multiplication(a, b)) {
                   sum += 10;
                   System.out.println("right");
               }
               else {
                   System.out.println("false");
               }
               break;
           case 2:
               System.out.println(i+": "+a+"+"+b+"=");
               int E = in.nextInt();
               out.println(a+"+"+b+"="+E);
               if (E == student.add(a, b)) {
                   sum += 10;
                   System.out.println("right");
               }
               else {
                   System.out.println("false");
               }
               
               break ;
           case 3:
               System.out.println(i+": "+a+"-"+b+"=");
               int F = in.nextInt();
               out.println(a+"-"+b+"="+F);
               if (F == student.reduce(a, b)) {
                   sum += 10;
                   System.out.println("right");
               }
               else {
                   System.out.println("false");
               }
               break ;
              } 
          }
       System.out.println("成绩"+sum);
        out.println("成绩:"+sum);
         out.close();        
   }
   }
jisuan 
package 小陈;
public class jieguo {
   private int a;
   private int b;
    public int  add(int a,int b)
    {
        return a+b;
    }
    public int   reduce(int a,int b)
    {
        return a-b;
    }
    public int   multiplication(int a,int b)
    {
        return a*b;
    }
    public int   division(int a,int b)
    {
        if(b!=0)
        return a/b;
        else return 0;
    }

}
jieguo

运行结果：

 

实验4：断言、日志、程序调试技巧验证实验。

实验程序1：

//断言程序示例

public class AssertDemo {

    public static void main(String[] args) {        

        test1(-5);

        test2(-3);

    }

    

    private static void test1(int a){

        assert a > 0;

        System.out.println(a);

    }

    private static void test2(int a){

       assert a > 0 : "something goes wrong here, a cannot be less than 0";

        System.out.println(a);

    }

}

 

l 在elipse下调试程序AssertDemo，结合程序运行结果理解程序；

l 注释语句test1(-5);后重新运行程序，结合程序运行结果理解程序；

l 掌握断言的使用特点及用法。

运行结果：

    注释掉语句test1(-5);之后，控制台只输出-3，不输出-5

实验程序2：

l 用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；

l 并掌握Java日志系统的用途及用法。

实验程序3：

l 用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；

l 按课件66-77内容练习并掌握Elipse的常用调试技术。

package logging;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.logging.*;
import javax.swing.*;

/**
 * A modification of the image viewer program that logs various events.
 * @version 1.03 2015-08-20
 * @author Cay Horstmann
 */
public class LoggingImageViewer
{
   public static void main(String[] args)
   {
      if (System.getProperty("java.util.logging.config.class") == null
            && System.getProperty("java.util.logging.config.file") == null)
      {
         try
         {
            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);
            //开启所有级别的记录
            final int LOG_ROTATION_COUNT = 10;
            Handler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);
            Logger.getLogger("com.horstmann.corejava").addHandler(handler);
            //增加这个日志记录器中的一个处理器
         }
         catch (IOException e)
         {
            Logger.getLogger("com.horstmann.corejava").log(Level.SEVERE,
                  "Can't create log file handler", e);
         }
      }
//这段代码确保将所有消息记录到应用特定的文件中
      EventQueue.invokeLater(() ->
            {
               Handler windowHandler = new WindowHandler();//通过Hander类自定义一个处理器
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);
               JFrame frame = new ImageViewerFrame();
               frame.setTitle("LoggingImageViewer");
               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

               Logger.getLogger("com.horstmann.corejava").fine("Showing frame");
               frame.setVisible(true);
            });
   }
}

/**
 * The frame that shows the image.
 */
class ImageViewerFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 400;   

   private JLabel label;
   private static Logger logger = Logger.getLogger("com.horstmann.corejava");
   //调用Logger类的getLogger方法得到一个日志记录器，

   public ImageViewerFrame()
   {
      logger.entering("ImageViewerFrame", "<init>");      
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

      // set up menu bar
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);

      JMenu menu = new JMenu("File");
      menuBar.add(menu);

      JMenuItem openItem = new JMenuItem("Open");
      menu.add(openItem);
      openItem.addActionListener(new FileOpenListener());

      JMenuItem exitItem = new JMenuItem("Exit");
      menu.add(exitItem);
      exitItem.addActionListener(new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               logger.fine("Exiting.");
               System.exit(0);
            }
         });

      // use a label to display the images
      label = new JLabel();
      add(label);
      logger.exiting("ImageViewerFrame", "<init>");
   }

   private class FileOpenListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         logger.entering("ImageViewerFrame.FileOpenListener", "actionPerformed", event);

         // set up file chooser
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         // accept all files ending with .gif
         chooser.setFileFilter(new javax.swing.filechooser.FileFilter()
            {
               public boolean accept(File f)
               {
                  return f.getName().toLowerCase().endsWith(".gif") || f.isDirectory();
               }

               public String getDescription()
               {
                  return "GIF Images";
               }
            });

         // show file chooser dialog
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // if image file accepted, set it as icon of the label
         if (r == JFileChooser.APPROVE_OPTION)
         {
            String name = chooser.getSelectedFile().getPath();
            logger.log(Level.FINE, "Reading file {0}", name);
            label.setIcon(new ImageIcon(name));
         }
         else logger.fine("File open dialog canceled.");
         logger.exiting("ImageViewerFrame.FileOpenListener", "actionPerformed");
      }
   }
}

/**
 * A handler for displaying log records in a window.
 */
class WindowHandler extends StreamHandler
{
    //WindowHandler这个处理器扩展于StreamHander类，并且安装了一个流。
    //使用这种方法时，处理器会缓存记录，并且只有在缓存满的时候，才将它们写入流中。
   private JFrame frame;

   public WindowHandler()
   {
      frame = new JFrame();
      final JTextArea output = new JTextArea();
      output.setEditable(false);
      frame.setSize(200, 200);
      frame.add(new JScrollPane(output));
      frame.setFocusableWindowState(false);
      frame.setVisible(true);
      setOutputStream(new OutputStream()
         {
            public void write(int b)//write方法将流显示输出到文本框中。
          
            {
            } // not called

            public void write(byte[] b, int off, int len)
            {
               output.append(new String(b, off, len));
               //append  新构造的文件处理器对象应该追加在一个已存在的日志文件尾部，则为TRUE
            }
         });
   }

   public void publish(LogRecord record)
   //将日志发送到目的地
   {
      if (!frame.isVisible()) return;
      super.publish(record);
      flush();//覆盖publish方法，以便在处理器获得每个记录之后刷新缓冲区。
   }
}
logging

运行结果：

设置断点，单步执行时的运行视图：

 总结：本周主要讲了异常方面的知识，学习了异常的处理方法，感觉自己学的没有特别清楚，尤其是日志方面的知识，最后一个程序阅读特别困难，还需要继续学习。

转载于:https://www.cnblogs.com/980303CYR/p/9863442.html

aixie0541
关注
JAVA实验作业——Java流程控制
endomorphism的博客
09-14 888
JAVA入门(面向程序对象的程序设计)的第三次上机实践课作业 实验目的 1． 理解 Java 程序语法结构 2． 掌握顺序结构、选择结构和循环结构语法的程序设计方法 编写程序，实现按 5 度的增量打印出一个从摄氏温度到华氏温度的转换表。 /** * @Author XT * @email 1416397544@qq.com * @date 2020/09/014 08:20 */ import java.util.*; public class Main { public stati
java web实验作业9
DS00HY的小博客
12-13 694
这次的java实验没想到写这么久，这还是之前有一点前端知识，，，不说了，各种傻的bug 实现一个模拟计算器 更改文本框中的数字值 document.getElementById("result").value=""; 判断鼠标点击按钮函数为 var isleftnumber=0; var isrightnumber=0; f
Java作业九
weixin_30556959的博客
05-25 81
（一）学习总结 1.用思维导图对javaIO操作的学习内容进行总结。 2.下面的程序实现了文件的拷贝，但采用的是一个字节一个字节的读写方式，效率很低。使用缓冲区可以减少对文件的操作次数，从而提高读写数据的效率。IO包中提供了两个带缓冲的字节流BufferedInputStream和BufferedOutputStream,查阅JDK帮助文档，修改程序，利用这两个类完成文件拷贝，对比执行效率。 i...
201621123063《java程序设计》第九周实验总结
a65171912的博客
11-18 149
1. 本周学习总结 1.1 以你喜欢的方式（思维导图或其他）归纳总结集合与泛型相关内容。 1.2 选做：收集你认为有用的代码片段 对Map进行排序 List<Entry<String,Integer>> list =new ArrayList<Entry<String,Integer>>(map.entrySet()); ...
Java学习 集合 部分作业01
endless_fighting的博客
08-11 603
package work01; /* * (1)定义一个学生类Student，包含属性：姓名(String name)、年龄(int age) (2)定义Map集合，用Student对象作为key，用字符串(此表示表示学生的住址)作为value (3)利用四种方式遍历Map集合中的内容，格式：key::value */ import java.util.HashMap; import j...
第14周 预习实验与作业：Java数据库编程
Capricorn_36的博客
11-24 420
第14周 预习、实验与作业：Java数据库编程
合工大Java实验和作业
01-04
【Java实验和作业详解】 在Java编程学习过程中，实验与作业是巩固理论知识、提升实践能力的重要环节。这里我们聚焦于“合工大Java实验和作业”，由教师张延孔指导，涵盖了1到9章的内容，以及三个实验项目。下面将...
Java课程作业CW2: 第九周项目分析与提交
但是，从作业提交的时间点和次数（第9周的第二次提交）可以推测，这可能是课程计划中的一个周期性任务，可能是一个项目、实验报告、编程练习或理论作业，用于评价学生在该周学习进度的掌握情况。 最后，关于文件...
第九周Java作业
小宇飞刀的BLOG
10-26 1845
本周主题：面向对象程序设计（三） Java 抽象类 Java 接口 Java 包(package) 一、Java 抽象类 1、抽象类的概念 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方...
第九周java作业
qq_35449441的博客
12-13 228
练习一：Java 2实用教程 第五版 160页第四题 Animal.java package chapter6; public interface Animal { void cry(); String getAnimalName(); } 1234567 Simulator.java package chapter6; public class Simulat
Java常见小实验代码合集
01-21
【Java实验代码】是学习Java编程过程中不可或缺的一部分，它们帮助初学者通过实践来巩固理论知识。这个合集涵盖了从基础到进阶的各种实验，包括了Java语法、面向对象编程、网络编程、文件操作、图形界面设计（JavaFX...
10.25第九周java作业
xx的博客
11-07 837
课堂练习1：教材160页4.编程题 设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声，要求如下。 编写接口Animal  Animal接口有两个抽象方法cry()和getAnimalName()，即要求实现该接口的各种具体的动物类给出自己的叫声和种类名称。 编写模拟器类Simulator  该类有一个playSound(Animal animal)方法，该
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 306
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 700
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 797
Rest请求处理
SpringBoot 实现图片加水印
心猿意码
11-11 407
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 448
顺序算法题----力扣刷题
java加锁问题详解
最新发布
qq_74056922的博客
11-14 447
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
如何合理设计一套springcloud+springboot项目中的各个微服务模块之间的继承关系的最优方案
tigerhhzz的博客
11-14 920
文章目录一、模块化设计所遵循的原则二、项目架构设计三、各个模块作用说明3.1 core 模块3.2 common 模块3.3 generatorcode模块3.4 business 模块3.5 web 模块3.6 admin 模块3.7 父pom四、采用import引入SpringBoot 在springcloud微服务项目中经常用到多模块化的架构设计，随着业务模块的增多，各个服务模块之间的依赖关系就越来越复杂；本文从项目起初的搭建，给出一套Model优秀设计方案。 一、模块化设计所遵循的原则 单一职责
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 1196
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值