什么是Java语言
一种面向对象的语言
编写程序的开始就是编写类的开始 class 用于定义类
一种平台无关的语言，必须程序运行的解释环境
真正的运行步骤为 javac编译–java解释执行
一种健壮的语言，吸收了C/C++语言的优点，但是去掉了影响程序健壮性的部分，例如指针、内存的申请与释放等。
典型的应用场景：互联网环境
常见错误
1、使用临时变量，Java要求必须是先定义后使用，必须是先赋初值后使用
2、目前的要求：将所有的程序都必须写在方法内部，不能写在方法外
Java的三种核心机制
Java语言包含三种核心机制：Java 虚拟机、垃圾收集机制和代码安全检测。
Java虚拟机 JVM
Java虚拟机可以理解成一个以字节码为机器指令的CPU
对于不同的运行平台，有不同的虚拟机
Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”
int k;
Systm.out.println(k);
public class ForTest{
int res=0;
for(int k=1;k<101;k++){
res+=k;
}
System.out.println(“1+2+3+…+100=”+res);
}
垃圾收集机制 gc
不再使用内存空间回收——垃圾回收
在C/C++等语言中，由程序员负责回收无用内存
Java语言消除了程序员回收无用内存空间的责任，它提供了一种系统级线程跟踪存储空间的分
配情况，并在JVM的空闲时检查并释放哪些可被释放的存储空间
垃圾收集在Java程序原型过程中自动运行，程序员无法精确控制和干预
代码安全性检查
Java代码的目标运行环境在于网络，Java以牺牲执行性能为代价换取了高安全性
首先由类加载器classLoader负责将类文件.class加载到Java虚拟机中。通过区分本地文件系统的类
和网络系统导入的类增加安全性，可以限制任何木马程序，因为本机类总是有限被加载，一旦所有
的类都被加载完毕，直线文件的内存就固定了。
其次字节码校验器进行校验。字节码校验器不检查那些可信任的编译器生成的类文件，而是对违背
命名空间规定和java语言规则的类进行检查，并且关闭具有安全性漏洞的类文件
最后字节码校验通过后，才由Java解释器负责将类文件解释成为机器码进行执行
Java中标识符
字母（Unicode编码字符集）、数字、下划线和
符构成，不允许数字打头严格区分大小写
I
S
O
8859
−
1
G
B
2312
和
G
B
K
【
G
B
8030
】
U
n
i
c
o
d
e
统一编码字符集由
于
和
符构成，不允许数字打头 严格区分大小写 ISO8859-1 GB2312和GBK【GB8030】 Unicode统一编码字符集 由于_和
符构成，不允许数字打头严格区分大小写ISO8859−1GB2312和GBK【GB8030】Unicode统一编码字符集由于和有特殊含义，一般不建议用户直接使用
不建议使用中文命名
不允许使用保留字(goto const)和关键字(public class static…)
长度没有限制
编码规范
类名首字母大写，大写字母分词 建议名词。例如UserName或者MingZi
方法名称首字母小写，大写字母分词
变量名称首字母小写，大写字母分词
包名称全小写，使用域名反转的方式定义
平常练习中遵循SUN的基础规范；项目开发中要求遵循ali发布的规范。进入公司首先考察公司的编码规
范
Java是一种先编译后解释执行型语言
javac Hello.java【源代码文件名称】编译，将源代码转换为虚拟机可以识别的中间性质语言，一般生成
一个同名的后缀为class的文件【二进制文件，字节码文件】,这里就是跨平台的原理
java Hello[类名称，就是源代码中class关键字后面所跟的名称]一般是解释执行字节码文件
Java语法基础
Java大小写敏感。比如HelloWorld和Helloworld是不一样的
包名Package是公司、组织、个人的域名的反转，一般是英文字母。英文字母必须是小写
包名称可以认为是一个名空间
例如蓝鸥的网址为lanou3g.com，定义包名称为com.lanou3g
类名ClassName和方法名称采用驼峰命名法，例如StudentName
Java源文件的文件名必须和文件中公共public类名称一样
关键字中所有字母都为小写。关键字不能用作变量名，方法名，类名，包名和参数。
Java是一种自由格式的语言，可用任意个空格、制表符、换行符隔开
每个词
System.
out.
println
( “Counted " + count + " chars.” );
同时也允许将多行代码写在一行上,注意使用分号隔开。所有的语句末尾以分号;收尾
java中空语句
常见的编程错误
目前的要求：将所有的程序都必须写在方法内部，不能写在方法外
使用临时变量，Java要求必须是先定义后使用，必须是先赋初值后使用
Java标识符
标识符可从一个字母(Unicode编码字符集)、下划线_或美元符号$开始，随后也可跟数字、字母、下划线
或美元符号。
标识符是区分大小写，没有长度限制，可以为标识符取任意长度的名字
标识符不允许使用保留字。关键字对Java编译器有特殊的含义，它们可标识数据类型名或程序构造
construct名， java语言中的保留字均用小写字母表示
变量
变量是Java程序中的基本存储单元，它的定义包括变量名、变量类型和作用域几个部分
例如int k=100; 其中int是数据类型，k是变量名 m
变量名称：在一个方法内部不允许出现多个同名称的变量
public class Hello { //公共类名称为Hello,则对应的文件名称必须为Hello.java
}
for(int i=0;i<10;i++)cc++; dd++;
;
java要求见名知意，例如username。但是xm则不建议使用
变量类型：
Java属于强类型编程语言，变量类型一旦声明，则不能进行修改
数据类型可以决定变量所需要的存储空间大小和对应的处理逻辑
作用域是指变量的有效范围，一般是在所在花括号范围内
JAVA是强类型语言
每个变量有类型，每个表达式有类型，而且每种类型都是严格定义的
Java编译器对所有的表达式和参数都要进行类型相容性的检查，以保证类型是兼容的
任何类型的不匹配都将被报告为错误而不是警告。在编译器完成编译以前，错误必须被改正过来
在Java语言数据类型可以分为两大类：基本类型和引用类型
int k; 声明一个变量，类型为整形，变量名称为k
int k=100; 声明变量的同时进行初始化
k=12.345; 语法错误，因为已经声明了类型为整形，但是12.345不是整数
d=123; 语法错误，因为Java语法要求对于变量必须是先定义后使用
public static void main(String[] args){
{
System.out.println(k);//错误1：要求临时变量必须是先定义后使用，必须是先赋初值后使
用
int k=100;
System.out.println(k);
}
System.out.println(k);//错误2：因为k定义在{}内部，所以k只在上面的{}分为内有效，离开了
{}则失效，{}外引用k则报错
}
public static void main(String[] args){
int k=99;
{
System.out.println(k);
int k=100; //错误：因为Java是强类型编程语言，所以在{}外已经声明了k的类型，在k的有效
范围内不允许重新声明。这里可以修改为k=100;
System.out.println(k);
}
System.out.println(k);
}
short k1=123;
int k2=k1;//没有错误
String s1=“123”;//字符串类型
int k1=s1;//语法报错
基本类型(原生类型)
基本类型是指不能再分解的数据类型，其数据在函数的调用中是以传值方式工作的。
简单数据类型代表单值，而不是复杂的对象
Java是完全面向对象的，但简单数据类型却不是，它们类似于其他大多数非面向对象语言中的简单数据
类型。这样做的原因是出于效率方面的考虑。在面向对象中引入简单数据类型不会对执行效率产生太多
的影响。
Java针对基本类型同时提供了对应的引用类型：包装类
Java编程语言有八个原始数据类型，可分为4种整型、浮点数、字符型数据和布尔型数据，不会随着计算
机类型而变化的，注意Java具有平台无关性，所以不论硬件平台是什么，1B都是8位
整型有4种：byte字节整、short短整、int整、long长整
java中的数据采用的是补码的存储方式
计算机中存储数据有3种不同的方式，分别是原码、反码和补码
byte：1B(8b)，-128到127
short：2B，-32768到32767
int：4B，-2147483648到2147483647
long：8B，-9223372036854775808到9223372036854775807
如果需要使用具体的上下限取值，可以通过包装类中的常量进行使用
十进制整数。如123，－456，0
八进制整数。以0开头，如0123表示十进制数83，－011表示十进制数－9。
十六进制整数。以0x或0X开头，如0x123表示十进制数291，－0X12表示十进制数－18
a–>10 b–>11 c–>12 d–>13 e–>14 f–>15
二进制整数，以0b或0B开头，例如0b10110010
byte k = 100;//语法正确100在指定范围内
byte kk = 130;//语法报错，因为130超出byte的存储范围限制
//这里的面试点在常量池
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
int k1=123;
int k2=0123;
int k3=0x123;
int k4=0b100101;
System.out.println(k1+“\t”+k2+“\t”+k3+“\t”+k4);//具体输出时，系统会自动将k2转换为10进
制输出
可以通过包装类中提供的方法将十进制数转换为2、8和16进制
整数类缺省为int类型，如在其后有一个字母“l或者L”表示一个long值
浮点数类型
float单精度、double双精度
float是4B，可以保证小数点后6位有效精度和第7位的部分精度 e38
32位,1个符号位,23个尾数位,8个指数位
1.4E-45到3.4028235E38
double是8B，可以保证小数点后15位有效精度和第16位的部分精度。e308
64位,1个符号位,52个尾数位,11个指数位
4.9E-324到1.7976931348623157E308
浮点数是无法精确存放的，原因在于将浮点数转换为补码时的限制。除非使用BigDecimal
针对浮点数则不能使用等值判断
Java浮点数都是用科学计数法来存储数据的，无论是单精度还是双精度在存储中都分为三个部分：
符号位Sign : 0代表正，1代表为负，是第一位
指数位Exponent：用于存储科学计数法中的指数数据，单精度为8位，双精度11位。用指数部分的
值（8位/11位unsigned）的值减去偏移附加值得到该数实际的指数。例如值为200，实际指数为
73=200-127，对于双精度的double来说常量1023
尾数部分Mantissa
样例17.625在内存中的存储为：
首先要把17.625换算成二进制：10001.101
int k = 123;
String ob=Integer.toBinaryString(k);//将十进制数转换为2进制的字符串
System.out.println(ob); //1111011
String oo=Integer.toOctalString(k);
System.out.println(oo); //173
String oh=Integer.toHexString(k);
System.out.println(oh);//7b
123系统会自动识别为int类型
123L或者123l系统自动识别为long
double res = 0;
for (int i = 0; i < 10; i++)
res += 0.1;
System.out.println(res); //0.9999999999999999
double d = 0.1d;
long l = Double.doubleToLongBits(d); //long类型和double类型都是64位的,他们的内存大小一
样,这个函数的做法就是把double对应的内存结构复制到同样大小的long类型变量的内存结构中.返回这个
long值
System.out.println(t.getLongBits(l));
整数部分：除以2，直到商为0，余数反转
小数部分：乘以2，直到乘位为0，进位顺序取。(即：乘2取整法)
再将10001.101右移，直到小数点前只剩1位，1.00011012^4 ，右移动了四位。
底数：因为小数点前必为1，所以IEEE规定只记录小数点后的就好。所以，此处的底数为
0001101
指数：实际为4，必须加上127（转出的时候，减去127/1023），所以为131。也就是
10000011
符号：因为是正数，所以是0
综上所述，17.625在内存中的存储格式是：01000001 10001101 00000000 00000000
表示方法：
十进制数形式。由数字和小数点组成，且必须有小数点，如0.123, 1.23, 123.0
科学计数法形式。如：123e3或123E-3，其中e或E之前必须有数字，且e或E后面的指数必须为整数
f或者F表示float，而d或者D代表double。例如123f或者123.45D，系统默认为double类型
Java精确计算问题
关键字strictfp是strict float point的缩写，指的是精确浮点，它是用来确保浮点数运算的准确性。
JVM在执行浮点数运算时，如果没有指定strictfp关键字，此时计算结果可能会不精确，而且计算
结果在不同平台或厂商的虚拟机上会有不同的结果，导致意想不到的错误。而一旦使用了strictfp
来声明一个类、接口或者方法，那么在所声明的范围内，Java编译器以及运行环境会完全依照IEEE
二进制浮点数算术标准来执行，在这个关键字声明的范围内所有浮点数的计算都是精确的。
需要注意的是，当一个类被strictfp修饰时，所有方法都会自动被strictfp修饰。因此，strictfp可以保证
浮点数运算的精确性，而且在不同的硬件平台会有一致的运行结果。但是精确计算事实上还是没有得到
保障，这是受到存储方式的限制。需要精确计算还是以来BigDecimal实现的。
金融类的应用中可以使用long存储数据，货币单位为分
常见数学计算
Java的Math类中包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math的方法都被定义为static 形式，通过Math类可以在主函数中直接调用。
Math.sqrt()计算平方根
Math.pow(a, b)计算a的b次方
Math.max(a,b)计算最大值
Math.min(a,b)计算最小值
Math.abs()求绝对值
Math.ceil天花板的意思，就是返回大的值；floor地板的意思，就是返回小的值；round 四舍五
入，float时返回int值，double时返回long值
int k=16; //如果不能执行计算，则返回NaN
double res=Math.sqrt(k);
System.out.println(res);
random 取得一个大于或者等于0.0小于不等于1.0的随机数
字符类型 char
Java中存放字符采用的是Unicode编码字符集，2B，0-65535
字符类型的变量可以当作整数使用
char c=‘a’; 注意：这里使用的是单引号，不是双引号，单引号中只能包含一个字符
需要记忆： ‘0’ < ‘A’ <‘a’
Java也提供转义字符，以反斜杠（\）开头，将其后的字符转变为另外的含义
基本使用
double d1=-1234.567;
System.out.println(Math.ceil(d1));//-1234.0
System.out.println(Math.floor(d1));//-1235.0
System.out.println(Math.round(d1)); //-1235 容易出错的位置
d1=1234.567;
System.out.println(Math.ceil(d1)); //1235.0
System.out.println(Math.floor(d1));//1234.0
System.out.println(Math.round(d1)); //1235
\ddd 1到3位8进制数所表示的字符(ddd) 例如’\110’实际就是字符H
\uxxxx 4位16进制数所表示的字符(xxxx)，例如’\u9110’表示字符’鄐’
\’ 单引号字符,例如’‘’
" 双引号字符,例如’“‘实际上是可以的，但是这样写可读性非常差，所以建议使用’”’
\ 反斜杠字符
char c=‘h’;
System.out.println((int)c); //获取’h’字符对应的unicode编码值 104
//GB2312
System.out.println©;
// c=‘ab’ 语法报错，因为只能对应一个字符
//引入转移字符
c=‘’‘;
c=’\110’;
System.out.println©;//H
System.out.println((int)c);//72
c=‘\u0050’;
System.out.println©; //P
System.out.println((int)c);//80
布尔类型 boolean
boolean数据类型有两种文字值：true真和false假
在Java编程语言中boolean类型只允许使用boolean值，在整数类型和boolean类型之间无转换计算
boolean类型被编译为int类型，等于是说JVM里占用字节和int完全一样，int是4个字节，于是
boolean也是4字节
00000000 00000000 00000000 00000001:true
00000000 00000000 00000000 00000000:false
boolean数组在Oracle的JVM中，编码为byte数组，每个boolean元素占用8位=1字节
boolean[] fs = {true,false};
{00000001,00000000}
基本数据类型转换
小转大自动转换
大转小需要强制转换
类型转换的语法：
double
boolean a1=true;
boolean b1=false;
byte b1=123;
long k1=b1;
double kk=k1;
System.out.println(kk);
long kk = 123456L;
float ff=kk; //没有错误。float 4B long 8B
double dd=123.567;
long kk=(long)dd;
System.out.println(kk);
int k=100;
char cc=(char)k; //强制类型转换：窄化操作
char k=‘d’;
System.out.println((int)k);
boolean bb=true;
System.out.println((int)bb);//因为boolean类型和数值类型之间没有任何对应关系，所以这里的强
转会报语法错误
复合数据类型
复合数据类型包括：class类、interface接口、数组。
null 索引在运行时并没有对应的类型，但它可以被转换为任何类型（不能是简单类型）。
索引类型的默认值就是null
常量
常量就是指在程序执行期间其值不能发生变化的数据，常量是固定的。如整型常量123，实型常量
1.23，字符常量’A’，布尔常量true等
需求：要求用户键盘输入一个整数的半径值，计算园的面积
还需要计算周长
float f1=123.456;//语法报错，因为系统默认带小数点的数据为double类型，所以123.456是double
类型的数据，而声明f1为float，所以这里需要进行数据类型转换或者进行特殊声明。如果浮点数转换为整数
是直接截断小数部分。
float f1=(float)123.456;
float f1=123.456f; //数字末尾的f类似于数字末尾的L，用于进行数据类型的说明，f/F表示这是一个
float类型的数据 d/D表示是一个double类型的数据
Scanner sc = new Scanner(System.in);
System.out.println(“请输入半径值：要求整数”);
int r=0;//定义一个变量
r=sc.nextInt();//会等待用户输入整数值，如果不正确则会有红色报错信息
//计算园的面积
double res=3.14rr; //Math.pow(r, 2)
//输出计算结果
System.out.println(“半径值为”+r+“的圆形面积为”+res);
但是客户提出需求变动，认为2位小数精度不足，需要进一步提升精度
解决方案就是将2处的3.14修改为3.1415926
新问题是：如果修改时漏改一处，则是一个隐藏的bug。引入常量以避免出现这样的问题。
如何接收键盘录入数据
java.util.Scanner类常用于控制台的输入，当需要使用控制台输入时即可调用这个类。
使用方法
首先需要构造一个Scanner类的对象，并且与标准输入流System.in关联 Scanner sc = new
Scanner(System.in);
调用Scanner类对象sc的方法从输入流中获取你需要的输入
说明：
当创建了一个Scanner类对象之后，控制台会一直等待输入，直到敲回车键结束，把所输入的内容
传给对象sc，若要获取需要的内容，调用sc的方法即可
Scanner sc = new Scanner(System.in);
System.out.println(“请输入半径值：要求整数”);
int r=0;//定义一个变量
r=sc.nextInt();//会等待用户输入整数值，如果不正确则会有红色报错信息
//计算园的面积
double res=3.14rr; //Math.pow(r, 2)
//计算圆的周长
double dd=3.142r;
//输出计算结果
System.out.println(“半径值为”+r+“的圆形面积为”+res+“,对应周长为”+dd);
public class Test1 {
static final double PI=3.14159267989;//定义一个常量，这个值一旦赋值则不允许修改。常
量的命名规则全大写，使用_分词
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入半径值：要求整数”);
int r=0;//定义一个变量
r=sc.nextInt();//会等待用户输入整数值，如果不正确则会有红色报错信息
//计算园的面积
double res=PIrr; //Math.pow(r, 2)
//计算圆的周长
double dd=PI2r;
//输出计算结果
System.out.println(“半径值为”+r+“的圆形面积为”+res+“,对应周长为”+dd);
}
}
Scanner sc=new Scanner(System.in);
System.out.println(“请输入园的半径值:”); //用于提示用户录入数据
int r=sc.nextInt(); //要求用户输入数据，否则阻塞等待用户输入
System.out.println(“接受到的数据为”+r);
每次可以只输入一个数字，回车确认，例如123，只能被一个nextInt读取。
也可以输入一组数字，例如123 456 789，每个数字之间用空格（一个或多个空格）隔开，可被多
个nextInt()读取，空格及回车不会被读取。（注：输入数字中不能夹杂除数字、空格、回车之外的
其他字符，否则会报错）
如何在控制台输出数据
表达式
表达式就是运算符、操作数以及方法调用的序列，用来说明某个计算过程并返回计算结果. 按照运算符功
能来分，基本的运算符分包括算术运算符、关系运算符、位运算符、条件运算符等
算术运算符 +、-、、/、%、++、–
关系运算符 >、<、>=、<=、、!=
逻辑运算符 &&、 ||、 !。注意：逻辑计算支持短路操作
位运算符 &、|、^、~、<< 、 >>、>>>。注意：为运算符不支持短路操作[考点]
赋值运算符 =，+=，―=，=，/=
三目条件运算符（？：）规则是完全一致的，使用的形式是： x ? y：z;
算术运算符 +、-、、/、%、++、–
System.out.println(数据);
System.out.println(“请输入园的半径值:”);
int kk=100;
double res=3.14kkkk;
System.out.println(“园的半径值为”+kk+“,对应面积为”+res);
±/
整除：参与运算的双方都是整数 10/3=3而不是3.33333
如果是10./3=3.333…这里由于10.是浮点数，则3会自动转换为大类型并参与计算，所以最终是10.0/3.0
的计算结果
计算次序为先乘除后加减，如果优先级一致，则自动从左向右进行计算 10+25=20
/除法分母不能为0，否则出错
% 求余（取模） 10%3=1实际就是10除以3求余数
double k=10.12;
System.out.println(k%3);
输出：1.1199999999999992 应该返回值为1.12，由于浮点数不能精确存放，所以返回值是一个类似值
double d1=-10.12;
double res=d1%3;
System.out.println(res);
输出值为-1.1199999999999992 求余计算中符号位不参与计算
double dd=12.45;
System.out.println(dd%3.1); //0.049999999999998934
++和–是单目运算符
i++等价于i=i+1,i–等价于i=i-1
以++为例写法有2个：i++或者++i
考核题目
考核题目2
关系运算符 >、<、>=、<=、、!=
用于判断两个数据之间的大小关系，计算结果为boolean，如果成立返回为true，否则为false
浮点数的比较
i++是先获取i的值，然后再对i加1
int age=100;
System.out.println(age++);输出为100
System.out.println(age); 输出为101,因为上面进行加1
++i是先对i加1，然后再获取i的值
int age=100;
System.out.println(++age);输出101,先加1然后获取值
System.out.println(age); 输出101
public class Oper11 {
public static void main(String[] args) {
int k = 0;
int res = k++ + k++ + k;
System.out.println(res); //3
int m = 0;
res = ++m + m++ + m;
System.out.println(res); //4
}
}
//编译失败
short k1=1;
k1=k1+1; //因为1默认是int类型，所以k1+1的结果为int类型。将int类型的数据赋值为short类型，所
以报错。可以修改为k1=(short)(k1+1)
k1++;//编译通过，自动进行转换
k1+=1;//编译通过，等价与k1=k1+1,自动进行转换
double d1=10;
System.out.println(d1>3); 返回true
和=的区别:
k=100;这是赋值运算符，意思是将=右边的计算结果储存在=左边的变量中
k100这是比较计算符，意思是判断k是否值为100；如果是则返回true，否则false
!=意思是判断是否不等于，表示如果相等时返回false，否则返回true
k!=100不等于判定，如果k值为100则返回false，如果k值不是100则返回true
由于浮点数无法精确存放，所以判断k==1.0这个写法是错误的
正确写法： a-b的绝对值小于1e-6
Java提供了一个工具类Math，其中包含一个abs()的方法实现求绝对值
Math.abs(d1-1)<1e-6 判断浮点类型的变量d1的值是否为1
需求：
用户输入身高和体重，计算对应的BMI指数值
BMI指数（英文为Body Mass Index，简称BMI），是用体重千克数除以身高米数的平方得出的数字，是
国际上常用的衡量人体胖瘦程度以及是否健康的一个标准
按照我国标准，18.5-24.9kg/m2为正常，24-27.9kg/m2为超重，≥28kg/m^2为肥胖，而BMI＜
18.5kg/m^2为消瘦
如何实现接受用户的键盘录入数据
如何实现屏幕输出
练习题：
1、键盘录入升数，输出对应的加仑数
double res = 0;
for(int i=0;i<10;i++)
res=res+0.1;
if(Math.abs(res-1)<1e-6) //|res-1|判断是否小于10的-6次方
System.out.println(“计算结果为1”);
else
System.out.println(“计算结果不为1”);
System.out.print(“请输入身高:”);
Scanner sc = new Scanner(System.in);
double height = sc.nextDouble();
System.out.println(“请输入体重：”);
double weight = sc.nextDouble();
//算法的问题 BMI指数
double bmi = weight / height / height;
System.out.println(“您的bmi指数为:” + bmi);
//建立一个变量指向键盘录入
Scanner sc = new Scanner(System.in);
//通过这个变量读取用户键盘录入的数据，如果用户不输入则一直等待,如果输入的数据不是浮点数，则报错
double height=sc.nextDouble();
变量sc中是Java提供的具体实现方法nextDouble实现从键盘读取一个浮点数，如果要求用户输入int，则方
法为nextInt，。。。
System.out.println(“具体需要输出的内容”);输出内容后会自动换行，如果不需要换行，则使用方法
System.out.print(“”)
System.out.println(“num:”+num);意思是输出【num：123】
System.out.println(“num:num”)意思是输出【num:num】
2、键盘录入华氏温度，输出对应的摄氏温度值
3、键盘录入公斤数，输出对应的磅数
4、有5英亩的草地，一只羊每小时吃1.2平方米的草地的草，请计算多长时间可以吃完所有草地的草
逻辑运算符 &&、 ||、 !
注意：逻辑计算支持短路操作
表达多个条件之间的关系。例如年龄大于等于18并且年龄小于65
&&:与运算，含义是两个条件必须同时成立，可以翻译为并且
1加仑(美)=3.785 412升
Scanner sc=new Scanner(System.in);
System.out.print(“请输入升数:”);
double d=sc.nextDouble();
double g=d/3.785412;
g=g10000+0.5;
g=(int)g/10000.;如果写成(int)g/10000结果一定是没有小数,因为参与运算的双方是整数，所以除法是
整除运算
System.out.println(d+“升等于”+g+“加仑”);
C = 5×(F- 32)/9
Scanner sc = new Scanner(System.in);
System.out.println(“请输入华氏温度值:”);
double f = sc.nextDouble();
// C = 5×(F- 32)/9
double cc = 5 * (f - 32) / 9;
//额外要求：只输出整数
System.out.println(“华氏” + (int) f + “等于摄氏” + (int) cc);
1英亩 =4046.864798平方米
1、将英亩转换为平方米
2、平方米/1.2获取小时数
3、将小数部分的小时值转换为分钟和秒
int num = 5;
double pfm = num * 4046.864798;
double h = pfm / 1.2;
int hour = (int) h;
double n2 = (h - hour) * 60;
int min = (int) n2;
n2 = (n2 - min) * 60;
int sec = (int) n2;
sec = sec + 1;
System.out.println(“吃完” + num + “英亩草地需要的时间为” + hour + “小时” + min + “分
钟” + sec + “秒”);
||：或运算，含义是两个条件中成立一个即可，可以翻译为或者
!：非运算，含义是不是，用于对某个条件进行否定
短路运算[考试,难度2星]
例如A && B:如果条件A为false,则不会执行B，因为根据运算规则结果一定是false，和B的值没有关系
A||B：如果条件A为true，则不会执行B，因为格局运算规则结果一定是true，和B的值没有关系
考核中主要配置++/–进行测试
年龄大于等于18并且年龄小于65
age>=18 && age<65
算法规则：同真则真，其余为假
年龄小于18岁或者年龄不小于65
age<18 || age>=65
算法规则：同假则假，否则为真
年龄不小于18
写法1：age >=18
写法2： !（age<18）
算法规则：非真则假，非假则真
int age=100;
char cc=‘A’;
if(cc>=‘B’ || age++<200){
System.out.println(“ZZZZZ”);
}
System.out.println(age);//?输出101
int age=100;
char cc=‘A’;
if(cc>=‘B’ && age++<200){
System.out.println(“ZZZZZ”);
}
System.out.println(age);//?输出100,因为短路的原因，导致age++并没有得到执行
int age=200;
char cc=‘A’;
if(cc>=‘B’ || age++<=200){
System.out.println(“ZZZZZ”);
System.out.println(age);//?输出201
}
赋值运算符 =，+=，-=，=，/=，%=
int k=100; 含义是将100赋值存储在k对应的存储单元中
k=k+3可以简写为k+=3 -= / /=类似
考点【难度系数3】
结构化编程
结构化程式设计(英语:Structured programming)是1960年代开始发展起来的一种编程典范。它采用子
程序、程式码区块、for循环以及while循环等结构来取代传统的goto。
指导思想
自顶向下、逐步求精、模块化
编程过程
流程图是流经一个系统的信息流、观点流或部件流的图形代表。在企业中，流程图主要用来说明某一过
程。这种过程既可以是生产线上的工艺流程，也可以是完成一项任务必需的管理过程。
常见的绘制工具有Visio、PowerDesigner等。
1、圆角矩形表示“开始”与“结束”。
2、矩形表示行动方案、普通工作环节用
3、菱形表示问题判断或判定（审核/审批/评审）环节
4、用平行四边形表示输入输出
5、箭头代表工作流方向
short k=3;
k=k+3; //出现了一个语法错误，因为k+3这里的3系统识别为int类型，所以计算时所有数据自动转换为
int类型，必然计算结果也是int类型，将int类型的数据赋值给short类型变量----错误
System.out.println(k);
short k=3;
k+=3; //没有语法错误，因为+=这种符号中包含了自动类型转换
推荐工具：ProcessOn 支持流程图、思维导图、原型图、UML、网络拓扑图、组织结构图等
结构化编程的推论
任何复杂的问题都可以三种基本算法结构来描述：顺序、选择、循环。因此用计算机语句描述的程序也
包含三种基本结构
条件分支语句
Java语言提供了两种判断语句：if语句和switch语句。这两种语句用于实现判断，当符合某些条件时执行
某段代码，否则将不执行
语法
if(条件判断语句){代码A;} 当条件成立时执行代码A，如果条件不成立则不执行代码A，而是直接
执行if的下一句
if(条件){代码块1;}else{代码块2;} 当条件成立时执行代码块1，如果条件不成立则执行代码块2。没
有一种情况是同时执行代码块1和2
if(条件1){代码块1;}else if(条件2){代码块2;}…else{代码块n;} 当条件1成立时执行代码块1，如果条
件1不成立继续判断条件2，如果条件2成立则执行代码块2,依次类推。没有一种情况是同时执行代
码块1和2
说明：允许多个if之间进行相互嵌套
需求：要求输入学生性别，如果false则显示女的啊!
要求输入学生成绩（假设成绩都是整数），如果>60显示及格，否则显示不及格
Scanner sc = new Scanner(System.in);
boolean bb = sc.nextBoolean();
if (bb == false) { //判真一般用法为if(bb){} 判假 if(!bb){}
System.out.println(“性别为女”);
}
要求输入学生成绩（假设成绩都是整数），如果>=85显示优秀，如果>=70显示良好，如果>=60显示及
格，否则显示不及格
修改代码
开关分支语言switch
语法：
switch(表达式){
case 值1： 判断表达式的值是否在值1，如果相等则执行代码块1
代码块1； break; 执行完成后，如果没有break，则自动执行后续语句，但是不进行判
定。如果有break则立即中断switch的执行，跳到switch块的下一局继续执行
多个case语句:
… …
default:如果所有的case都不能成立，则执行代码块n
代码块n; break;
}
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if (score >= 60) {
System.out.println(“成绩及格”);
} else {
System.out.println(“成绩不及格”);
}
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if (score >= 85) {//这里的顺序不能调整，因为条件成立后则立即执行代码块，执行结束则自动跳出
if，不会继续判断
System.out.println(“成绩优秀”);
} else if(score>=70) {
System.out.println(“成绩良好”);
} else if(score>=60){
System.out.println(“成绩及格”);
} else {
System.out.println(“成绩不及格”);
}
if (score > 70) {
System.out.println(“良好”);
} else if (score > 85) { //这里的代码永远不会有执行机会。因为这里的if条件实际上是一个复合
条件，if(score<=70 && score>85){}
System.out.println(“优秀”);
} else if (score > 60) { //score<=70 && score<=85 && score>60
System.out.println(“及格”);
} else {
System.out.println(“不及格”);
}
语法点：
表达式的计算结果可以是整型【不允许long类型】,可以是char，同时允许是字串类型[String]
也可以是枚举类型
case值类型必须和switch条件类型相同或者能隐式转换为switch表达式类型
case值必须唯一，不能与其它的重复
default的位置没有特殊要求，但是一定是所有的case值不相等时才会执行。但是为了增强可读
性，所以一般建议写在所有的case之后
需求：输入月份，显示对应的本月的天数
三目运算符
三目条件运算符（？：）规则是完全一致的，使用的形式是： x ? y：z;
需求：要求输入两个整数，输出最大的整数
使用if判断的实现方式：
System.out.println(“请输入月份:”);
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
switch (m) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(“本月31天”);
break;
case 2:
System.out.println(“请输入年份:”);
int year = sc.nextInt();
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
System.out.println(“本月29天”);
} else
System.out.println(“本月28天”);
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(“本月30天”);
break;
default: //default写在switch内部的任何位置上实际都不会影响执行逻辑，但是不建议，
因为会影响可读性
System.out.println(“月份错误!”);
break;
}
}
}
public class Test8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
使用三目运算符实现
要求表达式1必须返回值为boolean类型
要求表达式2和表达式3的返回值类型一致
Object max = num1 > num2 ? num1 : “num2”;
题目
循环结构
循环就是重复做某一件事情。在Java程序中，循环控制即在某一情况下，控制程序重复执行某一条或多
条语句，直到遇到终止条件为止
循环语句也称迭代语句，在Java语言中存在的while、for和do-while循环语句
需求：计算1+2+3+…+100=5050
while循环
while是Java中最基本的循环语句，满足条件才执行循环体，如果不满足条件则不执行。所以有可能循环
体一次都不执行。
语法：
System.out.println(“请输入第一个整数:”);
int num1 = sc.nextInt();
System.out.println(“请输入第二个整数:”);
int num2 = sc.nextInt();
int max = num1;
if (max < num2)
max = num2;
System.out.println(“两个整数(”+num1+“,”+num2+“)中最大的值为:”+max);
sc.close();
}
}
Scanner sc = new Scanner(System.in);
System.out.println(“请输入第一个整数:”);
int num1 = sc.nextInt();
System.out.println(“请输入第二个整数:”);
int num2 = sc.nextInt();
/
- if(num1>num2) max=num1;
- else max=num2;
*/
int max = num1 > num2 ? num1 : num2;
System.out.println(“两个整数(”+num1+“,”+num2+“)中最大的值为:”+max);
sc.close();
int k=100;
int m=99;
int res=k>100?m++:++m;
System.out.println(res); //100 k>100不成立，则直接执行++m，而和表达式2：m++无关，不会
执行
System.out.println(m); //100
while(条件){循环体;} 当条件成立时反复执行循环体，每执行一次判断一次条件。
没有很明确的次数控制
需求：要求输入一个合法的年龄值【和业务需求相关】
需求：计算所有100以内奇数的和
int res=0;//累加器，用于存放每次循环体的执行结果
int k=1;//控制循环次数
while(k<101){
res=res+k;
k++;
}
System.out.println(“1+2+3+…+100=”+res);
int res = 0;// 累加器，用于存放每次循环体的执行结果
int k = 0;// 控制循环次数
while (k++ < 100)
res += k;
System.out.println(“1+2+3+…+100=” + res);
int res = 0;// 累加器，用于存放每次循环体的执行结果
int k = 0;// 控制循环次数
while (++k <= 100)
res += k;
System.out.println(“1+2+3+…+100=” + res);
int res = 0;// 累加器，用于存放每次循环体的执行结果
int k = 1;// 控制循环次数
while(true){//这个写法一般用于没有很明确的次数控制时
res+=k;
if(++k>100)
break; //当满足条件则跳出while循环体
}
System.out.println(“1+2+3+…+100=”+res);
int age=0;
while(true){
System.out.println(“请输入学生年龄：”);
age=sc.nextInt();
if(age>=18 && age<=24)
break;
else
System.out.println(“您输入的是”+age+“,这是一个不合法的年龄”);
}
int res=0; //累加器
int k=0; //循环控制变量
while(++k<101){
if(k%21)
res+=k;
}
System.out.println(“1+3+5+…+99=”+res);
break和continue的用法
break和continue的区别：
break是立即终止循环，进入循环结构的后续代码继续执行,循环体执行结束
continue是终止本次循环，进入下次循环，循环并没有执行结束
do/while循环
语法：
do{循环体;}while(条件); 先执行循环体，然后进行条件判断，如果条件为true，则执行下次循环；如果
条件为false则终止循环。
不同于while循环的点：do/while循环至少执行循环体一次，而while循环有可能一次都不执行.
for循环
语法：for(表达式1；表达式2；表达式3){循环体;}
执行表达式1
执行表达式2，一般表达式2是一个条件，如果条件为true则执行循环体；如果条件为false则终止循
环
执行循环体
执行表达式3
执行第2步骤
for循环一般用于可以明确循环次数的场景中；while循环一般用于不能预先确定循环执行次数的场景
中；do/while循环一般用于不能预先确定循环执行次数，同时要求循环体至少执行一次的场景中
int res=0;
int k=0;
while(true){
if(++k>100){
break; //跳出循环体，执行循环体后的语句
}
if(k%20){ //如果是偶数不进行累加操作，而是从新开始后续的循环，continue之后的语句不执
行，从头开始下次循环
continue; //终止本次循环，立即进入下次循环
} else{
res+=k; //res=res+k
}
System.out.print(k+“+”);
}
System.out.println(“=”+res);
int res=0;
int k=1;
do {
res+=k++; //res=res+k;k++;
} while (k < 101);
System.out.println(res);
