1.什么是JDK，JRE

JDK基本介绍

jdk是Java开发工具包全称Java develoment kit

JDK = JRE + java的开发工具
JDK是提供给Java开发人员使用的其中包含了Java的开发工具，也包括了JRE.

所以安装了JDK,就不用单独安装JRE了。

JRE基本介绍

JRE (java runtime environment)也就是Java运行环境，只是运行Java而不是开发的话，只需要运行开发好的.class文件，只需要安装JRE就可以了

JRE = JVM + java核心类库
包括Java虚拟机（JVM java virtual machine)和Java程序所需核心类库等，

如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

2.配置环境变量path

豁然开朗，因为直接输入Javac的话系统从这个目录：C:\Users\fushuo>查找，但是软件不是装在这个目录的所以查找不到，如果直接在安装目标的bin文件夹执行该命令则可以，因为java.exe就在这个路径。
系统变量和环境变量的区别：系统变量范围更广，用户变量只能给该用户用。

3.Java快速入门

需求说明

开发一个Hello.java程序，可以输出“hello，world！“
开发步骤

将Java代码编写到扩展名为Hello.java的文件中
- 这个地方要注意编码格式，改完之后记得点保存
通过Javac命令对该Java文件编译，生成.class文件.class文件也叫字节码文件。
- 运行时使用Java Hello，注意不需要加.java
- 如果程序没有任何错误，就不会提示任何信息。
通过Java命令对生成的class文件进行运行。

运行原理示意图

什么是运行

有了可执行的Java程序（hello.class字节码文件）
通过运行工具Java.exe对字节码文件进行执行。本质就是将.class文件装载到jvm中执行

Java程序开发注意事项
对修改后的源文件需要重新编译，生成新的class文件后，再进行执行，才能生效。

4.Java开发细节

Java源文件以.java为扩展名。源文件的基本组成部分是类（class），如本类中的Hello类。
Java应用程序的执行入口是main()方法。他有固定的书写格式：

public static void main(string[] args){...}
java语言严格区分大小写。
Java方法由一条条语句构成，每个语句以分号；结束。
大括号成对出现，缺一不可，程序中每一个类在编译的时候都会对应一个.class文件
一个源文件最多只能有一个public类，其他类的个数不限
如果源文件包含一个public类，则文件名必须按该类名命名！
一个源文件中最多只能有一个public类，其他类个数不限，也可以将main方法写在非public类中然后指定运行非public类，这样入口方法就是非public的main方法

5.Java学习方法

首先要有需求
看看能否使用传统技术解决
引出我们学习的新技术和知识点
学习新技术或者知识点的基本原理和基本语法，先不要考虑细节
快速入门（基本程序，curd）
开始研究技术的注意事项和使用细节，使用规范，如何优化？

6.Java转义字符

这个实例演示了Java转义字符用法，特别注意回车和换行的区别

//演示转义字符
public class ChangeChar{
	public static void main(String[] args) {
		//\t :一个制表位，实现对齐功能
		System.out.println("北京\t天津\t上海");
		//\n :换行符号
		System.out.println("jack\nsmith\nmarry");
		//\\ :一个\
		System.out.println("C:\\Windows\\System32\\cmd.exe");
		//\" :一个"
		System.out.println("老韩说：\"要好好学习Java，有前途\"");
		//\' :一个'
		System.out.println("老韩说：\'要好好学习Java，有前途\'");
		// \r :一个回车，注意，回车和换行是不一样的
		// 这个地方回车，光标定位到开头，然后执行北京，替换开头两个字
		System.out.println("世界你好，我是傅硕\r北京");
	}
}

课堂练习

//转义字符课堂练习
public class ClassTestZy{
	public static void main(String[] args) {
		System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t120\t1000");
	}
}

效果如图：

7.初学Java容易犯的错误

找不到文件可能原因
- 文件名写错
- 当前路径有问题
主类名和文件名不一致

解决办法：声明为public的主类名应该与文件名一致，否则编译失败
缺少分号
解决办法：编译失败，注意错误出现的行数，再到源代码中指定位置改错
常见语法错误举例
- 1 ->l
- 0 ->o
- 英文符号写成中文符号;和;
- 拼写错误：void -> viod
- 业务错误，环境错误

8.注释

Java注释类型
- 单行注释//
- 多行注释/**/，多行注释不允许嵌套
- 文档注释/***/
  
  注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序说明文档，一般写在类
  - 基本格式
  - 如何生成对应的文档注释
  - 应用实例

//文档注释
/**
 * @author fushuo
 * @version  1.0
 */
public class common{
	//编写一个main方法
	public static void main(String[] args){

	}
}

命令行输入：

javadoc -d D:\Users\傅硕\OneDrive\桌面\javacode\temp -author -version common.java

9.javadoc 标签

javadoc 工具软件识别以下标签：

标签	描述	示例
@author	标识一个类的作者	@author description
@deprecated	指名一个过期的类或成员	@deprecated description
{@docRoot}	指明当前文档根目录的路径	Directory Path
@exception	标志一个类抛出的异常	@exception exception-name explanation
{@inheritDoc}	从直接父类继承的注释	Inherits a comment from the immediate surperclass.
{@link}	插入一个到另一个主题的链接	{@link name text}
{@linkplain}	插入一个到另一个主题的链接，但是该链接显示纯文本字体	Inserts an in-line link to another topic.
@param	说明一个方法的参数	@param parameter-name explanation
@return	说明返回值类型	@return explanation
@see	指定一个到另一个主题的链接	@see anchor
@serial	说明一个序列化属性	@serial description
@serialData	说明通过writeObject( ) 和 writeExternal( )方法写的数据	@serialData description
@serialField	说明一个ObjectStreamField组件	@serialField name type description
@since	标记当引入一个特定的变化时	@since release
@throws	和 @exception标签一样.	The @throws tag has the same meaning as the @exception tag.
{@value}	显示常量的值，该常量必须是static属性。	Displays the value of a constant, which must be a static field.
@version	指定类的版本	@version info

10.Java代码规范

类和方法的注释,要以javadoc的方式来写.
非Javadoc的注释,往往是给代码的维护者看的,着重告诉读者为什么这么写,如何修改,注意事项等
使用tab操作,实现缩进,默认整体向右边移动,使用时用shift+tab整体向左移
运算符和=两边习惯性各加一个空格.
源文件使用utf-8编码
行宽度不要超过80字符
代码编写次行风格和行尾风格

11.DOS命令

dir d:\abc\test200

切换到其他盘

cd /D c:

切换到当前盘的其他目录下(使用相对路径和绝对路径演示)

cd d:\abc\test

cd ..\..\abc\test

切换到上一级:

cd ..

cd \

tree:所有子目录目录树,cls清屏,exit退出dos,md创建目录,rd删除目录,copy拷贝文件,del删除文件,echo输入内容到文件,type,move[剪切]

第三章

1.变量原理

变量时程序的基本组成单位

变量有三个基本要素:类型,名称和值

如:int a = 1;定义一个变量,类型int整形,名称a,值1

2.变量使用注意事项

变量表示内存中那个一个存储区域(不同的变量,类型不同,占用的空间按大小不同,比如:int表示4个字节,double就是8个字节
该区域有自己的名称[变量名]和类型名[数据类型]
变量必须先声明,后使用,即有顺序
该区域数据可以在同一类型范围内不断变换
变量在同一个作用域内不能重名
变量=变量名+值+数据类型

3.程序中+号的使用原则

左右两边都是数值型号的时候,则做加法运算
左右两边有一方为字符串,则做拼接运算,运算顺序从左到右.

System.out.println(100 + 98);//198
System.out.println("100" + 98);//10098
System.out.println(100 + 3 + "hello");//103hello
System.out.println("hello" + 100 + 3);//hello1003

4.Java中数据类型

5.整形类型

整形的使用细节

Java个整数类型有固定的范围和字段长度,不受具体OS影响,以保证Java程序的可移植性
Java的整型常量默认为int型,声明long型常量后加l或者L
Java程序中变量常声明为int型,除非不足以表示大数采用long
bit,计算机中最小存储单位,byte计算机中基本存储单元,1byte= 8bit

public strtic void main(String[] args){
    int n1 = 1;
    long n2 = lL; 
}

6.浮点类型

浮点数的注意事项

与整数类型类似,Java浮点数也有固定的范围和字段长度,不受具体os的影响,[float 4个字节 double是8个字节]
Java的浮点型常量默认为double型,声明float型常量,须后加f或者F

float num1 = 1.1 这样写是错误的,因为默认是double类型.

float num1 = 1.1F 这样写是正确的

double num1 = 1.1 或者是这样写

double num1 = 1.1F 这样写也是对的,因为空间是足够的

浮点型常量有两种表现形式

十进制数形式如:5.12 431.0f .512(必须要有小数点)

科学计数法形式:如:5.12e2[5.12 *10的二次方] 5.2E-2 [5.12 *10的负二次方]

通常情况下,应该使用double型,因为他更加精确
浮点数使用陷阱

double num11 = 2.7;
double num12 = 8.1 / 3;//2.7
System.out.println(num11);//2.7
System.out.println(num12);//接近2.7的一个数,但不是2.7
//得到的启示是,在对运算结果是小数的进行相等判断时,小心
//应该是以两个数差值的绝对值,在某个精度范围内判断
if(num11 == num12){
    System.out.println("相等");//这样写是错误的,根本不会输出这个.
}
//正确的写法
if(Matn.abs(num11 - num12) < 0.000001){
    System.out.println("equal")
}

7.java文档

API(application programming interface,应用程序编程接口),是Java提供的基本编程接口(Java提供的类和相关方法).中文文档:https://www.matools.com
Java语言提供了大量的基础类,API文档告诉开发者如何使用这些类,和类里面的方法

举例说明如何使用ArrayList类有哪些方法

按包->类->方法

如果知道这个类在那个包下就先定位到包,再找到类,然后是方法.

直接索引

不知道类在哪个包的情况.

8.字符类型(char)

基本结束
字符类型可以表示单个字符,字符类型是char,char是俩个字节(可以存放汉字),多个字符我们使用String

//演示char的基本使用
public class VarDetail{
    public static void main(String[] args){
        char c1 = 'a';
        char c2 = '\t';
        char c3 = 'han';
        char c4 = 97; //说明:字符类型可以直接存放一个数字这里输出A
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
    }
}

字符常量是用单引号括起来的单个字符

char c1 = 'a';

char c2 = '中';

char c3 = "9";//这样写是错的,双引号是字符串.

Java允许转义字符''来将其后的字符转为特殊字符常量,例如

char c3 = '\n';

在Java中,char本质是一个整数,在输出的时候是Unicode对应的字符.
可以直接给char附一个整数,然后输出,按照对应的Unicode字符输出[97]
char类型可以进行运算,相当于一个整数,因为他都对应的有Unicode码.
字符串类型本质探讨

9.编码

ASCII码

一共规定了128个字符的编码，只占用了一个字节的后面7位，最前面的1位统一规定位0，缺点是不能表示所有的值。

Unicode编码

一个英文字母和一个汉字都占用2个字节，这对存储空间造成了浪费，Unicode兼容ASCII码，表示最大字符是65536

utf-8是对Unicode的改进，根据不同符号而变化字节长度。使用大小可变的编码，字母占一个字节，汉字占3个字节。

10.布尔类型

基本介绍

布尔类型只允许取值true和false，无null
布尔类型占一个字节。
布尔类型适用于逻辑运算，一般用于程序流程控制
- if条件控制语句；
- while循环语句
- do-while循环控制语句
- for循环控制语句

public class Boolean{
    public static void main(String[] args){
        //演示判断成绩是否通过
        //定义一个布尔变量
        boolean inPass = true;
        if(isPass == true){
            System.out.println("考试通过，恭喜");
        }else{
            System.out.println("考试没有通过，下次努力");
        }
    }
}

4. 使用细节

不可以用非0的整数替代false和true这点和c语言不同。

11.基本数据类型转换

自动类型转换

Java程序进行赋值或者运算的时候，精度小的类型自动转换为精度大的数据类型，这个就是自动转换类型

数据类型按精度大小排序位这个要记住

char->int->long->float->double
byte->short->int->long-float-double

int a = 'c';//这个是对的
double d = 80;//这个是对的

自动类型转换注意和细节

有多种的数据混合运算时，系统首先将所有数据转换为容量最大的那种数据类型，然后进行计算。
当我们把精度大（容量大）的数据类型赋值给精度小的的数据类型时，就会报错，反之就会进行自动类型转换。
注意byte，short和char之间不会进行相互转化。
byte,short,char他们三者可以计算，在计算时首先转换为int类型
Boolean类型不参与类型转换
自动提示原则：表达式结果自动提升为操作数中最大的类型

public class AutoConvertDetail{
    public static void main(String[] args){
        int n1 = 10;
        double d1 = n1 + 1.1;//注意1.1默认位double类型，
        float d1 = n1 + 1.1;//这样写时错误的因为1.1时double类型，1.1f才是float类型。
        
        int n2 = 1.1;//错误，double不能转为int
        //(byte,short)和char不发生类型转换
        //当把数赋给byte时，先判断数是否在byte范围内，如果是就可以
        byte b1 = 10;//对，-128，-127先判断类型
        int n2 = 1;
        byte b2 = n2;//这样是不行的，因为n2已经是int类型了
        char c1 = b1;//错误，原因是byte不能自动转成char
        //出现了short,char,byte中任何一个，精度就会提升。
        byte b2 = 1;
        byte b3 = 1;
        short s2 = 1;
        short s2 = b2 + s1;//错，b2+s1->int
        byte b4 = b2 + b3;//错,b2 + b2 ->int
    }
}

12.强制类型转换

介绍
自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型，使用时要加上强制转换符（），但可能造成精度降低或溢出，格外注意。

public class ForceConvert{
    public static void main(String[] args){
        //演示强制转换类型
        int n1 = (int)1.9;
        System.out.println("n1=" + n1);
        
        int n2 = 2000;
        byte b1 = (byte)n2;//数据超过了byte范围-127，128
        System.out.println("b1"+b1);
        
    }
}

强制转换的细节说明

进行数据的大小从大——>小就需要使用到强制转换
强制符号只针对最近的操作数有效，往往会使用小括号提升优先级

int x = (int)10*3.5 + 1.5*6//这样写会报错，因为强转符号只针对最近的操作数有效。
int x = (int)(10*3.5 + 6*1.5)//这样就是正确的。

char类型可以保存int的常量值，但不能保存int的变量值，需要强转

char c1 = 100;//ok
int m = 100;//ok
char c2 = m;//错误，int精度大
char c3 = (char)m;//可以，这是强转

基本数据类型转换练习题

判断下列语句能否通过编译：

short s = 12;//不可以，9是int类型，s是short无法赋值，必须强制类型转换
s = s-9;
//----------
byte b = 10;//不可以，理由同上
b = b + 11;
b = (byte)(b+11);
//----------
char c = 'a';//可以，自动转为精度最大的float，doule可以接受float
int i = 16;
float d = .314F;
double result = c + i + d;
//----------
byte b = 16;//不可以，只要有byte，short和char参与运算一律提升了精度为int
short s = 14;
short t = s + b;

13.基本类型和String类型的转换

基本类型转String加双引号就可以

int n1 = 100;
float f1 = 1.1F;
double d1 = 1.4;
boolean b1 = true;
//--------------
String s1 = n1 + "";
String s2 = f1 + "";
String s3 = d1 + "";
String s4 = n1 + "";
String s5 = "123"
System.out.println(s1+" "+s2+" "+s3+" "+s4);

字符串转为基本类型

语法：通过基本类型的包装类调用parsexx方法即可

String s5 = "123";
int num1 = Integer.parseInt(s5);
double num2 = Double.parseDouble(s5);
float num3 = Float.parseFloat(s5);
long num4 = Long.parseLong(s5);
byte num5 = Byte.parseByte(s5);
byte num5 = Boolean.parseBoolean("true");
short num6 = short.parseShort(s5);
//字符串转为字符：就是把字符串第一个字符取出
s5.charAt(0);//解读：就是将s5字符串的第一个字符返回。得到的是字符不是数字。

注意事项

在把String类型转为基本数据类型的时候，确保，String类型能够转为有效的数据，比如不能把“hello"转为一个整数，如果格式不正确，就会抛出异常。

14.本章作业

使用char类型，分别保存\n \r \r \ 1 2 3等字符，并打印输出

public class Homework02.java{
    public static void main(String[] args){
        char c1 = '\n';
        char c2 = '\t';
        char c3 = '\\';
        char c4 = '1';
        char c5 = '2';
        char c6 = '3';
        System.out.println(c1);
    }
}

编程，保存两个书名，用+拼接，看效果，保存两个性别，用加号拼接，看效果。保存两本书价格，用加号拼接看效果

public class HomeWork03{
    public static void main(String[] args){
        String s1 = "老人与海";
        String s2 = "骆驼祥子";
        char sex1  = "男";
        char sex2 = "女";
        double price1 = 10;
        double price2 = 11;
        System.out.println(s1+s2);
        System.out.println(sex1 + sex2);//得到男字符值+女字符值
        Syste.out.println(price1+price2);
    }
}

编程实现如下效果Homework04.java

public class Homework04{
    public static void main(String[] args){
        String name = "fushuo";
        char gender = "男";
        String hobby = "read";
        double score = 100.0;
        int age = 22;
        System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n"+name+"\t"+age+"\t"+score+"\t"+gender+"\t"+hobby)
    }
}

第四章运算符

1.运算符介绍

算数运算符

对数值型运算

public class ArithmeticOperator{
    public static void main(Strint[] args){
        //演示算术运算符的使用
        // /的使用
        System.out.println(10 / 4);//等于2.不是2.5
        double d = 10 / 4;
        System.out.println(d);//等于2.0而不是2，也不是2.5
        System.out.println(10.0/4);//等于2.5
        //-----------
        //取模的使用
        //%的本质是a%b = a-a/b*b
        System.out.println(10%3);//1
        System.out.println(-10%3);//-1
        System.out.println(10%-3);//1
        System.out.println(-10%-3);//-1
        //---------------
        //++的使用
        int i = 10;
        //如果作为独立语句使用前置加加和后置加加一样
        i++;
        ++i;
        //作为表达式使用，++i先自增后赋值i++先赋值后自增
        int j = 8;
        int k = ++j;
        int m = j++;
        System.out.println("k=" + k + "j=" +j);
    }
}

面试题

//面试题1
int i = 1;
i = i++;//使用临时变量，temp = i;->i = i+1;->i = temp
System.out.println(i);//结果是1
//面试题2
int i = 1;
i = ++i;//使用临时变量，i = i+1->temp = i;->i = temp
System.out.println(i);//结果是2
//面试题3
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.println("i="+i);//10
System.out.println("i2="+i2);//20
i = --i2;
System.out.println("i="+i);//19
System.out.println("i2="+i2);//19

假如还有59天放假，问：合xx个星期零xx天

public class ArithmeticOperatorExercise02{
    public static void main(String[] args){
        /*
        思路分析
        1.使用int变量days保存天数
        2.一个星期是7天，星期数：days/7零xx天days%7
        3.输出
        */
        int days = 59;
        int weeks = days/7;
        int leftDays = days%7;
        System.out.println(days+"天 合" + weeks + "星期零"+leftDays+"天")
    }
}

定义一个变量保存华氏温度，华氏温度转换摄氏温度公式为5/9*（华氏温度-100），请求出华氏温度对应地摄氏温度

public class ArithmeticOperatorExercise03{
    public static void main(String[] args){
        double f = 44.2;
        double c = 5.0/9*(f-100);//注意不可以是5，不然返回0！！！！！！因为5/9=0
        System.out.println("华氏温度:"+f+"对应的摄氏温度:"+c);
    }
}

2.关系运算符

关系运算符一览

关系运算符的相关案例

案例演示

public class RelationalOperator{
    public static void main(String[] args){
        int a = 9;
        int b = 8;
        System.out.println(a>b);//T
        System.out.println(a>=b);//T
        System.out.println(a<=b);//F
        System.out.println(a<b);//F
        System.out.println(a == b);//F
        System.out.println(a!=b);//T
        boolean flag = a>b;//T
        System.out.println(flag)//T
    }
}

3.逻辑运算符

短路与&&和逻辑与&的基本规则

public class LogicOperator{
    public static void main(String[] args){
        //&&和&的使用
        int age = 50;
        if(age > 20 && age < 90){
            System.out.println("ok100");
        }
        if(age > 20 & age < 90){
            System.out.println("ok100");
        }
    }
}

短路与&&和逻辑与&的区别

&&：如果第一个条件false，第二个条件不会判断，最终条件false，效率高

&：逻辑与，不管第一个条件是否为false，第二个条件都会判断，效率低

开发中基本使用&&，效率高

短路或||和逻辑或|

短路或：如果第一个条件是true那么第二个条件不会判断，效率较高，逻辑或，不管第一个条件是否为true第二个条件都会判断。

取反！

4.逻辑运算符练习题

int x = 5;
int y = 5;
if(x++==6 & ++y==6){
    x = 11;
}
System.out.println("x="+x+",y="+y);x:6,y:6
//--------
int x = 5,y = 5;
if(x++==5 | ++y==5){
    x = 11;
}
System.out.println("x="+x+",y="+y);x:11,y:6
//--------
int x = 5,y = 5;
if(x++==6 && ++y==6){
    x = 11;
}
System.out.println("x="+x+",y="+y);x:6,y:5
//----------
int x = 5,y = 5;
if(x++==5 || ++y==5){
    x = 11;
}
System.out.println("x="+x+",y="+y);x:11,y:5
//-----------
boolean x = true;
boolean y = false;
short z = 46;
if((z++==46)&&(y=true)) z++;//注意y=true赋值语句
if((x=false)||(++z==49)) z++;
System.out.println("z="+z);//输出z:50

5.赋值运算符

介绍

赋值运算符就是将某个运算后的值，赋给指定的变量

分类
- 基本赋值运算符：int a = 10;
- 复合赋值运算符
  - +=，-=，*=，/=，%=等
  - a += b;等价于a = a+b
赋值运算符的特点
1. 运算顺序从右向左，int num = a+b+c;
2. 赋值运算符的左边只能是变量，右边可以是变量表达式和常量值
int num = 20;int num2 = 78*34-10;int num3 = a;
1. 复合赋值运算等价于下面的效果
  
  比如：a+=3 等价于a=a+3
2. 复合赋值运算符会进行类型转换。
  
  byte b = 2;b+=3;b++;

int n1 = 10;
n1 += 4;//14
n1 /= 4;// 3
//复合赋值运算符会进行类型转换
byte b = 3;
b += 2;//真正等价于b = (byte)(b+2)因为b = b + 2会报错（精度提升）
//同样
b++;//底层也有类型转换b = (byte)(b+1)

6.三元运算符

基本语法

条件表达式？表达式1：表达式2；

运算规则

如果条件表达式为true，运算后的结果是表达式1；
如果条件表达式的结果是false，运算后的结果是表达式2；
口诀:[一灯大师：一真大师]

int a = 10;
int b = 99;
int result = a>b?a++:b--;//先返回b然后自减，返回的结果是99而不是98

三元运算符的使用细节
1. 表达式1和表达式2要为可以赋给接收变量的类型（或可以自动转换）

int a = 3;
int b = 8;
int c = a > b ? (int)1.1 : (int)3.4;//强转类型才能匹配
double d = a > b ? a : b + 3;//可以的，double可以接受int

1. 三元运算符可以转成if--else语句

int res = a>b ? a++ : --b;

课堂练习

案例：实现三个数的最大值

public class TernaryOperatorExerise{
    public static void main(String[] args){
        int n1 = 55;
        int n2 = 33;
        int n3 = 123;
        //思路
        //先得到n1和n2中最大数，保存到max1，然后和n2比较
        int max1 = n1 > n2 ? n1:n2;
        int max = max1 > n3 ? max1:n3;
        System.out.println(max);
        //尝试使用一条语句实现,可以这样写，但是不清晰，后面还可以使用更好的方法解决
    }
}

7.运算符的优先级问题

运算符有不同的优先级，所谓优先级就是表达式运算中运算顺序，只有单目运算符和赋值运算符是从右向左运算的。运算符运算顺序如下图所示，优先级从上而下：

8.标识符的命名规则和规范

标识符的概念

Java对各种变量，方法和类等命名的时候使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符int num1 = 90;

标识符的命名规则（必须遵守）

由26个英文字符大小写0-9，或<span data-formula="组成
数字不可以开头，
不可以使用关键字和保留字，但能包含关键字和保留字
Java中严格区分大小写，长度无限制，" aria-hidden="true">组成
数字不可以开头，
不可以使用关键字和保留字，但能包含关键字和保留字
Java中严格区分大小写，长度无限制，int totalNum = 10;int n = 90
标识符不能包含空格

标识符的命名规范

包名：多单词组成时，所有字母小写，：aaa.bbb.ccc//比如com.hsp.crm
类名、接口名：多单词组成时，所有的单词首字母大写：XxxYyyZzz(大驼峰法)

比如：ThankShotGame

变量名、方法名：多单词组成的时候，第一个单词首字母小写，第二个单词开始买个单词首字母大写：xxxYyyZzz(小驼峰，简称驼峰法)
常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ

比如：定义一个税率TAX_RATE
后面我们学习到类，包，接口等，我们命名规范要这样遵守，更加详细看文档

9.Java关键字

定义：被Java语言赋予了特殊含义，用作专门用途的字符串（单词）
特点：关键字中所有字母都为小写

保留字

10.键盘输入语句

介绍

键盘输入语句需要一个扫描器（对象），就是Scanner

步骤

导入该类的所在包，java.util.*
创建该类对象（声明变量）
调用里面的功能

//案例演示
import java.util.Scanner//表示把java.util下的Scanner类导入
public class Input{
    public static void main(String[] args){
        //演示接受用户的输入
        //步骤
        //Scanner 类 表示简单文本扫描器，在java.util包
        //1.引入/导入 Scanner类所在的包
        //2.创建Scanner对象
        Scanner myScanner = new Scanner(System.in);
        //3.接受用户输入
        System.out.println("请输入名字");
        String name = myScanner.next();//接受用户输入字符串
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();//接受用户输入int
        System.out.println("请输入薪水");
        double sal = myScanner.nextdouble();//接受用户double
        System.out.println("人的信息如下：");
        System.out.println("name="+name+"age="+age+"sal");
        
    }
}

11.进制

进制介绍

二进制：0，1满2进1.以0b或者0B开头
十进制：0-9，
八进制：0-7，满8进一。以数字0开头表示
十六进制：0-9以及a-f，或者A-F-以0x或者0X开头

int n1 = 0b1010;
int n2 = 1010;
int n3 = 01010;
int n4 = 0x10101;

进制转换
位运算的思考题

public static void main(String[] args){
    int a = 1>>2;//1向右位移两位
    int b = -1>>2;
    int c = 1<<2;//
    int d = -1<<2;//
    int e = 3 >>> 2;//无符号右移
    //a b c d e结果各是多少
}

~2 = ?;//按位取反
2&3 = ?;//按位与
2|3 = ?;//按位或
~-5=?;
13&7 = ?;
5|4 = ?;
-3^3 = ?//^按位异或

12.位运算符

Java中有7个位运算（& | ^ ~ >> << >>>）
分别是按位与&、按位或|按位异或^按位取反~运算规则如下：

按位与&：两位全为1，结果为1，否则0

按位或|：两位有一个是1，结果是1，否则0

按位异或^：两位一个为0，一个为1，结果为1，否则0

按位取反~：0->1,1->0

比如：2&3=？ ~-2 = ? ~2=?

还有三个位运算符>> <<和>>>运算规则如下：

算术右移>>:低位溢出，符号位不变，并用符号位补溢出的高位本质

int a = 1>>2 相当于1/2/2 = 0

算术左移<<:符号位不变，低位补0

int c = 1 << 2 相当于1*2 *2 = 4

>>>逻辑右移也叫无符号右移，运算规则：低位溢出，高位补0
特别说明：没有<<<符号

13.本章作业

计算下列表达式的值

10/3	3
10/5	3
10%2	0
//注意小数的取模运算
-10.5%3 -1.5//a%b 当a是小数时，公式= a -(int)a/b*b
int i = 66;
System.out.println(++i+i);//打印134

以下赋值语句正确的是

int num1 = (int)"18";//错误，要用包装类Interger.parseInt("18")
int num2 = 18.0;//错误
double num3 = 3d;//正确
double num4 = 8;//正确
int i = 49;char ch = i+1;t;//错误，尝试把int变成char
byte b = 19;short s = b+2;//错误，int-short

试着写出将String转换位double类型的语句，以及将char类型转换成String的语句

double d = Double.parseDouble("13.2");
char c1 = 'd';
String x = c1 + ""

第五章控制结构

1.顺序控制

程序从上到下逐行执行，中间没有任何判断和跳转

2.分支控制if-else

单分支

基本语法：

if(条件表达式){

执行代码块：（可以有多条语句）

}

说明：当条件表达式为true时，就会执行{}的代码。如果是false，就不执行。

特别说明，如果{}中只有一条语句，则可以不用{}，但是建议写上{}

//案例说明，编写一个程序，可以输入人的年龄，如果年龄大于18岁，则输出，你的年龄大于18，要对自己的行为负责
import java.utils.Scanner;
public class If01{
    public static void main(String[] args){
        //思路分析
        //接受输入的年龄，应该定义一个Scanner对象
        //把年龄保存到一个变量int age
        //使用if判断，输出信息
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();
        if (age >= 18){
            System.out.println("你的年龄大于18，你要对自己的行为负责")
        }
    }
}

双分支

基本语法

if(条件表达式){

执行代码块1；

}

else{

执行代码块2；

}

说明：当条件表达式成立，即执行代码块1，否则执行代码块2，如果执行代码块只有一条语句则{}可以省略，否则不可以省略。

案例演示

import java.util.Scanner;
public class If02{
    publci static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();
        if(age >= 18){
            System.out.println("你的年龄大于18")
        }else{
            System.out.println("你的年龄不大")
        }
    }
}

分支控制练习题

//单分支和双分支练习题
//对下列代码，若有输出，指出输出结果
int x = 7;
int y = 4;
if(x > 5){
    if(y>5){
        System.out.println(x+y);    
    }
    System.out.println("韩顺平教育");
}else
    System.out.println("x is" + x);
//输出内容是：
//韩顺平教育

//编写程序，声明两个double变量并赋值，判断第一个数大于10.0，第二个数小于20.0，打印两数之和
public class IfExercise2{
    public static void main(String[] args){
        double x = 18.0;
        double y = 3.0;
        if(x>10.0 && y<20){
            System.out.println("x+y="+(x+y))
        }
    }
}

//定义两个变量int判断二者之和，是否能被3又能被5整除，打印提示信息
public class IfExercise3{
    public static void main(String[] args){
        int x = 8;
        int y = 4;
        int z = x + y;
        if(z%3==0&&z%5==0){
            System.out.println(x+"和"+y"的和既可以被3又可以被5整除");
        }else{
            System.out.println(x+"和"+y"的和不能同时被3又可以被5整除");
        }
    }
}

//判断一个年份是否是闰年，闰年的条件时符合下面二者之一：
//年份能被4整除，但不能被100整除
//能被400整除
import java.util.Scanner;
public class IfExercise3{
    public static void main(String[] args){
        Scanner myYear = new Scanner(System.in);
        System.out.println("请输入一个年份");
        int year = myYear.nextInt();
        if (year%400 ==0||(year%4==0&&year%100!=0){
            System.out.println(year+"年是闰年");
        }else{
            System.out.println(year+"年不是润年");
        }
    }
}

多分支控制