java零基础笔记总结【适合初学者】

动力节点 java 课程笔记总结

关于二进制

关于字节

- Day 01 计算机历史

【1】显示文件扩展名
1、windows操作系统的文件扩展名设置
新建.java结尾的文件怎么做？
*文件资源管理器->文件->更改文件夹和搜索选项->查看->隐藏已知文件类型的扩展名

【2】计算机发展史
1、*第一代语言：机器语言
主要编写二进制码，010101，以打孔机为代表
*第二代语言：低级语言
汇编语言为代表，引入了一些英语单词
*第三代语言：高级语言
几乎和人类语言相同
例如：C，C++…

【3】Java语言发展史
1、时间：诞生于1995
2、1995年之前SUN公司（目前被Oracle（甲骨文：做数据库的）收购），开发了Oak（橡树）语言
*1996年，JDK1.0诞生
-什么是JDK？
Java开发工具包
从Oracle官网下载
*Java包括三大块：
-Java SE（标准版）
-Java EE（企业版）
-Java ME（微型版）
其中Java SE是基础

【3】Java语言特点
1、*简单性：
-Java不再支持多继承，C++支持，
-Java屏蔽指针
-Java语言底层是C++实现的
*面向对象
*可移植性（跨平台性）：
-什么是可移植性？
一次编译，多次运行
可以在不同操作系统上运行
windows和Linux操作系统的内核不同，两个操作系统执行指令的方式不一样
结论：Java不能和操作系统直接打交道
让Java运行在一台虚拟的计算机，叫做Java虚拟机，简称JVM，其和底层操作系统打交道（不同的操作系统安装不同的JVM）

  *多线程*健壮性:-和自动垃圾回收机制有关，自动垃圾回收机制称GC机制-Java语言运行产生的垃圾是自动收回的，不需要程序员关心（不需要释放储存空间）*安全性

- Day 02 DOS命令

【注】文件名带*，表示没储存，即使储存，以免丢失
【1】Edit plus
1、取消文件自动备份
- Tools->Preferences->Reload working files on startup
2、设置字体
- Tools->Prenferences->Fonts
【2】DOS命令：
1、如何打开？
- 开始菜单->运行->cmd / 开始菜单->R
2、常见DOS命令？

exit 退出当前命令窗口
cls 清屏
如何复制？
*在DOS窗口任意位置点击鼠标右键->选择标记->选择要复制内容
dir 列出当前目录下的子文件/子目录
cd命令
*cd: change directory【改变目录】
*怎么用？
绝对路径：从某个磁盘符下作为出发点的路径
cd C:\Users\Asministrator\Desktop
相对路径：从当前所在路径下作为出发点的路径
C:\Users\Asministrator
cd Desktop
*cd…回到上级目录
*cd\直接回到根目录
*怎么切换盘符？
c: Enter
e: Enter

【1】加载与运行
1、编译阶段
*检查源程序是否符合语法
-符合语法的生成字节码文件（.class）
-字节码文件不是纯粹的二进制
*编译过程：
-在磁盘的某一位置新建一个.java文件（Java源文件，其中编写的是源代码），这个源程序是不能随意编写，必须符合语法
-使用JDK中自带的javac.exe命令进行编译
*javac的使用规则：
-javac java源文件的路径
-在DOS命令窗口中使用
-javac是一个Java编译工具/命令
*一个java源文件可以编译生成多个.class文件
-字节码文件是最终要执行的文件，所以class文件生成以后，java源文件删除不影响java程序的执行。但一般不删，因为class文件的执行效果如果不是我们想要的，可以重新修改java源程序，然后再编译生成新的class文件，在运行这个class程序
-编译结束后，可以将class文件拷贝到别的操作系统运行（跨平台）

2、运行阶段
*JDK安装后，除了自带javac.exe之外，还有一个命令/工具，叫做java.exe
java.exe主要负责运行阶段
*java.exe怎么用？
- java 类名
例如：
硬盘上有一个A.class，那么这样用：java A
注：不要写成：java A.class（错）
*运行阶段过程：
- 打开DOS命令窗口
- 输入：java A
- java.exe命令会启动Java虚拟机（JVM），JVM会启动类加载器ClassLoader
- ClassLoader会去硬盘上搜索A.class文件，将该字节码文件装在到JVM中
- JVM将A.class字节码文件解释称二进制10101010这样的数据
- 操作系统执行二进制和底层硬件平台进行交互

【2】JDK、JRE、JVM关系
1、*JDK
Java开发工具包
*JRE（包括JVM）
Java运行时环境
*JVM
Java虚拟机
注：可只下载JDK（开发者）或JRE（客户），但一般JDK包含JRE

【3】开发HelloWorld源程序（注意大小写）
public class HelloWorld{
public static void main (Staing[] args){
System.out.println(“Hello World!”);
}
}

【4】通过 javac 命令进行编译
* 首先需要解决的问题是：javac是否可用？
* 打开DOS命令窗口，输入javac，回车，出现：
‘javac’不是内部或外部命令，也不是可运行的程序或批处理文件

原因：windows无法找到javac命令文件
* 如何解决？
windows如何搜索硬盘上某个命令？- 首先从当前目录下搜索- 当前目录搜索不到，从环境变量path指定的路径答盎中搜索某个命令- 如果都搜索不到，报以上错误* 配置环境变量path- 注：path环境变量和java语言没有关系，是专门给windows操作系统指路的- javac要想被随意使用，需要将javac所在目录配置环境变量path中：path=xxxxx;D:\新建文件夹\Java\jdk1.8.0_231\bin* javac命令怎么用？- javac 源文件路径（绝对/相对）* 绝对：将.class文件直接拖到DOS命令窗口* 相对：在.class文件所在位置输入框输入cmd,回车javac HelloWorld.java

【5】运行 java.exe 程序

* 首先需要使用java.exe命令* 使用方法：
java 类名
硬盘上有HelloWorld.class，那么HelloWorld是类名
注：java命令后面跟的不是文件路径，是类名* 首先需要将DOS窗口中的目录切换到HelloWorld.class文件所在位置- 点开.class所在位置，在文件夹位置输入框输入cmd，回车
* 然后执行：java HelloWorld

- Day 03 类和公开类、注释

【1】关于源程序当中的注释：
* 什么是注释？作用是什么？
- 出现在源程序中，对源代码的解释说明
- 注释不会被编译到.class字节码文件中
- 一个好的开发习惯应当是多编写注释，程序的可读性会增强

* 怎么写注释？- 单行注释//单行注释，只注释当前行- 多行注释/*多行注释多行注释多行注释*/- javadoc注释/*** javadoc注释* javadoc注释* javadoc注释* javadoc注释*/注：这种注释是比较专业的注释，该注释信息会被javadoc.exe工具解析提取并生成帮助文档

【2】HelloWorld注释

public class HelloWorld{                         //表示定义一个公开的类，类名HelloWorld//类体内不允许直接编写java语句（出声明变量外）//System.out.println("Hello World!");//类体/*main表示方法名是main(String[] args) 是一个main方法的形式参数列表记住：以下方法是程序的主方法，是程序的执行入口*/public static void main (String[] args){           //表示定义一个公开的静态的主方法，args可随意写成别的字母组合//方法体//方法体 System.out.println("Hello World!");              //向控制台输出消息
}

}

【3】public class和class的区别

* 一个java源文件当中可以定义多个class
* 一个class文件会定义生成一个字节码文件
* 一个java 源文件当中【定义公开类】的话，只能有一个，并且改类名称必须和java源文件名称一致*每个class当中都可以编写main方法，都可以设定程序的入口
想执行B.class中的main方法：java B
想执行X.class中的main方法：java X
注：在命令窗口中执行java A， 那么要求A.class当中必须有主方法

关于公开类与类

运行结果

Day 04 标识符

【1】关于java语言当中的标识符
1、什么是标识符？
* 在java源程序中凡是程序员有权自己命名的单词都是标识符
* 标识符在EditPlus编辑器当中以黑色高亮显示
* 标识符可以标识什么元素呢？
- 类名
- 方法名
- 变量名
- 接口名

2、标识符的命名规则？* 合法的标识符只能由“数字、字母、下划线、美元符号“组成，不能含有其他符号* 不能数字开头* 严格区分大小写* 关键字不能做标识符* 理论上五长度限制，但做好不要太长注：空格算是符号3、标识符的命名规范？【不属于语法，不遵守编译器不会报错】* 最好见名知意public class UserServices{public void Iogin(String username,String password){}}* 遵守驼峰命名方式SystemServive* 类名、接口名：首字母大写、后面每个单词首字母大写* 变量名、方法名：首字母小写、后面每个单词首字母大写* 常量名：全部大写

【2】关键字
* 蓝色高亮
* 常见关键词
public do double false
class default boolean throw
static byte char throws
void short private try
if int protected catch
for long switch
while float true

【3】字面值（C中称常量）
1、关于字面值：
* 字面值：
-10、3.14
-“abc”、 ‘a’、‘人’
- true、false
* 字面值就是数据

【4】变量
1、什么是变量？
* 变量本质上是内存的一块数据空间，这块空间有数据类型、名字、字面值
* 变量包含三部分：数据类型、名称、字面值
*变量是内存中存储数据的最基本单元

2、数据类型的作用？
* 不同的数据有不同的类型，不同的数据类型分配不同大小的空间
* 数据类型是知道程序在运行阶段应该分配多大的内存空间

3、有了变量的概念后，内存空间得到了重复的使用
int i=10;
System.out.println(i);
System.out.println(i);
4、赋值后，变量可重新赋值

5、通常访问一个变量有两种方式
* set 设置
int i=1;
* get 获取
System.out.println(i);

6、java中的变量必须先声明、再赋值，才能访问

public class VarTest01
{
public static void main(String[] args){
int i;
//编译报错：变量i没有初始化
//System.out.println(i);

 //给i变量赋值，i在这里完成初始化，内存开辟i=100;System.out.println(i);int a,b=100;//a尚未初始化，b赋值100}

}

- Day 05 变量、作用域

【从这一天的笔记以注释方式在代码中体现】

/*
关于变量：- 在同一个“作用域”中，变量名不能重名，但变量可以重新赋值
*/
public class VarTest02
{public static void main(String[] args){int i=100;System.out.println(i);i=200;System.out.println(i);/*int i=90;                           //不是重新赋值，加了数据类型会重新开辟存储空间，JVM不能分辨，编译错误System.out.println(i);*/}
}/*
关于变量的作用域：- 什么是作用域？* 描述的是变量的有效范围，在什么范围之内是可以访问的（出了大括号就不认识了）
*/public class VarTest03
{static int k=90;public static void main(String[] args){int i=100;//变量i的作用域是main方法//在整个main方法中是有效的，可访问的System.out.println(i);   //可以System.out.println(k);  //可以for(int a=0;a<10;a++){    //a变量的作用域是整个for循环，for循环结束后，a的内存就释放了}// System.out.println(a);//这里无法访问变量aint j;for(j=0;j<10;j++){}System.out.println(j);}public static void doSome(){System.out.println(k);         //可以//System.out.println(i);       //不可以，无法访问main方法中的变量i,超出了i变量的作用域}
}/*关于变量的分类：根据变量声明位置来分类* 局部变量- 在方法体内声明* 成员变量- 在方法体外声明在不同的作用域中，变量名可以相同同一个作用域中，变量名不能重名
*/public class VarTest04
{//成员变量int k=200;//主方法：入口public static void main(String[] args){//局部变量int i=10;//java遵循就近原则，所以输出的是100，不是90System.out.println(i);}//成员变量int i=100;    //声明变量//类体中不能直接编写java语句【除声明变量外】//System.out.println(i);  错public static void doSome(){//局部变量int i=90;}
}

Day 06 数据类型、ASCII码

/*关于java中的数据类型1、数据类型的作用？指导JVM运行程序的时候给数据分配相应的内存空间2、数据类型包括两种* 基本数据类型* 引用数据类型- 数组- 类-接口3、关于基本数据类型：* 包括四大类八小种：- 整数型byte,short,int,long- 浮点型float,double- 布尔型boolean- 字符型char4、字符串不属于基本数据类型，属于引用数据类型，字符属于基本数据类型5、基本数据类型占用空间大小   【单位：字节】byte                      1              【-128~127】short                     2              【-32758-32767】int                       4              【-2147483648-2147483647】long                      8float                     4double                    8boolean                   1              【true,false】char                      2              【0~65535】6、计算机在任何情况下至能识别二进制（数据的表示形式）7、字节（byte）:1 byte=8 bit      【一个字节=8个比特位】一个比特位表示一个二进制位1 KB=1024 byte1 MB=1024 KB1 GB=1024 MB1 TB=1024 GB8、在数字的二进制中有一个二进制位称为“符号位”，并且这个符号位在所有二进制的最左边，0表示正数，1表示负数* byte类型最大值：011111112的7次方减1，结果是：127* byte类型最小值：-1289、计算机只认识二进制，那么计算机是怎么表示现实世界中的文字？* 为了让计算机可以表示现实世界的文字，需要人为干涉，提前制定好“文字”和“二进制”的对照关系，这种对照被称为：字符编码10、最先出现的字符编码：ASCII码'a'-->97  【01100001】'A'-->65'0'-->48'a'---解码-->01000010100001--编码-->'a'解码和编码不是同一套对照表，会出现乱码* 后来出现了一种代码统一了全球所有文字：unicode编码java源代码采用unicode编码方式，所以“标识符”可以用中文例如：class 学生*//*
关于八种基本数据类型的默认值数据类型                    默认值byte,short,int,long       0float,double                 0.0boolean                        falsechar                               \u0000
*/public class DataTypeTest02{static int k=1000;//变量遵循：先声明，再赋值，才能访问//成员变量没有手动赋值，系统会默认赋值【局部变量不会】static int f;                  //成员变量public static void main(String[] args){/*int i;   //局部变量System.out.println(i);         //不通过*/System.out.println(k);System.out.println(f);}
}

关于 native2ascii 指令（可以展示中文的 unicode 编码）

- Day 07 整数型、精度损失、补码

/*
关于java语言中的char类型：转义字符  \转义字符出现在特殊字符前，会将特殊字符转义成普通字符\n 换行符\t  制表符\'  普通单引号符号\\  普通反斜杠\"  普通双引号介绍一个新的命令：native2ascii     将中文转化为unicode编码形式
*/public class Day08DataType
{public static void main (String[] args){//换行符char c2='\n';/*println表示输出后换行，print表示输出不换行*/System.out.print('A');System.out.print(c2);System.out.println('B');//制表符tab//强调：制表符和空格不同，ASCII不同，体现在键盘上两个不同的“按键”char y='\t';System.out.print('a');System.out.print(y);System.out.print('b');//要求在控制台输出“反斜杠字符”//"\"将后面的单引号转义成不具备特殊含义的普通单引号字符//左边单引号缺少结束的单引号字符/*char k='\';System.out.print(k);*/char k='\\';System.out.println(k);//在控制台输出普通单引号字符//错误：char a=''';char a='\'';System.out.println(a);//反斜杠将第二个单引号转义成普通单引号符号//第一个单引号和最后单引号配对System.out.println("HelloWorld");System.out.println("“HelloWrold”");System.out.println("\"HelloWrold\"");char m='中';System.out.println(m);//介绍JDK中一个新的命令：native2ascii     将中文转化为unicode编码形式//如何使用这个命令？在java文件所在位置输入  native2ascii，回车，输入汉字，回车，的得unicode编码char n='\u4e2d';System.out.println(n);}
}/*十进制：0 1 2 3 4 5 6 7 8 9 0 11 12 13....二进制：0 1 10 11 100 101...十六进制：1 2 3 4 5 6 7 8 9 0 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20...八进制：1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20...
*/

/*关于java语言中的整数型：*  “整数型字面值”被默认当作int 类型来处理。* 要让其被当作long 类型处理的话，需要在“整数型字面值”后面添加l/L，建议L * 整数型字面值有三种表示方式：- 十进制【一种缺省默认方式】- 八进制 【以0开始】- 十六进制【以0x开始】*/public class Day08DataType02{public static  void main(String[] args){int a=10;int b=010;// 以0开头，后面的一串数字就是八进制形式int c=0x10;// 以0x开头，后面的一串数字是十六进制形式System.out.println(a);     //10System.out.println(b);    //8System.out.println(c);    //16System.out.println(a+b+c);   //34//int类型的123赋值给int类型的变量i,不存在类型转换int i=123;System.out.println(i);//int转换成long//int是小容量，long大容量。小容量转换成大容量，称为自动类型转换机制long x=456;System.out.println(x);//2147483647字面值是int型，占用4字节//y是long类型，占用8个字节，自动类型转换long y=2147483647;System.out.println(y);//long z=2147483648;    错误   过大的正数   超出int类型范围long z=2147483648L;System.out.println(z);}
}

/*
关于java中的整数型byteshortint long
*/public class Day08DataType03
{public static void main(String[] args){long x=100L;//大容量转换成小容量，需要进行强制类型转换，加强制类型转换符
//加上强制类型转换后，但运行阶段可能损失精度//         int y=x;   错误//强转原理：//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100//强转之后：00000000 00000000 00000000 01100100//将左边的二进制砍掉【所有数据墙砖的时候这样完成】
int y=(int)x;
System.out.println(y);//原始数据：00000000 00000000 00000000 10000000 00000000 00000000 00000000 00000000//转化后：10000000 00000000 00000000 00000000 long k=2147483648L;int e=(int)k;System.out.println(e);        //损失精度严重，结果是负数【-2147483648】```java
/*
关于java中的整数型byteshortint long
*/public class Day08DataType03
{public static void main(String[] args){long x=100L;//大容量转换成小容量，需要进行强制类型转换，加强制类型转换符
//加上强制类型转换后，但运行阶段可能损失精度//         int y=x;   错误//强转原理：//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100//强转之后：00000000 00000000 00000000 01100100//将左边的二进制砍掉【所有数据墙砖的时候这样完成】
int y=(int)x;
System.out.println(y);//原始数据：00000000 00000000 00000000 10000000 00000000 00000000 00000000 00000000//转化后：10000000 00000000 00000000 00000000 long k=2147483648L;int e=(int)k;System.out.println(e);        //损失精度严重，结果是负数【-2147483648】//分析以下程序是否可以编译通过？//        *****    当一个整数字面值没有超出byte、short、char的取值范围时，这个字面值可以直接赋值给byte、short、char类型的变量。byte b=40;
byte c=127;byte d=(byte)128;   //超出byte 范围，强转            //-128
//会损失一定精度
//原始：00000000 00000000 00000000 10000000
//强转后：10000000【这是存储在计算机内部，是一个补码，他的原码是-128】System.out.println(b);
System.out.println(c);
System.out.println(d); //依据以前所学，不能通过编译，但实际编译通过了
//当一个字面值没有超出byte类型取值范围，改字面值可以直接赋值给byte类型的变量}
}/*计算机二进制有三种表示形式：原码反码补码* 计算机在任何时候底层表示和存储数据的啥时候采用了补码形式* 正数的补码：和原码相同* 负数的补码：负数的绝对值对应的二进制码所有二进制位取反，再加1//原始数据：00000000 00000000 00000000 11000110//强制类型转换后：11000110//11000110现在在计算机存储，是一个补码，将补码转换成原码就是该数字//11000110-1-->11000101//00111010【2+8+16+32】-->58//  -58 (原始数据开头为1)*///补码：10000000
//减一
//01111111
//反码：1000000          128
//原码：-128

- Day 08 浮点型、布尔型、类型转换

/*
关于浮点型数据类型：float 单精度【4】double 双精度【8 精度较高】对于财务软件来说，double精度太低。财务涉及到钱，需要高精度，所有SUN在基础SE类库中为程序员准备了精确度更高的数据类型，是：java.math.BigDecimal在java语言中，是所有浮点型字面值，都被当做double处理要想该字面值当作float处理，需要在字面值后面加F/f注：double和float在计算机内部二进制存储的时候都是近似值有些数字是无限循环的，333.3333333....*/public class Day09DataType04{public static void main(String[] args){double d=3.0;System.out.println(d);//大容量转换成小容量需要加强制类型转换，所以以下程序编译错误//float f=5.1;//解决方案：//第一种：强制类型转换//float m=(float)5.1;//第二种：不需要转换float m=5.1f;System.out.println(m);}
}

/*关于布尔型：boolean只有两个值：true false在底层存储，boolean类型占用一个字节，实际存储的时候false底层是0，true底层是1经常使用在逻辑运算和条件控制语句中*/
public class DataType05
{public static void main(String [] args){//编译错误：不兼容的类型//boolean flag=-1;boolean loginSuccess=false;if(loginSuccess)System.out.println("登陆成功");elseSystem.out.println("登陆失败");}
}

/*
关于八种基本数据类型：
1、八种数据类型中除了布尔型外都可以互相转换
2、小容量想大容量转换，称为自动类型转换
容量从小到大排序：
byte<short<int<long<float<double
char< 【short和char平级】

注：任意浮点型不管占多大字节，都比整数容量大char和short课表示的种类数量相同，但比char可取更大的整数3、char c=97;   //基本数据类型转换，未超过char取值范围
4、当字面值未超出byte,short,char取值范围，可以直接赋值给byte,short,char
5、byte,short,char混合运算时，各自转换成int类型再做运算
6、多种数据类型混合运算，先转换成容量大的那种类型再做运算注意：byte b=3;   可以编译通过，3没超出取值范围inti=10;byte b=i/3;   编译错误，编译只会检查语法错误，不会运算 i/3

**
- Day 9 算术、关系、逻辑运算符

/*关于运算符之：算术运算符+   -    *    /    %    求余数【取模】++--注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级提升没必要专门记忆优先级*/ //关于++运算符public class Operator01{public static void main(String [] args){int i=10;i++;System.out.println(i);  //11int j=10;++j;System.out.println(j);   //11//小结：++无论出现在变量后还是变量前，该变量值都会自加1//规则：先赋值，再自加int a=100;int b=a++;System.out.println(a);     //101System.out.println(b);     //100//规则：先自加1，再赋值int m=100;int n=++m;System.out.println(m);    //101System.out.println(n);     //101int e=100;System.out.println(e++);    //int x=e++;   100System.out.println(e);     //101int s=100;System.out.println(++s);   //int x=++s;   101System.out.println(s);     //101}}/*
关系运算符：>>=<<===!=注：=是赋值运算符关系运算符结果一定是布尔型
*/class Operator02{public static void main(String [] args){int a=10;int b=10;System.out.println(a>b);System.out.println(a<b);System.out.println(a!=b);System.out.println(a==b);}}/*
逻辑运算符：&         逻辑与 |           逻辑或^         逻辑异或（两边算子不一样，结果true）!           逻辑非（取反）&&     短路与||         短路或1、逻辑运算符要求两边算子都是布尔类型，并且逻辑运算符最终的运算结果也是布尔类型2、短路与和逻辑与的最终运算结果相同，只不过短路与存在短路现象
*/class Operator03{public static void main (String[] args){//优先级不确定，加小括号System.out.println(5>3 & 5>4);  //trueSystem.out.println(5>3 & 5>5);  //falseSystem.out.println(true & true); //trueSystem.out.println(!false );  // trueSystem.out.println(true ^ true);//falseSystem.out.println(5>3 | 5>4);//trueSystem.out.println(5>6 | 5>5);//false//逻辑与和短路与/*//逻辑与int x=10;int y=8;System.out.println(x<y & ++x<y);System.out.println(x);    //11*///短路与//后面的表达式没有执行，这种现象称为短路现象int x=10;int y=8;System.out.println(x<y && ++x<y);  //falseSystem.out.println(x);    //10//   短路与相对更智能，因为执行效率更高。短路与也更常用//   但某些特殊业务逻辑中，不能使用短路与，需要使用逻辑与/*什么时候发生短路与？* 第一个表达式执行结果false什么时候发生短路或？* 第一个表达式执行结果true*/}
}

- Day 10 赋值、字符串、三元运算符

/*
关于赋值类运算符：
赋值类运算符包括两种：* 基本赋值运算符* 扩展的赋值运算符+=-=/=%=1、赋值类的运算优先级：参照+=2、注意以下代码：byte i=10;k+=5;   等同于：k=(int)(k+5);3、结论：扩展类运算符不改变运算结果类型
*/public class Operator01
{public static void main(String[] args){byte b=10;//b=b+5编译错误，为什么？//编译器发现b+5的类型是int 类型，b变量数据类型是byte//大容量向小容量转换需要加强制类型转换符//纠正：b=(byte)(b+5);System.out.println(b);  //15byte x=10;x+=5;    //等同于：x=(byte)(x+5),其实并不等于x=x+5System.out.println(x);  //15byte z=0;z+=128;  //等同：z=(byte)(z+120)System.out.println(z);   //-128【精度损失】z+=10000;     //等同于：z=(byte)(z+10000)System.out.println(z);    //-112【精度损失】}}/*
关于"+"运算符1、数字+数字--->数字【求和】2、数字+”字符串“-->【字符串连接】3、在一个表达式中可以出现多个+，在没有加小括号的前提下，遵循自左向右的顺序依次计算*/class Operator02{public static void main(String[] args){System.out.println("10+20+30");//60System.out.println(10+20+"30");//3030System.out.println(10+(20+"30"));//102030int a=10;int b=20;System.out.println("10+20+30");System.out.println("10+20="+a+b);//10+20=1020；System.out.println("10+20="+(a+b));//10+20=30;System.out.println(a+"+"+b+"="+(a+b));//10+20=30；a=50;b=20;System.out.println(a+"+"+b+"="+(a+b));//50+20=70;//引用类型StringString username="abc";System.out.println("欢迎"+username+"回来");username="cvb";System.out.println("欢迎"+username+"回来");}}/*三元运算符/三元运算符/条件运算符*/class Operator03{public static void main(String[] args){boolean sex=false;char c =sex?'男':'女';System.out.println(c);//char c1=sex?"男":'女';//编译错误，类型不兼容System.out.println(10);  //10System.out.println('1');   //1System.out.println("10");   //10System.out.println(sex?'男':"女");   //可以}}

- Day 11 if语句、键盘输入

关于if语句

/*关于控制语句：* 选择结构if,if...elseswitch* 循环结构forwhiledo...while* 控制循环结构breakcontinue
*//*关于if语句【分支语句/条件控制语句】
*/public class If01
{public static void main(String[] args){double score = 59;score=87;String grade = "该考生成绩等级为E";if( score<0 || score > 100){grade = "您提供的考试成绩不合法";}else if (score >= 80){grade = "该考生考试成绩等级是A";}else if (score >= 60){grade= "该考生考试成绩等级为B";}System.out.println(grade);}
}//使程序短小精悍，提高效率

关于键盘输入

/*System.out.println();    从内存到控制台接受用户键盘输入：从键盘到内存*/public class KeyInput
{public static void main(String[] args){java.util.Scanner s = new java.util.Scanner(System.in);String userInputContent = s.next();System.out.println("您输入了："+userInputContent);int num = s.nextInt();//接收数字【以整数型int的形式来接收】System.out.println("您输入的数字是："+num);System.out.println("您输入的数字是："+(num+100));}
}/*总结：第一步：java.util.Scanner s = new java.util.Scanner(System.in);第二步：String str = s.next();或int num = s.nextInt();
*/

- Day 12 switch语句

/*关于switch语句：1、switch语句也属于选择结构，也是分支结构2、switch语句的语法结构：switch(int或String类型字面值){case int或String类型字面值：java 语句;...break;case int或String类型字面值：java 语句;...break;default;java语句;...}3、switch后面小括号当中的数据和case后面的数据进行一一匹配，匹配成功的分支执行按照自上而下的顺序依次匹配4、匹配成功的分支执行，分支当中最后有break的话，整个switch语句终止5、匹配成功的分支执行，分支当中没有break的话，直接进入下一个分支执行，这种现象被称为case穿透现象【提供break可以避免穿透】6、所有分支都没有匹配成功，当有default的话，会执行default中的程序7、switch后面和case后面只能使int或者String类型的数据* byte，char,short可以直接写到switch和case后面，因为它们可以进行自动类型转换8、case可以合并int i=1;switch(i){case 1:case 2:case10:System.out.println("hello");}*/public class Switch01
{public static void main(String[] args){/*long a=10L;int b=a; //编译错误long x=100Lswitch(x){}//编译错误*///解决编译错误long x=100L;switch((int) x){}byte h=10;switch(h){}char c='a';switch(c){}char cc=97;switch (cc){}String username = "zhang";switch(username){}}
}/*实现计算机中的+-*/%例如：欢迎使用计算器系统：请输入第一个数字:10请输入运算符：+请输入第二个数字：20运算结果：10+20=30*/class Switch02{public static void main(String[] args){java.util.Scanner s=new java.util.Scanner(System.in);System.out.println("欢迎使用计算机系统");System.out.println("请输入第一个数字：");int num1=s.nextInt();System.out.println("请输入运算符");String operator =s.next();System.out.println("请输入第二个数字");int num2=s.nextInt();int result=0;switch(operator){case "+":result=num1+num2;break;case"-":result=num1-num2;break;case"*":result =num1*num2;break;case"/":result = num1/ num2;break;case"%":result =num1%num2;break;}System.out.println("运算结果是:"+num1+operator+num2+"="+result);}
}class Switch03
{public static void main(String[] args){double score = 92.5;int grade=(int) (score/10);switch(grade){case 9:case 10:System.out.println("A");break;case 8:System.out.println("B");break;case 7:System.out.println("C");break;case 6:System.out.println("D");break;default:System.out.println("E");}}
}

运行结果