命名规范参考Java开发手册（嵩山版）
Java对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符
命名规则如下:
命名规范： 软性建议
1. 【强制】代码中的命名均不能以下划线或美元符号开始，也不能以下划线或美元符号结束。
反例：_name / __name / $name / name_ / name$ / name__
2. 【强制】所有编程相关的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式。
说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，纯拼音命名方式更要避免采用。
正例：ali / alibaba / taobao / cainiao/ aliyun/ youku / hangzhou 等国际通用的名称，可视同英文。
反例：DaZhePromotion [打折] / getPingfenByName() [评分] / String fw[福娃] / int 某变量 = 3
3. 【强制】代码和注释中都要避免使用任何语言的种族歧视性词语。
正例：日本人 / 印度人 / blockList / allowList / secondary
反例：RIBENGUIZI / Asan / blackList / whiteList / slave
4. 【强制】类名使用 UpperCamelCase 风格，但以下情形例外：DO / BO / DTO / VO / AO / PO / UID 等。
正例：ForceCode / UserDO / HtmlDTO / XmlService / TcpUdpDeal / TaPromotion
反例：forcecode / UserDo / HTMLDto / XMLService / TCPUDPDeal / TAPromotion
5. 【强制】方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格。
正例： localValue / getHttpMessage() / inputUserId
标识符命名习惯：见名知意
示例：
合法标识符：HelloWord、userName2、user_name、_userName、$abc_123
非法标识符：2UserName、user#Name、Hello World、class
Java中有一些赋予特定的含义，有专门用途的字符串称为关键字（keyword）。全部是小写。
保留字：没有定义用途，但保留备用。
例如：goto、const
如：十进制的10在计算机内保存为二进制的1010
位（Bit）：表示一个二进制数码0或1，是计算机存储处理信息的最基本的单位。
字节（Byte）：一个字节由8个位组成。它表示作为一个完整处理单位的8个二进制数码。
字：32位计算机：1字=32位=4字节，64位计算机：1字=64位=8字节
1. 原码 十进制数据的二进制表现形式就是原码，原码最左边的一个数字就是符号位，0为正，1为负。
例如：56 -> 0 0 1 1 1 0 0 0
左边第一位为符号位，其他位为数据位。 一个 byte 有 8bit，最大值是 0 1 1 1 1 1 1 1 (+127)，最小值是 1 1 1 1 1 1 1 1 (-127)
在计算机中之所以使用二进制来表示原码是因为逻辑简单，对于电路来说只有开或者关两种状态，用二 进制是在方便不过的了。如果使用的进制是十进制、八进制或者十六进制的话，电路没有办法表示那么多的状态。
（1）正数计算
使用原码对正数进行计算不会有任何问题的
例如：5 + 2
0 0 0 0 0 1 0 1
+ 0 0 1 0
-----------------
0 0 0 0 0 1 1 1
把这个结果转成十进制刚好就等于 7，完全正确无误
（2）负数计算
但是如果是负数的话，那计算的结果就会大相径庭了
我们拿 -56 这个数字来举例，它的原码是 1 0 1 1 1 0 0 0 ，减一之后，就会变成 1 0 1 1 0 1 1 1 ，这个 数转成十进制就是 -55。计算前是 -56，减一之后正确的结果应该是 -57（1 0 1 1 1 0 0 1）才对，居然还越减越大了
1 0 1 1 1 0 0 0
- 1
-----------------
1 0 1 1 0 1 1 1为了解决原码不能用于计算负数的这种问题，这时候，反码它出现了，作为负数的“计算的救星”。
计算规则是正数的反码不变和原码一致，负数的反码会在原码的基础上，高位的符号位不变，其他位取 反（ 1 变成 0 ， 0 变为 1 ）
3. 反码
正数的反码是其本身（等于原码），负数的反码是符号位保持不变，其余位取反。 反码的存在是为了正 确计算负数，因为原码不能用于计算负数
（1）负数计算
这时候，我们再来使用反码计算一下 -56 - 1 的结果
-56 的原码是 1 0 1 1 1 0 0 0 ，如果转成反码（符号位不变，其他位取反）， 那么它的反码就是1 1 0 0 0 1 1 1
1 1 0 0 0 1 1 1
- 1
-----------------
1 1 0 0 0 1 1 0-56 -1 = -57，-57 的原码是 1 0 1 1 1 0 0 1，转成反码刚好是 1 1 0 0 0 1 1 0，刚好等于刚才我们算出的值
（2）跨零计算
不过反码也有它的 “ 软肋 ”，如果是负数跨零进行计算的话，计算得出的结果不对 我们拿 -3 + 5 来举例
-3 的原码是 1 0 0 0 0 0 1 1，转成反码的话就是 1 1 1 1 1 1 0 0
1 1 1 1 1 1 0 0
+ 0 1 0 1
-----------------
0 0 0 0 0 0 0 1 把计算结果转成十进制就是 1，这结果显然不对。那么我们该怎么计算呢，这时候，作为反码的补充编码 —— 补码就出现了。
4. 补码
正数的补码是其本身，负数的补码等于其反码 +1。因为反码不能解决负数跨零（类似于 -6 + 7）的问 题，所以补码出现了。
（1）跨零计算
这时候，我们再来使用反码计算一下 -3 + 5 的结果
-3 的原码是 1 0 0 0 0 0 1 1，转成反码的话就是 1 1 1 1 1 1 0 0，再转成补码就是 1 1 1 1 1 1 0 1
1 1 1 1 1 1 0 1
+ 0 1 0 1
-----------------
0 0 0 0 0 0 1 0把这个数转成十进制刚好等于2，结果正确
总结：
程序处理的都是数据，由于不同数据的内容大小不同, 导致所需的存储单元大小不同，在Java语言中使用 数据类型的概念加以描述 。
字节是计算机技术用于计量存储容量的一种计量单位，作为一个单位来处理的一个二进制数字串，是构 成信息的一个小单位。Java中的字节是八位的字节，即它包含八位的二进制数。
String不是基本数据类型，属于引用数据类型 使用方式与基本数据类型一致。例如：String str = “abcd”;
一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str + “xyz” ;
int n = 100;
str = str + n;结果判断：
String str1 = 4; //判断对错：no
String str2 = 3.5f + ""; //判断str2对错：yes
System.out.println(str2); //输出：”3.5”
System.out.println(3 + 4 + "Hello!"); //输出：7Hello!
System.out.println("Hello!" + 3 + 4); //输出：Hello!34
System.out.println('a' + 1); //输出：98Hello!
System.out.println("Hello" + 'a' + 1); //输出：Helloa1
String a = “43”; int i = Integer.parseInt(a);变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。简单理解就是内存中一块空间的 表示。 由于该存储单元中的数据可以发生改变，因此得名为"变量"。
语法：数据类型 变量名称；
变量名称=值;
语法 ： 数据类型 变量名称=值;
package lina;
/*
* 变量的声明与使用
*/
public class Demo02_var {
public static void main(String[] args) {
//1、声明变量
//1.1 先声明后赋值：数据类型 变量名称；
int age;//声明
age=18;//赋值
//1.2 声明变量的同时赋初值：数据类型 变量名称=初值；
double money=1000.0;
//2、变量的使用：先声明并赋值之后才能使用
System.out.println("年龄是："+age);
System.out.println("私房钱有："+money);
//System.out.println(name);//错误 没有声明
//其他类型的变量
float num=12.5F;//小数点的数字默认是double类型，如果赋值给float,需要在值后面
加上后缀f 大小写都OK
long num2=100L;//整数数字默认是int类型，long类型的 变量的值后面可以添加L后
缀，也可以省略（省略的时候暗含类型转换,但是不能超过int的范围，否则不能省略）
char gender='男';//字符类型的值必须使用单引号引起来
String str="我爱你中国";//字符串类型的值必须使用双引号引起来
System.out.println(num);
System.out.println(num2);
System.out.println(gender);
System.out.println(str);
}
}package lina;
import java.util.Scanner;
/**
* 控制台输入
*
*/
public class Demo03_input {
public static void main(String[] args) {
//理解为扫描仪
Scanner input=new Scanner(System.in);//需要导入java.util.Scanner;
System.out.print("请输入您的年龄：");
int age=18;//声明变量并附了初值
//调用扫描仪的功能干活
age=input.nextInt();//扫描整数
System.out.print("请输入您的私房钱：");
double money=input.nextDouble();//扫描小数
System.out.print("请输入您的姓名：");
String name=input.next();//扫描字符串，空格不能扫描
System.out.print("请输入性别：M/F");
char gender=input.next().charAt(0);//扫描字符
System.out.println("你是单身嘛？");
boolean isSingle=input.nextBoolean();//扫描boolean类型
System.out.println("输入的年龄是："+age);
System.out.println(money);
System.out.println(name);
System.out.println(gender);
System.out.println(isSingle);
input.close();//可以省略，避免有黄色的警告
}
}特别注意：类的外面不能有变量的声明
++： 如果是变量前缀：先对此变量加1，再执行其他的操作。
如果是变量后缀：先执行当前语句的其他操作，再对此变量加1
--： 如果是变量前缀：先对此变量减1，再执行其他的操作。
如果是变量后缀：先执行当前语句的其他操作，再对此变量减1
赋值运算符作用是将一个值赋给一个变量，运算顺序从右到左
关系运算符作用是比较两边的操作数，结果总是boolean型的。
逻辑运算符用于对boolean
型结果的表达式进行运算，运算结果总是boolean型，后面结合条件结构讲解。
public static boolean f1() {
System.out.println("f1");
return false;
}
public static boolean f2() {
System.out.println("f2");
return true;
}
public static void main(String[] args) {
//不短路&，前面表达式false，后面表达式依然执行
System.out.println(f1() & f2()); //true
}
//结果
f1
f2
false
public class Test9 {
public static boolean f1() {
System.out.println("f1");
return false;
}
public static boolean f2() {
System.out.println("f2");
return true;
}
public static void main(String[] args) {
//短路与&&，前面的表达式false，fasle后面的表达式不再执行
System.out.println(f1() && f2() && f2() && f2()) ; //true
}
//结果
f1
false
String s="He" + "llo";//结果"Hello"
//"+"除了可用于字符串相连接，也能将字符串与其它的数据类型相连成一个新的字符串。
//如：
String s="x" + 123;// 结果"x123"
X ? Y : Z
X为boolean类型表达式，先计算x的值，若为true，整个三目运算的结果为表达式y的值，否则整个运算 结果为表达式z的值。
//例：
int score = 75;
String type = score >=60 ? "及格" : "不及格"位运算符对两个操作数中的每一个二进制位都进行运算 位运算符功能：
移位运算符
技巧
a % b = a & (b-1)，b是2的n次幂
10 % 8 = 10 & 7
public static void main(String[] args) {
System.out.println(113 % 8);
System.out.println(113 & 7);
}
运算符的优先次序
表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行：
1996年，计算机科学家Bohm和Jacopini证明了：任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本结构组合而成。
它们的共同点是都包含一个入口和一个出口，它们的每个代码都有机会被执行，不会出现死循环。
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作。
分支结构又被称为选择结构，根据条件成立与否来执行操作。
/*语法：
if(条件){
条件成立执行的内容
}
*/
/*语法：
if(条件){
条件成立执行的内容
}else{
条件不成立执行的内容
}
*/
用处：适合解决连续区间问题。
if(条件1){
//条件1成立的时候执行的条件
}else if(条件2){
//条件1不成立，条件2成立的时候执行的条件
}else if(条件3){
//条件1、2不成立，条件3成立的时候执行的条件
}......
else if(条件n){
//条件1到n-1不成立，条件n成立的时候执行的条件
}else{
//当以上的所有条件都不成立的时候执行的代码
}
/*
整个结构是一个整体，当一个条件成立并执行之后，整个结构就已经执行完毕；
if块必须有；
else if块可以有一个，也可以有多个；
else 可以有一个，也可以没有。
*/
如果高考成绩过700 清华 ， 600-700:重点本科 500-600：普通本科 300-500：专科 其他：其他出路。
public static void main(String[] args) {
// 示例 if-else 多重选择结构
// 如果高考成绩过700 清华 ，600-700:重点本科 500-600：
// 普通本科 300-500：专科 其他：其他出路。
Scanner input = new Scanner(System.in);
System.out.println("请输入你的分数：");
int score = input.nextInt();
if (score > 700) {
System.out.println("去清华");
} else if (score >= 600/* &&score<=700 */) {
System.out.println("重点本科");
}else if (score >= 500/* &&score<=600 */){
System.out.println("普通本科");
} else if (score >= 300) {
System.out.println("专科");
}else {
System.out.println("其他出路！");
}
}替换等值判定的多重选择结构
witch(表达式){
case 值1://相当于if(){}
//满足表达式的结果==值1的时候执行的代码
break;//退出当前的switch选择结构
case 值2://相当于else if(){}
//满足表达式的结果==值2的时候执行的代码
break;
......
case 值n:
//满足表达式的结果==值n的时候执行的代码
break;
default://相当于else
//以上的匹配都失败的时候执行的内容
break;
}
/*
表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
case子句中的取值必须是常量，且所有case子句中的取值应是不同的；
default子句是可选的；
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果case后面没有写break则直
接往下面执行！
Case后面的执行体可写{ }也可以不写{ }
*/
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 基金经理的业绩排名：1、欧洲游 2、东南亚游 3、国内游 其他：再接再厉！
System.out.println("请输入你的排名：");
int num = input.nextInt();
// 方式2：
switch (num) {// 小括号中的表达式或者变量结果类型可以是：int char String byte short
case 1:// 相当于if(num==1){}//case 后面的值必须是常量 'A' "星期一"
System.out.println("奖励是：欧洲游");
break;// 执行完毕一个case分支后跳出switch语句块
case 2:// 相当于if(num==2)
System.out.println("奖励是：东南亚游");
break;
case 3:// 相当于if(num==3)
System.out.println("奖励是：国内游");
break;
default:// 相当于else ,是可选的
System.out.println("再接再厉");
break;
}
// 方式1：
/*
if (num == 1) {
System.out.println("奖励是：欧洲游");
} else if (num == 2) {
System.out.println("奖励是：东南亚游");
} else if (num == 3) {
System.out.println("奖励是：国内游");
} else {
System.out.println("再接再厉");
}
*/
}多分支月份输出天数
public static void main(String[] args) {
// 巧用break的省略
// 多分支月份输出天数
Scanner input = new Scanner(System.in);
// 根据用户输入的月份，输出当月的天数，不考虑平年闰年
System.out.println("请输入月份：");
int month = input.nextInt();
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月共有31天！");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月共有30天！");
break;
case 2:
System.out.println(month + "月共有28天！");
break;
default:
System.out.println("您输入的月份有误！");
break;
}
}以上的所有的选择结构都相互嵌套
运动会百米赛跑项目： 16秒之内才能进入决赛，根据性别分男女组
public static void main(String[] args) {
//运动会百米赛跑项目： 16秒之内才能进入决赛，根据性别分男女组
Scanner input = new Scanner(System.in);
System.out.println("请输入跑步时间秒：");
float time = input.nextFloat();
if (time <= 16) {
//进入决赛
System.out.println("请输入性别：");
String gender = input.next();
//字符串比较内容是否相等，不能使用== 使用.equlas()
if ("男".equals(gender)) {
System.out.println("进入男子组决赛！");
} else {
System.out.println("进入女子组决赛！");
}
} else {
System.out.println("很遗憾，没能进入决赛！下次努力！");
}
}
} String str1="abc";
String str2=input.next();
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。 循环两个点：1、循环操作 2、循环条件
while(循环条件){
//循环操作
}
1、分析循环条件和循环操作
2、套用到循环语法中
3、检查循环能否退出（循环条件是否会发生变化）
用while循环描述：万米赛跑项目（操场400米一圈，共跑25圈）
步骤1：编写伪代码
步骤2：转换为java代码
public static void main(String[] args) {
// 用while循环描述刚刚的万米赛跑，操场400米一圈，共跑25圈
//1、分析循环条件和操作
//循环操作：跑圈，现在第圈
//循环条件：不够25圈
//2、套用循环语法
int num=1;//圈数
while(num<=25) {
//跑圈，现在第圈
System.out.println("跑圈，现在第"+num+"圈");
//跑完一圈圈数+1
num++;
}
System.out.println("完成了万米赛跑项目！");
//3、检查循环能否退出--循环条件是否发生变化
}
打印1-100之间的所有数字
public static void main(String[] args) {
//1、分析循环条件和操作
//循环操作：打印数字
//循环条件：不够100
int i=1;
while(i<=100) {
System.out.println(i);
i++;
}
}
do{
//循环操作
}while(循环条件);
//PS:特别注意最后的分号不能丢掉
用户登录：用户输入用户名和密码，用户名是admin 密码是123才能登录成功，其余都失败！
import java.util.Scanner;
/*
* do-while
* 特征：先执行一次，再判定 初始条件不满足，循环至少会执行一次
*/
public class Demo11_dowhile {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//用户登录：用户输入用户名和密码，用户名是admin 密码是123才能登录成功，其余都失
败！
//1、分析
//循环条件：用户名是admin 密码是123
//循环操作：用户输入，判定对错
//2、套用语法
String name;
int password;
do {
//循环操作：用户输入，判定对错
System.out.println("请输入用户名和密码：");
name=input.next();
password=input.nextInt();
if(!"admin".equals(name) || password!=123) {
System.out.println("用户名或密码错误！登录失败！");
}
}while(!"admin".equals(name) || password!=123);
System.out.println("登录成功！");
}
}
for(表达式1：定义循环变量;表达式2：循环条件;表达式3：循环变量的变化){
//循环操作
}
先判断后执行
适合解决循环次数固定的题目
public class Demo12_for {
public static void main(String[] args) {
//案例1：打印1-100
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
//案例2：打印1-100的所有的数字之和
//循环条件：没有加到100次
//循环操作：累加
int sum=0;
for(int k=1;k<=100;k++) {
sum=sum+k;
}
System.out.println("1-100之和："+sum);
//案例3：打印1-100之间所有的偶数
for(int i=1;i<=100;i++) {
if(i%2==0) {
System.out.println(i);
}
}
//可以仿写while的格式，语法正确，但是不推荐
// int j=1;
// for(;j<=100;) {
// System.out.println(j);
// j++;
// }
}
}
万米赛跑项目，坚持不住可以退出！
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int i=1;
while(i<=25) {
System.out.println("跑圈，第"+i+"圈");
i++;
System.out.println("还能坚持吗？T/F");
char isOk=input.next().charAt(0);
if(isOk=='f') {
System.out.println("坚持不住了，退出！");
break;
}
}
System.out.println("over");
}
作用--结束当次循环，进入下一次循环
利用二重循环打印图形。
public static void main(String[] args) {
//使用*号打印5行6列的矩形
for(int i=1;i<=5;i++) {//外层循环控制行数
for(int j=1;j<=6;j++) {//内层循环控制个数
System.out.print("*");
}
System.out.println();
}
}
public static void main(String[] args) {
//打印直角三角形
for(int i=1;i<=5;i++) {
for(int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println();
}
}
public static void main(String[] args) {
//打印等腰三角形
for(int i=1;i<=5;i++) {
//打印空格
for(int k=1;k<=5-i;k++) {
System.out.print(" ");
}
//打印*号
for(int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println();
}
}
就近原则：
public static void main(String[] args) {
//打印九九乘法表
for(int i=1;i<=9;i++) {
for(int j=1;j<=i;j++) {
System.out.print(j+"*"+i+"="+i*j+"\t");
if(j==5) {
break;
}
System.out.print("===");
}
System.out.println();
}
}