JavaSE基础知识点(二)

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

数组

1、java中的数组：是一个用来存储数据的容器
	/*
	 * **所有声明的变量存放于栈(stack)区：系统自动分配，不用我们控制
	 * 
	 * 数组的声明：
	 * int[] array; (*)
	 * int array[] ; 
	 * 数值是引用数据类型：数据存在在堆heap区:
	 * 
	 * 数组的初始化：
	 * 数组数据类型[]  变量名=new 数组数据类型[数组长度] 
	 * 数组中的数据存放在堆heap区,堆heap区的内存需要程序员区控制，使用内存空间分配符new开辟内存
	 * 
	 */
	//声明
	int[] array;
	int array_new[];
	//初始化
	array=new int[5];
	
	System.out.println();

//动态初始化
		array=new int[5];//堆内存中创建了一个数据对象(开一个房间)，存放5个元素的数组
		System.out.println(array);//[I@7852e922
		//控制台输出数组内容
		System.out.println(Arrays.toString(array));//[0, 0, 0, 0, 0]
		//定义
		char[] char_array=new char[5]; 
		System.out.println(Arrays.toString(char_array));//[ , , , , ]
		//定义一个引用数据类型的数组
		String[] strign_array=new String[5]; 
		System.out.println(Arrays.toString(strign_array));//[null, null, null, null, null]
		//静态初始化
		/**数组初始化时 赋值自己想要的值*/
		int[] array_int=new int[] {1,2,3,4,5,6};
		int[] array_int_two= {12,13,14,15,16,17};//.class --自动加上new 
		
		//数组的赋值 索引从0开始
		array[0]=13;
		array[1]=14;
		array[2]=15;
		array[3]=16;
		array[4]=17;
		System.out.println(Arrays.toString(array));
		/*array[5]=18;//java.lang.ArrayIndexOutOfBoundsException: 5   数组越界异常
*/		/*array[4]="zhangsan";  array是int类型的数组，元素只能是int类型*/
		
		//数组的访问：Arrays.toString(数组名)
		/**通过索引访问*/
		System.out.println(array[3]);//16
		/**数组的快速访问*/
		for(int i=0;i<array.length;i++) {
			System.out.println(array[i]);
		}
		/**foreach循环  加强for循环
		 * for(数组元素数据类型 变量名:遍历的数组名) {
				
			}
			该循环方式为按照数组下标顺序
		    ，依次将冒号右边数组中的每个元素赋值给冒号左边的变量，数组长度为for循环的次数。
		 * */
		for(int j:array) {
			System.out.println("j:"+j);
		}
		/*	
		int a;
		a=10;
		System.out.println(a);*/
	}

二维数组

/**
		 *[数组,数组,数组..]
		 *二维数组：Java中没有真正的多维数组，只有数组的数组
		 *
		 *声明：
		 *数据类型[][] 数组名 ;
		 *数据类型      数组名[][];
		 *数据类型[] 数组名[];
		 * 
		 * 创建：
		 * int[][] arrays_4=new int[3][3];
		   int[][] arrays_5=new int[3][];
		 * 
		 * 初始化：
		 *  数组类型  数组名[ ][ ] = {{元素11，元素12，…} , {元素21，元素22，… }}
		 *  数组类型  数组名[ ][ ] = new 数据类型[ ][ ] { {元素11，元素12，…} , {元素21，… } }
		 * 
		 */
		//声明
		int[][] arrays_1;
		int arrays_2[][];
		int[] arrray_3[];
		
		//创建二维数组  定义
		int[][] arrays_4=new int[3][3];
		int[][] arrays_5=new int[3][];
		/*int[][] arrays_6=new int[][];//维度必须初始化,告诉编译器数组有多少个元素*/
		/*int[][] arrays_6=new int[][3];//维度必须初始化empty dimension*/
		/*int[] array_1=new int[5];*/
		
		//二维数组的初始化
		int[][] arrays_6=new int[][]{{1,2,3},{4,5},{6,7}};
		int[][] arrays_7={{1,2,3},{4,5},{6,7}};
		System.out.println(arrays_6);//[[I@7852e922
		System.out.println(arrays_7);//[[I@4e25154f

		//二维数组的访问
		System.out.println(Arrays.toString(arrays_6));
		System.out.println(Arrays.toString(arrays_6[0]));//[1, 2, 3]
		System.out.println(Arrays.toString(arrays_6[4]));//数组越界
		//遍历二维数组

//遍历二维数组 
		/*System.out.println(arrays_6.length);//3   行数*/
		/*for(int i=0;i<arrays_6.length;i++) {
			//行数
			System.out.println(Arrays.toString(arrays_6[i]));
			//每行每列的结果
			for(int j=0;j<arrays_6[i].length;j++) {
				System.out.println(arrays_6[i][j]);
			}
		}*/
		
		/*foreach*/
		for(int[] i:arrays_6) {
			for(int j:i) {
				System.out.println(j);
			}
		}
		
		//二维数组的赋值
		int[][] arrays_8=new int[4][4];
		arrays_8[0][0]=1;
		arrays_8[0][1]=1;
		arrays_8[0][2]=1;
		arrays_8[0][3]=1;  
		
		arrays_8[1][0]=1;
		arrays_8[1][1]=1;
		arrays_8[1][2]=1;
		arrays_8[1][3]=1;
		
		/**
		 * 快速赋值：
		 * 1 2 3
		 * 4 5 6
		 * 7 8 9
		 */
		int num=1;
		int[][] arrays_9=new int[3][3];
		for(int i=0;i<arrays_9.length;i++) {
			//给每一行每一列赋值
			for(int j=0;j<arrays_9[i].length;j++) {
				arrays_9[i][j]=num;
				num++;
			}
		}

冒泡排序：

	/**
		 * 冒泡排序：
		 * 
		 * 
		 * {78,12,23,6,17,49}
		 * 
		 * 
		 */
		int[] a= {78,12,23,6,17,49};
		//升序排序
		/*for(int i=0;i<a.length-1;i++) {
			if(a[i]>a[i+1]) {
				int temp=a[i+1];
				a[i+1]=a[i];
				a[i]=temp;
			}
		}
		System.out.println(Arrays.toString(a));//[12, 23, 6, 17, 49, 78]
*/
		//降序排序
	for(int j=0;j<a.length;j++) { //循环六次
		for(int i=0;i<a.length-1;i++) {//6个数比较5次
			if(a[i]>a[i+1]) {
				int temp=a[i+1];
				a[i+1]=a[i];
				a[i]=temp;
			}
		}
		System.out.println(Arrays.toString(a));
	}
	/*System.out.println(Arrays.toString(a));
	
	for(int j=0;j<a.length;j++) { //循环六次
		for(int i=0;i<a.length-1;i++) {//6个数比较5次
			if(a[i]<a[i+1]) {
				int temp=a[i+1];
				a[i+1]=a[i];
				a[i]=temp;
			}
		}
	}
	System.out.println(Arrays.toString(a));*/
	//优化冒泡排序
	
	for(int j=1;j<a.length;j++) { //循环五次
		for(int i=0;i<a.length-j;i++) {//6个数比较5次
			if(a[i]>a[i+1]) {
				int temp=a[i+1];
				a[i+1]=a[i];
				a[i]=temp;
			}
		}
		
	}
	System.out.println(Arrays.toString(a));
	}

方法的定义和调用

  • 方法的定义
/***
 * 方法是什么?
 * 方法是完成某个功能的一组语句，通常将常用的功能写成一个方法
 * 方法使用大括号包含语句块称为方法体，用于执行特定的功能操作
 * 
 * 方法的分类：
 * 无参无返回值
 * 无参有返回值
 * 
 * 有参无返回值
 * 有参有返回值
 * 
 * 方法的定义：
 * 方法定义在类中
 * 方法不能定义在方法中
 * 
 * 作用：可以实现代码的重用。简化了程序的编写和维护工作。
 */
public class _方法的说明_方法的分类和定义 {
	
	//无参无返回值
	/**
	 * public:访问修饰符
	 * void:标志着这个方法没有返回值
	 * startXiJi:方法名
	 */
	public void startXiJi() {
		//实现洗衣机工作的方法  --在控制台中输出
		System.out.println("我是无参无返回值方法--洗衣机工作");
		
	}
	//无参有返回值
	/**
	 * 
	 * public:访问修饰符
	 * int:标志着这个方法返回值是int类型
	 * return:这个方法返回的值
	 * 注意：return的值的数据类型一定要和方法返回值类型一致
	 * 	   	有返回值的方法必须要有return(无论如何都要执行return)，而且一个方法只能返回一个值
	 * @return
	 * retrun是一个方法结束的标志，一旦return执行之后，return之后的代码就没有意义了
	 */
	public int getAge() {
		int age=5;
		if(age>10) {
			return age;
		}else {
			return age;
			/*System.out.println(" ss");*/
		}
		/*return 20;*/
		
	}
	
	//有参无返回值
	/**
	 * int money：形式参数--这个方法执行需要什么类型的数据，就要给什么数据类型的
	 * 
	 * 
	 * @param money
	 */
	public void startBingXiang(int money) {
		System.out.println("有参无返回值");
	}
	public void getName(int userId,String phone) {
		System.out.println("有参无返回值");
	}
	//有参有返回值
	/**
	 * 方法的返回值可以是基本数据类型也可以是引用数据类型
	 * 
	 * 
	 */
	public int[] getSex(int id) {
		int[] arrays=new int[5];
		return arrays;
		
	}
	/**
	 * main:程序的入口
	 * @param args
	 */
	public static void main(String[] args) {
		

	}
  • 方法的调用
	/**
	 * 注意：需要根据方法名称调用方法，方法只有在被调用后才生效
	 * 
	 * 方法的调用：
	 * 定义的方法可以被多次调用。
	 *定义方法中的代码，只有在调用后才生效。 
	 * 
	 * 无参无返回值方法的调用
	 * 
	 * 
	 * @param args
	 */
	//无参无返回值方法
	public static void startXiYiJi() {
		System.out.println("无参无返回值的方法--让洗衣机启动");
	}
	/**
	 * 有参无返回值
	 * 形参的作用域在整个方法，
	 * 变量只有初始化才能使用，形参其实就是一个变量,形参的初始化是在方法被调用的时候完成的
	 * @param money
	 */
	public static void startShouMaiJi(int money) {
		
		System.out.println("有参无返回值"+money);
	}
	public static void startDianShiJi(int id,String name) {
		
		System.out.println(name+"打开了"+id+"号电视机");
	}
	/**
	 * 无参有返回值
	 */
	public static String getName() {
		System.out.println("无参有返回值的方法");
		return "lisi";
	}
	
	/**
	 * 有参有返回值
	 */
	public static String getName(String userName,String password) {
		String name="zhangsan";
		System.out.println("有参有返回值的方法");
		return name;
	}
	
	/**
	 * 程序的入口
	 * @param args
	 */
	public static void main(String[] args) {
		/*无参无返回值
		startXiYiJi();
		startXiYiJi();
		startXiYiJi();
		/*
		 * 有参无返回值
		 *  实参和形参的数量、类型、顺序必须匹配
		 * qian和300称为实参
		 * 	实参可以是常量，也可以是有值的变量。
		int qian=100;
		startShouMaiJi(qian);//传参
		startShouMaiJi(300);
		startDianShiJi(1,"张三");
		*/
		
		/*
		 *无参有返回值的方法 
		 * 如果方法有返回值，调用方法可以得到该方法的返回值，然后赋值给与方法返回值类型相同的变量
		 
		String name=getName();
		if(name.equals("lisi")) {
			System.out.println(name);
		}else {
			System.out.println("不是他");
		}*/
		
		/*有参有返回值的方法 
		 * 
		String name=getName("lisi","123");
		System.out.println(name);*/

	}

方法的互相调用

/**
	 * 方法之间互相调用
	 * 
	 * 发动机启动需要油，如果油量大于200Ml那么才能启动，发动机启动后车才能跑起来
	 */
	public static void startFaLali() {
		boolean t=startFaDongJi();
		if(t) {
			System.out.println("思行的法拉利 跑起来了，来兜风呀");
		}
	}
	
	public static boolean startFaDongJi() {
		boolean temp=false;
		int you=getYouLing(500);
		//油量大于200发动机才能启动
		if(you>200) {
			temp=true;
		}
		return temp;
		
	}
	public static int getYouLing(int youLiang) {
		int realYou=youLiang/2;
		return realYou;	
	}

_基本数据类型和引用类型作为参数比较

/**
	 * 参数是基本数据类型
	 * 
	 * 变量随着方法的执行完毕而死亡
	 * 
	 * @param x
	 * @return
	 */
	public static void getX(int x) {
		x=x*10;
		/*System.out.println("方法中的x"+x);*/
	}
	/**
	 * 参数是引用数据类型
	 * 
	 * 传递的是地址，拿到引用地址后可以对堆区中的对象的数据进行操作
	 * @param y
	 */
	public static void getY(int[] y) {
		System.out.println(y);
		y[0]=y[0]*10;
	}

	public static void main(String[] args) {
		int x=10;
		System.out.println("调用方法前x："+x);//10
		getX(x);
		System.out.println("调用方法后x："+x);//10
		
		int[] y= {10};
		System.out.println(y);
		System.out.println("调用方法前y："+y[0]);//10
		getY(y);
		System.out.println("调用方法后y："+y[0]);//100

	}

方法的重载

/**
	 * 方法的重载：方法的重载就是在同一个类中允许同时存在一个以上同名的方法
	 * 
	 * 
	 * 实现方法重载：一同一不同
	 * 方法名相同
	 *方法的参数列表不同：参数的个数或者参数的类型不同
	 *返回值可以同可以不同 
	 *作用：相同名称的方法实现的功能不一样，扩展方法的功能
	 */
	public void getUser(String userName,String passWord) {
		System.out.println("通过名字和密码查询用户");
	}
	//方法重载
	public void getUser(String userName) {
		System.out.println("通过名字查询用户");
		
	}
	//方法重载
	public void getUser(int sex) {
		System.out.println("通过性别查询用户");
	}

方法的递归

/**
	 * 方法的递归：某个方法本身调用自己，达到循环执行该方法的效果
	 */
	//编写一个方法，求整数n的阶乘，例如5的阶乘是1*2*3*4*5
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int message=sc.nextInt();
		/**
		 * 有返回值的方法可以直接输出
		 */
		System.out.println(getResult(message));
	}

	public static int getResult(int message) {	
		if(message==1) {//如果message等于1结束递归
			return 1;
		}
		return message*getResult(message-1);//8*7*6*5*4*3*2*getResult(1)
	}

面向对象基础

  1. 构造器

    /**
	 * 
	 * new :分配堆内存，创建对象
	 * 构造方法可以重载
	 * 
	 * 构造器(构造方法)：
	 * 语法：
	 * <修饰符> 类名(){
	 * 
	 * }
	 *构造方法名必须与类相同的名称
	      不含返回值类型，也没有void
	  不能在方法中用return语句返回一个值
	 * 
	 * 
	 * 作用：
	 * 初始化对象--包括初始化属性(给默认值)以及方法
	 * 属性(成员变量)和方法都是初始化之后才能使用
	 * 成员方法可以直接调用属性
	 * 
	 * 执行：
	 * 在对象被创建之前要完成对象的初始化工作，调用构造方法
	 * 对象创建出来的同时就完成了对象的初始化工作
	 * 
	 * 
	 * 注意：
	 * 
	 * 
	 * 如果代码中没有声明构造器，编译器会自动给我加上一个无参的构造器，因为对象初始化一定要调用构造器
	 * 
	 * 有参构造器：
	 * 	<修饰符> 类名(参数列表){
	 * 			
	 * }
	 * 作用：
	 * 初始化对象，初始化属性(自定义值)以及方法
	 * 
	 * 
	 * 注意：一个类中有了有参的构造器，编译器会将无参的构造器删除
	 * (也就是说当你提供了构造器了之后，编译器不会给你加上无参构造器了)
	 * 
	 * 所以我们一般这样操作：提供有参构造器的同时也提供无参的构造器
	 */
	String name;
	int age;
	char sex;
	
	/**
	 * 无参构造器  构造方法
	 */
	public Person() {
		System.out.println("我是无参构造器");
	}
	/**
	 * 有参构造器
	 */
	public Person(String name,int age,char sex) {
		System.out.println("我是有参构造器");
		this.name=name;
		this.age=age;
		this.sex=sex;
	}
	
	public void getResult() {
		System.out.println("name:"+this.name+" age:"+this.age+" sex:"+this.sex);
	}
	
	public static void main(String[] args) {
		Person p1=new Person();
		p1.age=10;
		p1.name="liss";
		p1.sex='女';
		p1.getResult();
	/*	p1.getResult();*/
		/*Random r=new Random(); 
		int a=r.nextInt(); */
		
		Person p2=new Person("zhangsan",12,'男');
		/*p2.name="zhangsan";*/
		p2.getResult();
		
	}

2、垃圾回收机制

/***
 * 
 * 垃圾回收机制：
 * 堆内存自动回收垃圾线程
 * 
 * 垃圾：只要没有引用指向，jvm垃圾回收线程会把该对象识别为垃圾
 * （我们并不知道垃圾回收线程什么时候执行，一般是堆内存的使用达到一定的容量时执行）
 * 1、匿名对象
 * 2、对象的引用被赋值为null
 * 3、超出对象的声明周期
 * 
 * finalize():销毁对象，内存的使用达到一定的容量时执行,垃圾回收线程开始工作，
 * 去找堆内存中那些对象时垃圾，当对象被识别为垃圾就会调用该对象的finalize()方法销毁该对象
 * 
 * @author Administrator
 *
 */
public class GarbageRecycling {
	
	public static void getX() {
		int x=10;
	}
	public static void getY() {
		int y=10;
	}
	public static void main(String[] args) {
		/*getX();*/
		GarbageRecycling gr=new GarbageRecycling();
	/*	GarbageRecycling gr1=new GarbageRecycling();
		GarbageRecycling gr2=new GarbageRecycling();*/
		//如果只想执行一次对象的操作，可以创建匿名对象
		new GarbageRecycling().getX();
		
		new GarbageRecycling().getY();
		
		new GarbageRecycling().getX();
		gr=null;
		new GarbageRecycling().getY();
		
		
		for(int i=0;i<10;i++) {
			GarbageRecycling grl=new GarbageRecycling();
		}
		
	}

继承

/** 
 * 继承(泛化)：public class Worker extends Employee
 * 子类 is a kind of 父类
 * 
 * 语法：子类(派生类) extends 父类(基类，超类)
 * 注意：子类继承了父类，就可以使用父类非private修饰的方法和属性
 * 作用：子类继承父类的所有非private修饰的属性和方法，同时也可以增加自己的属性和方法。
 * 1、提高代码复用率
 * 2、子类功能得到增强
 * 
 * 
 * 注意：Java中只支持单继承,但是支持一个类可以是另一个类的爷爷
 * 一个父类可以有多个子类
 * 
 * 
 * @author Administrator
 *
 */

封装

/**
 * 封装：
 * 就是将不想或不该告诉他人的东西隐藏起来，
 * 将可以告诉他人的内容公开（隐藏对象的属性和方法的实现细节，只公开对外接口）
 * 
 * 本类中有的一些属性或者方法不想在其他类中或者其他包中的类可见(被调用)，
 * 将可以对外的类公开的属性或者方法提供对外访问的方法
 * 
 * 访问修饰符：控制类中的方法或者属性访问的权限
 * 
 * @author Administrator
 *
 */

访问修饰符

同一个类中同个包中的其他类不同包中的子类不同包中的非子类
privateoknotnotnot
defaultokoknotnot
protectedokokok（用子类引用调用父类的protected修饰方法和属性，不能用父类的）not
publicokokokok
/**
	 * 属性
	 */
	private int age;
	String name;
	protected String address;
	public int salary;
	
	/**
	 * 成员方法
	 */
	private void getPrivate() {
		System.out.println("private修饰的方法");
	}
	void getDefault() {
		System.out.println("default修饰的方法");
	}
	protected void getProtected() {
		System.out.println("protected修饰的方法");
	}
	public void getPublic() {
		System.out.println("public修饰的方法");
	}
	public static void main(String[] args) {
		TestEncapsulation_one one=new TestEncapsulation_one();
		one.age=10;
		one.getPrivate();
		one.name="李四";
		one.getDefault();
		System.out.println(one.age);
	}

类的修饰符只有两个：public 和default

单例模式

  • 保证一个类仅有一个实例（对象），并提供一个访问它的全局访问点。

  • 要点：

    某个类只能有一个实例；
    它必须自行创建这个实例；
    必须自行向整个系统提供这个实例。

  • 实现：

    1、拥有一个私有构造器；
    2、提供一个自身静态私有的成员变量；
    3、提供一个公有的静态公有的方法。

wbw1314520
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java2SE基础知识点整理（一）
ITMonkeyKing的博客
02-18 949
主要是对Java2SE面试可能会遇到的问题罗列了出来，并给出了答案。
JavaSE基础知识总结
XiongChenhong的专栏
08-06 455
最近回顾了一下Java的基础知识，决定写成博客梳理一遍，主要是JavaSE部分最基础的知识，适合考前突击，学后回顾，不适合作为初学材料。 简单的列个目录吧： 一、数据类型和运算符 二、流程控制与数组 三、面向对象基础 四、集合概述 五、泛型入门 六、异常处理 七、输入输出 八、多线程 九、反射 一、数据类型和运算符 这一块基本上各种语言都大同小异 基本数据类型： 整数类
javaSE（三）
YooFale的博客
09-20 261
1.数组 整数默认初始化值0 浮点数默认初始化值0.0 布尔类型默认初始化值false 字符类型默认初始化值\u0000   [I@7852e922 [有几个代表是几维数组 I代表是Int类型 @固定格式 7852e922代表的是十六进制的地址值   2.java内存分配及堆栈 堆：new出来的东西 栈：局部变量 方法区：代码 本地方法区：和系统相关 寄存器：给寄...
java顺序堆栈,java – 在控制台上没有以正确的顺序打印堆栈跟踪与其他消息
weixin_39900045的博客
03-11 94
为什么在控制台屏幕上没有以正确的顺序显示为以下Java程序打印的堆栈跟踪？它与屏幕上的其他消息混在一起.是否涉及导致它的任何并行性？Java程序：package evm;public class Client {public static void main(String[] args) {EVM evm = new EVM();try {evm.setCandidates(90); /**A...
Java中的一维数组
Of_Mine的博客
04-10 442
   Java程序中通常使用变量来存放各种数据，如果将一组数据用变量的形式存放和使用数据这样会很麻烦。所以Java使用了数组来存放数据。数组是可以存储多个元素并且这多个元素是同一种数据类型的容器。一、一维数组的定义    数据类型[] 数组名;    数据类型 数组名[];  例:    int[] a;        定义了一个int类型的数组变量a    int a[] ;       定义了...
JavaSE阶段知识点
07-02
以下是一些关键的JavaSE知识点： 1. **Java语法基础**： - **数据类型**：包括基本数据类型（如整型、浮点型、字符型、布尔型）和引用数据类型（类、接口、数组）。 - **变量**：声明、初始化和使用变量来存储...
JavaSE基础知识文档、源码
12-15
本资源是我自己复习巩固JavaSE知识所写，知识点比较全面。 抽象类、多态、io、多线程、数据结构和集合、参考图片、案例源码class、有零有整的知识点。 可能并不适用所有人，但希望对你有所帮助。 文档和源代码纯自己...
JavaSE基础知识总结.ppt
01-01
本资源有老师提供，里面简单的概述了java每一个知识点，但只是大体的有一个思维的路线，具体的相关操作就需要去查阅其它资料和学习。针对知识回顾是相当有用的。
JavaSE知识点梳理
05-27
给java初学者或者进阶者提供帮助的学习资料，有面试重点，对于较难的知识点有举例说明且内附代码， 内容为java基础内容。
JavaSE基础知识思维导图
11-07
学习java，基础很重要，空闲时间细化了知识点，更好的理解基础知识
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 605
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 819
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 958
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 319
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
Java 线程池详解
qq_41591215的博客
07-13 908
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 573
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 464
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 425
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 656
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
一、JavaSE-（Java基础）
03-01
Java 基础语法阶段包括包、注释、编码规范、if 语句、循环、函数、数组等知识点。这个阶段是 Java 语言的基础，需要掌握这些知识点来编写 Java 程序。 面向对象编程阶段包括面向对象编程思想、封装、继承、多态、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值