四、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;
    }
}

注意点总结：

1. 不能对布尔值进行转换
2. 不相干的类型不能进行转换
3. 高优先级类型转换为低优先级类型需要使用强制转换；反之不需要进行多余操作
4. 转换的时候可能存在内存溢出，或者精度问题

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文档；

基础知识，基本在后面的每一天都会用，所以非常重要重要重要！！！