JAVASE第一阶段基础

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量185 收藏
点赞数
分类专栏： se基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52997822/article/details/121998261
版权

JavaSE基础知识

文章目录

一.Java的语法基础

1.标识符

只要在Java中能够起名字的，都叫标识符。
标识符的规则：

  1. 由数字， 字母， 下划线， $ 符号组成
  2. 不能以数字开头
  3. 不能有空格
  4. 驼峰命名法
  5. 见名知意： name userAge

2.关键字

Java已经用过的名字， 这些名字，自己写代码的时候不能使用。
不用死记硬背。
在这里插入图片描述

3.数据类型

	Java的数据类型：
	基本数据类型：
	数值型：
	整型： byte, short, int , long(1, 100, 256)
	浮点型： float, double(3.14, 0.0001)
	字符型：char ( 'J'，'a', '成')
	布尔型：boolean (true, false)
	引用数据类型：
	类： （String, String str = "abcd";）
	接口： （List）
	数组： (Array)

在这里插入图片描述

（1）整型
	Java中默认的整型是int.

在这里插入图片描述

（2）浮点型
	Java中默认的浮点型是double.

在这里插入图片描述

（3）字符型
	Java中字符型只能用单引号来包裹： '国'，'信'
	Java中的字符占用两个字节。
	Java中的字符可以表示特殊字符： 换行符('\n')， 制表符('\t')
（4）布尔型
	布尔型在Java中只有两个值： true, false
	true 表示 真 =》 正确
	false 表示 假 =》 错误

4.变量

	变量： 可变的量
	变量的三要素：
	数据类型 变量名 变量值

在这里插入图片描述

5.常量

	一旦申明就不能改变。
	好处： 一处修改，多处修改， 主要是方便维护代码。
	注意关键字： final
	变量名的规范： 所有的字母必须大写， 单词与单词之间用下划线连接。

// 常量 
// 常量的命名规范： 所有的字母必须大写， 单词与单词之间用下划线连接 
// 常量值一旦申明就不能改变了。 
final int NUM = 10; 
final int USER_COUNT = 10; 
//final int NUM = 20; 
//final int USER_COUNT = 30;
// 常量的好处： 一处修改， 多处修改 
System.out.println(NUM); 
System.out.println(USER_COUNT);  
System.out.println(NUM); 
System.out.println(USER_COUNT);

6.运算符

（1）赋值运算符
	=, 最主要的作用就是给变量赋值

int num = 10;
（2）算术运算符
	主要是+，-，*，/， %
	%： 取模（取余数）	

// % 
int num = 9%2; 
System.out.println(num);
（3）比较运算符
	主要包含： >, >=, == , <, <=, !=
	比较运算符最终计算的结果是： boolean

Scanner scanner = new Scanner(System.in); 
System.out.println("请输入第一个数字："); 
int num1 = scanner.nextInt(); 
System.out.println("请输入第二个数字："); 
int num2 = scanner.nextInt(); 
System.out.println("请选择操作： 1 ： +， 2 ： -， 3 ： *， 4 ： /"); 
int choose = scanner.nextInt();
 if (choose == 1) { 
 	// 加法运算 System.out.println(num1+num2); 
 }else if (choose == 2) { 
 	System.out.println(num1-num2); 
 }else if (choose == 3) { 
 	System.out.println(num1*num2); 
 }else if (choose == 4) { 
 	System.out.println(num1/num2);
 }
（4）逻辑运算符
	主要包含： && || ！
	逻辑运算符主要运算条件表达式.
	&& : 必须都为true => true
	||: 只要一个为true => true
	! : ! true => false, ! false => true

public static void main(String[] args) {
 	Scanner scanner = new Scanner(System.in); 
 	System.out.println("你有多少钱？");
 	 int money = scanner.nextInt(); 
  	System.out.println("请输入是否下雨？"); 
  	String isRain = scanner.next(); 
  	if (money >= 10 && "否".equals(isRain)) { 
  		System.out.println("可以买好吃的！！"); 
  	}else {
  		 System.out.println("等一下！！"); 
  	} 
  }
（5）单目运算
	++， --
	++： 表示自增1
	--： 自减一

public static void main(String[] args) { 
	int num = 10;
 	num++;// num = num + 1; num += 1; 
 	num--;// num = num -1; num -= 1; 
 	System.out.println(num); 
 }

	前置和后置的区别： 程序是从左到右执行

// 前置和后置的区别 
int num = 100; 
int num1 = ++num;// 101 
int num2 = num++;// 100
（6）三目运算
	条件表达式 ? 值1 : 值2；
	条件表达式 -》 true -> 值1
	条件表达之-》false -> 值2

public static void main(String[] args) { 
	// 三目运算 
	int a = 10; 
	int b = 20; 
	a = a > b ? a : b; 
	// 用if写 
	if(a > b) { a = a; }else { a = b; }
 }
（7）连接运算符
	+
	加号的两边有任意一边是字符串， 这个时候就是连接运算。
（8）调用符
	.
	对象调用属性
	对象调用方法

7.数据类型转换

在这里插入图片描述

8.强制类型转换

	类型1 变量名 = (类型1)类型2

强转会造成一个问题： 精度的损失。
注意：
boolean不能和其他任意类型的值进行转换。

int i=1,j = 0;
 float f1=0.1f; 
 float f2=123; 
 double d1=2020,d2=124; 
 byte b1=1,b2=2,b3=120;
 j=j+10; 
 i=i/10;
 i=(int) (i*0.1); 
 char c1='a',c2=125; 
 // byte, short 在运算的时候自动转换成int 
 byte b=(byte) (b1-b2); 
 float f3=f1+f2; 
 float f4=(float) (f1+f2*0.1); 
 double d=d1*i+j; 
 float f=(float)(d1*5+d2);

9.流程分支

if

分支语句： 将代码分成不同的部分， 条件不同执行的代码就不一样。
分支的种类：
     单分支

// Java中分支语句规范 
// 分支体里面无论是一行代码还是多行代码，都将{}写出来 
if(条件表达式){
 // 分支体语句 
 }

     双分支

// 满足条件进入分支1 不满足进入分支2 
if(条件表达式){ 
// 分支1 
}else{
// 分支2 
}

     多分支

// 满足哪个条件表达式 就进入哪个分支 
// 最终只会进入一个分支 
if(条件表达式1){ 
// 分支1 
}else if(条件表达式2){ 
// 分支2 
}else if(条件表达式3){
 // 分支3 
 }else if(条件表达式n){ 
 // 分支n 
 }else{
 // 分支n+1 
 }

/** * 2.输入a ,b,c 三个个位数（0-9）之间，组成一个最大的三位数 */
  System.out.println("请输入第一个数:"); 
  int num1 = scanner.nextInt(); 
  System.out.println("请输入第二个数:");
  int num2 = scanner.nextInt(); 
  System.out.println("请输入第三个数:");
  int num3 = scanner.nextInt();
   if (num1 < 0 || num1 > 9 || num2 < 0 || num2 > 9 || num3 < 0 || num3 > 9) { 
   System.out.println("输入的数字满足条件！"); 
   }else { // 交换的思想 
   // 最终的效果： num1 最大， num2 次之 num3 最小 
   int temp; 
   if (num1 < num2) { 
   temp = num1; 
   num1 = num2; 
   num2 = temp; 
   }
   if (num1 < num3) {
	temp = num1; 
	num1 = num3;
 	num3 = temp; 
 }
 	if (num2 < num3){ 
 	temp = num2; 
 	num2 = num3;
  	num3 = temp; 
  }
  System.out.println("三个数字组成的最大数："+num1+num2+num3);
}
switch
	是优雅版的if...else....
	语法有差距， 最终效果一致。
	根据实际的情况选择使用即可。

// 比较值 是不能相同的。 
// 比较值的数据类型： 字符， 字节， 短整型， 整型， 字符串。
 // break必须得加上。 
 switch(值){ 
   case 比较值1 ：
  // 逻辑 break;
   case 比较值2 ： 
   // 逻辑 break; 
   case 比较值n ： 
   // 逻辑 break; 
   default: 
   // 默认情况 
   break; 
 }

/** * 利用switch来完成 
* 完成一个简单的计算器程序。程序要求如下： 
* 1. 读入两个整数 
* 2. 提示用户选择对这两个整数的操作，即输出
*  1 ： + 
* 2 ： - 
* 3 ： * 
* 4 ： / 
* */
 Scanner scanner = new Scanner(System.in); 
 System.out.println("请输入第一个数字："); 
 int num1 = scanner.nextInt(); 
 System.out.println("请输入第二个数字：");
 int num2 = scanner.nextInt();
 System.out.println("请选择操作： 1 ： +， 2 ： -， 3 ： *， 4 ： /");
 int choose = scanner.nextInt(); 
 switch(choose) { 
 case 1: 
 // 逻辑代码 
 	System.out.println(num1+num2); 
 	break;
 case 2: 
  // 逻辑代码 
  	System.out.println(num1-num2); 
  	break;
 case 3: 
   // 逻辑代码 
   System.out.println(num1*num2); 
   break;
 case 4:
     // 逻辑代码 
     if (num2 == 0) { 
     	System.out.println("0不能作为除数！"); 
     }else { 
     	System.out.println(num1/num2); 
     }
     break;
     default: 
     System.out.println("运算符错误！"); 
     break; 
  }

10.循环语句

	while循环

// 1. 先判断条件表达式计算的结果 
// 2. 如果为true=>执行循环体 
// 3. 如果为false=> 结束循环 
// 属于先验循环
 while(条件表达式){ 
 	// 循环体 
 }
 // 做一个小小的练习 
 // 输出1~100之间的奇数 
 int num = 1;
  while (num <= 5) { 
  // 判断是否是奇数 
  if (num%2 != 0) { 
  	System.out.println(num); 
  }
  num++; 
  }

do…while循环

// 是一个后验循环： 先执行循环体，再判断条件 
// 1. 先执行循环体 
// 2. 判断条件， true=> 继续执行循环体， false =>结束循环
 do{
 	// 循环体 
 }
 while(条件表达式); 
 do {
 System.out.println("后验循环"); 
 }while(false);
for循环
	for循环是用的最多的，也是最复杂的

for(初始值的申明;条件的判断;迭代){
	//循环体
}
//for循环执行的步骤
//1.执行初始化
//2.执行条件判断
//3.循环体
//4.迭代
//5.执行条件判断
//.....重复步骤，直到条件不满足，结束循环

//计算1累加到100
for(int i=1;i<=100;i++){
	sum+=i;
}
System.out.println(sum);

/*:3、有一分数序列: 2/1, 3/2, 5/3, 8/5, 13/8, 21/13.求出这个数列的前20项之和。*/
public class Demo1 {
	public static void main(String[] args) {
		
		double a1=1;
		double a2=2;
		double temp;
		double sum=0;
		
		for(int i=1;i<=20;i++) {
			sum+=a2/a1;
			temp=a2;
			a2=a2+a1;
			a1=temp;
			
		}
		System.out.println(sum);
	}
}
跳出循环

跳出循环有两种方式：
break : 直接结束(跳出)循环。
continue： 结束当次循环， 继续下一次循环。

/** 
* 1、打印0-50以内所有能被7整除的数（使用continue） 
* */
* for (int i = 0; i <= 50; i++) { 
* 	if (i%7 != 0) { 
* 		continue; 
* 	}
* 	System.out.println(i); 
* }

/** 
* 2、打印0-50以内前5个能被7整除的数（使用break） 
* */
int count = 0; 
for (int i = 0; i <= 50; i++) { 
	if (i%7 == 0) { 
		System.out.println(i); // 把次数+1 			
		count++; 
	}
	if (count == 5) { 
		break; 
	}
}
双层循环
	双层循环： 循环里面嵌套循环。

// 语法
 for(int i=0; i<=n; i++){ 
 	// 循环体 
 	for(int j=0; j<=m; j++){ 
 		// 循环体 
 	} 
 }
 // 打印出99乘法表 
 // 双层循环 
 // 打印99乘法表 
 // 有行和列 
 // 外层循环： 循环行=》9 外层循环的范围 1~9 
 // 内存循环： 循环列=》 列数和行数相等 
 // 什么时候换行： 内层循环完了之后换行
  for (int i = 1; i <= 9; i++) {
  	// 循环行 
  	for (int j = 1; j <= i; j++) { 
  		System.out.print(j+"×"+i+"="+(i*j)+"\t");
  	}
  	// 换行 
  	System.out.println(""); 
  }
/** 
	（循环）*读入一个整数n，输出如下图形 
	 n = 3 
	   *
	  *** 
	 ***** 
	 n = 4
	    *
	   *** 
	  ***** 
	 ******* 
	 思路：输入的数字就是行数 
	 列数：2*n-1 
	 */ 
	 int n = 5; 
	 for (int i = 1; i <= n; i++) {
	 	// 行 
	 	for (int j = 1; j <= n-i; j++) {
	 		// 输出空格 
	 		System.out.print(" "); 
	 	}
	 	for (int j = 1; j <= 2*i-1; j++) {
	 		// 输出* 
	 		System.out.print("*"); 
	 	}
	 	// 换行 
	 	System.out.println(""); 
	}
多层循环的跳出
	关键字都是一样的： break, continue;
	直接break, continue => 只能退出一层循环
	多层循环的退出 需要一个标记
	这个标记自定义。

flag:for(int i=0; i<=n; i++){ 
	// 循环体 
	for(int j=0; j<=m; j++){ 
		// 循环体 
		break flag; 
	} 
}

// 多层循环的退出 
flag:for (int i = 0; i < 10; i++) {
	for (int j = 0; j < 10; j++) { 
		System.out.print("*");
		 if (j == 5) {
			break flag; 
		} 
	}
	System.out.println(""); 
}

11.数组

	数组是所有语言中**最为重要的结构**
	现在我们的程序需要将班级所有的同学的名字装起来，并且在控制台输出
	如果用基本数据类型的变量来装：定义48个变量装每个人的名字
	有一种数据结构可以很简单的实现：**数组**
	数组一旦申明，长度不能改变
（1）如何定义数组？
//定义数组并初始化（静态初始化）
	int[] nums = {1,2,3,4};
	//或
	int nums3[] = {3,55};
	//或
	int[] nums4 = new int[] {1,2,3,4,5};
		
	//定义数组并初始化（动态初始化）
	int[] nums2 = new int[5];
	//注意事项
	//静态初始化：定义和初始化不能分开写
	String[] names;
	//names = {"jack"};   报错
	names = new String[5];  //动态初始化是可以的

	数组是引用数据类型
	
	内存里面有两个区域：栈区 和 堆区
	
	基本数据类型存入 **栈区**
	
	引用数据类型存入 **堆区**

在这里插入图片描述

（2）下标
下标就是索引。
数组里面元素的地址是连续的：可以通过			       	
索引地址来取出对应的元素
索引是从0开始

// 索引的作用就是位了快速的取获取数组中的元素 
// 获取数组中的元素 0 1 2 
String[] names = {"jack", "rose", "lucy"}; 
// 取第一个元素 
System.out.println(names[2]); 
System.out.println(names[1]); 
System.out.println(names[0]); 
// 动态初始化 
int[] nums = new int[5]; 
nums[0] = 11; 
nums[4] = 4;
（3）数组的长度
// length属性 
//数组.length 
int[] nums = new int[5]; 
int len = nums.length;
（4）遍历数组

for循环

	需要依赖于数组的长度
	注：循环内不要定义变量，在循环外定义，循环内使用

int len = nums.length; 
for (int i = 0; i < len; i++) { 
	System.out.println(nums[i]); 
}

foreach

	不用依赖于数组的长度

// foreach遍历 
for (int i : nums) { 
	System.out.println(i); 
}
（5）数组的冒泡排序
	冒泡排序的核心思想： 交换。

// 冒泡排序法 =》 核心思想是交换 
// 通过每一次遍历交换前后两个值， 大的排后面， 小的排前面 
int[] nums = {23,1,7,55,3,6,22}; 
// 获取长度 
int len = nums.length; 

int temp = 0; 
for (int i = 0; i < len; i++) { 
	// -1 的原因 当最后一个元素的时候， 继续和下一个元素比较， 下一个元素没有， 会越界 
	// -i 的原因是 每遍历一次会少一个 
	for (int j = 0; j < len-1-i; j++) { 
		// 交换 
		// 把大的值 往后面排 =》 升序 
		if (nums[j] > nums[j+1]) { 
			temp = nums[j+1]; 
			nums[j+1] = nums[j]; 
			nums[j] = temp; 
		}
	 } 
}
System.out.println(Arrays.toString(nums));
（6）数组下标越界的情况

在这里插入图片描述

（7）数组初始值的问题
	byte,short,int,long 初始值都是 0
	float, double 初始值都是 0.0
	char 初始值是 ‘’(空字符)
	boolean 初始值 false
	引用数据类型初始值 null
（8）数组容量的问题
	数组的长度一旦确定之后，就不能更改了
	我们要去操作数组里面的数据是很麻烦的：增加一个数据、修改一个数据、删除一个数据
	我们需要使用java提供的工具类：
		Arrays   /  System
----数组的扩容
	在原来的数组的长度基础之上，增加指定长度。
	注意：内存里面并不是在原来的数组基础之上增加，而是**新创建了数组**
	需要用到Arrays里的copyOf方法(地址会发生变化，并非同一个数组)

在这里插入图片描述

在这里插入图片描述

		//数组扩容
		String[] names = {"admin"};
		System.out.println(names);
		System.out.println(Arrays.toString(names));
		
		//长度+1
		names = Arrays.copyOf(names, names.length+1);
		System.out.println(names);
		System.out.println(Arrays.toString(names));
----数组的缩容

主要用于数组数据的删除。
任意位置的数据删除。删除数据后不能留空。
关键点：找到需要删除的下标

在这里插入图片描述

		//删除3这个元素
		//随机的复制数组中的元素
		int[] nums = {1,2,3,4,5,6,7};
		int index = -1;
		int delete = 3;
		//通过遍历找到3的下标
		for (int i = 0; i < nums.length; i++) {
			if(delete == nums[i]) {
				index=i;
				break;
			}
		}
		
		
		//copyOfRange  包前  不包后
		int[] nums1 = Arrays.copyOfRange(nums, 0, index);
		int[] nums2 = Arrays.copyOfRange(nums, index+1,nums.length);
		System.out.println(Arrays.toString(nums1));
		System.out.println(Arrays.toString(nums2));
		
		//准备一个新的数组，装最终的数据
		int[] newNums = new int[nums.length-1];
		System.out.println(Arrays.toString(newNums));
		//将nums1和nums2中的数据放入newNums中
		
		//先复制nums1
		
		System.arraycopy(nums1, 0, newNums, 0, nums1.length);
		System.out.println(Arrays.toString(newNums));

		//再复制nums2
		
		System.arraycopy(nums2, 0, newNums, nums1.length, nums2.length);
		System.out.println(Arrays.toString(newNums));
二维数组

数组中存放的元素是一个数组
语法：

//一维数组的语法
数据类型[] 数组名 = {};
数据类型[] 数组名 = new 数据类型[长度];
//二维数组的语法
数据类型[][] 数组名 = {{},{},{}....};
数据类型[][] 数组名 = new 数据类型[长度][长度] 

// 二维数组 
// 静态初始化 
int[][] nums = {{1,2},{2,3}}; 
System.out.println(nums[1][1]); 
// 动态初始化 
int[][] nums2 = new int[3][2]; 
nums2[0][0] = 100; 
nums2[0][1] = 250; 
nums2[1][0] = 200; 
nums2[1][1] = 300; 
// 遍历
// 需要知道长度 
for (int i = 0; i < nums2.length; i++) { 
	for (int j = 0; j < nums2[i].length; j++) {
		 System.out.print(nums2[i][j]+"\t");
	 }
	 System.out.println("");
 }

在这里插入图片描述

Java中有没有二维数组
从内存的角度是没有二维数组的
从使用的角度是有的

在这里插入图片描述

12.函数

定义：将业务代码中，公共的部分取出来，并且封装，取一个函数名，供其他地方调用

//语法：
public static 返回值数据类型 函数名字(形参数据类型 形参1，形参数据类型 形参2....){
	//定义一个函数add(int a,int b)
	/**
	 * 加法运算
	 * @param a：数值1
	 * @param b：数值2
	 * @return a+b
	 */
	public static int add(int a,int b) {
		return a+b;
	}

	//调用
	int sum = add(10,20);
	System.out.println(sum);
函数分类

（1）有参有返回值

/**
	 * 有参有返回值
	 * @param a
	 * @param b
	 * @return a-b
	 */
	public static int jian(int a,int b) {
		return a-b;
	}

（2）有参无返回值

/**
	 * 有参无返回值
	 * @param a
	 * @param b
	 */
	public static void cheng(int a,int b) {
		System.out.println(a*b);
	}

（3）无参有返回值

/**
	 * 无参有返回值
	 * @return 
	 */
	public static void getRandomName() {
		Random random = new Random();
		int c = random.nextInt(100);
		System.out.println(c);
	}```

（4）无参无返回值

```java
/**
	 * 无参无返回值
	 */
	public static void welcome() {
		
		System.out.println("jhhh");
		System.out.println("pppppp");
		System.out.println("cccccch");
	}

注意：函数里面定义的变量（局部变量），该变量的作用域在函数体{}中

即将拥有人鱼线的本酋长
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第一阶段：狂神说——javaSE(基础)
qq_44697268的博客
07-10 594
狂神说java，学习笔记，javaSE第一阶段，打基础基础，
终止循环（输出100以内能被7整除的前5个数）
zs_66666的博客
10-13 5142
输出100以内能被7整除的前5个数 （1）while循环 public class DemoA{ public static void main(String[] args) { int count = 0; int i = 1; //while循环实现 while(i &lt;= 100) { if(i%7 == 0) { System.out.println(i...
JavaSE第一阶段知识概括
qq_52997822的博客
07-23 195
JavaSE基础知识 一.Java的语法基础 1.标识符 只要在Java中能够起名字的，都叫标识符。 标识符的规则： 由数字， 字母， 下划线， $ 符号组成 不能以数字开头 不能有空格 驼峰命名法 见名知意： name userAge 2.关键字 Java已经用过的名字， 这些名字，自己写代码的时候不能使用。 不用死记硬背。 3.数据类型 Java的数据类型： 基本数据类型： 数值型： 整型： byte, short, int , long(1, 100, 256) 浮点型： float,
《JavaEE黑马》 第一阶段 JavaSE基础 第一章
ye_liu_arch的博客
09-03 443
Java
JavaSE基础阶段测试+平时测验
一名在校大三学习JAVA
07-05 258
目录编程题
JavaSE第一阶段笔试题.docx
08-18
1. **选择题第一题**：考察的是整型溢出。在Java中，整数的最大值是`Integer.MAX_VALUE`，如果超过这个值再进行加法操作，会从头开始计算，因此存在使 `i + 1 的情况。 2. **选择题第二题**：考察数据类型的精度。`...
javaSE第一天学习
04-20
"javaSE第一天学习" 一、课程简介 JavaSE 第一天学习课程旨在为初学者提供了 Java 语言的基础知识，涵盖了 Java 语言的应用场景、Java 基础阶段知识结构、软件开发介绍、计算机编程语言介绍、Java 语言概述、Java ...
JavaSE基础面试题.docx
06-11
45. **数据库范式**：第一范式到第三范式（1NF、2NF、3NF），消除数据冗余，提高数据独立性。 46. **数据库事务特性**：ACID，即原子性、一致性、隔离性和持久性。 47. **数据库隔离级别**：READ UNCOMMITTED、...
Java第1阶段—Java基础.zip
07-15
"Java第1阶段—Java基础.zip"这个压缩包文件包含了学习Java初阶所必需的核心概念和语法，旨在帮助初学者建立坚实的基础。以下是对每个子文件内容的详细解读： 1. **Java第一阶段_day01_Java基础语法** 这一部分...
1阶段Java基础.zip
10-26
【标题】"1阶段Java基础.zip"所包含的是学习Java编程语言的第一阶段基础知识。这个压缩包集合了多种资源，帮助初学者系统地掌握Java SE（标准版）的基础知识。 【描述】"1阶段Java基础.zip"暗示了这个资料集主要...
配置Java开发环境
Broken_x的博客
07-10 1265
Java开发环境配置
java集合工具类
最新发布
hejiefeng111的博客
07-12 131
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 240
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 395
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2044
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1367
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 487
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 119
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3225
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
全国v3.0) javase加强第一阶段-第2套卷
07-13
全国v3.0版javase加强第一阶段-第2套卷主要是指在javase基础上进行加强学习和应用。在这套卷中，学习者需要掌握更高级的Java编程知识和技巧。 首先，学习者需要对Java语言有扎实的掌握。他们应该熟练掌握Java的基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值