1. static final double PI=3.14;//使用常量时记得声明变量类型和变量名大写；

  2. 进制 二进制0b 十进制 八进制0 十六进制0x 所有的字符本质还是数字;

    位运算符 & | ^ ~
    * A = 0011 1100
    * B = 0000 1101
    *----------------------------
    * A&B = 0000 1100 & : 都为1才为1，否则为0
    * A|B = 0011 1101 | : 都为0才为0，否则为1
    * A^B = 0011 0001 ^ : 两个相同则为0，否则为1异或运算符
    * ~B =1111 0010 ~ : 与B相反
    *
    * 效率极高！！！！
    * << *2 左移位符 逢二进一
    * >> /2 右移位符

    
编码 Unicode 表：(97=a  65=A)  2字节   0-65536
    •  float 有限  离散  舍入误差  大约  接近但不等于*      所以，最好避免使用浮点数进行比较*/
float f=0.1f; //0.1
double d=1.0/10; //0.1
System.out.println(f==d); //falsefloat d1=235626532f;
float d2=d1+1;
System.out.println(d1==d2);  //true&&&&

      char c=‘a’;
      int d=c+1;
      System.out.println(d);// 98
      System.out.println((char)d);// b

    //String字符串在前时，后面的数会当成字符串拼接
    System.out.println(""+a+b); //1020
    System.out.println(a+b+""); //30

  3. 养成良好习惯，shift+ctrl+F对eclipse的代码进行格式化，换行用tap健和上下左右键【尽量避免反复空格】，养成建包的好习惯。

  4. 笔记本程序开发四步走；(建立工程；手动编写Java文件；javac命令将Java文件编译为.class字节码文件；java命令运行字节码文件)

  5. 集成开发环境是指程序开发环境和程序调试环境在一起；main方法不是关键字，main()方法是Java程序的入口点；main()方法的四要素包含public,static ,String[]args,void四要素都是关键字

  6. String不是关键字，是个final类。short不常用也是八大基本类型之一，String不在包含内。

  7. 变量名不可以用大写字母，数字，开头；可以用$下划线开头；变量名称中不可以包含%#等特殊字符；[Java标识符不一定是变量，可以首字母大写，例如类名，工程名]标识符：

  8. Boolean是1位 ，

  9. typora位置英文模式下esc键下面 的数字；三个和语言类型可以建立特定语言的代码块；ctrl+w关闭文档 ；ctrl+shift+esc打开任务管理器；ctrl+shift+delete进行电脑强制重启

  10. JAVA Error occurred during initialization of VM

在VM初始化期间发生JAVA错误

虚拟机内存不够，可能是因为控制台的小红方格子一直没有关闭，因为手动的所以必须要关闭

  1. switch 结构必须要有switch和case；不一定要有default和break，贯穿性！判断条件类型有

    byte，short ,int ,String ,enum ,char,不包含float，double；

  2. 随机数强制转换： int discount=(int)(Math.random*9+1); 折扣1-9折； int强制类型转换时应该作为一个整体，否则编译错误

    在Java中，下面代码的输出结果为（ ）
public static void main(String[] args) {int x=2;double y=2.5;System.out.println(int(x+y));
}
//输出语句中int(x+y)应为（int）(x+y)，    输出结果不是4

  3. for循环 初始化（迭代变量）；循环条件；循环体；迭代部分【后进行判断是否再次进入循环条件，循环体】

  4. continue 跳出本次循环；继续下次循环；break结束当前内层循环；return相当于flag=false,不再继续往结构单元代码块下走。flag在判断数组中是否含有某数，或删除某个元素时使用，一组数中是否包含某数；

    package test0909;
//
public class DoubleCycle {
public static void main(String[] args) {int  i,j,x=0;for (i=0;i<2;i++){x++;              //第一次x=1;for(j=0;j<=3;j++ ){//内部循环走完之后才走外部， 出现continue当前for循环不往下走，/**j=0,2跳过，j=1,3 时，for循环每次加1；所以此时for内结束循环+2 ，然后x=3;** */if(j%2 == 0) continue;x++;}x++;//for结束加1，第一次结果 x=4; 因为两次循环所以最终结果为8} System.out.println(x);}
}

  5. 使用数组原因：当用变量存储数据时，存储大量数据不能满足需求，所以需要用到数组，但必须保证变量类型相同；使用循环原因是许多相似代码冗余，；

  6. 三个数或两个数要求换位置从小到大顺序，借助中间量temp进行交换；实现数字反转while（while num!=0）{int mod=num%10//个位上的余数；十位到万位的数字依次 num/=10;}顺序输出mod就可以了；

  7. continue本次循环跳过，比如求不含七的倍数一定范围的数；

  8. 有百分号时求比例必须先乘后除--------------比例为"+count*100/4+"%"

  9. 旧数组中剔除元素后获得新数组，先遍历旧数组元素，判断新数组元素个数（新数组长度），剔除元素符合条件的开始计数count；然后声明并给新数组开辟空间，元素个数刚才count已求出，必须是获得个数后才建立数组，否则下标越界， int newArr[]=new int[count];

    package test0909;
/***现在有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; *要求将以上数组中的0项去掉，将不为0的值存入一个新的数组，*生成新的数组为 int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}* */
public class DelZero {public static void main(String[] args) {int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};int count=0;//新数组中的元素个数,旧数组中不为0的个数；新数组长度int index=0;//新数组的每个元素的下标//遍历旧数组中所有元素，获得新数组长度，for (int i = 0; i < oldArr.length; i++) {if (oldArr[i]!=0) {count++;}}int newArr[]=new int[count];//声明并给新数组开辟空间；此时已经获得了新数组的数组长度；for (int i = 0; i < oldArr.length; i++) {if (oldArr[i]!=0) {newArr[index]=oldArr[i];//旧数组中符合新数组中元素进行赋值index++;}}for (int i = 0; i < newArr.length; i++) {System.out.print(newArr[i]+"  \t ");}}}

    16.当经过多长时间会超过，连续迭代时用while（变量名<额度）；

    17.代码尽量不要引入过多变量，尽量自增；如

    pay=money*0.75;直接写money*=0.75;

    18.注释时斜杠向左；换行符和制表符（可以多出来一个空格）的斜杠向右，也叫反斜杠；

    19.break后不能有任何代码，括号要成对出现，当if后只有一句语句时可以省略大括号，切记代码规范要有缩进

    20。path带有bin;classpath指具体类所在目录；java中环境的配置。classpath和path，从字面上来看，classpath比path多了一个class，即是’类’的意思，所以，classpath配置的是类的路径，path配置的是包或者二进制文件夹的路径。比如配置JDK的时候，classpath配置指向具体的JAR文件(rt.jar\tools.jar)，在path中，指向的是jdk\bin的路径 path环境变量里面记录的是可执行性文件，如.exe文件，对可执行文件先在当前路径去找，如果没找到就去path环境变量中配置的路径去找classpath环境变量里记录的是java类的运行文件所在的目录

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RNUh56Tx-1599838307355)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599647036638.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eYfIVyu9-1599838307357)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599646796599.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EfcrCxve-1599838307359)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599625271324.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wkxx3GWU-1599838307360)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599625682536.png)]

1变量、运算符和类型转换

1.1手动输入一个学生的成绩，对这个成绩进行一次加分，加当前成绩的20%，输出加分后成绩

package test0908;
/**手动输入一个学生的成绩，对这个成绩进行一次加分，加当前成绩的20%，输出加分后成绩* */
import java.util.Scanner;public class Score {public static void main(String[] args) {Scanner input=new Scanner(System.in);System.out.println("请输入一个整数");int score=input.nextInt();score+=0.2*score;System.out.println(score);
}
}

1.2商场举行店庆，抽几折打几折， 先手动输入消费金额，再输入，抽到的折扣，计算出折后价格

package test0908;
/*** 商场举行店庆，抽几折打几折， 先手动输入消费金额，再输入，抽到的折扣，计算出折后价格* */
import java.util.Scanner;public class Price {public static void main(String[] args) {Scanner input=new Scanner(System.in);System.out.println("请输入一个金额");double price=input.nextInt();//System.out.println("请输入一个折扣");//int discount=input.nextInt();int discount =(int)(Math.random()*10+1);//随机数生成System.out.println(price*discount*0.1);}

1.3手动输入一个4位数，求各位数字之和

package test0908;import java.util.Scanner;
//.手动输入一个4位数，求各位数字之和
public class NumSum {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("输入一个四位数");int num=sc.nextInt();int ge=num%10;//个位数字int shi=num/100%10;//十位数字int bai=num/10%10;//百位数字int qian=num/1000;//千位int sum=ge+shi+bai+qian;System.out.println("数字之和为："+sum);
}
}

2分支结构

2.1商场消费返利活动，手动输入顾客消费金额， 如果金额打8折后仍然满1000元，用户就获得200元代金券一张（不考虑多张）

package test0908;import java.util.Scanner;//1商场消费返利活动，手动输入顾客消费金额， 如果金额打8折后仍然满1000元，用户就获得200元代金券一张（不考虑多张
public class Voucher {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("输入消费金额");double money=sc.nextDouble();money*=0.8;if (money>1000) {money-=200;System.out.print("恭喜获得200代金券");}else {System.out.print("谢谢惠顾");}System.out.println(",应支付"+money+"元");
}
}

2.2用户输入一个年份，如果是闰年输出是闰年 （年份能被4整除，且不能被100整除，或者能被400整除的年份）

package test0908;
//用户输入一个年份，如果是闰年输出是闰年 （年份能被4整除，且不能被100整除，或者能被400整除的年份
import java.util.Scanner;public class LeapYear {public static void main(String[] args) {Scanner input=new Scanner(System.in);System.out.println("输入年份");int year=input.nextInt();if ((year%4==0&&year%100!=0)||year%400==0) {System.out.println("该年是闰年");}else {System.out.println("平年");}
}
}

2.3手动输入一个整型会员号， 如果用户输入的是4位数字， 输出登录成功， 如果用户输入的不是4位数字, 输出“您输入的会员号有误”

package test0908;import java.util.Scanner;//2.3手动输入一个整型会员号， 如果用户输入的是4位数字， 输出登录成功， 如果用户输入的不是4位数字, 输出“您输入的会员号有误”
public class CardNum {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("输入卡号");String cardnum=sc.next();if (cardnum.length()==4) {System.out.println("登录成功");}else {System.out.println("您输入的会员号有误");}
}
}

2.4手动输入a，b，c三个变量的数值， 要求通过数值交换， 把输入的数值从小到大 排序放入a,b,c中，并输出

ppackage test0908;import java.util.Scanner;
//2.4手动输入a，b，c三个变量的数值， 要求通过数值交换， 把输入的数值从小到大 排序放入a,b,c中，并输出
public class MaxNum {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("请输入a值");int a=sc.nextInt();System.out.println("请输入b值");int b=sc.nextInt();System.out.println("请输入c值");int c=sc.nextInt();int temp=0;//临时变量交换两数，如果不大于，不用交换；最后a的值确保最小（）if(a>b) {temp=b;b=a;a=temp;}if(a>c) {temp=c;c=a;a=temp;}if(b>c) {temp=c;c=b;b=temp;}System.out.println("顺序为"+a+","+b+","+c);
}
}

3多分支结构

3.1商场根据会员积分打折， 2000分以内打9折， 4000分以内打8折 8000分以内打7.5折， 8000分以上打7折， 使用if-else-if结构，实现手动输入购物金额和积分，计算出应缴金额

package test0908;import java.util.Scanner;//3.1商场根据会员积分打折， 2000分以内打9折， 4000分以内打8折 8000分以内打7.5折， 8000分以上打7折， 使用if-else-if结构，实现手动输入购物金额和积分，计算出应缴金额
public class RewardPoints {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("输入积分");int points=sc.nextInt();//积分double pay=0;//实际支出System.out.println("输入消费金额");double money=sc.nextDouble();if (points>8000) {pay=money*0.7;}else  if (points>4000) {pay=money*0.75;}else  if (points>2000) {pay=money*0.8;}else {pay=money*0.9;}System.out.println("应缴金额为"+pay+"元");
}
}

3.2机票价格按照淡季旺季、头等舱和经济舱收费、 输入机票原价、月份和头等舱或经济舱， 其中旺季（5-10月）头等舱9折，经济舱85折， 淡季（11月到来年4月）头等舱7折，经济舱65折， 最终输出机票价格

package test0908;import java.util.Scanner;//3.2机票价格按照淡季旺季、头等舱和经济舱收费、 输入机票原价、月份和头等舱或经济舱， 其中旺季（5-10月）头等舱9折，经济舱85折， 淡季（11月到来年4月）头等舱7折，经济舱65折， 最终输出机票价格
public class TicketPrice {public static void main(String[] args) {Scanner input =new Scanner(System.in);double ticketPrice;//实付金额，票原价System.out.println("输入机票原价");ticketPrice=input.nextDouble();System.out.println("输入月份");int month=input.nextInt();System.out.println("输入y请选择确定头等舱");String ans=input.next();if (ans.equals("y")) {if (5<=month&&month<=10) {ticketPrice*=0.9;}else {ticketPrice*=0.7;}}else {if (5<=month&&month<=10) {ticketPrice*=0.85;}else {ticketPrice*=0.65;}}System.out.println("机票价格为"+ticketPrice+"元");
}
}

3.3选择一个形状（1长方形、2正方形、3三角形、4圆形） 根据不同的选择让用户输入不同的信息， 长方形有长和宽、 正方形有边长、 三角形有底和高、 圆形有半径， 计算输出指定形状的面积

package test0908;import java.util.Scanner;//3.3选择一个形状（1长方形、2正方形、3三角形、4圆形） 根据不同的选择让用户输入不同的信息， 长方形有长和宽、 正方形有边长、 三角形有底和高、 圆形有半径， 计算输出指定形状的面积
public class FigureArea {public static void main(String[] args) {int a,b,c,l,h,r;//长方形的长；宽；正方形边长；三角形底；高；圆形半径；double PI=3.14;double squre=0;Scanner input=new Scanner(System.in);System.out.println("根据序号选择图形形状1长方形、2正方形、3三角形、4圆形，");int choice=input.nextInt();switch(choice) {case 1:System.out.println("请输入长");a=input.nextInt();System.out.println("请输入宽");b=input.nextInt();squre=a*b;break;case 2:System.out.println("请输入边长");c=input.nextInt();squre=c*c;break;case 3:System.out.println("请输入底");l=input.nextInt();System.out.println("请输入高");h=input.nextInt();squre=l*h/2;break;case 4:System.out.println("请输入半径");r=input.nextInt();squre=r*r*PI;break;}System.out.println("输出指定形状的面积"+squre);
}
}

3.4输入年份和月份，输出这个月应该有多少天（使用switch结构）

package test0908;import java.util.Scanner;//3.4输入年份和月份，输出这个月应该有多少天（使用switch结构）
public class FigureDays {public static void main(String[] args) {Scanner input=new Scanner(System.in);int days=0;System.out.println("输入年份");int year=input.nextInt();System.out.println("输入月份");int month=input.nextInt();switch(month) {case 1:case 3:case 5:case 7:case 8:case 10:case 12:days=31;break;case 4:case 6:case 9:case 11:days=30;break;case 2:if ((year%4==0&&year%100!=0)||year%400==0) {System.out.println("该年是闰年,");days=29;}else {System.out.println("平年,");days=28;}break;}System.out.println("这个月应有的天数是："+days);
}
}

4循环结构（上）

死循环，无限for循环
 for(;;){System.out.println("我就是这么帅，不服不行***");}

4.1随机生成一个1-100之间的数字num，循环让用户输入猜这个数， 如果用户输入的数字大于num提示输入的数字比较大， 如果用户输入的数字小于num提示输入的数字比较小， 直到用户输入的数字和num相等为止，然后输出用户猜数的总次数

package test0908;import java.util.Scanner;public class GuessNums {public static void main(String[] args) {Scanner sc=new Scanner(System.in);int num=(int)(Math.random()*100+1);//随机数int guess=0;//猜的数字int count=0;//猜的次数System.out.println("系统生成的随机数是"+num);//外挂显示随机数do {System.out.println("输入你猜的数");guess=sc.nextInt();if (guess>num) {System.out.println("输入的数字比较大");}else if(guess<num) {System.out.println("输入的数字比较小");}count++;}while(guess!=num);System.out.println(count);
}
}

4.2打印出1-100之间所有不是7的倍数和不包含7的数字，并求和

package test0908;
//4.2打印出1-100之间所有不是7的倍数和不包含7的数字，并求和
public class NumberMultiples {public static void main(String[] args) {int sum = 0;for (int i = 1; i <= 100; i++) {if(i%7 ==0 || i%10 == 7 || i/10 == 7){//注意：70-79容易漏掉，跳出xunhuancontinue;}sum += i;}System.out.println(sum);
}
}

4.3***循环输入5个数，输完后显示这些数中有没有负数***

package test0908;import java.util.Scanner;//4.3循环输入5个数，输完后显示这些数中有没有负数
public class ConfirmNegative {public static void main(String[] args) {Scanner sc=new Scanner(System.in);int i=1;//循环次数int flag=0;//标记符号,负数的个数while (i<=5) {System.out.println("请输入1个数字");int num=sc.nextInt();if(num<0) {flag=1;}i++;++flag;}//System.out.println(flag);
if (flag>0) {System.out.println("这些数中有负数");
}else {System.out.println("这些数中没有负数");
}
}
package test0908;
//boolean 类型和布尔一起判断
import java.util.Scanner;//4.3循环输入5个数，输完后显示这些数中有没有负数
public class ConfirmNegative {
public static void main(String[] args) {Scanner sc=new Scanner(System.in);int i=1;//循环次数boolean flag=false;//假设不含有负数；while (i<=5) {System.out.println("请输入1个数字");int num=sc.nextInt();if(num<0) {flag=true;}i++;}//System.out.println(flag);
if (flag) {System.out.println("这些数中有负数");
}else {System.out.println("这些数中没有负数");
}
}
}

5循环结构（下）

5.1有一个有钱的神经病，他往银行里存钱， 第一天存1元,以后每天比前一天多存50%，完成下列计算任务

1)他存到第几天，当天存的钱会超过10元

package test0908;import java.util.Iterator;
import java.util.Scanner;/**有一个有钱的神经病，他往银行里存钱， 第一天存1元,以后每天比前一天多存50%，完成下列计算任务
1)他存到第几天，当天存的钱会超过10元个月（30天）后，他总共存了多少钱** */
public class SaveMoney {public static void main(String[] args) {Scanner input = new Scanner(System.in);double money=1;int day=1;double sum=0;while(money<10) {sum+=money;money*=1.5;day++;System.out.println("day:"+day+",money:"+money);}System.out.println(sum+money);//最后一天已经超过10，不在sum中相加
}
}

2)一个月（30天）后，他总共存了多少钱

public class SaveMoney2 {public static void main(String[] args) {Scanner input = new Scanner(System.in);double money=1;int day=1;double sum=0;for (int i = 1; i <=30; i++) {sum+=money;money*=1.5;}System.out.println(sum);
}
}

5.2有一个400米一圈的操场，一个人要跑10000米， 第一圈50秒，其后每一圈都比前一圈慢1秒， 按照这个规则计算跑完10000米需要多少秒

package test0908;import java.util.Scanner;//#### 5.2有一个400米一圈的操场，一个人要跑10000米， 第一圈50秒，其后每一圈都比前一圈慢1秒， 按照这个规则计算跑完10000米需要多少秒public class RunCircle {public static void main(String[] args) {Scanner input = new Scanner(System.in);int count=10000/400;//圈数int time=50;int sum=0;for (int i = 1; i < count; i++) {//剩余跑49圈的时间time+=1;sum+=time;}sum+=50;//第一圈时间System.out.println(sum);
}
}

5.3用户输入任意一个整数，求各位数字之和

package test0908;import java.util.Scanner;/***户输入任意一个整数，求各位数字之和* */
public class NumSum2 {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.println("请输入一个整数 ");int num=input.nextInt();int sum=0;
while(num>0) {int mod=num%10;//10的余数，各位上数字累加sum+=mod;num/=10;//循环后余数分别获得十位，百位的数字，
}
System.out.println(sum);
}
}

5.4井里有一只蜗牛，他白天往上爬5米，晚上掉3.5米，井深56.7米 计算蜗牛需要多少天才能从井底到爬出来

package test0908;
/***5.4井里有一只蜗牛，他白天往上爬5米，晚上掉3.5米，井深56.7米
计算蜗牛需要多少天才能从井底到爬出来* */
public class ClimbWell {public static void main(String[] args) {int day=1;double sum=0;//爬过距离while (true) {sum+=5;//白天上System.out.print(day+"白天结束时上升了"+sum+"米   ");if (sum>56.7) {break;}sum-=3.5;//晚上下day++;}System.out.println();System.out.println(day);
}
}

6循环嵌套

乘法表

package test0909;public class MultiyTable {public static void main(String[] args) {for (int i = 1; i < 10; i++) {//外层圈数for (int j = 1; j <=i; j++) {System.out.print(j+"*"+i+"="+(i*j)+"\t");}System.out.println();}}
}

用for循环输出1-1000之间能被7整除的数，且每行输出五个。

  • public class Test6 {
public static void main(String[] args) {for (int i = 1; i <1000; i++) {if (i%7==0) {System.out.print(i+"\t");}//获得符合七倍数的条件；if (i%(5*7)==0) {//五个数一换行System.out.println();}}}}

6.1求1~1000以内质数列表 PS：质数是只能被1和自身整除的整数

package test0908;public class Prime {public static void main(String[] args) {int i,j;
for (i = 1; i <=1000; i++) {//数值范围for ( j= 2; j<i; j++) {//质数范围if (i%j==0) {//排除多余因子，fei质数break;}};if (i==j) {System.out.print(j+"  ");}
}
}
}

循环组合练习

package test0909;import java.util.Scanner;public class GameMenu {
public static void main(String[] args) {int choice=0;do {System.out.println(" 欢迎进入青鸟游戏迷你平台");Scanner input = new Scanner(System.in);System.out.println("请选择您喜欢的游戏：\n ");System.out.println(" *******************************************************");System.out.println("                      1.斗地主                          ");System.out.println("                      2.斗牛                            ");System.out.println("                      3.泡泡龙                          ");System.out.println("                      4.连连看                          ");System.out.println(" *******************************************************");choice =input.nextInt();switch (choice) {case 1:System.out.println("您已进入斗地主房间！");return;case 2:System.out.println("您已进入斗牛 房间！");return;case 3:System.out.println("您已进入泡泡龙  房间！");return;case 4:System.out.println("您已进入连连看房间！");return;case 0: exit();return;default:System.out.println("请选择正确的功能编号 ");break;}}while(choice!=0);}private static void exit() {System.out.println("您已选择退出游戏，欢迎下次再来 ");

package test0909;import java.util.Scanner;public class GameCoins {
public static void main(String[] args) {int money;
System.out.println(" 青鸟游戏迷你平台>游戏币支付");
Scanner input = new Scanner(System.in);
System.out.println("请选择游戏类型\n1.牌类\n2.休闲竞技类 ");
int choice=input.nextInt();
System.out.println("请输入游戏时长 ");
int hours=input.nextInt();
switch (choice) {
case 1:if (hours>10) {money=hours*10*5/10;System.out.println(" 您玩的是牌类游戏，时长是"+hours+"小时,可以享受五折优惠，总共需要"+money+"个游戏币");}else {money=hours*10*8/10;System.out.println(" 您玩的是牌类游戏，时长是"+hours+"小时,可以享受八折优惠，总共需要"+money+"个游戏币");}break;case 2:if (hours>10) {money=hours*20*5/10;System.out.println(" 您玩的是竞技类游戏，时长是"+hours+"小时,可以享受五折优惠，总共需要"+money+"个游戏币");}else {money=hours*20*8/10;System.out.println(" 您玩的是竞技类游戏，时长是"+hours+"小时,可以享受八折优惠，总共需要"+money+"个游戏币");}break;
}}
}

————————————————————————————————————————————————————————————

package test0909;import java.util.Scanner;public class GamePoints {public static void main(String[] args) {int money;System.out.println(" 青鸟游戏迷你平台>游戏点击率");Scanner input = new Scanner(System.in);int count=0;//点击率大于100的数目；for (int i =1; i <=4; i++) {System.out.println("请输入第 "+i+"个游戏的点击率");int points=input.nextInt();if (points>100) {count++;}else {continue;}}System.out.println("点击率大于100 的游戏数是"+count+"\n比例为"+count*100/4+"%");}}

————————————————————————————————————————————————————————————

package test0909;import java.util.Scanner;public class GameRank {public static void main(String[] args) {System.out.println(" 青鸟游戏迷你平台>游戏晋级");Scanner input = new Scanner(System.in);String ans="";int count=1;//游戏局数int score=0;//游戏得分//boolean flag=true;//假设能晋级for (int i = 1; i <=5; i++) {System.out.println("您正在玩第 "+i+"局，成绩为");score=input.nextInt();if (score>=80) {count++;}if (count<4) {System.out.println("继续玩下一局yes,no");ans=input.next();if (ans.equals("no")) {System.out.println("您已中途推出游戏\n对不起，您未能晋级，继续加油啊");//flag=false;//相当于return；return;}}}if (count>=4) {System.out.println(" 恭喜您晋级一级");}else if (count==3) {System.out.println(" 恭喜您晋级二级");}else {System.out.println(" 很遗憾，out！");}}}

——————————————————————————————————————————————————————————

package test0909;import java.util.Scanner;public class GameUser {public static void main(String[] args) {System.out.println(" 青鸟游戏迷你平台>添加用户信息");Scanner input = new Scanner(System.in);System.out.println(" 请输入用户的数量");int count = input.nextInt();String num = "";//会员卡号不一定为数字可以为字母组合int scores = 0, age = 0;// 用户编号，年龄，积分for (int i = 1; i <= count; i++) {System.out.println("请输入第 " + i + "个用户的信息");System.out.println("用户编号四位数 ");num = input.next();while (num.length() != 4) {System.out.println("用户编号必须是四位数，请重输 ");num = input.next();}System.out.println(" 用户年龄：");while (input.hasNextInt()) {//排除不合适的数据类型，利用scanner进行过滤判断age=input.nextInt();};if (age < 18) {System.out.println("很抱歉，您的年龄不适合玩游戏");continue;}System.out.println(" 积分");scores = input.nextInt();System.out.println("用户编号 " + num + "\t年龄" + age + "\t积分" + scores);}
冒泡，求最值不用break，一直进行比较；数组中是否包含此数，插入到有序数组中时用break，找到最接近值，就停止比较

冒泡排序（从小到大）

冒泡排序双重for循环，借用temp做量值交换

int temp=arr[j]; //升序时 arr[j]>arr[j+1]才比较、

int temp=arr[j]; //降序时 arr[j]<arr[j+1]才比较、


package test0909;public class BubbleSort {
public static void main(String[] args) {int []arr= {6,3,8,2,9,1};System.out.println("排列前顺序为： ");for (int i : arr) {System.out.print(i+"\t");
}for (int i = 0; i < arr.length-1; i++) {//外层循环比的次数是数组长度-1，因为最后一个元素就是最大值，自己不哟个和自己比比较for (int j = 0; j < arr.length-1-i; j++) {//内层是控制每一圈排序多少次if (arr[j]>arr[j+1]) {int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}
}System.out.println("\n排列后升序为： ");for (int i : arr) {System.out.print(i+"\t");}
}
}

package test0909;public class BubbleSort {public static void main(String[] args) {int []arr= {6,3,8,2,9,1};System.out.println("排列前顺序为： ");for (int i : arr) {System.out.print(i+"\t");
}for (int i = 0; i < arr.length-1; i++) {//外层循环比的次数是数组长度-1，因为最后一个元素就是最大值，自己不哟个和自己比比较for (int j = 0; j < arr.length-1-i; j++) {//内层是控制每一圈排序多少次if (arr[j]<arr[j+1]) {int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}
}System.out.println("\n排列后降序为： ");for (int i : arr) {System.out.print(i+"\t");}
}
}

插入值（升序，降序）到数组中

需要用到break；for循环中i>=index,否则输入相同数值时会出现覆盖情况

1给插入值下标初始化等于数组长度；

2获得index//升序时nums[i]>input;降序时nums[i]<input.获得index=i;

3循环顺次移位 //升序时arr.length -2开头，arr[i+1]=arr[i];//降序时arr.length -1开头，arr[i]=arr[i-1];

4 将输入值input赋值到nums[index ] 然后进行foreach循环输出

package test0909;import java.util.Arrays;
import java.util.Scanner;//一组有序的字符序列a、b、c、e、f、p、u、z，向次字符序列中插入一个新的字符，要求插入之后字符序列仍保持有序
//,'b','c','e','f','p','u','z'
public class InserCharAsc {public static void main(String[] args) {char[]arr= new char[9];arr[0]= 'a' ;arr[1]=  'b';arr[2]= 'c' ;arr[3]= 'e' ;arr[4]= 'f' ;arr[5]= 'p' ;arr[6]=  'u';arr[7]=  'z';System.out.print("原序列：");for (char ch : arr) {System.out.print(ch+"\t");}int index=arr.length-1;//首先给它赋值把它放入最后一个位置  8 System.out.println("\n待插入的字符是：");Scanner input = new Scanner(System.in);String c=input.next();////升序插入数值1，找到下标；2，循环移位，3把输入的结果赋值给该数组的下标for (int i = 0; i < arr.length; i++) {if (arr[i]>c.charAt(0)) {index=i;System.out.println("插入的下标为"+index);break;}}//循环yi位  8  7for (int i = arr.length -2; i >= index; i--) {//与index比较，前面的东西不用动，i+1=数组长度=arr.length-1,所以cong//要移动的话，从第八位可以移动到第九位，arr.lenght-1是第九位不能往后移了arr[i+1]=arr[i];//}//输入的数赋值给数组元素arr[index]=c.charAt(0);System.out.print("\n插入后字符序列：");for (char ch : arr) {System.out.print(ch+"\t");}}
}
package test0909;import java.util.Arrays;
import java.util.Scanner;/***有一组学员的成绩{99，85，82，63， 60}，将它们按升序排列。*要增加一个学员的成绩，将它插入成绩序列，并仍保持降序*
将成绩序列保存在长度为6的数组中
通过比较找到插入位置
将该位置后的元素后移一个位置
将增加的学员成绩插入到该位置
//Arrays.sort()方法只是显示，实际上数组位置并没有移动* */
public class InsertElementDesc {public static void main(String[] args) {int[] scores=new int[6];//数组长度扩容scores[0]=99;scores[1]=85;scores[2]=82;scores[3]=63;scores[4]=60;int index=scores.length-1;//把插入的数字放在最后一位；插入的坐标初始化为数组的长度减1//接收值因为有默认值0存在，所以插入数值后可能会把其中元素给占据掉，题目要求的是插入后排序；所以首先把他插入到第一位。保证数组元素不丢失，把他放在元素首位Scanner input = new Scanner(System.in);System.out.println(" \n输入的成绩为");int newscore=input.nextInt();
//不能用arrays排序 //找到坐标插入的位置for (int i = 0; i < scores.length; i++) {if (scores[i]<newscore) {//因为降序，让数组中元素小于输入的新元素index=i;break;//找到位置后必须停止，否则没有结果}}//位置整体后移一位for (int i =scores.length-1; i>=0; i--) {scores[i]=scores[i-1];}//给新输入的元素赋值到需要插入的数组下标的元素；scores[index]=newscore;//插入的下标位置是System.out.println(index);//插入后数序为：System.out.println("插入后成绩降序序为");for (int i : scores) {System.out.print(i + "\t");}
}
}

判断是否包含某数

package test0909;
//判断一个输入的数值是否在此数列中
import java.util.Scanner;public class BooleanInclued {public static void main(String[] args) {int [] arr= {8,4,2,1,23,344,12};
System.out.println("输入一个成绩");Scanner input = new Scanner(System.in);int num=input.nextInt();boolean flag=false;//不在数列中for (int i = 0; i < arr.length; i++) {if (num==arr[i]) {flag=true;break;}
}if (flag) {System.out.println("数列中包含此数");
}else {System.out.println(" 不包含");
}
}
}
 System.out.print(Arrays.asList(目标数组).contains("检查的元素") );

删除数组中的特定值

int[] intArray = { 1, 2, 3, 4, 5 };  int[] removed = ArrayUtils.removeElement(intArray, 3);//创建新的数组  System.out.println(Arrays.toString(removed));

package test0909;
/***现在有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; *要求将以上数组中的0项去掉，将不为0的值存入一个新的数组，*生成新的数组为 int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}* */
public class DelZero {public static void main(String[] args) {int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};int count=0;//新数组中的元素个数,旧数组中不为0的个数；新数组长度int index=0;//新数组的每个元素的下标//遍历旧数组中所有元素，获得新数组长度，for (int i = 0; i < oldArr.length; i++) {if (oldArr[i]!=0) {count++;}}int newArr[]=new int[count];//声明并给新数组开辟空间；此时已经获得了新数组的数组长度；for (int i = 0; i < oldArr.length; i++) {if (oldArr[i]!=0) {newArr[index]=oldArr[i];//旧数组中符合新数组中元素进行赋值index++;//切记不可忘记}}for (int i = 0; i < newArr.length; i++) {System.out.print(newArr[i]+"  \t ");}}}

最大值和最小值

package test0909;import java.util.Scanner;public class MinPrice {
public static void main(String[] args) {double[]prices=new double[4];Scanner input = new Scanner(System.in);for (int i = 0; i < prices.length; i++) {System.out.println("请输入第"+(i+1)+"家超市的商品价格");prices[i]=input.nextDouble();}double min=100000000;//不能初始化为0,否则就一直为0for (int i = 0; i < prices.length; i++) {if (prices[i]<min) {min=prices[i];}}System.out.print("商品的最低价格为"+min+"元\t");}
}******************************************************************************************package test0909;import java.util.Arrays;
import java.util.Scanner;public class MinPrice2 {
public static void main(String[] args) {double[]prices=new double[4];Scanner input = new Scanner(System.in);for (int i = 0; i < prices.length; i++) {System.out.println("请输入第"+(i+1)+"家超市的商品价格");prices[i]=input.nextDouble();}Arrays.sort(prices);double min=prices[0];System.out.print("商品的最低价格为"+min+"元\t");}
}

//求最大值及下标
package homework0911;import java.util.Arrays;public class MaxAndIndex2{public static void main(String[] args) {int []arr1= {18,25,7,36,13,2,89,63};Arrays.sort(arr1);//只显示排序，不改变数组元素本身的位置；//升序后获得最大值；System.out.println(arr1[arr1.length-1]);//通过数组方法获得下标System.out.println(Arrays.binarySearch(arr1,arr1[arr1.length-1])); }***************************************************************************************************
package test0909;import java.util.Arrays;//4有8个整数（18，25，7，36，13，2，89，63）的数组中找出其中最大的数及其下标
public class MaxAndIndex {
public static void main(String[] args) {int []arr= {18,25,7,36,13,2,89,63};int max=0;for (int i = 0; i < arr.length; i++) {if (arr[max]<arr[i]) {max=i;}}System.out.println("数组中最大值为"+arr[max]+"\t索引为"+max);

平均值

package homework0911;public class Test7 {public static void main(String[] args) {int []arr1= { -10,2,3,246,-100,0,5};int max=0;int  min=0;int sum=0;for (int i = 0; i < arr1.length; i++) {System.out.println(arr1[i]);sum+=arr1[i];//平均值if (max<arr1[i]) {max=arr1[i];//最大值}if (min>arr1[i]) {min=arr1[i];//最小值}}System.out.println(max+"\t"+min+"\t"+sum/arr1.length);
}
}

数组vs数字逆序反转

//一个数组中的元素逆序存放
public class ConverseArray {public static void main(String[] args) {int []arr= {6,3,8,2,9,1};int temp;for (int i = 0; i < arr.length/2; i++) {temp=arr[i];arr[i]=arr[arr.length-1-i];//数组长度分为两个数arr[arr.length-1-i]=temp;}System.out.println("排列的顺序为");for (int i : arr) {System.out.print(i+"\t");}}
}
package test0908;
//一个变量的逆序输出
public class Converse {
public static void main(String[] args) {int val=54321;System.out.println("数字反转后为");while(val!=0) {int mod=val%10;System.out.print(mod);val/=10;}}
}

数组反转

    int[] intArray = { 1, 2, 3, 4, 5 };  ArrayUtils.reverse(intArray);  //[5, 4, 3, 2, 1]  System.out.println(Arrays.toString(intArray));

合并数组

  int[] intArray = { 1, 2, 3, 4, 5 };  int[] intArray2 = { 6, 7, 8, 9, 10 };  // Apache Commons Lang 库  int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

package homework0911;import java.util.Arrays;public class Test8 {public static void main(String[] args) {int []a={7,12,4,9,6,3,9};int[] b={2,6,3,54,2,56,21,33};int[]c= new int[a.length+b.length];/***c=Arrays.copyOf(a, a.length);//只能保存赋值数组的长度，否则数据丢失；c=Arrays.copyOfRange(b, a.length, a.length+b.length );System.out.println(Arrays.toString(c));* */System.arraycopy(a, 0, c, 0, a.length);System.arraycopy(b, 0, c, a.length, b.length);//截取合并后记得输出System.out.println(Arrays.toString(c));}
}

打印数组

 int[] intArray = { 1, 2, 3, 4, 5 };  // 直接打印,则会打印出引用对象的Hash值  // [I@7150bd4d  System.out.println( Arrays.toString(intArray));

数组复制

System.arraycopy(a ,0 ,b ,0 ,8)这句话可以翻译为：把数组a从下标为0的位置依次开始复制到数组b下标为0的位置，复制长度为8。
使用时需要用CTRL+shift+O进行导包import java.util.Arrays;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
函数原型：arraycopy（Object src, int srcPos, Object dest, int destPos, int length）src: 原数组   srcPos:原数组起始的位置dest:目的数组 destPos:目的数组的起始位置length：所需复制数组的长度需要注意的是要重新声明一个同类型且长度足够的数组，否则会出现异常。

     int[] a= {3,456,4,3,2,45,5,65,35,6,5,5,43};int[] b=new int[8];b=Arrays.copyOf(a, 8);System.out.println(Arrays.toString(b));
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&函数原型：copyOf(oringinal, int newlength)oringinal:原数组      newlength:复制数组的长度这个方法是从原数组的起始位置开始复制，复制的长度是newlength。相比较于前一种，这种相当于特殊的情况，只能从原数组的起始位置开始复制。

函数原型：copyOfRange(oringinal,int from, int to)该方法是从original数组的下标from开始复制，到下标to结束

数组填充

array = new int[5];
Arrays.fill(array, 2);//填充相同的数
out.println(Arrays.toString(array)); //[2, 2, 2, 2, 2]
***************************************************
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
array = new int[5];
Arrays.fill(array, 1, 4, 2); //部分填充
out.println(Arrays.toString(array));//[0, 2, 2, 2, 0]

equals 与deepEuqals（或者toString/deepToString）

int[] array = new int[]{1, 2, 3};
out.println(Arrays.toString(array)); //[1, 2, 3]
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
*****************************************
//deep方法主要用于二位数组及以上，判断的是deepArray
int[][] deepArray = new int[][]{{1, 3},{2, 4}};
out.println(Arrays.toString(deepArray)); //[[I@1540e19d, [I@677327b6]
out.println(Arrays.deepToString(deepArray)); //[[1, 3], [2, 4]]

break和continue；一维二维数组的应用

package test0909;
/***需求说明
有3名顾客去商场购物，每人买3件商品
商品单价300元以上的商品享受8折优惠
请统计每人享受打折优惠的商品的数量* */
import java.util.Scanner;
//有5家衣服专卖店，每家最多购买3件。用户可以选择离开，可以买衣服
//最后打印总共买了几件衣服
public class BreakAndDimensionalArrays {public static void main(String[] args) {Scanner input = new Scanner(System.in);String ans="";int count=0;//全局变量购买衣服数for (int i = 0; i < 5; i++) {System.out.println("欢迎进入第"+(i+1)+"店购买物品");int count2=0;//局部变量控制购买衣服的个数（单家店最多买三个）do {System.out.println("要离开吗n/y");ans=input.next();if (!ans.equals("n")) {System.out.println("离店结账");break;//break跳出当前循环，进入下次循环的首句，不能用return，否则结束整个方法块，直接结束两个循环；}if (ans.equals("n")) {count2++;count++;if (count2==3) {System.out.println("离店结账");break;}}} while (ans.equals("n"));}System.out.println("您一共购买了"+count+"件商品");
}
}
package test0909;import java.util.Scanner;/*** 若有3个班级各4名学员参赛，计算每个班级参赛学员平均分，统计成绩大于85分学员数 使用continue统计大于85分的学员人数**/
public class ContinueAndTwoDimensionalArrays {public static void main(String[] args) {Scanner input = new Scanner(System.in);int[][] scores = new int[5][5];// 1.建立数组// 二维数组必须分配空间，子元素可选择输入或不输入// 第一个【】必须给数组长度，否则报错，第二个可以不给长度，因为，scoers[i]的子元素不一定一致，可以不一致；// 如果数组元素soces[i]子元素个数也相同,那样就可以给第二个括号也赋值；// 2.分析局部变量和全局变量；每个班平均分sum/5定性分析为局部；总人数全局；int count = 0;// 高于85分的全班人数；for循环内部声明每个班级的总分；for (int i = 0; i < scores.length; i++) {int sum = 0;// 每个班的平均成绩之和；System.out.println("请输入第" + (i + 1) + "个班同学的成绩");for (int j = 0; j < scores[i].length; j++) {System.out.println("请输入第" + (i + 1) + "个班第" + (j + 1) + "个同学的成绩");scores[i][j] = input.nextInt();sum += scores[i][j];if (scores[i][j] < 85) {continue;}count++;// 跳出内部循环，加速循环；}System.out.println("请输入第" + (i + 1) + "个班同学的平均成绩是" + sum / 5);}System.out.print(count);}
}

ArrayUtils工具类


// 1.打印数组
ArrayUtils.toString(newint[] { 1, 4, 2, 3 });// {1,4,2,3}
ArrayUtils.toString(new Integer[] { 1, 4, 2, 3 });// {1,4,2,3}
ArrayUtils.toString(null, "I'm nothing!");// I'm nothing!// 2.判断两个数组是否相等,采用EqualsBuilder进行判断
// 只有当两个数组的数据类型,长度,数值顺序都相同的时候,该方法才会返回True
// 2.1 两个数组完全相同
ArrayUtils.isEquals(newint[] { 1, 2, 3 }, newint[] { 1, 2, 3 });// true
// 2.2 数据类型以及长度相同,但各个Index上的数据不是一一对应
ArrayUtils.isEquals(newint[] { 1, 3, 2 }, newint[] { 1, 2, 3 });//true
// 2.3 数组的长度不一致
ArrayUtils.isEquals(newint[] { 1, 2, 3, 3 }, newint[] { 1, 2, 3 });//false
// 2.4 不同的数据类型
ArrayUtils.isEquals(newint[] { 1, 2, 3 }, newlong[] { 1, 2, 3 });// false
ArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false
// 2.5 Null处理,如果输入的两个数组都为null时候则返回true
ArrayUtils.isEquals(newint[] { 1, 2, 3 }, null);// false
ArrayUtils.isEquals(null, null);// true// 3.将一个数组转换成Map
// 如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value
// 对于Object[]数组里的元素必须是instanceof Object[]或者Entry,即不支持基本数据类型数组
// 如:ArrayUtils.toMap(new Object[]{new int[]{1,2},new int[]{3,4}})会出异常
ArrayUtils.toMap(new Object[] { new Object[] { 1, 2 }, new Object[] { 3, 4 } });// {1=2,
// 3=4}
ArrayUtils.toMap(new Integer[][] { new Integer[] { 1, 2 }, new Integer[] { 3, 4 } });// {1=2,
// 3=4}// 4.拷贝数组
ArrayUtils.clone(newint[] { 3, 2, 4 });// {3,2,4}// 5.截取数组
ArrayUtils.subarray(newint[] { 3, 4, 1, 5, 6 }, 2, 4);// {1,5}
// 起始index为2(即第三个数据)结束index为4的数组
ArrayUtils.subarray(newint[] { 3, 4, 1, 5, 6 }, 2, 10);// {1,5,6}
// 如果endIndex大于数组的长度,则取beginIndex之后的所有数据// 6.判断两个数组的长度是否相等
ArrayUtils.isSameLength(new Integer[] { 1, 3, 5 }, new Long[] { 2L, 8L, 10L });// true// 7.获得数组的长度
ArrayUtils.getLength(newlong[] { 1, 23, 3 });// 3// 8.判段两个数组的类型是否相同
ArrayUtils.isSameType(newlong[] { 1, 3 }, newlong[] { 8, 5, 6 });// true
ArrayUtils.isSameType(newint[] { 1, 3 }, newlong[] { 8, 5, 6 });// false// 9.数组反转
int[] array =newint[] { 1, 2, 5 };
ArrayUtils.reverse(array);// {5,2,1}// 10.查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1
// 10.1 从正序开始搜索,搜到就返回当前的index否则返回-1
ArrayUtils.indexOf(newint[] { 1, 3, 6 }, 6);// 2
ArrayUtils.indexOf(newint[] { 1, 3, 6 }, 2);// -1
// 10.2 从逆序开始搜索,搜到就返回当前的index否则返回-1
ArrayUtils.lastIndexOf(newint[] { 1, 3, 6 }, 6);// 2// 11.查询某个Object是否在数组中
ArrayUtils.contains(newint[] { 3, 1, 2 }, 1);// true
// 对于Object数据是调用该Object.equals方法进行判断
ArrayUtils.contains(new Object[] { 3, 1, 2 }, 1L);// false// 12.基本数据类型数组与外包型数据类型数组互转
ArrayUtils.toObject(newint[] { 1, 2 });// new Integer[]{Integer,Integer}
ArrayUtils.toPrimitive(new Integer[] { new Integer(1), new Integer(2) });// new int[]{1,2}// 13.判断数组是否为空(null和length=0的时候都为空)
ArrayUtils.isEmpty(newint[0]);// true
ArrayUtils.isEmpty(new Object[] { null });// false// 14.合并两个数组
ArrayUtils.addAll(newint[] { 1, 3, 5 }, newint[] { 2, 4 });// {1,3,5,2,4}// 15.添加一个数据到数组
ArrayUtils.add(newint[] { 1, 3, 5 }, 4);// {1,3,5,4}// 16.删除数组中某个位置上的数据
ArrayUtils.remove(newint[] { 1, 3, 5 }, 1);// {1,5}// 17.删除数组中某个对象(从正序开始搜索,删除第一个)
ArrayUtils.removeElement(newint[] { 1, 3, 5 }, 3);// {1,5}

附录Java关键字

关键字属于保留字，在 Java 中具有特殊的含义，比如说 public、final、static、new 等等，它们不能用来作为变量名。为了便于你作为参照，我列举了 48 个常用的关键字，你可以瞅一瞅。1. **abstract：** abstract 关键字用于声明抽象类——可以有抽象和非抽象方法。2. **boolean：** boolean 关键字用于将变量声明为布尔值类型，它只有 true 和 false 两个值。3. **break：** break 关键字用于中断循环或 switch 语句。4. **byte：** byte 关键字用于声明一个可以容纳 8 个比特的变量。5. **case：** case 关键字用于在 switch 语句中标记条件的值。6. **catch：** catch 关键字用于捕获 try 语句中的异常。7. **char：** char 关键字用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。8. **class：** class 关键字用于声明一个类。9. **continue：** continue 关键字用于继续下一个循环。它可以在指定条件下跳过其余代码。10. **default：** default 关键字用于指定 switch 语句中除去 case 条件之外的默认代码块。11. **do：** do 关键字通常和 while 关键字配合使用，do 后紧跟循环体。12. **double：** double 关键字用于声明一个可以容纳 64 位浮点数的变量。13. **else：** else 关键字用于指示 if 语句中的备用分支。14. **enum：** enum（枚举）关键字用于定义一组固定的常量。15. **extends：** extends 关键字用于指示一个类是从另一个类或接口继承的。16. **final：** final 关键字用于指示该变量是不可更改的。17. **finally：** finally 关键字和 `try-catch` 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。18. **float：** float 关键字用于声明一个可以容纳 32 位浮点数的变量。19. **for：** for 关键字用于启动一个 for 循环，如果循环次数是固定的，建议使用 for 循环。20. **if：** if 关键字用于指定条件，如果条件为真，则执行对应代码。21. **implements：** implements 关键字用于实现接口。22. **import：** import 关键字用于导入对应的类或者接口。23. **instanceof：** instanceof 关键字用于判断对象是否属于某个类型（class）。24. **int：** int 关键字用于声明一个可以容纳 32 位带符号的整数变量。25. **interface：** interface 关键字用于声明接口——只能具有抽象方法。26. **long：** long 关键字用于声明一个可以容纳 64 位整数的变量。27. **native：** native 关键字用于指定一个方法是通过调用本机接口（非 Java）实现的。28. **new：** new 关键字用于创建一个新的对象。29. **null：** 如果一个变量是空的（什么引用也没有指向），就可以将它赋值为 null。30. **package：** package 关键字用于声明类所在的包。31. **private：** private 关键字是一个访问修饰符，表示方法或变量只对当前类可见。32. **protected：** protected 关键字也是一个访问修饰符，表示方法或变量对同一包内的类和所有子类可见。33. **public：** public 关键字是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。`main()` 方法必须声明为 public。34. **return：** return 关键字用于在代码执行完成后返回（一个值）。35. **short：** short 关键字用于声明一个可以容纳 16 位整数的变量。36. **static：** static 关键字表示该变量或方法是静态变量或静态方法。37. ###### **strictfp：** strictfp 关键字并不常见，通常用于修饰一个方法，确保方法体内的浮点数运算在每个平台上执行的结果相同。38. **super：** super 关键字可用于调用父类的方法或者变量。39. **switch：** switch 关键字通常用于三个（以上）的条件判断。40. **synchronized：** synchronized 关键字用于指定多线程代码中的同步方法、变量或者代码块。41. **this：** this 关键字可用于在方法或构造函数中引用当前对象。42. **throw：** throw 关键字主动抛出异常。43. **throws：** throws 关键字用于声明异常。44. **transient：** transient 关键字在序列化的使用用到，它修饰的字段不会被序列化。45. **try：** try 关键字用于包裹要捕获异常的代码块。46. **void：** void 关键字用于指定方法没有返回值。47. **volatile：** volatile 关键字保证了不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。48. **while：** 如果循环次数不固定，建议使用 while 循环。

Java小白入门总结相关推荐

  1. 小白学编程“Java小白”入门解疑大全

    成功的人分几种,有一种人叫做关系户,他们渠道多,广织关系网,有一种叫做平台户,他们平台有多硬,他们就有多硬,但无论是关系户还是平台户,依靠的总是别人的手.别人的嘴巴.别人辛苦创立下来的资源,归根到底, ...

  2. Java小白入门200例14之求最大公约数

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  3. Java小白入门200例81之Java接口

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  4. Java小白入门200例56之鸡兔同笼问题

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  5. Java小白入门200例80之Java继承（extends）

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  6. Java小白入门200例39之Java字符串拼接（连接）

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  7. Java小白入门200例79之Java类的封装

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  8. Java小白入门200例98之Java异常

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  9. Java小白入门200例51之根据出生日期计算星座

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

  10. Java小白入门200例50之Java判断闰年并打印月份对应的天数

    作者简介 作者名:编程界明世隐 简介:CSDN博客专家,从事软件开发多年,精通Java.JavaScript,博主也是从零开始一步步把学习成长.深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢 ...

最新文章

  1. 自定义apt升级脚本
  2. php字符串常用算法--字符串加密解密
  3. JAVA两类比较器的区别(Comparable,Comparator)
  4. Gartner分享物联网和智慧城市最新数据
  5. javamail “535 5.7.3 Authentication unsuccessful“ 问题排查
  6. matlab相位连续显示,matlab设计复合信号不同频率的初相位
  7. 基本飞行模式中英文对照
  8. tsql 正则_sql里的正则表达式
  9. 2021安徽高考成绩及录取结婚查询,2020安徽高考录取结果查询时间及通知书发放时间...
  10. 禁止双击、拖动listctrl列头
  11. 第一次在CSDN上写博客
  12. 2021年国内好用的可视化工具
  13. python的PIL库
  14. [转载]主流漫游技术-OKC802.11r介绍
  15. 单行道行车模拟（元胞自动机）——greatji1994
  16. ABP——切换MySQL数据库
  17. Greenplum查看表/库大小、进程、表膨胀处理（sql语句）
  18. Post请求，参数跟在url后面的问题
  19. xp显示桌面很慢,解决办法
  20. 在OpenGL中利用shader进行实时瘦脸大眼等脸型微调

热门文章

  1. python拍七游戏代码_python实现逢七拍腿小游戏的思路详解
  2. 2023 年 3 月阿拉丁指数榜单更替率 18%
  3. 关于队里面最菜的在博客打卡第十一天这件事
  4. Web前端开发HTML清华大学,清华大学出版社-图书详情-《Web前端开发——HTML5+CSS+JavaScript+ jQuery +Dreamweaver》...
  5. python爬取京东商品（使用cookies，header，xpath匹配），解决ajax。 后附有selenium模拟访问抓取网页方法和视频演示
  6. Python抓取腾视频所有电影，不用钱就可以看会员电影
  7. GPS接收机的灵敏度分析
  8. php 整形转浮点型,整型与浮点型相互转换
  9. 惠普服务器CPU位置,手把手教你换CPU 看惠普16核产品性能变化
  10. WSL Ubuntu 20.04下Android源码下载