四、Java基础
Java基础
在开始学习Java基础之前，我们先来学习一下IDEA
打开IDEA，新建一个项目(New Project)，选择空项目(Empty Project)，填写项目名(Project name)比如我的JavaSE，填写路径(Project localtion)比如我的D:/代码/JavaSE，最后选择结束Finish；这样我们的空项目就建好了；加载好后如果提示就选择This Windows
在IDEA左上角选择文件(File)，选择新(New)，选择新建模块(New Module)，选择Java，保证模块的SDK与我们安装的版本一致，选择下一步(Next)，模块名(Module name)比如我的基础语法，选择根路径(Content root)比如我的D:\代码\JavaSE\基础语法，最后选择结束(Finish)l；这样新的模块就建好了
最后来配置Java的环境，这一步不做的话Java在IDEA上是无法运行的。在左上角选择文件(File)，选择项目结构(project Structure)，再选择项目(project)，名字(Name
)填项目名即可，比如我的JavaSE，SDK选择我们对应的版本，语言等级(Language level)选择8，因为我们装的是8，编译器输出的内容保持路径(Compiler output)比如我的D:\代码\JavaSE\out，然后应用(Apply)，最后ok
这样我们就可以新建class了，我一般习惯在src下面新建
如果代码class文件多的话可以新建一个包(也就是文件夹来存放代码)，在src这里右键，选择new，选择package，输入名字，然后就能把包拖进去；不过需要注意，每个java文件开头都会多一句(package 包名;)这一句不能删，删了就会报错，这句是用来声明，这个java文件是在这个包里面
注释、标识符、关键字
注释
平时我们编写代码，在代码量较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释
注释并不会被执行，是给我们写代码的人看的
- 重点书写注释是一个非常好的习惯，利于自己也利于别人！
这里我在这里吐槽一下：我一个学了一年多Python的同事，为了便利 工作写了一个自动化脚本，跟我说运行起来老是报错，检查过了很多遍，想让我帮忙看一眼。我觉得也没有多大事，就让他发来，下载后我打开一看，整篇下来一个注释都没有。。。我直接傻眼。想着毕竟话都放出去了，而且代码量不是很庞大。硬着头皮给他看完了，我还给他加上了注释！在此我奉劝各位仁兄，为了我们的头发也为了自己的头发，一定要好好写注释！一定要好好写注释！一定要好好写注释！
Java中的注释有三种
- 单行注释（// 注释）
public class Hello{
public static void main(String[] ages){
// 输出一个Hello,World!
System.out.println("Hello,World!")
}
}
- 多行注释（/星号开头星号/结尾，中间都为注释）
public class Hello{
public static void main(String[] ages){
/*
输出一个Hello,World!
输出一个Hello,World!
输出一个Hello,World!
*/
System.out.println("Hello,World!")
}
}
- 文档注释
这个后面JavaDoc再讲，一般很少写文档注释
关键字
在学习标识符之前我们先了解一下关键字
在我们使用IDEA写java程序的时候那些高亮的单词就是关键字，比如：public class等
常用的关键字有下面这些
以后就要记住取名字就不能使用关键字里面有的了，比如你创建一个类
public class class{
......
}
这样是会报错的！
标识符
- Java 所有的组成部分都需要名字。比如：类名、变量以及方法名都被称为标识符
类名：我们写Hello程序的时候，其中和文件名一样的那个就是类名；是标识符
变量：String a = "小迪"; 我们定义一个变量就是这样，其中a是变量名；是标识符
方法：public static void main(String[] args) {}其中main就是我们的方法名；是标识符
如果上面这些变量这些看的不是很懂的话没关系，我这里只是告诉你上面是标识符，其他的后面会讲
标识符的注意点
- 所有的标识符都应该以字母（A-Z或a-z），美元符($)、或者下划线(_)开始
- 首字符之后可以是字母（A-Z或a-z），美元符($)、或者下划线(_)或数字的任何字符组合
- 不能使用关键字作为标识符
- 标识符是大小写敏感的(意思就是区分大小写)
- 合法标识符举例：age、$xiaodi、_China、__2_value
- 非法举例：1value、%salary、^open
- 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音(不过我不精通英语有时候也会用)
什么是字节
位（bit）：是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数
字节（byte）：是计算简中 数据处理 的基本单位，习惯用大写的B来表示
1B （byte，字节）= 8bit （位）
字符：是指计算机中使用的字母、数字、字和符号
1bit表示1位
1Byte表示一个字节 1B=8b
1024B=1kb
1024kb=1M
1024M=1G
数据类型
强类型语言
- Java是一种强类型语言；要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用；也就是说一旦定义了一个变量，指定了某个数据类型，如果你不经过转换的话他就永远是这个类型了；安全性高相对的弊端速度会变慢；
如下代码：
public class Demo01{
public static void main(String[] args){
String name=1;
int num="XiaoDi";
}
}
这是错误示范：
我们定义name为字符串类型的变量却把数字类型的值赋值给它
定义num为数值类型却把字符串类型的值赋值给它
以上这种书写是错误的，我们必须严格符合规定的书写，将name的值改为字符串类型、num的值改为数字类型；如下代码：
public class Demo01{
public static void main(String[] args){
String name="XiaoDi";
int num=1;
}
}
弱类型语言
与强类型语言相反，这里就不做演示了！
Java的数据类型分为两大类
基本数据类型（primitive type）
数值类型
整数类型
byte占一个字节范围：-128-127 超过字节范围就会报错
short占两个字节范围：-32768-32767
int占4个字节范围：-2147483648-2147483647 一般这个就够用了
long占8个字节范围：-9223372036854775808-9223372036854775807
浮点类型
float占4个字节
double占8个字节 常用
字符类型
char占两个字节
boolean类型
占1位其值只有true和false两个
public class Demo02{
public static void main(String[] args){
//八大基本数据类型
//整数
int num1 = 10; //最常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L; //long类型要在数字后面加个L
//小数：浮点数
float num5 = 50.1F; //float类型要在数字后面加个F
double num6 = 3.1415926535;
//字符
char name = 'A'; //只能写一个字符，超过就报错
//字符串,String不是关键字，是类
//String namea = "小迪";
//布尔值：是，非 1，0
boolean flag = true;
//boolean flag = false;
}
}
引用数据类型 (reference type)
类、接口、数组；后面学
数据类型扩展及面试题讲解
整数、浮点类型扩展
public class Demo03{
public static void main(String[] args){
//整数扩展： 进制 二进制用0b表示 十进制 八进制0表示 十六进制0x表示
int i = 10;
int i2 = 010; //八进制0表示
int i3 = 0x10; //十六进制0x 0~9 A~F F为16
//浮点数扩展
float f = 0.1F; //0.1
double d = 1.0/10; //0.1
System.out.println(f==d); //输出结果false
//明明两个是相等的应该输出true才对啊
//再来看一下下面这个更诡异的
float d1 = 231313123123123113F;
float d2 = d1 + 1;
System.out.println(d1==d2); //输出结果true
//两个值完全是不相等的，但是判断时却返回true
}
}
那么为什么会出现上面这种情况呢？首先，我们这个浮点数表现的字长是有限的，一般会存在一个舍入误差的东西，因为有很多数字它没办法精确表示，所以它的结果只能是个大约数。（接近但不等于）
所以总结出一句话：
- 最好完全避免使用浮点数进行比较
- 最好完全避免使用浮点数进行比较
- 最好完全避免使用浮点数进行比较
那么有人就会问：我们如果一定需要用到浮点数进行比较怎么办？比如银行的业务怎么表示？钱
我们后面会学到一个类：BigDecimal 数学工具类
字符类型扩展
public class Demo04{
public static void main(String[] args){
//字符型扩展
char c1 = 'a';
char c2 = '中';
System.out.println((int)c1); //强制转换 输出结果为97
System.out.println((int)c2); //强制转换 输出结果为20013
}
}
以上这种情况，我们是使用了类型转换，将字符转换成了数字，那为什么a是97，中是20013呢？
记住下面这句话：
- 所有的字符本质还是数字
char类型会涉及到编码问题：Unicode编码 可以处理各种语言的文字，占2字节
我们也可以像下面这样直接给变量c3赋值Unicode编码，再进行输出 （其中\是转义不懂没关系下面会讲）
char c3 = '\u0061';
System.out.println(c3); //输出结果为：a
//这个是一些底层的原理，了解一下就ok，万一以后大家面试被问到了就懂了！
转义字符
- \t：制表符：转义成tab键
- \n：换行：相当于回车键
如图下：
这里我给大家留一个悬念
String sa = new String(original:"hello world");
String sb = new String(original:"hello world");
System.out.println(sa==sb); //输出结果为false
为什么两个值是一样的，却返回false
等后面学到对象的时候，再给大家从内存级别分析一下为什么
布尔值扩展
if语句我们还没有学我们也留一个悬念在这！
public class Demo05{
public static void main(String[] args){
boolean flag = true;
//我们一般会通过布尔值做一些判断；如下
if (flag==true){} //新手
//有的代码它不会把==true写出来它会像下面这种写法
if (flag){} //老手
//只是写法不一样但是意思和作用是一样的
}
}
这两种写法可以看出写代码的人是新手还是老手；
java中有一个概念叫做：Less is More！(少即是多)；我的理解是：代码要精简易读
类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
底--------------------------------------------->高
byte,short,char -> int -> long -> float -> double
//有人会问float才4个字节32位，为什么会比long8个字节64位高
//整型的优先级比浮点型低是因为，浮点类型的数据如果转换成整型就会损失精度，就是小数点后面的数会被省略
运算中，不同类型的数据，必须先转化为同一类型，然后进行运算。
强制类型转换
高转低的时候使用的转换方式
强制类型转换格式：(类型)变量名
public class Demo06{
public static void main(String[] args){
//int i = 128;
//byte b = i;
//上面这种写法是错误会报错的，因为i是int类型，b是byte类型，而且int的类型的优先级比byte的优先级高，是不能进行自动类型转换的；我们需要把i进行强制转换成byte类型才能进行赋值操作。如下：
int i = 128;
byte b = (byte)i;
System.out.println(i); //输出结果为：128
System.out.println(b); //输出结果为：-128
}
}
i输出结果为128没问题，那么为什么b的输出结果会等于-128呢？
我们在IDEA输入Byte按住Crte双击这个会打开这个函数的帮助文档;在帮助文档可以看到byte最大值是127，然而我们却给它b赋值了128，就导致了内存溢出的问题了；内存溢出的话你就不知道这个值会变成什么了。
- 所以我们在转换的过程中尽量避免这种内存溢出的情况
自动类型转换
底转高的时候使用的转换方式
自动类型转换是可以直接转的
public class Demo07{
public static void main(String[] args){
int i = 128;
double b = i;
}
}
注意点总结：
- 不能对布尔值进行转换
- 不相干的类型不能进行转换
- 高优先级类型转换为低优先级类型需要使用强制转换；反之不需要进行多余操作
- 转换的时候可能存在内存溢出，或者精度问题
public class Demo08{
public static void main(String[] args){
//精度问题，存在于浮点型
System.out.println((int)23.7); //输出结果为：23
System.out.println((int)-45.89F); //输出结果为：-45
}
}
类型转换例子：
public class Demo09{
public static void main(String[] args){
char c = 'a'; //这里注意一下，字符型要使用单引号，字符串使用双引号；
int d = c+1;
System.out.println(d); //输出结果为：98
System.out.println((char)d); //输出结果为：b
}
}
常见问题
public class Demo10{
public static void main(String[] args){
//操作较大的数的时候，注意溢出问题；顺便介绍一下JDK7的新特性：数字之间可以使用下划线分割，且不被输出
int money = 10_0000_0000; //大家一年赚的钱
//System.out.println(money); //输出结果为：1000000000
int years = 20; //大家比较勤奋干了20年
int total = money*years; //全部的钱
//System.out.println(total);
//输出结果为：-1474836480；怎么还倒赔了？噢原来是 内存溢出；那么我用long试试
long tota2 = money*years;
//System.out.println(tota2);
//输出结果还是：-1474836480；难道真的亏了？不不不，是因为money和years是int类型，money*years先计算好之后才把它转换为long类型，转换之前已经存在问题了，这个时候我们就不能这样去做
//正确操作
long tota3 = money*((long)years);
System.out.println(tota3); //输出结果：20000000000
//这才是大家总共赚的钱，我写的那么辛苦多多少少也拿点分我花哈哈
}
}
好习惯
long num4 = 30L; //long类型要在数字后面加个L，虽然小写的l也可以，但是容易看成1，最好使用大写的L
float num5 = 50.1F; //float也是一样最好使用大写
//像上面这种代码中赋值操作=两边最好也是加一个空格，这样代码看起来会比较整洁，养成好习惯从小迪做起
变量、常量、作用域
变量
- 变量是什么：就是可以变化的量！
- Java是一种强类型语言，每个变量都必须声明其类型。
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
type varName [=value] [{,varName[=value]}];
数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量，但是我是不建议在一行里定义多个值的，因为这样看起来会很乱。
public class Demo11{
public static void main(String[] args){
//声明变量
//格式：数据类型 变量名 = 值
String name = "XiaoDi";
char x = 'X';
int num = 123;
}
}
注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量作用域
新认知
public class Demo12{
//Demo12{}，这是我们定义的一个类
//类里面可以定义方法、属性(大家可以先理解为变量)
public static void main(String[] args){
//main(String[] args){}，这是我们的一个main方法
}
//除了main方法我们还可以定义其他方法
public void add(){
}
}
有了上面的这些新认知我们来看一下局部变量：
局部变量是在我们方法和语句块里面的；（语句块还没学先不管）
public class Demo12{
public static void main(String[] args){
//局部变量：必须声明和初始化值
// int i;
// System.out.println(i); 你会发现这样是输出不了的，因为他没有初始化值
int i = 10;
System.out.println(i); //输出结果：10 且它的作用域只限于main的方法里面
}
public void add(){
// System.out.println(i); //我在这里输出main方法里面的i是不行的，会报错
}
}
我们再来看一下实例变量：
实例变量在我们的方法外面，类的里面；而且你需要通过这个类才能使用
public class Demo12{
//实例变量：从属于对象；(我们还没有学对象，你只要知道我们需要通过Demo12这个类才能去使用它)
//需要声明，可无须初始化值
String name;
int agr;
public static void main(String[] args){
//实例变量的使用：这一段大家看不懂没关系，先了解一下，看一下就行
//变量类型 变量名字 = new Demo12();
Demo12 demo12 = new Demo12();
System.out.println(demo12.age); //输出结果为：0
System.out.println(demo12.name); //输出结果为：null
}
public void add(){
}
}
注意：
实例变量如果没初始化值，所有的数值类型的默认初始化值都是：0或0.0（0是整数类型;0.0是浮点数）；字符类型的话是 u0000，但是它也会输出0；布尔值默认是false；除了基本类型其他都为null。
类变量：
也是在方法外面，类里面；只不过他再调用的时候不需要像实例变量那么麻烦。
public class Demo12{
//类变量：static 后面讲到jvm会给大家分析
static double salary = 2500;
public static void main(String[] args){
System.out.println(salary); //输出结果为2500.0；是可以直接输出的
}
public void add(){
}
}
后面我们在学习的过程中，遇到需要在类里面方法外面定义的变量，我们就使用类变量，这样就不用去new了
有一些大家听不懂的，不用去纠结，我们后面都会学到的；重点记一下关键字：static
常量
常量(Constant)：初始化后不能在改变值！不会变动的值。
常量可以理解为一种特殊的变量，它的值被设定后，在程序运行的过程中不允许被改变。
- 语法：final 常量名 = 值 或者 final 数据类型 常量名 = 值；
- 常量名一般使用大写字符
public class Demo13{
//类变量的定义方法 +常量
static final double PI = 3.14;
//修饰符不存在先后顺序，static和final谁在前面都一样
public static void main(String[] args){
System.out.println(PI);
}
}
一般运用在：假如你要写一个游戏，要设置宽和高(不需要变动的值)，我们把宽和高设置成赋值给常量即可；
变量的命名规范
所有变量、方法、类名：见名知意
类成员变量(类里面方法外面的变量)：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
方法名：首字母小写和驼峰原则：run()，runRun()
常量：大写字母(如果多个单词就以下划线分开)：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
运算符
Java语言支持如下运算符
算数运算符：+，-，*，/，%，++，--（加、减、乘、除、取余、后面两个等一下讲）
赋值运算符：=（java中=是赋值才是等于）
关系运算符：>，<，>=，<=，，!=，instanceof（大于、小于、大于等于、小于等于、等于、不等于、最后这个学到面向对象讲）
逻辑运算符：&&，||，!（与、或、非）
位运算符：&，|，^，~，>>，<<，>>>（了解即可）
条件运算符：?，:
扩展赋值运算符：+=，-=，*=，/=
- 前面字体加粗的4种运算符是一定要掌握的，位运算符了解一下就行，后面这两个是用来偷懒用的，会就行
算数运算符
演示 加减乘除：
public class Demo14{
public static void main(String[] args){
//+ - * / 二元运算符：就是需要两个操作数的
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b); //结果：30
System.out.println(a-b); //结果：-10
System.out.println(a*b); //结果：200
System.out.println(a/b); //结果：0
}
}
为什么这个a/b等于0呢？
因为a是int型的b也是int型的，他们两个除完还是int型的，他们的值应该等于0.5，但是被整数形类型限制住了，只能舍去小数，所以等于0；所以我们不能这样写，我们要随便对一个进行强制类型转换，System.out.println(a/(double)b);
演示 4种整数类型相加的情况
public class Demo15{
public static void main(String[] args){
long a = 123123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); //算出来还是long类型
System.out.println(b+c+d); //int类型
System.out.println(c+d); //int类型
}
}
得出结果：
- 多个操作数中，有一个数为long类型，那么这个结果类型也为long
- 如果多个操作数中，没有一个数为long类型，那么结果的类型都为int
我们再来看一下其他基础数据类型类型：
public class Demo16{
public static void main(String[] args){
double a = 0.3;
int b = 3;
char c = 'a';
System.out.println(a+b); //结果：3.3为浮点型
System.out.println(a+c); //结果：97.3为浮点型
System.out.println(b+c); //结果：100为整形
}
}
得出结果：
- 不同基本的相加最终得出的结果的类型，取决于操作数中在类型转换中较高优先级的类型
- 我能大胆的告诉你-，*，/也是这样的；但是也会遇下面这两种种情况：
public class Demo17{
public static void main(String[] args){
int a = 3;
int b = 6;
char c = 'a';
System.out.println(a/c); //结果为0
System.out.println(b/c); //结果为0
}
}
那么这两种情况与上面演示 加减乘除：这种情况是一样的
关系运算符
关系运算符只有两种返回结果：正确和错误，就是通过布尔值来表示的
public class Demo18{
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println(a>b); //false
System.out.println(a<b); //true
System.out.println(a==b); //false
System.out.println(a!=b); //true
}
}
后期会经常与if去使用！
取余、自增自减运算符、初识Math类
取余、模运算
public class Demo19{
public static void main(String[] args){
int a = 10;
int b = 21;
System.out.println(b%a);//结果为1
}
}
就像我们小学学的余数21/10=2......1；取余就是要这个余数；也叫模运算+
自增、自减(一定要理解起来)
这个比较难理解，但是我会讲的通俗一点
public class Demo20{
public static void main(String[] args){
// ++ -- 自增、自减 一元运算符
int a = 3;
int b = a++;
int c = ++a;
System.out.pringln(a); //5
System.out.pringln(b); //3
System.out.pringln(c); //5
}
}
为什么会是这样的结果呢？
原因就在++的位置：
int b = a++;
++在后面：先给b进行赋值，再进行自增
就是说a初始值是3；int b = a++;这句是先把初始值3赋值给b之后，然后再进行a=a+1;
int c = ++a;
++在前面：先进行自增，再进行赋值
就是说现在a的值是4，int c = ++a;这句是先进行a=a+1;之后a值为5，再把5赋值给c
自减也是这样的！
初识Math
public class Demo21{
public static void main(String[] args){
//幂运算 2^3 2*2*2 = 8
//java中是像下面这样写的；我们会借助到数学类Math
double pow = Math.pow(2,3); //这样是表示2的3次方
System.out.println(pow); //8.0
}
}
在java中，很多运算，我们会使用一些工具类来操作！
逻辑运算符、位运算符
逻辑运算符
public class Demo22{
public static void main(String[] args){
// 与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b："+(a&&b)); //a && b：false
//逻辑与运算：两个变量都位true，结果才为true
System.out.println("a || b："+(a||b)); //a || b：true
//逻辑或运算：两个变量有一个位true，结果才为true
System.out.println("! (a && b)："+!(a&&b));//! (a && b)：true
//逻辑非运算：对结果进行取反，如果结果为真则变为假，结果为假，则变为真
}
}
- 逻辑与运算：两个变量都位true，结果才为true
- 逻辑或运算：两个变量有一个位true，结果才为true
- 逻辑非运算：对结果进行取反，如果结果为true则变为false，结果为false，则变为true
短路运算
public class Demo23{
public static void main(String[] args){
//短路运算
//因为逻辑与运算需要两个变量都为真结果才为真
//这样的话是不是第一个为假第二个就不会执行了？下面我们来实验一下
int a = 5;
boolean b = (a<4)&&(a++<4);
//c<4结果肯定为假，如果第一个变量为假，第二个变量没有执行的话那么a还是等于5，实验成功；如果第二个变量执行了的话那么a就等于6，实验失败；
System.out.println(b); //false
System.out.println(a); //5
}
}
短路法则：
变量1 && 变量2
变量1为“假”，则变量2不会再执行；
否则，变量1“真”，则变量2必须执行。
变量1 || 变量2
变量1为“真”，则变量2不会再执行；
否则，变量1“假”，则变量2必须执行。
位运算符
别轻易去用位运算，很容易出错
$ | ^ ~位运算符里面的 位与、位或、位异或、位非(其中只有位非(~)是一元操作符，其他都为二元操作符)
public class Demo24{
public static void main(String[] args){
/*
布尔值：false即是0，true即是1
比如我们现在有两个值
A = 0011 1100
B = 0000 1101
A&B
位与运算符：A与B上面的和下面对其的都为1那么结果为1，否则为0；结果：0000 1100
也就是说两者对其位都为true则结果为true，否则为false
A|B
位或运算符：A或B的对其位其中有一个为1那么结果为1，否则为0；结果0011 1101
也就是说两者对其位只要有一个为true结果就为true，否则为false
A^B
位异或运算符：对其位不同即为1，相同则为0；结果：0011 0001
也就是对其位不相同为true，相同则为false
~B
位非运算符：就是取反，1取反为0,0取反为1；结果：1111 0010
也就是说如果为true就取反为false，为false取反为true
*/
}
}
<<、>>位运算符里面的 左移、右移 (涉及到一道面试题)
public class Deomo25{
public static void main(String[] args){
/*
常见的一道面试题
问：2*8怎么算最快
2*8大家都都可以直接知道等于16，但是计算机不知道
我们先来做一下这道题：
*/
System.out.println(2<<3); //2左移3位，结果为16
/*
给大家分析一下为什么2移一下为什么就变成16了
二进制 代表10进制的
0000 0000 0
0000 0001 1 *
0000 0010 2 *
0000 0011 3
0000 0100 4 *
0000 0101 5
0000 0110 6
0000 0111 7
0000 1000 8 *
0000 1001 9
0000 1010 10
0000 1011 11
0000 1100 12
0000 1101 13
0000 1110 14
0000 1111 15
0001 0000 16 *
上面这些就是2进制对应10进制的转换结果
我标*号这些请仔细观察一下你就会发现，十进制的1开始每次乘以2的结果，都对应着二进制的1往左移1位
*/
}
}
得出结果：
<<：左移相当于*2 所以2<<3相当于2x2x2x2
>>：右移相当于/2
- 把这个结果死死记载心里
- 我们现在虽然接触不到算法，但是很多底层的算法它们会用位计算来做一些非常精巧的东西，因为位运算有一个好处：效率极高；因为它是直接跟底层打交道的，底层说的就是这个二进制
所以2*8在计算机中这么算最快：2<<3；
扩展赋值运算符、条件运算符
扩展赋值运算符
public class Demo26{
public static void main(String[] args){
int a = 10;
int b = 20;
a+=b; //这句话相当于a=a+b
System.out.println(a); //输出30
}
}
我说过这个是用来偷懒的，但是我不建议大家偷懒
+=、-=、*=、/=都是像上面+=这个例子差不多
顺便扩展一下字符串连接符
public class Demo27{
public static void main(String[] args){
//涉及到一道常见面试题
int a = 10;
int b = 20;
//问下面两种写法有什么区别
System.out.println(""+a+b); //这个会输出1020
System.out.println(a+b+""); //这个会输出30
}
}
也就是说
如果这个字符串在前面，那么后面的会拼接
如果这个字符串在后面，那么前面的依旧进行运算
条件运算符
public class Demo28{
public static void main(String[] args){
//三元运算符
//x ? y : z
//如果x为true，则结果为y，否则结果为z
//演示个例子
int score = 50;
String type = score<60 ? "不及格" : "及格";
//上面这一句就是说，如果score小于60为真的(true)，那么就是不及格，为假的(false)，那么就及格
System.out.println(type);
}
}
这个也是用来偷懒的，因为后面我们会学if语句，我们一般使用条件分支语句if来判断！
虽然是偷懒的，但是这个必须掌握，因为在我们开发中非常常见
优先级
就跟小学的先加减后乘除差不多
在java中一元运算符是最优先的然后加减乘除再来就是与或非等，但是这些东西在大家使用的时候会发现，这个东西不需要刻意去记住，表达式里有就优先使用括号()去组织，多打一些括号不影响代码的理解，反而会更清晰
包机制、JavaDoc
包机制
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
package pkg1[.pkg2[.pkg3...]];
//放于文件的最开头
演示：这是我的一个package结构
package com.xiaodi.operator.base;
包的本质就是文件夹
我们的包名不是凭空定义的，一般利用公司域名倒置作为包名比如：
baidu.com com.baidu
为了能够使用某一个包的成员，我们需要在java中明确导入该包。使用inport语句即可完成此功能
import package1[.package2].(classname|*);
//放于 package下面
演示：导入java自带的Date类
package com.xiaodi.operator.base;
import java.util.Date;
public class Demo10 {
public static void main(String[] args){
//写一个时间，直接像下面这样写是不行的，IDEA会报错，会提示你按住Alt+回车，会帮你生成错误信息和自动排错,选择第一个就行；你这个不用管我Date写的是什么意思，你只要知道Date是来着java自带的类就行
Date;
}
}
演示：导入自己写的类
package com.xiaodi.operator.base;
import com.xiaodi.operator.Demo01; //这样是会报错的，因为和我们下面这个类名一样了，所以我们要避免包里面的文件名重复
//下面这种名字不重复的就不会报错
import com.xiaodi.operator.Demo02;
public class Demo01 {
public static void main(String[] args){
}
}
我们要避免文件名重复，即使不同的包，文件名也尽量不要重复，会干涉到import导入报错
有的人会问：我包里写了100多个类，我不想一个一个去导入；那么就可以使用通配符*；会把我们包里所有类都导入进去；写法如下
import com.xiaodi.operator.*;
这篇文章看完推荐大家去看个东西：百度搜索阿里巴巴开发手册
认真看一遍
JavaDoc
JavaDoc文档注释：javadoc命令是用来生成自己的API文档的；一种能将你的注释信息生成帮助文档的技术；类似java的API帮助文档一样：可以去搜索jdk帮助文档
参数信息
- @author 作者名
- @version 程序版本号
- @since 指明需要用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
加在类上面就是类的注释，加在方法上面的就是我们方法的注释
package com.xiaodi.operator.JavaDoc;
/**
* @author XiaoDi
* @version 1.0
* @since jdk8
*/
public class Doc {
String name;
/**
*
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
}
使用IDEA开发工具来写的话，一般类的这个信息是需要自己写的，方法的只要你方法写好了，在方法上面写一行/**然后回车它就会自动生成
这个时候我们就可以使用javadoc命令来生成这个API文档了，从文件夹中打开Doc.java文件；然后在地址栏输入cmd；输入下面这些代码即可在当前文件夹生成：
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
我们的注释中可能会有中文，所以需要加编码参数-encoding UTF-8；表示使用UTF-8编码，还需要加字符集参数-charset UTF-8
生成出来的文件看index.html就行，其他不用管；
现在很少人用这种注释方式(看一下就行)，这是用命令行生成的，也可以百度查一下怎么使用IDEA生成API文档；
基础知识，基本在后面的每一天都会用，所以非常重要重要重要！！！
最新文章
- C# 通过反射获取扩展方法
- ASP.NET Core 使用 Redis 和 Protobuf 进行 Session 缓存
- 1.Powershell认识
- My安卓知识6--关于把项目从androidstudio工程转成eclipse工程并导成jar包
- 在Mongoose中使用嵌套的populate处理数据
- Linux：两台服务器之间添加信任关系，进行远程操作的时候不需要输入密码
- 基于nginx的HLS简单服务器搭建
- ora-01031:insufficient privileges 解决方案
- 【ASP.NET】判断访问网站的客户端是PC还是手机
- js二维码插件总结
- [.NET Core] 简单读取 json 配置文件
- maven工程 java 实现文件上传 SSM ajax异步请求上传
- 常用jq代码
- java接口深入
- Ubuntu Firefox HTML5
- MySQL中使用连接查询
- 前端如何在h5页面调用微信支付？
- curl定时任务下载执行
- 16 python xml模块
- wdatepicker控件de使用小方法汇总