day03

Ayui.

已于 2023-08-25 10:49:59 修改

阅读量33

点赞数

分类专栏： 01_javase 文章标签： java

于 2023-07-25 15:11:10 首次发布

本文链接：https://blog.csdn.net/m0_61569709/article/details/131918395

版权

01_javase 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1 helloworld

1.1 三个关键字

jvm:JavaVirtualMachine Java虚拟机实现java跨平台技术，根据当前操作系统执行java字节码文件
jre：java runtime environment java运行环境

jre=java基础类库+jvm
jdk：Java development kits ：java开发工具包

jdk=jre+java开发工具(javac.exe编译器+javadoc.exe文档生成器)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Oygoyh1-1690268798371)(imgs/image-20220829104712142.png)]

1.2 第一个程序

1.2.1 编辑：编写java源文件

编辑概念：写java代码 生成java源文件
编辑工具：所有支持文本的软件都可以：notepad.exe、notepad++
编辑步骤： 1创建文件：后缀名为.java
         2创建类：class 类名{}
         3类中创建主方法：public static void main(String[] s){}
         4主方法中打印输出：System.out.println("额和和");
注意事项： 1 除了""中的内容 其他都不能更改
         2 命名增加可读性+ 对其缩进

//注意1：一个文件中可以有多个类 但只能有一个public类 此public类的类名必须和文件名一致
//注意2：注释有三种
//注意3：;表示语句结束
//注意4：大括号表示范围
class HelloWorld{//1 创建类
	//2 创建主方法
    /*
      aaaa
      1111
      12222
    */
    /**
      33333
      1111
    */
	public static void main(String[] s){
		//3 打印输出语句
		 System.out.println("java43：天道酬勤 不忘初衷！");
	}
}

1.2.2 编译

编译概念：根据java源文件生成 电脑可执行的字节码文件
编译工具：javac.exe 编译器
编译命令：javac 源文件名.java
编译作用：语法检查+生成字节码文件(类名.class)

在这里插入图片描述

1.2.3 运行

运行概念：执行java程序
运行工具：java.exe 虚拟机
运行命令：java 类名

在这里插入图片描述

2 基础语法

2.1 关键字：

Java中被赋予特殊含义的单词或者字符
class  interface 
public protected private
byte short int long char float double boolean
true false
if while for switch case break continue 
final static abstract  void
extends implements

2.2 标识符

概念：java中所有的名字
意义：同类之间区分 方便调用
命名规则：不遵守 编译器报错
         1 由数字 字母 下划线 美元符号组成
         2 不能以数字开头
         3 不能是java关键字
         4 区分大小写
命名规范：编程习惯
        1 尽量增加可读性
        2 首字母大小写(不同标识符 要求不同)
        (类名：所有单词首字母大写：WoDeZiWoJieShao)
        (变量名：方法名：除了第一个单词 其他单词首字母大写)
        (常量：所有字母大写：单词之间用_连接)

2.3 数据类型

4种8类
整数类型：不带小数点的数字
     byte: 字节型： 注意：1 描述数据的最小单位  2 取值范围[-128,127]  
     short:短整型： 1short=2byte 注意：1 取值范围[-32768,32767]
     int:整型：  1int=4byte:注意：1 默认类型
     long：长整型： 1long=8byte： 注意： 1 long类型的常量后面加l/L     
浮点类型：带小数点的数字
     float: 单精度： 1float=4byte :注意1： 小数点有效位数6-8 2: float常量后面加f/F
     double：双精度：1double=8byte:注意1：浮点的默认类型 2 小数点后有效位数为12
字符类型：所有的符号
      char :字符型： 1char=2byte:注意1：char常量必须写在''中 2 ''中有且只有一个字符
布尔类型：只有两个结果 并且是相反的
      boolean：布尔型：1boolean=1byte 注意1：只有两个值：true/false

2.4 常量和变量

常量：运算过程中值不能更改的数据
     常量值： 1  'a'  1.1 true
     final变量：
变量：运算过程中值可以更改的数据
     步骤：先定义 再赋值 然后使用
定义变量：变量类型 变量名;
变量赋值：变量名=常量值;
使用变量：打印输出 进行运算

int i1=1,i2=2;
char c1='1',c2='2';
short s1=1,s2=2;
long l1=1L,l2=2;
double d1=1,d2=2;
float f1=1,f2=2;
   
  i1=c1+i2; // 1 通过编码表获取'1'对应的整数 49 2 拿int的49和int的2运算 得到int 51 赋值给i1
  f1=(int)(d1+f2); // 1 吧float的2.0f提升为double的2.0 2 两个double运算得到double的3.0 
                   // 3：double强制转化为int的3 4：int的3向上提升为float的3.0f 然后赋值
  f1=f1+l1; 
  d1=c1+i1+f1;
  c1=s1+s2;
  i1=c1+s1;

2.5 数据类型转换

数据类型精度表

byte-short-(char)-int-long-float-double

自动类型转换情况一：

概念：把低精度值赋值给高精度变量：
格式：高精度变量=低精度值;
     float f1=1;

自动类型转换情况二：

概念：给byte/short/char 类型的变量赋值int常量值 自动进行范围判断 装下就转换 装不下就报错
格式： byte/short/char 类型的变量=int常量
      byte b1=1;// 00000000 00000000 00000000  00000001 --->  00000001
      int i1=1;
      b1=i1;//错误

强制类型转换

概念：把给精度值强制赋值给低精度变量
格式：低精度变量=(低精度变量类型)高精度值;
     int i1=(int)1.34;
     int i=(char)(1.1+48)

2.6 运算符

算术运算符

数学中已有的：+ - * /
特有的： %  ++ --

        //1 算术运算符
		//1.1 + 作用1：正负
		int i1=+1;i1=-1;
		//      作用2：加减
		i1=1+1;
		//      作用3：字符串连接符
		int a=1,b=2;
		//打印a=1,b=2
		System.out.println("a=1,b=2");
		//1 区分变量(打印的是变量的值)和字符串(原封不动的内容)
		//2 字符串写在字符串中 变量的值用变量表示 之间用连接符+连接即可
		System.out.println("a="+a+",b="+b);
		//打印a=1,b=2,a+b=3
		System.out.println("a="+a+",b="+b+",a+b="+(a+b));
		
		//1.2 ++ --
		a++;//完全等价于a=(a的类型)(a+1)
		
		//1.3 %  余数的正负 取决于被除数
		//n%m= n除以m得到一个整数 除不尽的那部分
		System.out.println("4.7%2.3="+(4.7%2.3));//0.1
		System.out.println("-4.7%2.3="+(-4.7%2.3));//-0.1
		System.out.println("4.7%(-2.3)="+(4.7%(-2.3)));//0.1
		System.out.println("(-4.7)%(-2.3)="+((-4.7)%(-2.3)));//-0.1
		
		
		//判断一个数是不是水仙花数：
		//1 必须是三位数
		//2 各个位数的三次方之和等于此数： 153=1*1*1+5*5*5+3*3*3=1+125+27=153
		int n=371;
		//1 获取每一位的值
		int n1=n%10;
		int n2=n/10%10;
		int n3=n/100;
		//2 获取这三个数的三次之和
		int sumn=n1*n1*n1+n2*n2*n2+n3*n3*n3;
		//3 判断n是否等于sumn
		if(sumn==n) {
			System.out.println(n+"是水仙花数！");
		}else {
			System.out.println(n+"不是水仙花数！");
		}

赋值运算符

         // 2 赋值运算符：
		// 2.1 =
		// 给变量赋的值的类型必须和变量类型一致
		// 2.2 特有：+= -= *= /= %=
		a += b;// 等价于a=(a的类型)(a+b)
		byte b1 = 1, b2 = 2;
		b1 += b2;
		// 运算后结果的数据类型取决于精度最高的数据
		// byte,short,char不能直接参加运算 必须自动提升为int 才能运算
		b1 = (byte) (b1 + b2);// Type mismatch: cannot convert from int to byte

比较运算符

        // 3 比较运算符:结果是boolean
		// 3.1 > < >= <=
		// 3.2 != ==
		System.out.println(1 != 1);
		System.out.println(1 == 1);

逻辑运算符

        // 4 逻辑运算符：只能操作布尔数据 而且结果也是布尔胡数据
		// 4.1 & 单 与 && 双与 and ：两个都成成立 才成立
		// | 单或 || 双或 or ：只要有一个成立 就成立
		// ^ 异或 ：两个不同就成立
		// ！ 取反
		// 注意1：双和单 结果一样
		// 注意2：双和单的区别： 双存在逻辑短路+单可以作为位运算符

		System.out.println("--测试&和&&---");
		System.out.println("true&true=" + (true & true));
		System.out.println("true&false=" + (true & false));
		System.out.println("false&false=" + (false & false));
		System.out.println("false&true=" + (false & true));
		System.out.println("true&&true=" + (true && true));
		System.out.println("true&&false=" + (true && false));
		System.out.println("false&&false=" + (false && false));
		System.out.println("false&&true=" + (false && true));
		System.out.println("--测试^---");
		System.out.println("true^true=" + (true ^ true));
		System.out.println("true^false=" + (true ^ false));
		System.out.println("false^false=" + (false ^ false));
		System.out.println("false^true=" + (false ^ true));
		
		System.out.println("--测试双的逻辑短路---");
		a = 1;
		b = 1;
		if (true && ++a != 0) {
			System.out.println("true&&a++!=0 成立");
		} else {
			System.out.println("true&&a++!=0 不成立");
		}
		System.out.println("a=" + a + ",b=" + b);

		a = 1;
		b = 1;
		if (false && ++a != 0) {
			System.out.println("false&&a++!=0 成立");
		} else {
			System.out.println("false&&a++!=0 不成立");
		}
		System.out.println("a=" + a + ",b=" + b);
		
		//逻辑短路：当通过第一个式子就知道结果时  后面的式子不再运算 直接得出结果
		
		a = 1;
		b = 1;
		if (false & ++a != 0) {
			System.out.println("false&a++!=0 成立");
		} else {
			System.out.println("false&a++!=0 不成立");
		}
		System.out.println("a=" + a + ",b=" + b);

三元运算符

格式：boolean值?值1:值2
boolean值为true 结果是值1 boolean值为false结果是值2

//5 三元运算符
int a=1,b=3,c=4;
int max;//定义变量记录大值
max=a>b?a:b;

//求三个数的大值
int max1=a>b?a:b;
int max2=max1>c?max1:c;
int max3=(a>b&&a>c)?a:(b>c?b:c);
int max4=a>b?(a>c?a:c):(b>c?b:c);

位运算符(了解)

位运算符： &  |  ^  >> <<
位运算符：操作的是数字的二进制  0是false 1是true

	//6 位运算符 了解
		//位运算符：操作的是数字的二进制  0是false 1是true
		//13: 8+4+1=1000+100+1=1101
		//1101  = 1*8+1*4+0*2+1*1 =13
		//123=1*100+2*10+3*1=
		System.out.println("13&3="+(13&3));//1
		System.out.println("17|6="+(17|6));//23
		System.out.println("17>>2="+(17>>2));//4
		System.out.println("17<<2="+(17<<2));//68

在这里插入图片描述

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
评论
day03

jvm:JavaVirtualMachine Java虚拟机实现java跨平台技术，根据当前操作系统执行java字节码文件jre：java runtime environment java运行环境jre=java基础类库+jvmjdk：Java development kits ：java开发工具包 jdk=jre+java开发工具(javac.exe编译器+javadoc.exe文档生成器)
复制链接

扫一扫

专栏目录