常亮和变量

今日知识梳理：

常量

常量就是指在程序执行期间其值不能发生变化的数据，常量是固定的。如整型常量123，实型常量1.23，字符常量’A’，布尔常量true等
Java中的常量用final来实现，例如final double PI=3.14;注意声明常量的时候可以不赋值，而在构造器结构中赋初值，但是若在声明时同时进行了赋值，则不可以在初始化结构中赋值了。

final boolean out=true;
// out=false;语法报错的原因是out是常量，一旦赋值则不允许在运行期间进行修改
if(out)
 System.out.println("我的第一次输出");
System.out.println("其它的输出");
if(out)
 System.out.println("我的第二次输出");

表达式

表达式就是运算符、操作数以及方法调用的序列，用来说明某个计算过程并返回计算结果
按照运算符功能来分，基本的运算符分包括算术运算符、关系运算符、位运算符、条件运算符等

• 算术运算符 +、-、*、/、%、++、–
• 关系运算符 >、<、>=、<=、==、!=
• 逻辑运算符 &&、 ||、 !。注意：逻辑计算支持短路操作
• 位运算符 &、|、^、~、<< 、 >>、>>>。注意：为运算符不支持短路操作 [考点]
• 赋值运算符 =，+=，-=，*=，/=
• 三目条件运算符（？：）规则是完全一致的，使用的形式是： x ? y：z;

算术运算符

+、-、*、/、%、++、–

整除：参与运算的双方都是整数 10/3=3而不是3.33333
10./3=3.333…这里由于10.是浮点数，则3会自动转换为大类型并参与计算，所以最终是 10.0/3.0的计算
结果

int kk=3;
int res=(kk/2); //没有语法错误，因为除数和被除数都是整数，所以计算结果为整数
System.out.println(res);
//如果需要计算小数部分，则除数或者被除数之一必须为非整数
3./2=1.5
double res=(1.*kk/2);  //因为1.是double类型的浮点数，所以计算结果一定是浮点数

计算次序为先乘除后加减，如果优先级一致，则自动从左向右进行计算 10+2*5=20
%求余（取模） 10%3=1实际就是10除以3求余数

//假设总行数为10行，每页3行，如何计算需要多少页进行显示
int rowsNum = 12;// 总行数
int rowsPerPage = 3;// 每页行数
int pageNum = rowsNum / rowsPerPage;// 总页码数
System.out.println(pageNum);// 由于整除的问题，所以计算结果为3，这样就会有数据丢失
if(rowsNum%rowsPerPage!=0)
 pageNum=pageNum+1;
System.out.println("最终结果为："+pageNum);

注意：求余计算可以用于浮点数。浮点数没有整除的概念，只能针对计算结果进行强制类型转换(窄化操作)

double dd=-12.3; //求余计算中符号不参与计算，所以计算结果为-2.4
System.out.println(dd%3.3); //执行结果为2.4000000000000012

++和–是单目运算符

i++等价于i=i+1
i–等价于i=i-1

double k = 100; k--;// k=k-1;
System.out.println(k);

i++是先取值后计算，++i是先计算后取值

int k = 100;
 System.out.println(k++);//100 先获取k的当前值，然后再进行加1计算
 System.out.println(k);//101
------ 
int k = 100;
 System.out.println(++k);//101 先加1然后再取值
 System.out.println(k);//101

int k = 100;
int i = 50;
int res = k+++i;  //实际是按照k++ +i进行计算
System.out.println(res);  //150
System.out.println(k + "---" + i); //101 50

int k = 100;
 int i = 50;
 int res = k+ ++i;//是按照k+(++i)进行计算
 System.out.println(res);   //151
 System.out.println(k + "---" + i); //100 51

一般会配合短路操作进行考核

比较运算符

、<、>=、<=、==、!= 用于判断两个数据之间的大小关系，计算结果为boolean,如果成立返回为true，否则为false

boolean bb = 1 > 2;
 System.out.println(bb);
 System.out.println(1 <= 2);
 //=是赋值计算 ==是等值判定
 int kk;
 System.out.println(kk=3);
 System.out.println(kk==3);

==和=的区别

k=100;这是赋值运算符，意思是将=右边的计算结果储存在=左边的变量中
k100这是比较计算，意思是判断k是否值为100；如果是则返回true，否则false
!=意思是判断是否不等于，表示如果相等时返回false，否则返回true
由于浮点数无法精确存放，所以判断k1.0这个写法是错误的
正确写法： a-b的绝对值小于1e-6

Java提供了一个工具类Math

Math中包含一些常见的数学计算的实现，例如三角函数、反三角函数等，

• abs()的方法实现求绝对值

Math.abs(d1-1)<1e-6 判断浮点类型的变量d1的值是否为1

double d1 = 0.999999999;
double d2 = 1;
 //一般不建议这种写法，因为浮点数无法精确存放
System.out.println(d1==d2);
double res=Math.abs(d2-d1); //Math数学库中提供的abs方法用于获取绝对值
System.out.println(res);
if(res<1e-6)
 System.out.println("d1和d2相等");
else
 System.out.println("d1和d2不相等");

• floor(double):double 从小到大逼近参数最大整数
• ceil(double):double从大到小逼近参数最小整数
• round(double):double 四舍五入，计算时和符号无关
• pow(double a, double b):double 计算a的b次方
• sqrt(double a):double 针对a进行开根号计算

逻辑运算符

&&与、 ||或、 !非
表达多个条件之间的关系。例如年龄大于等于18并且年龄小于65

age>=18 && age<65

age>1 || age<10  //逻辑错误，因为任意值都满足条件
age>1 && age<10 //正确

计算规则：

• && 同真则真，其余为假
• || 同假则假，其余为真
• ！ 非真则假，非假则真

注意：逻辑计算支持短路操作

int a = 2;
 int b = 3;
 boolean bb = a > 1 && b++ < 4;
 System.out.println(bb);//true
 System.out.println(a + ":" + b);   //2:4

int a = -2;
 int b = 3;
 //因为++a>1值为false,所以b++<4并没有执行，这就是短路操作
 boolean bb = ++a > 1 && b++ < 4;
 System.out.println(bb);//false
 System.out.println(a + ":" + b);//-1:3

&&:与运算，含义是两个条件必须同时成立，可以翻译为并且
年龄大于等于18并且年龄小于65: age>=18 && age<65
||：或运算，含义是两个条件中成立一个即可，可以翻译为或者
年龄小于18岁或者年龄不小于65 : age<18 || age>=65
算法规则：同假则假，否则为真
!：非运算，含义是不是，用于对某个条件进行否定
年龄不小于18
写法1：age >=18
写法2： !（age<18）
算法规则：非真则假，非假则真

短路运算

例如A && B:如果条件A为false,则不会执行B，因为根据运算规则结果一定是false，和B的值没有关系
A||B：如果条件A为true，则不会执行B，因为格局运算规则结果一定是true，和B的值没有关系
考核中主要配置++/–进行测试

位运算符

&按位与、|按位或、^按位异或、~按位取反、<<左移位 、 >>右移位，空位置补符号位上的值、>>>无
符号右移位，空位置补0
注意：为运算符不支持短路操作

int a = -2;
 int b = 3;
 //因为++a>1值为false,所以b++<4并没有执行，这就是短路操作
 boolean bb = ++a > 1 & b++ < 4;
 System.out.println(bb);//false
 System.out.println(a + ":" + b);//-1:4

7&3=3
7|3=7
7^3=4
~3=-4

赋值运算符

=，+=，-=，*=，/=
int k=100; 含义是将100赋值存储在k对应的存储单元中
k=k+3可以简写为k+=3
-= */ /=类似

注意前方高能

int a=1;
int b=2;
short c1=1+2;  //语法不报错，因为编译器可以判定结果不越界
short c2=(short)a+(short)b;  //计算结果为int，所以这样会报错
short c3=(short)(a+b);//语法正确

short k=3; k=k+3;  //出现了一个语法错误，因为k+3这里的3系统识别为int类型，所以计算时所有数据自动转
换为int类型，必然计算结果也是int类型，将int类型的数据赋值给short类型变量----错误
System.out.println(k);

short k=3; k+=3;  //没有语法错误，因为+=这种符号中包含了自动类型转换

三目条件运算符

规则是完全一致的，使用的形式是： x ? y：z;
计算规则

• x是一个条件表达式
• 如果x计算结果为true，则返回y表达式的结算结果
• 否则返回z表达式的计算结果

int k=-10;
int b=k>6?5:3;
System.out.println(b);

注意

int a=5;
int b=3;
int res=++a>b--?a+++3:b---4;  
System.out.println(res);//9
System.out.println(a+":"+b);//7:2

其他运算符

对象运算符instanceof用来判断一个对象是否是某一个类或者其子类的实例。如果对象是该类或者其子类的实例，返回ture；否则返回false

Object k1 = 123;
System.out.println(k1 instanceof Integer);  //true
System.out.println(k1 instanceof Double);   //false

点.运算符用于访问对象实例或者类的类成员函数

System.out.println(Integer.MAX_VALUE);
int k1=12,k2=23;
System.out.println(Integer.max(k1, k2));

new运算符 用于创建一个新的对象或者新的数组

Date new = new Date();
System.out.println(new);

运算符的优先级

运算符这里不用记忆，当不确定时，注意有个神器就是()小括号，可以使用它强制表达自己的编写意图

结构化编程

结构化程式设计Structured programming是1960年代开始发展起来的一种编程典范。它采用子程序、程式码区块、for循环以及while循环等结构来取代传统的goto。希望借此来改善计算机程序的明晰性、品质以及开发时间，并且避免写出面条式代码。

已经证明，任何复杂的问题都可以三种基本算法结构来描述：顺序、选择、循环。因此用计算机语句描述的程序也包含三种基本结构

设计方法：使用流程图表示算法

流程图是流经一个系统的信息流、观点流或部件流的图形代表。在企业中，流程图主要用来说明某一过程。这种过程既可以是生产线上的工艺流程，也可以是完成一项任务必需的管理过程。常见的绘制工具有Visio、PowerDesigner等

• 圆角矩形表示“开始”与“结束”；
• 矩形表示行动方案、普通工作环节用；
• 菱形表示问题判断或判定（审核/审批/评审）环节；
• 用平行四边形表示输入输出；
• 箭头代表工作流方向。

结构化程序设计原则

自顶向下、逐步求精、模块化
结构化程序设计还有一个重要的规定，那就是只能使用顺序结构、选择结构、循环结构这三种基本结构（或由它们派生出来的结构）来定义程序的流程

条件分支语句

Java语言提供了两种判断语句：if语句和switch语句。这两种语句用于实现判断，当符合某些条件时执行某段代码，否则将不执行
语法规则1：

if(条件表达式){
  代码块;  //0条到多条可执行语句，含义是当【条件表达式】返回值为true时执行这里，如果返回
为false这里不执行。如果代码块中只有一条语句，则{}可以省略
}

要求用户输入学生性别，如果输入true则显示男，其它不回显

Scanner sc = new Scanner(System.in);
System.out.println("请输入性别：true/false");
boolean bb = sc.nextBoolean();
if (bb) {//可以写成if(bb==true)
    //如果if(bb==false){}可以简写为if(!bb){}
 System.out.println("您输入的是男");
}
System.out.println("程序执行结束!");

语法规则2：一定会执行其中的一个分支，不可能出现都不执行或者都执行的情况

if(条件表达式){
  代码块1;  //0条到多条可执行语句，含义是当【条件表达式】返回值为true时执行这里
}else{
  代码块2; //当条件为true时执行[代码块1]，否则执行【代码块2】，不可能出现都执行或者都不
执行的情况
}

要求用户输入学生性别，如果输入true则显示男，其它显示女

Scanner sc = new Scanner(System.in);
System.out.println("请输入性别：true/false");
boolean bb = sc.nextBoolean();
if (bb) {
 System.out.println("您输入的是男");
}else {
 System.out.println("您输入的是女");
}
System.out.println("程序执行结束!");

语法3：多个条件多个分支

if(条件表达式1){
 代码块1; }else if(条件表达式2){  //允许多次出现
 代码块2; }else{    //当上面所有条件都不成立时执行
 代码块n; }

需求：要求输入学生成绩（假设成绩都是整数），如果>85显示优秀，如果>70显示良好，如果>60显示及格，否则显示不及格

System.out.println("请输入学生成绩:");//提示信息
Scanner sc = new Scanner(System.in);//构建Scanner对象
int score = sc.nextInt();//阻塞当前程序的执行，等待用户输入int类型的数据
//首先对用户录入的数据进行合法性验证
if(score>=0 && score<=100) {
 if (score > 85) {
 System.out.println("优秀");  //当其中一个语句块执行后则立即跳出if结构，不
会继续执行后续判断
 } else if (score > 70) //如果语句块只有一条语句则{}可以省略
    // 第二个条件实际上是一个复合条件   !(score>85) && score>70
 System.out.println("良好");
 else if (score >= 60)
 System.out.println("及格");
 else  //当所有条件都不成立时执行的语句
 System.out.println("不及格");
}else {
 System.out.println("输入的成绩不合法！");
}
System.out.println("执行结束");

if/if…else/if…else if…else允许嵌套

需求：要求输入学生成绩（假设成绩都是整数）和学生性别，如果男生>60显示你是个猪？，如果小于60显示你连猪都不如；如果女生>60显示还可以阿，如果小于60显示继续加油啊

public class Test1 {
 public static void main(String[] args) {
 int score = 0;// 定义临时变量用户存储学生成绩
 System.out.println("请输入学生成绩");
 Scanner sc = new Scanner(System.in);
 score = sc.nextInt();// 条件中要求学生成绩必须为整数
 // 由于sc.nextInt不能消费掉末尾的回车符，所以下一个nextLine则不能接收到数据
 if (sc.hasNextLine())
 sc.nextLine();
 boolean sex = true;// 用于存储性别
 System.out.println("请输入学生性别");
 String ss = sc.nextLine();// 读取一行数据
 sex = "男".equals(ss);
 // 验证程序的输入逻辑是否正确
 System.out.println("您输入的学生成绩为：" + score + ",性别为：" + sex);
 if (sex) {
 // 男生 , 如果男生>60显示你是个猪？，如果小于60显示你连猪都不如
 if (score > 60)
 System.out.println("你是个猪？");
 else if (score < 60)
 System.out.println("你连猪都不如");
 //注意：else不是必须的,else的含义是score<=60
 } else {
 // 女生,>60显示还可以阿，如果小于60显示继续加油啊
 if(score>60)
 System.out.println("还可以阿");
 else if(score<60)
 System.out.println("继续加油啊");
 }
 } }

标准输出

System.out.println(obj) 参数obj可以是任意类型的数据，实际上其它类型的数据是自动转换为字符串类型进行输出显示

键盘数据录入

Scanner用于实现接收用户的键盘录入数据
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();从键盘上接受一个用户录入的整数

Scanner s = new Scanner(System.in);//构建一个Scanner对象用于接收用户的键盘录入数
据
String ss=s.nextLine();//读取用户输入的一行数据，以回车作为标志
System.out.println("input:"+ss+"1111");

Scanner s = new Scanner(System.in);// 构建一个Scanner对象用于接收用户的键盘录入数
据
int ss = s.nextInt();// 接收用户输入的整数,如果输入数据的格式不正确，则报错中断程序;
如果用户不输入数据则一直等待用户输入
System.out.println("input:" + ss + "~~~~");

类似的方法还有用于接收浮点数的s.nextDouble等多种

开关分支语言

多个分支的等值判断时，使用switch比if使用方便

switch (表达式) {
 case 值1:
 操作 1 的语句;            break;
 case 值2:
 操作 2 的语句;            break;
 ….
 case 值n :
 操作 n 的语句;            break;
 default:
 默认语句; }

重点的语法规则：switch后面的表达式允许的数据类型？

• 允许byte\short\int，但是不允许long类型
• 允许字符类型和字串类型[特殊点，要求JDK1.7+],究其本质是比较字符串的hashcode值

String str="12";
switch (str) {
 case "0":
 System.out.println("黄口");
 //break用于实现跳出switch结构，否则继续向后执行直到break或者
switch结构结束
 break;  
 case "1":
 System.out.println("舞象之年");
 break;  
 case "2":
 System.out.println("弱冠");
 break;  
 case "3":
 System.out.println("而立之年");
 break;  
 default:
 System.out.println("乐期颐");
 break; //由于没有后续语句，所以break可以省略
}

 String和枚举类型的具体实现延迟到面向对象章节之后

• 枚举类型

需求：输入学生成绩，如果>=80显示优秀，如果>=60显示及格，否则显示不及格

int score=87;
switch(score){
    case 100:
    case 99:
   ......
    case 80:
   System.out.println("优秀！");
        break;
    case ....
}

简化代码：

public class Test2 {
 public static void main(String[] args) {
 System.out.println("请输入学生成绩:");
 Scanner sc=new Scanner(System.in);
 int score=sc.nextInt();
 if(score>=0 && score<=100) {
 int level=score/10;
 switch (level) {
  case 10:
                case 9:
                case 8:
                    System.out.println("优秀");
                    break;
                case 7:
                case 6:
                    System.out.println("及格");
                    break;
                default:
                    System.out.println("不及格");
                    break;
               }
 }else {
 System.out.println("输入的成绩不合法!");
 }
 } }

循环结构

循环就是重复做某一件事情。在Java程序中，循环控制即在某一情况下，控制程序重复执行某一条或多条语句，直到遇到终止条件为止
循环语句也称迭代语句，在Java语言中存在的while、for和do-while循环语句

while循环

while是Java中最基本的循环语句，满足条件才执行循环体，如果不满足条件则不执行。所以有可能循环体一次都不执行。
语法格式： while (继续循环的条件) { 循环所执行的代码; }

public class Test3 {
 public static void main(String[] args) {
 int res = 0;// 累加器
 int k = 1;// 用于控制循环次数
 while (k <= 100) {
 res += k++;//这里等价于res=res+k;k++;
 }
 System.out.println("1+2+3+...+100=" + res);
 } }

用while循环接收用户输入小明的成绩，如果用户输入不合法就反复输入，直到正确为止

public class Test3 {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int score = -1;
 while (score < 0 || score > 100) {
 System.out.println("请输入小明成绩:");
 String ss = sc.nextLine();
 try {
 score = Integer.parseInt(ss);
 if (score < 0 || score > 100) {
 System.out.println("要求成绩值应该0-100之间");
 }
 } catch (Exception e) {
 System.out.println("请输入合法的整数成绩值");
 }
 }
 System.out.println("小明的成绩为：" + score);
 } }

do-while循环

do-while 循环执行某些语句，直到指定的条件为假。此循环确保循环体至少执行一次。
语法格式： do{循环所执行的逻辑；}while(继续循环的条件);
样例：计算1+2+3+…+100=?

public class Test4 {
 public static void main(String[] args) {
 int res = 0;
 int k = 1;
 do {
 res+=k++;
 } while (k <= 100);
 System.out.println("1+2+3+...+100="+res);
 } }

for循环

for 循环主要用于按预定的次数执行语句或语句块
语法： for(语句1，一般用于初始化循环控制变量； 语句2，是循环继续执行的条件； 语句3，是每次循环执行结束后必须执行的语句){ 循环体语句； }
样例：计算1+2+3+…+100=?

public class Test6 {
 public static void main(String[] args) {
 int res = 0;
 for (int k = 1; k <= 100; k++)
 res += k;
// System.out.println(k); 報錯：变量k是在表达式1上声明的，只能在for循环内部有
效
 System.out.println("1+2+3+...+100=" + res);
 } }

三种循环的选择

1、如果不能提前预知循环次数，则使用while或者do/while循环，而for循环一般用在可提前预知循环次数的场景下
2、while循环可以出现一次都不执行的情况，但是do/while循环无论如何循环体都会被执行一次

输出九九乘法表

public class Test7 {
 public static void main(String[] args) {
 for(int i=1;i<=9;i++) {//控制行数
 for(int k=1;k<=i;k++) {//控制每行的列数
 System.out.print(k+"*"+i+"="+(i*k)+"\t");
 }
 System.out.println();
 }
 } }

循环中使用的跳转语句

Java提供了三种跳转语句：break、continue以及return，用来强制转移程序执行的顺序

break

break语句除了与switch结合使用外，还用来强制中断当前的循环，不再执行循环体中break后面的语句而退出循环。譬如在后续将学到从数据库里循环取出数据，用来验证用户的用户名是否正确。如果当用户名符合某一条数据时，就需要用到break语句来结束当前的循环验证

continue

continue语句的功能是，在循环语句中，当碰到continue时，将不再执行循环体continue之后的语句，而重新判断循环控制的条件，继续循环，直到循环条件的值为假时退出循环
例如：用continue语句来计算1～10中所有偶数之和