day02

已于 2023-08-25 10:48:11 修改
阅读量29 收藏
点赞数
分类专栏： 01_javase 文章标签： java 开发语言
于 2023-07-25 15:03:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61569709/article/details/131918239
版权
文章详细介绍了Java中的流程控制，包括ifelse、switch、while、do-while和for循环的使用，以及break和continue的控制。接着讲解了数组的概念、创建、遍历和排序，特别提到了二维数组的定义和遍历。最后，介绍了方法的定义和调用，以及面向对象的基本思想。
摘要由CSDN通过智能技术生成

3 流程控制

通过java关键字来控制代码的执行顺序

3.1 选择结构

if else结构

       //1 单分支
		char sex='男';
		if(sex=='男') {
			  System.out.println("你是男生：请去对面班：sex="+sex);
		}
		if(sex=='女') {
			  System.out.println("你是女生：请来我们班：sex="+sex);
		}
		//2 双分支
		if(sex=='男') {
			  System.out.println("你是男生：请去对面班：sex=="+sex);
		}else{
			   System.out.println("你是女生：请来我们班：sex=="+sex);
		}
		//3 多分支
		float score=99;
		if(score<0||score>100) {
			System.out.println("score="+score+",成绩无效！");
		}else if(score<60) {//隐藏条件 score>=0&&score<=100
			System.out.println("score="+score+",成绩不及格！");
		}else if(score<70) {//隐藏条件：score>=60&&score<=100
			System.out.println("score="+score+",成绩及格！");
		}else if(score<80) {
			System.out.println("score="+score+",成绩良好！");
		}else if(score<100) {
			System.out.println("score="+score+",成绩优秀！");
		}else {
			System.out.println("score="+score+",成绩满分！");
		}
  • swicth
//switch
/*注意事项：1 switch表达式的值结果只能是：int String enum
		 *         2 case后面的值不能重复
		 *         3 break作用结束整个switch结构
		 *         4 default:所有的case值都不是switch的结果时 才执行default
		 * 
		 * */
//根据月份判断季节
int month=11;
//345 春  678 夏 9 10 11 秋 12 1 2 冬
switch(month) {//Cannot switch on a value of type long. Only convertible int values, strings or enum variables are permitted
    default:
        System.out.println("month="+month+",对应的季节是火星季5！");
        break;
    case 3:
        System.out.println("month="+month+",对应的季节是春季！");
        break;
    case 4:
        System.out.println("month="+month+",对应的季节是春季！");
        break;
    case 5:
        System.out.println("month="+month+",对应的季节是春季！");
        break;
    case 6:
        System.out.println("month="+month+",对应的季节是夏季！");
        break;
    case 7:
        System.out.println("month="+month+",对应的季节是夏季！");
        break;
    case 8:
        System.out.println("month="+month+",对应的季节是夏季！");
        break;
    case 9:
        System.out.println("month="+month+",对应的季节是秋季！");
        break;
    case 10:
        System.out.println("month="+month+",对应的季节是秋季！");
        break;
    case 11:
        System.out.println("month="+month+",对应的季节是秋季1！");
        //break;
    case 12:
        System.out.println("month="+month+",对应的季节是冬季2！");
        //break;
    case 1:
        System.out.println("month="+month+",对应的季节是冬季3！");
        //break;
    case 2:
        System.out.println("month="+month+",对应的季节是冬季4！");
        break;

}

month=11;
//345 春  678 夏 9 10 11 秋 12 1 2 冬
switch(month) {//Cannot switch on a value of type long. Only convertible int values, strings or enum variables are permitted
    default:
        System.out.println("month="+month+",对应的季节是火星季5！");
        break;
    case 3:
    case 4:
    case 5:
        System.out.println("month="+month+",对应的季节是春季！");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("month="+month+",对应的季节是夏季！");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("month="+month+",对应的季节是秋季1！");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("month="+month+",对应的季节是冬季4！");
        break;
}

3.2 循环结构

while

 /*
		   * while格式：
		   * while(条件表达式){
		   *      循环体：(循环执行的代码+迭代语句)
		   * }
		   * 
		   * 迭代语句：按指定算法 不断地更改某个变量的值
		   * */ 
			{
			   int n;
			   n=1;
			   if(n<5) {
				   System.out.println("if:::"+n);
				   n++;
			   }
			   n=1;
			   while(n<5) {
				   System.out.println("while:::"+n);
				   n++;//迭代语句
			   }
			}
		   
//		   n=1;
//		   while(n<5) {
//			   System.out.println("while:::"+n);
//			   //没有迭代语句 是死循环 循环不会结束
//		   }
		   
			{
			   //使用循环的场景：希望一个数从值1跑到值2时 使用循环
			   //获取1到100的和:::
			   int sum=0;
			   //让一个数从1跑到100 不断的加到sum中：：：使用while
			   int n=1;
			   while(n<=100) {
				    sum+=n;
				    n++;
			   }
			   System.out.println("获取1到100的和="+sum);
			}
			
			
			//使用while打印九九乘法表
			{
				int i=4;
				while(i<=9) {
					//System.out.println("i="+i);
					int j=1;
					while(j<=i) {
						System.out.print(i+"*"+j+"="+i*j+"  "+(i*j<10?" ":""));
						j++;
					}
					i++;
					System.out.println();//打印一个换行
				}
			}
			//总结
			/*二维图形题：必须使用两次for循环
			 * 外层for循环控制行数
			 * 内层for循环控制列数
			 * */

dowhile

         /*while格式：
		  * while(条件表达式){
		  *     循环体
		  * }
		  * 
		  * dowhile格式：
		  * do{
		  *    循环体
		  * }while(条件表达式);
		  * 
		  * 总结： while：是先判断 后执行
		  *       dowhile：是先执行 后判断
		  * dowhile：循环体任何情况下至少执行一次
		  * */
		  int n;
		  n=11;
		  while(n<=5) {
			  System.out.println("while:::n="+n);
			  n++;
		  }
		  n=11;
		  do{
			  System.out.println("do  while:::n="+n);
			  n++;
		  }while(n<=5);

for

/*
		 * while格式：
		 * 初始化语句;
		 * while(条件表达式){
		 *    循环体：循环执行的代码+迭代语句
		 * }
		 * 
		 *for格式：
		 *for(初始化语句;条件表达式;迭代语句){
		 *    循环体：循环执行的代码
		 *}
		 *
		 *初始化语句：定义变量+变量赋初始值
		 *
		 * */
		 //求1+...100
		 int n1=1;
		 int sum1=0;
		 while(n1<=100) {
			 sum1+=n1;
			 n1++;
		 }
		 System.out.println("求1+...100="+sum1);
		 
		 int sum2=0;
		 for(int n2=1;n2<=100;n2++) {
			 
			 sum2+=n2;
		 }
		 System.out.println("求1+...100="+sum2);//sum2 cannot be resolved to a variable
		 
		 //2 for的执行过程
		 System.out.println("-------------");
		 int m=1;
		 for(System.out.println("初始化语句：m="+m);    m<=10;    System.out.println("迭代语句：：：m="+m)) {
			     System.out.println("循环执行的代码：：：m="+m);
			     m++;
		 }
		 //1 初始化语句
		 //2 条件表达式：不成立就结束 成立继续 3
		 //3 执行循环体
		 //4 执行迭代语句
		 //5 继续：2 - 3 - 4 直到 2不成立
		 
		 //3 for语句是否可以省略
		 // 条件表达式可以省略：默认是true  
		 // 初始化语句可以省略
		 // 迭代语句可以省略
//		 int a=1;
//		 for(;;) {
//			     System.out.println("循环体：：a="+a);
//			     a++;
//		 }
		 
		 //4 for循环中变量的作用域
		 int a=1;             //a在for循环外面定义：                       main方法
		 for(int b=1;a<=5;) { //b在for循环的初始化语句中定义的：整个循环
			 int c=1;         //c在for循环的循环体中定义的：      本次循环
			 System.out.println("a="+a+",b="+b+",c="+c);
			 c++;a++;b++;
		 }
		 //变量的作用域：取决于定义此变量的大括号！！！

3.3 跳转

  /* break:
		   * 使用场景1：switch中 使用break 表示结束整个switch结构
		   * 使用场景2：for/while/dowhile中：  结束整个for循环
		   * continue:
		   * 使用场景1：for/while/dowhile中：结束本次for循环 继续++ 进行下次for循环
		   * */
		   int n;
		   n=1;
		   for(;n<=5;n++) {
			   if(n==2) {
				    continue;
			   }
			   System.out.println("continue:::"+n);
		   }
		   
		   n=1;
		   for(;n<=5;n++) {
			   if(n==2) {
				    break;
			   }
			   System.out.println("break:::"+n);
		   }
		   System.out.println("n="+n);
		   
		   //1 1+2+...求加到几时 和第一次大于1000
		   n=1;
		   int sum=0;
		   for(;sum<=1000;n++) {
			   sum+=n;
			   System.out.println(sum+"：：："+n);
		   }
		   System.out.println(sum+":::"+n);
		   
		   n=1;
		   sum=0;
		   for(;;n++) {
			   sum+=n;
			   if(sum>1000) {
				   break;
			   }
			   System.out.println(sum+"：：：："+n);
		   }
		   System.out.println(sum+"::::"+n);
		   
		   //2 获取1到100内个位数不为1的所有数的和
		   n=1;
		   sum=0;
		   for(;n<=100;n++) {
			   if(n%10==1) {
				   continue;
			   }
			   sum+=n;
			   System.out.println("n="+n);
		   }

4 数组

4.1 数组概念

/*
		装指定个数个 相同类型数据  的容器
		1：数组是引用数据类型(非基本数据类型：4种8类)：：复杂数据：：：对象
		2：数组中的数据称为元素：数组的元素个数固定
		3：数组的元素类型一致
		
		数组的关键字：[]
		定义数组名格式：元素类型[] 数组名;
		创建数组对象格式：new 元素类型[元素个数];
		
		*/
		//格式1：创建数组 并起个名字的格式1：
		// 元素类型[] 数组名=new 元素类型[元素个数];
		int[] ageArr=new int[20];//在内存中创建一个可以装20个int元素的数组对象 此数组对象名字叫ageArr
		// 定义数组名=创建数组对象
		
		
		//创建基本数据类型的数据
		int age=11;
		// 定义变量名=常量值
		
		//数组优势：1 数组中装元素时 会自动给元素分配下标(索引) 从0开始
		//数组优势：2 获取数组中的元素时 通过数组名+下标来获取
		//格式2： 调用数组中元素的格式：数组名[下标]
		ageArr[1]=19;
		ageArr[2]=21;
		ageArr[4]=20;
		System.out.println(ageArr[1]+10);
		
		
		
		System.out.println("获取数组的元素个数："+ageArr.length);//获取数组的元素个数：数组名.length
		//遍历数组
		for(int i=0;i<ageArr.length;i++) {
			System.out.println("ageArr["+i+"]="+ageArr[i]);
		}
		//注意事项1：数组中的元素不赋值 有默认初始值:::0/false
		byte[] arr11=new byte[3];
		System.out.println("byte:::"+arr11[0]);
		short[] arr12=new short[3];
		System.out.println("short:::"+arr12[0]);
		int[] arr13=new int[3];
		System.out.println("int:::"+arr13[0]);
		long[] arr14=new long[3];
		System.out.println("long:::"+arr14[0]);
		float[] arr15=new float[3];
		System.out.println("float:::"+arr15[0]);
		double[] arr16=new double[3];
		System.out.println("double:::"+arr16[0]);
		char[] arr17=new char[3];
		System.out.println("char:::"+(int)arr17[0]);
		boolean[] arr18=new boolean[3];
		System.out.println("boolean:::"+arr18[0]);
		
		//注意事项2：访问到不存在的下标时 抛出异常：ArrayIndexOutOfBoundsException
		//System.out.println("boolean:::"+arr18[18]);//ArrayIndexOutOfBoundsException: 18
		//System.out.println("boolean:::"+arr18[-1]);//ArrayIndexOutOfBoundsException: -1
		
		//格式3：创建数组 并起个名字的格式2：
		//元素类型[] 数组名=new 元素类型[]{元素1,元素2,元素3....};
		int[] ageArr2=new int[]{11,13,14,18,19,20,22};
		int[] ageArr1=new int[10];
		
		//格式4：创建数组 并起个名字的格式3：格式2的简化写法
		//元素类型[] 数组名={元素1,元素2,元素3....};
		int[] ageArr3={11,13,14,18,19,20,22};//省略 但编译器帮你补上
		
		
		//注意事项3：new一次 就创建一个对象
		//说明以下语句的意思：
		int[] array1;         //定义一个数组名：array1 只能指向元素为int类型的数组
		array1=new int[10];   //让数组名array1指向了一个 装10个int类型元素的数组对象
		array1[0]=11;         //给array1指向的数组对象 的下标为0的元素赋值为11
		array1[0]=array1[1]+1;//
		int[] array2=array1;  //创建一个新的数组名array2 让其指向数组名array1指向的数组对象 77行的对象
		array2[3]=11; 
		System.out.println("array1[3]="+array1[3]);
		array1=new int[10];    //让array1指向一个新的数组对象

插入排序

        //插入排序: 了解
		//假设前面元素是有序的，拿当前元素倒着和其前面的元素作比较
		for (int i = 1; i < arr.length; i++) {
			int k=arr[i];//定义一个变量记录当前元素的值
			int j;
			for (j = i-1; j >=0; j--) {
				if(arr[j]<k) {
					arr[j+1]=arr[j];
				}else {
					break;
				}
			}
			//当前元素的位置是j+1
			arr[j+1]=k;
		}

4.2 数组遍历

4.3 数组排序

两个变量互换值

        int a,b;
		a=1;b=2;
		System.out.println("a="+a+",b="+b);
		//变量互换值：1 再定义一个变量
		int c=a;//c=1 a=1 b=2
		a=b;//c=1 a=2 b=2
		b=c;//c=1 a=2 b=1
		System.out.println("a="+a+",b="+b);
		a=1;b=2;
		System.out.println("a="+a+",b="+b);
		//变量互换值：2 加法运算
		a=a+b;//a=3 b=2
		b=a-b;//a=3 b=1
		a=a-b;//a=2 b=1
		System.out.println("a="+a+",b="+b);

顺序排序

  • 1 概念：
顺序排序：依次拿当前元素 和其后面的所有元素作比较

  • 2 画图
    在这里插入图片描述

  • 3 使用代码 实现比较细节

        int[] arr= {1,4,7,8,0,3};
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+(i==arr.length-1?"\r\n":","));
		}
		//顺序排序：依次拿当前元素 和其后面的所有元素作比较
		
		//1 画图
		//2 打印比较细节
		for (int i = 0; i < arr.length-1; i++) {//比较的轮数：length-1
			//当前元素是arr[i]
			//当前元素arr[i]和其后面的所有元素arr[j]做比较：：：
			for (int j = i+1; j < arr.length; j++) {
				 System.out.print("arr["+i+"]-arr["+j+"]\t");
			}
			System.out.println();
		}
  • 4 把打印更改为比较
       //3 更改打印为比较
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				//要求大的排在左边:arr[i]<arr[j]就互换值
				if(arr[i]<arr[j]) {
					int t=arr[i];arr[i]=arr[j];arr[j]=t;
				}
			}
		}

冒泡排序

  • 概念
依次拿相邻的元素做比较
  • 代码
        //冒泡排序
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-i-1; j++) {
				if(arr[j]>arr[j+1]) {
					int t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;
				}
			}
		}

4.4 二维数组

         /* 数组：数据多了 方便管理 方便命名  使用数组
		 * 多维数组：元素类型是数组的数组
		 *     n维数组：n-1维数组的容器
		 * 注意：一般说的数组 默认是一维数组
		 * 二维数组：关键字：[][]
		 * 二维数组定义格式1：元素类型[][] 数组名=new 元素类型[n][m];   
		 *             n:表示此二维数组中一维数组的个数
		 *             m:表示此二维数组每个一维数组的元素的个数
		 * 二维数组定义格式2：元素类型[][] 数组名=new 元素类型[][]{{值11,值21..},{值12,值22..},{值13,值23..}...};    
		 * 二维数组定义格式3：元素类型[][] 数组名={{值11,值21..},{值12,值22..},{值13,值23..}...}; 
		 *
		 * */
		int[][] arr1=new int[3][5];//二维数组定义格式1
		int[][] arr2=new int[][] {{1,2},{3},{4,5,6,7},{9,1,2}};//二维数组定义格式2
		int[][] arr3={{1,2},{3},{4,5,6,7},{9,1,2}};//二维数组定义格式3
		int n=1;
		System.out.println("n="+n);      //  1                    打印基本数据类型变量 打印的是：变量的值
		System.out.println("arr3="+arr3);//[[I@7852e922  打印对象名   打印的是：对象类型@地址
		System.out.println("二维数组名.length= 获取的是二维数组中一维数组的个数：："+arr3.length);  
		System.out.println("二维数组名[1]= 获取的是二维数组中下标为1的一维数组对象：："+arr3[1]);//[I@4e25154f
		System.out.println("二维数组名[1].length= 获取的是二维数组中下标为1的一维数组对象中元素的个数：："+arr3[1].length);//1
		System.out.println("二维数组名[3][2]= 获取的是二维数组中下标为3的一维数组对象中下标为2的元素的值：："+arr3[3][2]);//2
		
		//遍历二维数组
		for (int i = 0; i < arr3.length; i++) {//外层for循环 遍历二维数组中的一维数组
			for (int j = 0; j < arr3[i].length; j++) {//内层for循环遍历二维数组中下标为i的一维数组对象中的元素
				  System.out.print(arr3[i][j]+(j==arr3[i].length-1?"\r\n":","));
			}
		}

4.5 数组练习

5 方法

5.1 概念

在这里插入图片描述

        public static void main(String[] args) {
		/*方法：在类中定义的具有特定功能的代码块
		 *作用：实现代码块的复用
		 *方法--小程序
		 *   -- 把原始数据 按方法内部的算法运算后 得到结果数据
		 *关键字：()
		 *定义方法格式：
		 *    修饰符  返回值类型 方法名(参数列表){
		 *         方法体;
		 *         return 返回值;
		 *    }
		 *解释：
		 *   修饰符：让被修饰者 具有指定的特点
		 *           static ::: 可以被main方法调用
		 *   返回值：  结果数据
		 *   返回值类型：结果数据的类型
		 *   方法名：除了第一个单词 其他单词首字母大写
		 *   参数列表：用于接收原始数据而定义的变量列表
		 *   方法体：实现方法具体功能的代码块
		 *定义方法必须明确： 1 方法运行需要的原始数据--参数列表
		 *                 2 方法运行后的结果数据----返回值 
		 *                 
		 *把洗衣机写成一个方法：
		 *洗衣机的原始数据：脏衣服 洗衣粉 电 水
		 *洗衣后的结果数据：干净衣服
		 *
		 *static 衣服类型   小天鹅1号(衣服类型 脏衣服1号,洗衣粉类型 洗衣粉1号,电类型 电1号,水类型 水1号){
		 *         注水, 翻滚,抽水,注水,翻滚,甩干
		 *         return 干净衣服1号;
		 *}
		 *
		 * 调用洗衣机
		 * 衣服类型  衣服1号=小天鹅1号(脏衣服,洗衣粉,电,水);  
		 *             
		 * */
		int[] arr= {1,4,5,7,8,9,0,2};
		printArray(arr);
		//更改值
		arr[1]+=2;arr[3]+=3;
		//遍历打印
		printArray(arr);
		//排序
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				  if(arr[i]>arr[j]) {
					  int k=arr[i];arr[i]=arr[j];arr[j]=k;
				  }
			}
		}
		printArray(arr);
		
		
		//在主方法中调用方法：
		int summ=add1(1,4);
		System.out.println("结果==="+summ);
		
		
		summ=add2();
		System.out.println("结果==="+summ);
		
		//注意事项4：方法有返回值 调用者可以选择接收返回值 也可以选择不接收返回值
		add2();
		
		
		
	}

//	 *定义方法格式：
//	 *    修饰符  返回值类型 方法名(参数列表){
//	 *         方法体;
//	 *         return 返回值;
//	 *    }
	
	//注意3：return作用：1 结束方法 2 传递返回值给调用者
	//注意2：如果方法没有返回值 返回值类型用void标识
	//3: 打印一个int与一个double的和
	static void  add3(int a,double b) {
		System.out.println(a+"+"+b+"="+(a+b));
		return;
		//System.out.println(111);//Unreachable code
	}
	
	//注意1：方法如果没有原始数据 参数列表可以空着
	//2：获取1到100内的和
	static  int add2() {
		int sum=0;
		for (int i = 1; i <=100; i++) {
			sum+=i;
		}
		System.out.println("add2:::::");
		return sum;
	} 
	
	//1：获取两个整数的和
	//原始数据：两个int
	//结果数据：和
	static int add1(int a,int b) {//This method must return a result of type int
		System.out.println("a="+a+":::b="+b);
		int sum=a+b;
		return sum;
	}
	

	private static  void printArray(int[] arr1) {
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i]+(i==arr1.length-1?"\r\n":","));
		}
	}

5.2 方法练习

//1 定义方法：判断一个数是不是质数
//2 定义方法：求1到n中可以被3整除的数的平均值
//3 定义方法：获取一个int数组的最大值
//4 定义方法：获取一个double的四舍五入保留1位有效小数
//5 定义方法：打印一个二维数组
//6 定义方法：获取两个数组按类似于({1,4,5,6},{1,7,8}--->{1,4,5,6,1,7,8})运算后的结果：
//          获取两个数组按类似于({1,4,5,6,10},{1,7,9,3}--->{0,3,4,3,10})运算后的结果：
//          获取两个数组按类似于({1,4,5,6,10},{1,7,9,3}--->{2,11,14,9,10})运算后的结果：
//7 定义方法：判断指定年指定月有多少天：

6 面向对象

Oriented  Object  Programming :OOP  编程思想：写代码的套路

6.1 概念

饿了吃饭：
面向过程：(自己做饭)种米 种菜 洗米 生火 煮饭 切菜 做菜 吃饭 刷碗  问题解决
面向对象：(让别人給我做饭) 找饭店 点菜 给钱 等饭 吃饭 拍屁股走人  问题解决
面向过程：c
面向对象：java c#
一半一半：c++

面向过程：把解决问题的过程按动作分成多个步骤 逐个步骤去完成 最终解决问题
面向对象：找具有帮助我解决问题功能的对象 调用对象的功能来解决问题

面向对象优点：
1 程序员由执行者转化为指挥者 思路简单
2 面向对象代码复用性强 代码简单
3 面向对象更符合现在人处理事情的思维方式

6.2 面向对象四步

在电脑中：实现xxx进行自我介绍
需要电脑中创建一个xxx的模型(实物在电脑中的模型)
xxx模型是复杂数据 不是基本数据类型  就是引用数据类型的对象
电脑中创建对象 必须先声明对象的类型(给电脑描述此对象的具体细节)
给电脑描述xxx模型的类型--人(数据+功能)

在这里插入图片描述

package day03_fuxi;

public class Demo04OOP {
	public static void main(String[] args) {
		//2 根据类创建对象: 对象类型 对象名=new 对象类型();
		Person p1=new Person();
		//3 给对象的变量赋值
		p1.sex='男';p1.job="法师";p1.age=35;p1.name="xxx";
		//4 调用对象的方法 
		p1.show();
        
		//同一个类 可以创建多个对象
		p1=new Person();//p1指向新的对象 此新的对象 数据全是默认值
		p1.show();
		p1.sex='女';p1.job="模特";p1.age=30;p1.name="韩梅梅";
		Person p2;//定义一个新的对象名   只能指向Person对象
		
		//一个对象可以有多个名字：：引用名/引用
		p2=p1;//让对象名p2指向对象名p1指向的对象
		p1.show();
		p2.show();
	}
}
//1 定义类描述一类事物：人
class Person{
	  //1.1 使用变量描述数据
	   int age;char sex;String name;String job;
	   //1.2使用方法描述功能
	   void show() {
		   System.out.println(age+":"+name+":"+sex+":"+job);
	   }
	   void add() {
		   System.out.println("1+1=2");
	   }
}

注意：类中只需要定义 与当前需求相关的变量和功能
Ayui.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cgb2106-day02
cgblpx的博客
07-27 5722
标题
Python Day02习题
Bailulu000的博客
08-16 2093
对三个整数排序 比较价钱 石头剪刀布 编写程序提示用户输入月和年，然后显示这个月的天数 硬币 回文数 三角形
实训Day02
qq_67958752的博客
05-07 1898
自定义配置项 name : zhang。
瑞吉外卖-全网最全笔记-Day02
eadzsdad的博客
04-17 9264
黑马教程-瑞吉外卖笔记，基于流行的Spring Boot、mybatis plus等技术框架进行开发，体验真实项目开发流程、需求分析过程和代码实现过程。增加开发的经验，适合刚学完java全家桶的小白入手。
算法刷题-Day02
weixin_45374181的博客
05-10 1469
书接上回。
Mybatis-Day02
Anoraker的小屋
03-07 6917
Mapper.xml解析 statement 标签:select、update、delete、insert 分别对应查询、修改、删除、添加操作。 parameterType:参数数据类型 基本数据类型,包装类,String等，如通过 id 查询 Account <select id="findById" parameterType="int" resultType="com.edu.hncj.entity.User"> select * from user4
p6-day02 作业
weixin_45228198的博客
03-27 2435
看图完成如下作业 创建Vue项目，并配置element-ui组件、配置路由router、配置vuex集中状态管理、配置vue的跨域代理 实现如上的页面布局，提示：容器布局、导航菜单、表格 点击每个菜单项都有子菜单，如图： 点击预览部门，展示出所有的部门数据。 后端使用day01 作业的django项目及对应的API 点击管理部门，可以实现增删改 后端使用day01 作业的django项目及对应的API ...
# Day02-Java基础
Java厂长
07-27 6823
Day02-Java 1、方法的基本定义 限制条件：本次所讲解的方法指的是在主类中定义，并且由主方法由主方法直接调用。 方法是指就是一段可以被重复调用的代码块。 在java里面如果想要进行方法的定义，则可以使用如下的方法进行完成。 public static 方法返回值 方法名称（[参数类型 变量，....]）{ 方法体代码 ; return [返回值]; } 在定义方法的时候对于方法的返回值由以下两类：void没用返回值和数据类型（基本类型、引用类型）。 public class T
Day02
03-09
在IT学习过程中，"Day02"这样的标题可能代表着学习日程或课程的第二天，通常会涵盖前一天基础知识的巩固以及新知识的引入。虽然没有具体的描述和标签来指明涉及的具体技术领域，我们可以根据常见的学习路径来推测...
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
day02-SpringCloud02
12-13
在本课程"day02-SpringCloud02"中，我们将深入探讨Spring Cloud这一微服务框架的第二日学习内容。Spring Cloud是Java开发者广泛使用的工具，用于构建分布式系统中的服务发现、配置管理、断路器、智能路由、微代理、...
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2675
Java面试篇（JVM相关专题）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 309
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 281
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
软件测试需要具备的基础知识【功能测试】---后端知识（三）
最新发布
yang_xs的博客
08-12 814
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
集合（1）
supercool7的博客
08-12 446
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
反射和注解
supercool7的博客
08-08 275
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值