标签：red 了解 栈内存 解析 很多 数学 逻辑运算 led 简写
Java基础语法
0.Java语法的组成
1.1 关键字
关键字的定义和特点
定义：被Java语言赋予了特殊含义的单词
特点：关键字中所有字母都为小写
1.2 标识符
在程序中自定义的一些名称。由26个英文字母大小写，数字：0-9 符号：_ $ 组成
定义合法标识符规则：
1，数字不可以开头。
2，不可以使用关键字。
3，Java中严格区分大小写。
注意：在起名字的时，为了提高阅读性，见名知意。
1.2.1 Java中的名称规范：
包名：多单词组成时所有字母都小写。
xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写。
XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。
xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。
XXX_YYY_ZZZ
1.3 注释
用于注解说明解释程序的文字就是注释。
提高了代码的阅读性。
Java中的注释格式：
单行注释
对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。[查看源文件的属性大小作比较比较直观的了解]
对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，在用代码去体现。因为代码仅仅是思想的一种体现形式而已。
1.4 常量和变量
1.4.1 常量表示不能改变的数值。
Java中常量的分类：
1，整数常量：所有整数
2，小数常量：所有小数
3，布尔(boolean)型常量：较为特有，只有两个数值。true false。
4，字符常量。将一个数字字母或者符号用单引号( ‘ ‘ )标识。
5，字符串常量。将一个或者多个字符用双引号(" ")标识。
6，null常量。只有一个数值就是:null.
对于整数：有四种表现形式。
二进制：0,1 ，满2进1.
八进制：0-7 ，满8进1. 用0开头表示。
十进制：0-9 ，满10进1.
十六进制：0-9，A-F，满16进1. 用0x开头表示。
进制的基本转换
十进制 二进制 互转
十进制转成二进制 除以2取余数
二进制转成十进制 乘以2的幂数
十进制 八进制 互转
十进制 十六进制 互转
负数的二进制表现形式
对应的正数二进制取反加1
1.4.2变量的概念：
内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。
为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用
使用变量注意：
变量的作用范围（一对{}之间有效）
初始化值：定义变量的格式：
数据类型 变量名 = 初始化值；
int x=3;
注：格式是固定的，记住格式，以不变应万变。
理解：变量就如同数学中的未知数。
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
自动类型转换（也叫隐式类型转换） 强制类型转换（也叫显式类型转换）
类型转换的原理，什么时候要用强制类型转换?表达式的数据类型自动提升
所有的byte型、short型和char的值将被提升到int型。
如果一个操作数是long型，计算结果就是long型；
如果一个操作数是float型，计算结果就是float型；
如果一个操作数是double型，计算结果就是double型。
自动类型提升
byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。
强制类型转换
byte b = 3;
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b
Example
1 /*变量 2 整数默认：int 小数：double 双精度 3 */ 4 class VarDemo 5 { 6 public static void main(String[] args) 7 { 8 //数据类型 变量名 = 初始化值 9 byte b=3; 10 short s=4000; 11 int x=12; 12 13 long l=12345678; 14 long l=541646465464564l;/*数值较大取值末尾+l*/ 15 16 float f= 2.3;/*报错：单精度*/ 17 float f=2.3f/*强制转换f*/ 18 double d=2.5; 19 20 char ch=‘C‘; 21 boolean b1=true; 22 b1=false; 23 System.out.println("Hello World"); 24 } 25 } 26 //------------------------------------------------------------------------------------------// 27 /*类型提升&强制转换*/ 28 class VarDemo2 29 { 30 public static void main(String[] args) 31 { 32 /* 33 int x=2; 34 byte b=1; 35 x=x+b;//占用较小的自动提升为int型 36 37 byte b1=2; 38 b1=(byte)(b1+5);//强制类型转换 39 40 System.out.println((char)(‘a‘+1));//强制转换为char 41 */ 42 byte b=4; 43 byte b1=3; 44 byte b2=7; 45 int s;/*强制转换*/ 46 s=b1+b2; 47 System.out.println("s="+s); 48 49 //Integer.MIX_VALUE int类型最大最小值 50 int max=Integer.MAX_VALUE; 51 int min=Integer.MIN_VALUE; 52 System.out.println("MAX="+max+"\n"+"MIN="+min); 53 } 54 }
1.5 运算符
1.5.1算术运算符
Example
1 /* 2 运算符： 3 算术运算符：+ - * / %(取余，模运算) +(连接符) 4 ++（自增） --（自减） 5 6 */ 7 class OperateDemo 8 { 9 public static void main(String[] args) { 10 int x=446; 11 x=x/15; 12 13 System.out.println(3%2); 14 //连接符应用 15 int a=4,b=5; 16 System.out.println("a="+a+",b="+b); 17 18 int a1=3,b1; 19 //a1++;//a=a+1 20 b1=a1++; 21 System.out.println("a1="+a1+",b1="+b1); 22 } 23 }
1.5.2赋值运算符
符号：
= , +=, -=, *=, /=, %=
示例：
int a,b,c; a=b=c =3;
int a = 3; a+=5;等同运算a=a+5;
Example
1 /* 2 赋值运算符 = += -= *= /= %= 3 */ 4 class OperateDemo2 5 { 6 public static void main(String[] args) 7 { 8 int a=4; 9 a+=2;//a=a+4 a=6 10 11 short s=3; 12 //s+=4; s=7 13 s=s+4; 14 System.out.println("s="+s); 15 } 16 }
1.5.3比较运算符
Example
1 //比较运算符 2 class OperateDemo3 3 { 4 public static void main(String[] args) 5 { 6 /* 7 比较运算符，运算结果：TRUE或FALSE 8 */ 9 // System.out.println(5>8);//false 10 // System.out.println(3==3);//false 11 12 /*逻辑运算符 13 逻辑运算符作用：用于连接两个Boolean类型的表达式 14 &：与 |：或 ^:异或 !:非 15 16 &:运算特点：true & true =>true; 17 true & false =>false; 18 false & true =>false; 19 false & false =>false; 20 &:运算规律： 21 两边表达式同时为T则为T，一边表达式为F则为F; 22 */ 23 int x=5; 24 System.out.println(x>2&x<=5);//true 25 26 /* |：运算特点：true | true =>true; 27 true | false =>true; 28 false | true =>true; 29 false | false =>false; 30 |:运算规律： 31 两边表达式同时为F则为F，一边表达式为T则为T; 32 */ 33 int i=3; 34 System.out.println(i>2 | i>6);//true 35 36 /* ^:运算特点： true ^ true =>false; 37 true ^ false =>true; 38 false ^ true =>true; 39 false ^ false =>false; 40 ^:运算规律： 41 两边表达式一样则为F，不同则为T; 42 */ 43 //------------------------------------------------------// 44 45 /* !：运算特点：!true =>false; 46 !false =>true; 47 48 */ 49 //------------------------------------------------------// 50 51 /* &&：短路与 &：与区别 52 &：无论左边的运算结果是什么，右边参与运算; 53 &&：当左边为false,右边不参与运算; 54 55 ||:短路或 |：或区别 56 |：无论左边运算结果是什么，右边参与运算; 57 ||:当左边为true时，右边不参与运算; 58 59 */ 60 //------------------------------------------------------// 61 62 } 63 }
1.5.5逻辑运算符
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
"&"和"&&"的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
"|"和"||"的区别同理，双或时，左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
1.5.5位运算符
Example
1 // 位运算符 2 class OperateDemo4 3 { 4 public static void main(String[] args) 5 { 6 // System.out.println(6&3); 7 // System.out.println(6|3); 8 // System.out.println(6^3^3);//一个数异或同一个数两次，结果还是这个数 9 // System.out.println(~6);//取反+1 =>-7 10 11 System.out.println(3<<2);//3左移2位 3*(2^2)=12 12 System.out.println(6>>2);//6右移1位 6/(2^2)=1 13 } 14 }
1.5.6三元运算符
格式
(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
示例：
获取两个数中大数。
int x=3,y=4,max;
max= (x>y)?x:y;//max变量存储的就是两个数的大数。
Example
1 class OperateDemo5 2 { 3 public static void main(String[] args) 4 { 5 6 //求最大值(三元运算符) 7 int x=3,y=9; 8 int max=x>y?x:y; 9 System.out.println("max="+max); 10 11 //获取三个整数的最大值 12 int a=28,b=14,c=36; 13 int temp=a>b?a:b;//比较a,b数值，取出max存放temp; 14 int max2=temp>c?temp:c;//temp跟第三个数比较取出max 15 System.out.println("max2="+max2); 16 } 17 } 18 /* 19 三元运算符：(条件表达式?表达式1:表达式2) 20 1、条件表达式为T，返回表达式1； 21 2、条件表达式为F，返回表达式2； 22 */
三元运算符测试Test：
1 class OperateTest 2 { 3 public static void main(String[] args) 4 { 5 //最有效率的方法实现2*8=16? 6 System.out.println(2<<3);//2*(2^3)=>16 7 8 //对两个整数变量的值进行互换(不需要第三方变量) 9 int a=3,b=5; 10 System.out.println("a="+a+",b="+b); 11 /* 12 int c; 13 c=a; 14 a=b; 15 b=c; 16 */ 17 18 //数值过大超过int取值范围，出现强制转换，数据发生变化 19 /* 20 a=a+b;//a=3+5;a=8 21 b=a-b;//3+5-5=3;b=3 22 a=a-b;//3+5-3=5;a=5 23 */ 24 25 //一个数异或同一个数两次，结果还是这个数(阅读性差) 26 a=a^b;//a=3^5; 27 b=a^b;//(3^5)^5;b=3; 28 a=a^b;//a=(3^5)^3;a=5 29 System.out.println("a="+a+",b="+b); 30 } 31 }
1.6 语句（程序的流程控制）
1.6.1 判断结构
if语句特点：
a,每一种格式都是单条语句。
b,第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。
c,条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;
Example
1 //判断结构 2 class IfDemo 3 { 4 public static void main(String[] args) 5 { 6 7 int x=5; 8 if(x>9) 9 System.out.println("yes"); 10 System.out.println("no"); 11 } 12 } 13 /* 14 if语句第一种格式： 15 1、if(条件表达式) 16 { 17 执行语句; 18 } 19 if语句为单条语句时，if控制的大括号可省略; 20 */
1 class IfDemo2 2 { 3 public static void main(String[] args) 4 { 5 int x=12; 6 if(x>1){ 7 System.out.println("yes"); 8 } 9 else{ 10 System.out.println("no"); 11 } 12 /////////////////////////////////////////////////// 13 14 int a=3,b; 15 /*if(a>1){ 16 b=222; 17 } 18 else{ 19 b=333; 20 } 21 */ 22 b=a>1?222:333;//三元运算符是if...else的简写格式;（简化的局限性） 23 System.out.println("b="+b); 24 } 25 } 26 /* 27 if语句第二种格式： 28 1、if(条件表达式) 29 { 30 执行语句; 31 } 32 else 33 { 34 执行语句; 35 } 36 37 简写格式用法？ 38 当if else运算后有具体的结果，可简化三元运算符 39 */
1 class IfDemo3 2 { 3 public static void main(String[] args) 4 { 5 int x=3; 6 if (x>1) 7 System.out.println("a"); 8 else if(x>2) 9 System.out.println("b"); 10 else if(x>3) 11 System.out.println("c"); 12 else 13 System.out.println("d"); 14 15 // System.out.println("Hello World!"); 16 17 int y=3; 18 if (y>1) 19 System.out.println("a1"); 20 if(y>2) 21 System.out.println("b1"); 22 if(y>3) 23 System.out.println("c1"); 24 else 25 System.out.println("d1"); 26 27 } 28 } 29 /* 30 if(条件表达式){ 31 执行语句; 32 } 33 else if(条件表达式){ 34 执行语句; 35 } 36 ...... 37 else{ 38 执行语句; 39 } 40 */
小测试：
1 //根据用户指定的具体数据，判断对应的日期 2 class IfTest 3 { 4 public static void main(String[] args) 5 { 6 int week=6; 7 if (week==1) 8 { 9 System.out.println("星期一"); 10 } 11 else if (week==2) 12 { 13 System.out.println("星期二"); 14 } 15 else if (week==3) 16 { 17 System.out.println("星期三"); 18 } 19 else if (week==4) 20 { 21 System.out.println("星期四"); 22 } 23 else if (week==5) 24 { 25 System.out.println("星期五"); 26 } 27 else 28 { 29 System.out.println("周末"); 30 } 31 } 32 }
1 /* 2 春季：3 4 5 3 夏季：6 7 8 4 秋季：9 10 11 5 冬季：12 1 2 6 */ 7 8 class IfTest2 9 { 10 public static void main(String[] args) 11 { 12 int month=19; 13 if (month<1 || month>12)//短路与运算 一边为T则为T 14 { 15 System.out.println(month+"数字没有对应的月份"); 16 } 17 else if (month>=3 && month<=5) 18 { 19 System.out.println(month+"月是春季【3 4 5】"); 20 } 21 else if (month>=6 && month<=8) 22 { 23 System.out.println(month+"月是夏季【6 7 8】"); 24 } 25 else if (month>=9 && month<=11) 26 { 27 System.out.println(month+"月是秋季【9 10 11】"); 28 } 29 else 30 { 31 System.out.println(month+"月是冬季【12 1 2】"); 32 } 33 } 34 }
1.6.2 选择结构
switch语句特点：
a,switch语句选择的类型只有四种：byte、short、int、char。
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
Example
1 class SwitchDemo 2 { 3 public static void main(String[] args) 4 { 5 int x=3; 6 switch (x)//byte,short,int,char 7 { 8 case 4: 9 System.out.println("a"); 10 break; 11 case 3: 12 System.out.println("b"); 13 break; 14 default: 15 System.out.println("d"); 16 } 17 ///////////////////////////////////////////// 18 //switch char类型演示 19 int a=3,b=9; 20 char opr=‘+‘; 21 switch (opr) 22 { 23 case ‘+‘: 24 System.out.println(a+b); 25 break; 26 case ‘-‘: 27 System.out.println(a-b); 28 break; 29 case ‘*‘: 30 System.out.println(+a*b); 31 break; 32 case ‘/‘: 33 System.out.println(a/b); 34 break; 35 default: 36 System.out.println("此功能为开发！！！"); 37 } 38 } 39 } 40 /* 41 switch(表达式) 42 { 43 case 取值1: 44 执行语句; 45 break; 46 case 取值2: 47 执行语句; 48 break; 49 ...... 50 default: 51 执行语句; 52 break; 53 } 54 */
小测试：
1 class SwitchTest 2 { 3 public static void main(String[] args) 4 { 5 //用户输入数据对应的星期 6 int week=1; 7 switch (week) 8 { 9 case 1: 10 System.out.println("星期一"); 11 break; 12 case 2: 13 System.out.println("星期二"); 14 break; 15 //以此类推 16 } 17 18 ////////////////////////////////// 19 20 int month=8; 21 switch (month) 22 { 23 case 3: 24 case 4: 25 case 5: 26 System.out.println(month+"月是春季"); 27 break; 28 case 6: 29 case 7: 30 case 8: 31 System.out.println(month+"月是夏季"); 32 break; 33 case 9: 34 case 10: 35 case 11: 36 System.out.println(month+"月是秋季"); 37 break; 38 case 12: 39 case 1: 40 case 2: 41 System.out.println(month+"月是冬季"); 42 break; 43 default: 44 System.out.println(month+"月无对应的季节！！！"); 45 } 46 } 47 }
if语句和switch区别：
1 class IfAndSwitch 2 { 3 public static void main(String[] args) 4 { 5 System.out.println("Hello World!"); 6 } 7 } 8 /* 9 if switch的应用： 10 11 if： 12 1、对具体的值进行判断； 13 2、对区间判断； 14 3、对运算结果是boolean类型的表达式进行判断； 15 switch： 16 1、对具体值进行判断； 17 2、值的个数通常固定的； 18 3、对于几个固定值得判断，使用switch语句，switch将具体的值加载内存，效率相对高； 19 20 */
1.6.3 循环结构
格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；(循环体)
}
注：
a,for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
c,最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
Example
1 class WhileDemo 2 { 3 public static void main(String[] args) 4 { 5 int x=1; 6 while(x<=3) 7 { 8 System.out.println("x="+x); 9 x++; 10 } 11 } 12 } 13 /* 14 while(条件表达式) 15 { 16 执行语句; 17 } 18 */
1 class WhileTest 2 { 3 public static void main(String[] args) 4 { 5 //获取1-100之和 6 int i=1,s=0; 7 while(i<=100) 8 { 9 s=s+i; 10 i++; 11 } 12 System.out.println("sum="+s); 13 14 //能被2整除的数之和 15 int x=1,sum=0; 16 while (x<=10) 17 { 18 if(x%2==0) 19 sum=sum+x; 20 x++; 21 } 22 System.out.println("sum="+sum); 23 } 24 }
1 class WhileTest2 2 { 3 public static void main(String[] args) 4 { 5 int i=1; 6 int count=0;//定义累加个数 7 while(i<=100) 8 { 9 //判断i%6是否等于0，T，count++，i++ 10 if(i%6==0) 11 count++;//累加器 12 i++; 13 } 14 System.out.println("count="+count); 15 } 16 } 17 //1~100之间6的倍数出现次数
1 class DoWhileDemo 2 { 3 public static void main(String[] args) 4 { 5 int x=1; 6 do 7 { 8 System.out.println("x="+x); 9 x++; 10 }while(x<1); 11 12 int y=1; 13 while(y<1) 14 { 15 System.out.println("y="+y); 16 y++; 17 } 18 } 19 } 20 /* 21 do 22 { 23 执行语句; 24 }while(条件表达式); 25 */ 26 27 //do while特点：无论条件是否满足，循环体至少执行一次;
1 class ForDemo 2 { 3 public static void main(String[] args) 4 { 5 int s=0; 6 for (int i=0;i<=100;i++ ) 7 { 8 s=s+i; 9 } 10 System.out.println("s="+s); 11 12 //for 循环图解 13 int x=1; 14 for (System.out.println("a");x<3;System.out.println("c")) 15 { 16 System.out.println("d"); 17 x++; 18 } 19 //a d c d c 20 } 21 } 22 /* 23 for(初始化表达式;循环条件;循环后的表达式) 24 { 25 执行语句;(循环体) 26 } 27 */
1 class ForTest 2 { 3 public static void main(String[] args) 4 { 5 //for 完成累加 6 int s=0; 7 for (int i=1;i<=100;i++) 8 { 9 s=s+i; 10 } 11 System.out.println("s="+s); 12 13 /* 14 for和while特点： 15 1、for和while可以互换； 16 2、格式上的不同，在使用上有点区别 17 若需要通过变量来对循环进行控制，改变量作为循环增量存在时，区别就体现了。 18 19 */ 20 int x=1; 21 while (x<=5) 22 { 23 System.out.println("x="+x); 24 x++; 25 } 26 System.out.println("x==>"+x);//while循环体外 27 28 //----------------------------------------// 29 for (int y=1;y<=5;y++) 30 { 31 System.out.println("y="+y); 32 } 33 // System.out.println("y==>"+y);//for循环体外,y离开作用域，报错 34 } 35 } 36 //无限循环最简单的形式 37 // while (){} 38 // for (; ; ){} 39 40 //什么时候使用循环结构？ 41 /* 42 1、当对某些代码执行很多次，使用循环结构； 43 2、当对一个条件进行一次判断，if语句 44 3、当对一个条件进行多次判断，while语句 45 46 注：1、在使用循环时，明确哪些语句需要参与循环，哪些不需要； 47 2、循环通常情况下，需要定义条件，需要控制次数； 48 49 50 */
For循环的嵌套：
Example
1 class ForForDemo 2 { 3 public static void main(String[] args) 4 { 5 /*for (int x=0;x<3;x++ ) 6 { 7 for (int y=0;y<4;y++ ) 8 { 9 System.out.println("ok"); 10 } 11 }*/ 12 13 /* 14 ***** 15 ***** 16 ***** 17 ***** 18 */ 19 for (int i=0;i<4;i++)//外循环控制行数 20 { 21 for (int j=0;j<5;j++)//内循环控制列数（每一行的个数） 22 { 23 System.out.print("*"); 24 } 25 System.out.println(""); 26 } 27 } 28 }
1 class ForForTest2 2 { 3 public static void main(String[] args) 4 { 5 //99乘法表 6 for (int i=1;i<=9;i++) 7 { 8 for (int j=1;j<=i;j++) 9 { 10 System.out.print(i+"*"+j+"="+i*j+"\t");// /t转义字符 制表符 11 } 12 System.out.println(""); 13 } 14 } 15 } 16 /* 17 \n:回车 18 \t:制表符 19 \b:退格 20 \r:按下回车键 21 22 windows中回车符由两个符号组成 \r\n 23 linux中回车符：\n 24 */
1 class ForForTest3 2 { 3 public static void main(String[] args) 4 { 5 /* 6 * * * * * 7 -* * * * 8 --* * * 9 ---* * 10 ----* 11 */ 12 for (int x=1;x<=5;x++) 13 { 14 for (int y=1;y<=x;y++) 15 { 16 System.out.print(" "); 17 } 18 for (int z=x;z<=5;z++) 19 { 20 System.out.print("* "); 21 } 22 System.out.println(""); 23 } 24 } 25 }
1.6.1其他控制语句
break(跳出)， continue(继续)
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注：
a,这两个语句离开应用范围，存在是没有意义的。
b,这个两个语句单独存在下面都不可以有语句，因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现，可以让这两个语句作用于指定的范围。
Example
1 class BreakContinueDemo 2 { 3 public static void main(String[] args) 4 { 5 /* 6 break:跳出； 7 break作用范围：switch 或者循环语句； 8 当break语句单独存在时，下面不要定义其他语句，因为执行不到； 9 10 for (int x=0;x<3;x++) 11 { 12 break; 13 System.out.println("x="+x); 14 } 15 */ 16 17 out:for (int x=0;x<3;x++) 18 { 19 inner:for (int y=0;y<4;y++) 20 { 21 System.out.println("x="+x); 22 break out;//循环标识,跳出指定的循环； 23 } 24 } 25 26 27 System.out.println("===================="); 28 29 /* 30 continue:继续; 31 作用范围：循环结构; 32 continue：结束本次循环，执行下次循环; 33 当continue语句单独存在时，下面不要定义其他语句，因为执行不到; 34 */ 35 for (int i=0;i<11;i++) 36 { 37 if (i%2==0) 38 continue; 39 System.out.println("i="+i); 40 } 41 } 42 }
1.7 函数
什么是函数？
/>函数定义在类中的具有特定功能的一段独立的小程序。
/>函数也称为方法。
函数的格式：
修饰符 返回函数类型 函数名(参数类型 形式参数1,参数类型 形式参数2, ...)
{
执行语句;
return 返回值;
}
>>返回值类型:函数运行后的结果数据类型；
>>参数类型：形式参数的数据类型；
>>实际参数：传递给形式参数的具体数值；
>>return ：用于结束函数
>>返回值：函数运算后的结果，该结果返回给调用者；
Example
1 //方法的简单应用 2 class FunctionDemo 3 { 4 public static void main(String[] args) 5 { //调用函数add 6 int temp=add(3,4); 7 } 8 //定义函数add 9 static int add(int a,int b) 10 { 11 return a+b; 12 } 13 }
函数特点：
a.将功能代码进行封装
b.提高了代码的复用性
细节： a,对于函数没有具体的返回值，返回值类型用关键字：void表示；return语句也可省略不写。
b,函数中只能调用函数，不可以在函数内部定义函数。
1 //格式错误：方法(函数)内部不能定义其他方法(函数) 2 class err 3 { 4 public static void main(String[]args) 5 { 6 static void sop() 7 { 8 System.out.println("Hello World!"); 9 } 10 sop(); 11 } 12 }
c,定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的重载：
同一个类中，允许存在一个以上的同名函数，他们的参数个数或者参数类型不同即可。
满足条件：
1，方法名相同
2，参数个数或参数类型不同
重载的特点：重载与返回类型无关，跟参数列表
重载示例：
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}
Example
1 //函数的重载 2 class FunctionDemo2 3 { 4 public static void main(String[] args) 5 { 6 int temp=add(3,2); 7 double temp2=add(3.6,3.1); 8 int temp3=add(3,6,9); 9 System.out.println("temp="+temp); 10 System.out.println("temp2="+temp2); 11 System.out.println("temp3="+temp3); 12 System.out.println("/----------------------- sop乘法表 -----------------------/"); 13 sop99(); 14 System.out.println("/----------------------- sop乘法表指定num -----------------------/"); 15 sop99(6); 16 } 17 //两个整数的加法运算 18 public static int add(int a,int b) 19 { 20 return a+b; 21 } 22 //两个小数之和 23 public static double add(double a,double b) 24 { 25 return a+b; 26 } 27 //三个整数之和 28 public static int add(int a,int b,int c) 29 { 30 // return a+b+c; 31 return add(a,b)+c;//重载a+b函数功能省略，return a+b+c;语句，提高代码复用性 32 } 33 34 //定义两个功能：打印标准乘法表；打印指定的乘法表 35 //标准乘法表 36 public static void sop99() 37 {/* 38 for (int i=1;i<=9;i++) 39 { 40 for (int j=1;j<=i;j++) 41 { 42 System.out.print(j+"*"+i+"="+j*i+"\t"); 43 } 44 System.out.println(""); 45 }*/ 46 47 sop99(9);//重载下面的代码，提高复用性 48 } 49 50 //打印指定乘法表:传入相关的num值 51 public static void sop99(int num) 52 { 53 for (int i=1;i<=num;i++) 54 { 55 for (int j=1;j<=i;j++) 56 { 57 System.out.print(j+"*"+i+"="+j*i+"\t"); 58 } 59 System.out.println(""); 60 } 61 } 62 } 63 /* 64 函数的重载 65 1,同一个类 66 2，同名 67 3，参数个数不同，参数类型不同 68 4,函数的重载和返回值类型无关 69 */
1.8 数组
1.8.1 数组的定义
概念：同一种类型数据集合。可理解为容器；数组都是从0开始编号
数组格式1：ArrayDemo
1 //数组定义格式1 2 class ArrayDemo 3 { 4 public static void main(String[] args) 5 { 6 //元素类型[] 数组名 = new 元素类型 [元素个数或数组长度]; 7 int[] arr=new int[5];//定义int类型数组，长度为5；[0-4] 8 arr[0]=12;//为数组第一个角标赋值12 9 System.out.println("arr[0]="+arr[0]);//打印0角标的数组元素 10 } 11 }
数组格式2：ArrayDemo3
1 //数组格式2 2 class ArrayDemo3 3 { 4 public static void main(String[] args) 5 { 6 //格式1 />需要容器，不明确具体数据 7 //元素类型[] 数组名 = new 元素类型 [元素个数或数组长度]; 8 int []arr=new int [3]; 9 10 //格式2 />需要容器，存储已知的具体数据 11 //元素类型[] 数组名= new 元素类型[]{元素1,元素2, ...}; 12 int []arr =new int [] {12,34,5,4,6};//常规初始化 13 int []arr={12,34,5,35,6};//静态初始化 14 } 15 }
1.8.2数组的内存分配及特点
数组的内存结构
内存的划分：
1/>寄存器
2/>本地方法区
3/>方法区
4/>栈内存
存储的都是局部变量(定义在方法中变量);且变量所属的作用域结束，变量自动释放；
for(int x=0;x<=3;x++){}
System.out.println("x="+x);//执行不到，x值被释放
5/>堆内存
存储是数组和对象(数组就是对象，new建立的都在堆内存中);
特点：
1,每一个实体都有首地址值;
2,堆内存中的每一个变量都有默认初始化值，类型不同而不同；
整数/>0;小数/>0.0或0.0f;boolean/>false;char/>‘\u0000‘
3,垃圾回收机制;
1.8.3数组操作常见问题
1 //数组常见错误问题 2 class ArrayDemo2 3 { 4 public static void main(String[] args) 5 { 6 int []arr=new int[3]; 7 System.out.println(arr[3]);//ArrayIndexOutOfBoundsException 8 //当访问到数组中不存在的角标时：角标越界 9 10 arr=null; 11 System.out.println(arr[0]);//NullPointerException 12 //当引用型变量没有任何实体指向时，继续指向实体，发生空指针异常 13 14 System.out.println(arr);//[I@3219ab8d:哈希值 15 } 16 }
1.8.4 数组操作[遍历、求最值、排序、查找]
数组的遍历:
1 //数组遍历 2 class ArrayDemo3 3 { 4 public static void main(String[] args) 5 { 6 //对数组操作最基本的动作：存和取;核心思想：对角标的操作 7 //数组的遍历 8 int []arr={12,3,15,57,548,123}; 9 System.out.println("length:"+arr.length);//数组长度 10 for (int x=0;x<=arr.length-1;x++) 11 System.out.println("arr ["+x+"] ="+arr[x]); 12 13 System.out.println(""); 14 15 System.out.println("==/反向遍历/=="); 16 for (int x=arr.length-1;x>=0;x--) 17 System.out.println("arr ["+x+"] ="+arr[x]); 18 } 19 }
数组的最值:
1 //数组的最值 2 class ArrayDemo4 3 { 4 public static void main(String[] args) 5 { 6 int []arr={-123,-1,-53,-62,-23,-32}; 7 int max=getMax(arr);//调用最值函数 8 System.out.println("max="+max); 9 10 } 11 //获取最值函数（元素比较） 12 public static int getMax(int []arr) 13 { 14 //定义变量记录较大值 15 // int maxElement=0; //直接用max初始化0；全是负数求最值则取不到max 16 int maxElement=arr[0]; 17 for (int x=1; x<arr.length;x++ ) 18 { 19 if(arr[x]>maxElement) 20 maxElement=arr[x]; 21 } 22 return maxElement; 23 } 24 25 //角标比较 26 public static int getMax_2(int []arr) 27 { 28 int maxIndex=0; 29 for (int x=1; x<arr.length;x++ ) 30 { 31 if(arr[x]>arr[maxIndex]) 32 maxIndex=x; 33 } 34 return arr[maxIndex]; 35 } 36 } 37 /* 38 1，定义变量记录每次比较后较大的值 39 2，数组进行遍历取出，和变量中记录的元素进行比较，若变量的元素大于变量中记录的元素，就用该变量记住该值； 40 3，遍历结果，该变量记录就是max 41 */
数组的排序[选择排序]
1 //选择排序 2 class ArrayDemo5 3 { 4 //遍历数组功能sopArray 5 public static void sopArray(int []arr) 6 { 7 System.out.print("["); 8 for (int x=0;x<arr.length ;x++) 9 { 10 //判断最后是否为最后一个数组，T=>" 、" 11 if (x!=arr.length-1) 12 { 13 System.out.print(arr[x]+"、"); 14 }else 15 { 16 System.out.println(arr[x]+"]"); 17 } 18 } 19 } 20 21 public static void main(String[] args) 22 { 23 int []arr={34,19,11,109,3,56}; 24 //调用功能 25 sopArray(arr); 26 selectSort(arr); 27 sopArray(arr); 28 29 } 30 31 //selectSort功能 32 public static void selectSort(int[] arr) 33 { 34 for (int x=0;x<arr.length-1;x++) 35 { 36 for (int y=x+1;y<arr.length;y++) 37 { 38 if (arr[x]>arr[y]) 39 { 40 //位置置换 41 int temp=arr[x]; 42 arr[x]=arr[y]; 43 arr[y]=temp; 44 } 45 } 46 } 47 } 48 }
数组的排序[冒泡排序]
1 class ArrayDemo6 2 { 3 //遍历数组 4 public static void sop(int [] arr) 5 { 6 for (int x=0;x<arr.length;x++ ) 7 { 8 System.out.print(arr[x]+" "); 9 } 10 System.out.println(""); 11 } 12 13 public static void main(String[] args) 14 { 15 int arr[]={34,19,11,109,3,56}; 16 sop(arr); 17 bubbleSort(arr); 18 sop(arr); 19 20 } 21 //bubbleSort 22 public static void bubbleSort(int [] arr) 23 { 24 for (int x=0;x<arr.length-1;x++) 25 { 26 for (int y=0;y<arr.length-1-x;y++ ) 27 { 28 if (arr[y]>arr[y+1]) 29 { 30 int temp=arr[y]; 31 arr[y]=arr[y+1]; 32 arr[y+1]=temp; 33 } 34 } 35 } 36 } 37 }
数组的排序[Arrays.sort()]
1 //导入Java包 2 import java.util.*; 3 class Temp 4 { 5 //遍历数组 6 public static void sop(int [] arr) 7 { 8 for (int x=0;x<arr.length;x++ ) 9 { 10 System.out.print(arr[x]+" "); 11 } 12 System.out.println(""); 13 } 14 15 public static void main(String[] args) 16 { 17 int arr[]={34,19,11,109,3,56}; 18 sop(arr); 19 //导入Java自身的排序函数 20 Arrays.sort(arr); 21 sop(arr); 22 } 23 }
数组[置换代码抽取封装]
1 //[排序位置 置换代码抽取] 2 class ArrayDemo7 3 { 4 //遍历数组 5 public static void sop(int [] arr) 6 { 7 for (int x=0;x<arr.length;x++ ) 8 { 9 System.out.print(arr[x]+" "); 10 } 11 System.out.println(""); 12 } 13 14 public static void main(String[] args) 15 { 16 int arr[]={34,19,11,109,3,56}; 17 System.out.print("排序前:"); 18 sop(arr); 19 bubbleSort(arr); 20 // selectSort(arr); 21 System.out.print("排序后:"); 22 sop(arr); 23 24 } 25 //定义置换功能 [排序位置 置换代码抽取] 26 /* 27 int temp=arr[y]; 28 arr[y]=arr[y+1]; 29 arr[y+1]=temp; 30 31 //位置置换 32 int temp=arr[x]; 33 arr[x]=arr[y]; 34 arr[y]=temp; 35 */ 36 37 //抽取置换代码 定义置换功能swap 38 public static void swap(int[] arr,int a,int b) 39 { 40 int temp=arr[a]; 41 arr[a]=arr[b]; 42 arr[b]=temp; 43 } 44 45 //bubbleSort 46 public static void bubbleSort(int [] arr) 47 { 48 for (int x=0;x<arr.length-1;x++) 49 { 50 for (int y=0;y<arr.length-1-x;y++ ) 51 { 52 if (arr[y]>arr[y+1]) 53 { 54 //传入相关的变量 55 swap(arr,y,y+1); 56 /* 57 int temp=arr[y]; 58 arr[y]=arr[y+1]; 59 arr[y+1]=temp; 60 */ 61 } 62 } 63 } 64 } 65 66 67 //selectSort功能 68 public static void selectSort(int[] arr) 69 { 70 for (int x=0;x<arr.length-1;x++) 71 { 72 for (int y=x+1;y<arr.length;y++) 73 { 74 if (arr[x]>arr[y]) 75 { 76 swap(arr,x,y); 77 /* 78 //位置置换 79 int temp=arr[x]; 80 arr[x]=arr[y]; 81 arr[y]=temp; 82 */ 83 } 84 } 85 } 86 } 87 }
数组简单查找
1 //基本数组的查找 2 class ArrayDemo8 3 { 4 public static void main(String[] args) 5 { 6 //*[arr中有两个相同的元素，按照第一个出现的位置元素找] 7 int arr[]={12,2,45,25,62,5,2,6}; 8 int index=getIndex(arr,2); 9 System.out.println("incex="+index); 10 } 11 12 //getIndex找角标 13 public static int getIndex(int [] arr,int key) 14 { 15 for (int x=0;x<arr.length;x++ ) 16 { 17 if (arr[x]==key) 18 { 19 return x; 20 } 21 } 22 return -1; 23 } 24 }
二维数组
1 //二维数组定义格式 2 class Array2Demo 3 { 4 public static void main(String[] args) 5 { 6 // int [][]arr=new int[3][2]; 7 // System.out.println(arr);//直接打印二维数组(哈希值) 8 // System.out.println(arr[0]);//打印二维数组中角标0的一维数组(哈希值) 9 // System.out.println(arr[0][0]);//打印二维数组中角标0的一维数组中角标为0的元素 10 // System.out.println("length:"+arr.length);//二维数组的长度就是一维数组的个数 11 12 //二维数组的第二种格式 13 int [][] arr={{3,1,2},{6,3,2,1},{2,4}}; 14 //二维数组的遍历 15 int sum=0; 16 for (int x=0;x<arr.length;x++) 17 { 18 for (int y=0;y<arr[x].length;y++) 19 { 20 sum+=arr[x][y]; 21 // System.out.print(arr[x][y]+" "); 22 } 23 } 24 System.out.println("sum="+sum); 25 } 26 }
标签：red 了解 栈内存 解析 很多 数学 逻辑运算 led 简写
原文地址：https://www.cnblogs.com/cao-yin/p/8710412.html
