java第九章总结

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量109 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65555440/article/details/124922211
版权

9.1包装类

在 Java 的设计中提倡一种思想，即一切皆对象。但是从数据类型的划分中，我们知道 Java 中的数据类型分为基本数据类型和引用数据类型，但是基本数据类型怎么能够称为对象呢？于是 Java 为每种基本数据类型分别设计了对应的类，称之为包装类（Wrapper Classes），也有地方称为外覆类或数据类型类。

9.1.1Integer

Integer 类中的构造方法有以下两个：

  • Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值。
  • Integer(String s)：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

Integer integer1 = new Integer(100);    // 以 int 型变量作为参数创建 Integer 对象
Integer integer2 = new Integer("100");    // 以 String 型变量作为参数创建 Integer 对象

 在实际的编程过程中，经常将字符串转换为 int 类型的数值，或者将 int 类型的数值转换为对应的字符串。


String str = "456";
int num = Integer.parseInt(str);    // 将字符串转换为int类型的数值
int i = 789;
String s = Integer.toString(i);    // 将int类型的数值转换为字符串


public class Test03 {
    public static void main(String[] args) {
        int num = 40;
        String str = Integer.toString(num); // 将数字转换成字符串
        String str1 = Integer.toBinaryString(num); // 将数字转换成二进制
        String str2 = Integer.toHexString(num); // 将数字转换成八进制
        String str3 = Integer.toOctalString(num); // 将数字转换成十六进制
        System.out.println(str + "的二进制数是：" + str1);
        System.out.println(str + "的八进制数是：" + str3);
        System.out.println(str + "的十进制数是：" + str);
        System.out.println(str + "的十六进制数是：" + str2);
    }
}

Integer 类包含以下 4 个常量。

  • MAX_VALUE：值为 231-1 的常量，它表示 int 类型能够表示的最大值。
  • MIN_VALUE：值为 -231 的常量，它表示 int 类型能够表示的最小值。
  • SIZE：用来以二进制补码形式表示 int 值的比特位数。
  • TYPE：表示基本类型 int 的 Class 实例。
int max_value = Integer.MAX_VALUE;    // 获取 int 类型可取的最大值
int min_value = Integer.MIN_VALUE;    // 获取 int 类型可取的最小值
int size = Integer.SIZE;    // 获取 int 类型的二进制位
Class c = Integer.TYPE;    // 获取基本类型 int 的 Class 实例

 

9.1.2Double类

Double 类中的构造方法有如下两个。

  • Double(double value)：构造一个新分配的 Double 对象，它表示转换为 double 类型的参数。
  • Double(String s)：构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。

Double double1 = new Double(5.456);    // 以 double 类型的变量作为参数创建 Double 对象
Double double2 = new Double("5.456");       // 以 String 类型的变量作为参数创建 Double 对象

 


String str = "56.7809";
double num = Double.parseDouble(str);    // 将字符串转换为 double 类型的数值
double d = 56.7809;
String s = Double.toString(d);    // 将double类型的数值转换为字符串

在 Double 类中包含了很多常量，其中较为常用的常量如下。

  • MAX_VALUE:值为 1.8E308 的常量，它表示 double 类型的最大正有限值的常量。
  • MIN_VALUE：值为 4.9E-324 的常量，它表示 double 类型数据能够保持的最小正非零值的常量。
  • NaN：保存 double 类型的非数字值的常量。
  • NEGATIVE_INFINITY：保持 double 类型的负无穷大的常量。
  • POSITIVE_INFINITY：保持 double 类型的正无穷大的常量。
  • SIZE：用秦以二进制补码形式表示 double 值的比特位数。
  • TYPE：表示基本类型 double 的 Class 实例。

9.1.3Boolean类 


Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类的对象只包含一个类型为 boolean 的字段。此外，此类还为 boolean 和 String 的相互转换提供了很多方法，并提供了处理 boolean 时非常有用的其他一些常用方法。
 

Boolean 类有以下两种构造形式：
 
Boolean(boolean boolValue);
 
Boolean(String boolString);

 


public class Test05 {
    public static void main(String[] args) {
        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("ok");
        Boolean b3 = new Boolean("true");
        System.out.println("b1 转换为 boolean 值是：" + b1);
        System.out.println("b2 转换为 boolean 值是：" + b2);
        System.out.println("b3 转换为 boolean 值是：" + b3);
    }
}

在 Boolean 类中包含了很多的常量，其中较为常用的常量如下。

  • TRUE：对应基值 true 的 Boolean 对象。
  • FALSE：对应基值 false 的 Boolean 对象。
  • TYPE：表示基本类型 boolean 的 Class 对象

 

9.1.4Character类 

Character 类是字符数据类型 char 的包装类。Character 类的对象包含类型为 char 的单个字段，这样能把基本数据类型当对象来处理

Character character = new Character('S');

 CompareTo() 方法将这个字符与其他字符比较，并且返回一个整型数组，这个值是两个字符比较后的标准代码差值。当且仅当两个字符相同时，equals() 方法的返回值才为 true。


Character character = new Character('A');
int result1 = character.compareTo(new Character('V'));
System.out.println(result1);    // 输出：0
int result2 = character.compareTo(new Character('B'));
System.out.println(resuit2);    // 输出：-1
int result3 = character.compareTo(new Character('1'));
System.out.println(result3);    // 输出：-2



public class Register {
    public static boolean validateUser(String uname,String upwd,String age) {
        boolean conUname = false;       // 用户名是否符合要求
        boolean conPwd = false;    // 密码是否符合要求
        boolean conAge = false;    // 年龄是否符合要求
        boolean con = false;    // 验证是否通过
        if (uname.length() > 0) {
            for (int i = 0;i < uname.length();i++) {
                // 验证用户名是否全部为字母，不能含有空格
                if (Character.isLetter(uname.charAt(i))) {
                    conUname = true;
                } else {
                    conUname = false;
                    System.out.println("用户名只能由字母组成，且不能含有空格！");
                    break;
                }
            }
        } else {
            System.out.println("用户名不能为空！");
        }
        if (upwd.length() > 0) {
            for (int j=0;j<upwd.length();j++) {
                // 验证密码是否由数字和字母组成，不能含有空格
                if (Character.isLetterOrDigit(upwd.charAt(j))) {
                    conPwd = true;
                } else {
                    conPwd = false;
                    System.out.println("密码只能由数字或字母组成！");
                    break;
                }
            }
        } else {
            System.out.println("密码不能为空！");
        }
        if (age.length() > 0) {
            for (int k = 0;k < age.length();k++) {
                // 验证年龄是否由数字组成
                if (Character.isDigit(age.charAt(k))) {
                    conAge = true;
                } else {
                    conAge = false;
                    System.out.println("年龄输入有误!");
                    break;
                }
            }
        } else {
            System.out.println("年龄必须输入！");
        }
        if (conUname && conPwd && conAge) {
            con = true;
        } else {
            con = false;
        }
        return con;
    }
}

 

import java.util.Scanner;
public class Test04 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("------------用户注册--------------");
        System.out.println("用户名：");
        String username = input.next();
        System.out.println("密码：");
        String pwd = input.next();
        System.out.println("年龄：");
        String age = input.next();
        boolean con = Register.validateUser(username,pwd,age);
        if (con) {
            System.out.println("注册成功！");
        } else {
            System.out.println("注册失败！");
        }
    }
}

 

 9.1.5Number

Number 是一个抽象类，也是一个超类（即父类）。Number 类属于 java.lang 包，所有的包装类（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象类 Number 的子类。

 

 


Number num = new Double(12.5);
System.out.println("返回 double 类型的值：" + num.doubleValue());
System.out.println("返回 int 类型的值：" + num.intValue());
System.out.println("返回 float 类型的值：" + num.floatValue());

9.2Math 


在 Java 中 Math 类封装了常用的数学运算，提供了基本的数学操作，如指数、对数、平方根和三角函数等。Math 类位于 java.lang 包，它的构造方法是 private 的，因此无法创建 Math 类的对象，并且 Math 类中的所有方法都是类方法，可以直接通过类名来调用它们。

9.2.1Math类概述


Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）。

System.out.println("E 常量的值：" + Math.E);
System.out.println("PI 常量的值：" + Math.PI);

9.2.2常用数学运算方法 

 


public class Test02 {
    public static void main(String[] args) {
        System.out.println("10 和 20 的较大值：" + Math.max(10, 20));
        System.out.println("15.6 和 15 的较小值：" + Math.min(15.6, 15));
        System.out.println("-12 的绝对值：" + Math.abs(-12));
    }
}

 

import java.util.Scanner;
public class Test03 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.outprintln("请输入一个数字：");
        double num = input.nextDouble();
        System.out.println("大于或等于 "+ num +" 的最小整数：" + Math.ceil(num));
        System.out.println("小于或等于 "+ num +" 的最大整数：" + Math.floor(num));
        System.out.println("将 "+ num +" 加上 0.5 之后最接近的整数：" + Math.round(num));
        System.out.println("最接近 "+num+" 的整数：" + Math.rint(num));
    }
}

 

 

 

public class Test04 {
    public static void main(String[] args) {
        System.out.println{"90 度的正弦值：" + Math.sin(Math.PI/2));
        System.out.println("0 度的余弦值：" + Math.cos(0));
        System.out.println("1 的反正切值：" + Math.atan(l));
        System.out.println("120 度的弧度值：" + Math.toRadians(120.0));
    }
}

 

 

public class Test05 {
    public static void main(String[] args) {
        System.out.println("4 的立方值：" + Math.pow(4, 3));
        System.out.println("16 的平方根：" + Math.sqrt(16));
        System.out.println("10 为底 2 的对数：" + Math.log1O(2));
    }
}

 9.3随机数

9.3.1Math.random（）

在 Java 中要生成一个指定范围之内的随机数字有两种方法：一种是调用 Math 类的 random() 方法，一种是使用 Random 类。

Random 类提供了丰富的随机数生成方法，可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数，这是它与 random() 方法最大的不同之处。random() 方法只能产生 double 类型的 0~1 的随机数。

9.3.2Random类


Random 类位于 java.util 包中，该类常用的有如下两个构造方法。

  • Random()：该构造方法使用一个和当前系统时间对应的数字作为种子数，然后使用这个种子数构造 Random 对象。
  • Random(long seed)：使用单个 long 类型的参数创建一个新的随机数生成器。

import java.util.Random;
public class Test06 {
    public static void main(String[] args) {
        Random r = new Random();
        double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
        double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数
        int i1 = r.nextInt(10); // 生成[0,10]区间的整数
        int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
        long l1 = r.nextLong(); // 生成一个随机长整型值
        boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
        float f1 = r.nextFloat(); // 生成一个随机浮点型值
        System.out.println("生成的[0,1.0]区间的小数是：" + d1);
        System.out.println("生成的[0,7.0]区间的小数是：" + d2);
        System.out.println("生成的[0,10]区间的整数是：" + i1);
        System.out.println("生成的[-3,15]区间的整数是：" + i2);
        System.out.println("生成一个随机长整型值：" + l1);
        System.out.println("生成一个随机布尔型值：" + b1);
        System.out.println("生成一个随机浮点型值：" + f1);
        System.out.print("下期七星彩开奖号码预测：");
        for (int i = 1; i < 8; i++) {
            int num = r.nextInt(9); // 生成[0,9]区间的整数
            System.out.print(num);
        }
    }
}

 


public class Test07 {
    public static void main(String[] args) {
        int min = 2; // 定义随机数的最小值
        int max = 102; // 定义随机数的最大值
        // 产生一个2~100的数
        int s = (int) min + (int) (Math.random() * (max - min));
        if (s % 2 == 0) {
            // 如果是偶数就输出
            System.out.println("随机数是：" + s);
        } else {
            // 如果是奇数就加1后输出
            System.out.println("随机数是：" + (s + 1));
        }
    }
}

 

9.4时间日期类

9.4.1Date类

在 Java 中获取当前时间，可以使用 java.util.Date 类和 java.util.Calendar 类完成。其中，Date 类主要封装了系统的日期和时间的信息，Calendar 类则会根据系统的日历来解释 Date 对象。

Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

Date 类有如下两个构造方法。

  • Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
  • Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数
  1. Date date1 = new Date(); // 调用无参数构造函数
  2. System.out.println(date1.toString()); // 输出：Wed May 18 21:24:40 CST 2016
  3. Date date2 = new Date(60000); // 调用含有一个long类型参数的构造函数
  4. System.out.println(date2); // 输出：Thu Jan 0108:01:00 CST 1970

 

import java.util.Date;
import java.util.Scanner;
public class Test11 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要做的事情：");
        String title = input.next();
        Date date1 = new Date(); // 获取当前日期
        System.out.println("[" + title + "] 这件事发生时间为：" + date1);
        try {
            Thread.sleep(60000);// 暂停 1 分钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Date date2 = new Date();
        System.out.println("现在时间为：" + date2);
        if (date2.before(date1)) {
            System.out.println("你还有 " + (date2.getTime() - date1.getTime()) / 1000 + " 秒需要去完成【" + title + "】这件事！");
        } else {
            System.out.println("【" + title + "】事情已经过去了 " + (date2.getTime() - date1.getTime()) / 1000 + " 秒");
        }
    }
}

9.4.2Calendar  

Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。

创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

  1. Calendar c = Calendar.getInstance();

 

 

  1. Calendar calendar = Calendar.getInstance(); // 如果不设置时间，则默认为当前时间
  2. calendar.setTime(new Date()); // 将系统当前时间赋值给 Calendar 对象
  3. System.out.println("现在时刻：" + calendar.getTime()); // 获取当前时间
  4. int year = calendar.get(Calendar.YEAR); // 获取当前年份
  5. System.out.println("现在是" + year + "年");
  6. int month = calendar.get(Calendar.MONTH) + 1; // 获取当前月份（月份从 0 开始，所以加 1）
  7. System.out.print(month + "月");
  8. int day = calendar.get(Calendar.DATE); // 获取日
  9. System.out.print(day + "日");
  10. int week = calendar.get(Calendar.DAY_OF_WEEK) - 1; // 获取今天星期几（以星期日为第一天）
  11. System.out.print("星期" + week);
  12. int hour = calendar.get(Calendar.HOUR_OF_DAY); // 获取当前小时数（24 小时制）
  13. System.out.print(hour + "时");
  14. int minute = calendar.get(Calendar.MINUTE); // 获取当前分钟
  15. System.out.print(minute + "分");
  16. int second = calendar.get(Calendar.SECOND); // 获取当前秒数
  17. System.out.print(second + "秒");
  18. int millisecond = calendar.get(Calendar.MILLISECOND); // 获取毫秒数
  19. System.out.print(millisecond + "毫秒");
  20. int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); // 获取今天是本月第几天
  21. System.out.println("今天是本月的第 " + dayOfMonth + " 天");
  22. int dayOfWeekInMonth = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); // 获取今天是本月第几周
  23. System.out.println("今天是本月第 " + dayOfWeekInMonth + " 周");
  24. int many = calendar.get(Calendar.DAY_OF_YEAR); // 获取今天是今年第几天
  25. System.out.println("今天是今年第 " + many + " 天");
  26. Calendar c = Calendar.getInstance();
  27. c.set(2012, 8, 8); // 设置年月日，时分秒将默认采用当前值
  28. System.out.println("设置日期为 2012-8-8 后的时间：" + c.getTime()); // 输出时间

import java.util.Calendar;
public class CalendarDemo {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2016, 5, 1); // 实际的calendar对象所表示的日期为2016年6月1日
        // 判断2016年6月1日为一周中的第几天
        int index = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        char[] title = { '日', '一', '二', '三', '四', '五', '六' }; // 存放曰历的头部
        int daysArray[][] = new int[6][7];// 存放日历的数据
        int daysInMonth = 31; // 该月的天数
        int day = 1; // 自动增长
        for (int i = index; i < 7; i++) {
            // 填充第一周的日期数据，即日历中的第一行
            daysArray[0][i] = day++;
        }
        for (int i = 1; i < 6; i++) {
            // 填充其他周的日历数据，控制行
            for (int j = 0; j < 7; j++) {
                // 如果当前day表示的是本月最后一天，则停止向数组中继续赋值
                if (day > daysInMonth) {
                    i = 6;
                    break;
                }
                daysArray[i][j] = day++;
            }
        }
        System.out.println("------------------2016 年 6 月--------------------\n");
        for (int i = 0; i < title.length; i++) {
            System.out.print(title[i] + "\t");
        }
        System.out.print("\n");
        // 输出二元数组daysArray中的元素
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 7; j++) {
                if (daysArray[i][j] == 0) {
                    if (i != 0) {
                        // 如果到月末，则完成显示日历的任务，停止该方法的执行
                        return;
                    }
                    System.out.print("\t");
                    continue;
                }
                System.out.print(daysArray[i][j] + "\t");
            }
            System.out.print("\n");
        }
    }
}

 

啵啵爱桂圆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Integer （int）类型分析及相关面试题
ZHANGDX的博客
07-18 552
Integer类是Java开发中最常用的基础类之一，也是基本数据类型int对应的包装类。Integer能使在Java中像类一样使用整型数字，自Java 5引入自动装箱拆箱机制以后，能够混合使用Integer和int来表示整型数字，极大的方便了对数字的操作。同样如果使用不当，也有意想不到的结果产生。所以通过之前的学习和开发过程中踩过的坑，本文总结一下Integer需要注意的一些使用问题和常遇到的相关面试题。 Integer对象 和 int 进行比较 Integer是类，有两种创建方式：= 赋值和new关键字，
JAVA第9章总结JAVA常用类
Wxx190的博客
05-23 176
9.1包装类 在 Java 的设计中提倡一种思想，即一切皆对象。但是从数据类型的划分中，我们知道 Java 中的数据类型分为基本数据类型和引用数据类型，但是基本数据类型怎么能够称为对象呢？于是 Java 为每种基本数据类型分别设计了对应的类，称之为包装类（Wrapper Classes），也有地方称为外覆类或数据类型类。 9.1.1Integer Integer 类中的构造方法有以下两个： Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer的一些有趣的事
虎小币的博客
07-09 235
一、new出来的对象 public static void main(String[] args) { Integer i=new Integer(20); Integer j=new Integer(20); System.out.println(i==j); //结果没有任何意外会输出false ，开出新空间。 } 二、直接给Integer赋值 ...
Integer it = new Integer(i)；总是报错
qq_44839042的博客
04-01 647
这里的 Integer it = new Integer(i);总是报错，奇怪
简单的JAVA小程序 用户注册功能
naoyou2370的博客
07-31 668
在注册会员时，需要验证用户输入的用户名、密码、性别、年龄和邮箱地址等信息是否符合标准，如果符合标准方可进行注册。那么，下面就使用 Character 类中的一些静态方法来完成这个程序，具体的实现步骤如下。 import java.util.Scanner; public class Test{ public static void main(String[] args) { System.out....
Java第九章总结
Loga6的博客
11-09 209
volatile关键字有什么作用 一般来说，多线程环境下各线程之间共享的变量都应该加volatile修饰，来指示JVM这个变量是不稳定的，每次使用它都需要到主存中进行读取。其不稳定主要是由于在多线程程序中，由于多核可见性受限，核心操作的是寄存器中的副本，导致数据不同步。 编写Java程序模拟烧水泡茶最优工序 class ThreadA implements Runnable{ int t = 0; Thread tb = new Thread(new Runnable() {
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
java第九章学习总结
YQ_PAN81的博客
12-09 504
第九章 1.图形用户界面（Graphics User Interface,GUI）:用于用户和程序之间的交互。 2.Java的java.awt包，即Java抽象窗口工具包（Abstract Window Toolkit，AWT）提供了很多用来设计GUI的组件类。 JDK1.2推出之后，增加了一个新的Javax.swing包，该包提供了功能更为强大的用来设计GUI的类。 javax.swin...
2018版 04747 Java语言程序设计（一）七八九十章知识点总结
04-07
Java语言程序设计（一）七八九十章知识点总结 第七章：输入和输出流 一、数据流的基本概念 * 在 Java 中，把不同类型的输入、输出源抽象为流，其中输入或输出的数据成为数据流，用统一的接口表示。 * 数据流是...
Java基础入门教程 第9章 Java的高级特性（共32页）.ppt
12-04
【完整课程列表】 ... Java基础入门教程 第1章 Java 简介（共31页）.ppt Java基础入门教程 第2章 java语言基础（共52页）....Java基础入门教程 第9章 Java的高级特性（共32页）.ppt jdk api 1.7.chm JDK_API_1_6_zh_CN.CHM
Java语言程序设计：第五章 异常.ppt
05-29
九、总结 异常处理是Java语言程序设计中的一部分，了解异常的分类、产生、捕获和处理是非常重要的。通过try-catch语句、多重catch块、throws子句等，可以捕获和处理异常，确保程序的安全和稳定。
Java-第六章程序清单.docx
09-30
本文将对Java程序设计的基础知识点进行总结和解释。 1. Java基本语法 Java语言的基本语法包括变量、数据类型、运算符、控制结构、方法等。 Java中的变量可以分为基本类型和引用类型两种，基本类型包括整数、浮点数...
秒杀系统：第9章 课程总结及重难点回顾
01-08
秒杀系统：第9章 课程总结及重难点回顾 解压密码： www.hegoubbs.com 或者 第十一期 或者 www.hegouvip.com 。
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1916
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 609
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1266
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 417
修改菜品——后端Java
java语言程序设计第九章思维导图
01-15
很抱歉，我无法提供关于"java语言程序设计第九章思维导图"的具体内容，因为您提供的引用内容中没有包含相关信息。但是，我可以为您提供一些关于Java语言程序设计的基本知识和思维导图的使用方法。 Java语言程序设计...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值