一.注释、标识符、关键字

（一）注释

     1.单行注释：// 注释

     2.多行注释:  /* 注释 */

     3.文档注释： /** 注释 */

(二) 标识符

 定义：标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。标识符通常由字母和数字以及其它字符构成。

 标识符命名规则

     1、标识符用作给变量、方法和类命名。

     2、以字母、下划线“_”和“$”符开头，后面可跟字母、下划线“_”和“$”符或数字。

     3、标识符大小写敏感。

     4、合法标识符举例：age,$salary,_value,_ _1_value

           非法标识符举例：123abc,-salary,#abc

     5、应该使用有意义的名称，达到见名知意的目的，并且长度无限制。

     6、尽量不要使用中文。

     7、不可以是true和false。true和false虽然不是关键字，但是有特殊用途。

     8、避免与java关键字与java类库的类名重名，java关键字一共有51个，如下：

二.数据类型

强类型语言：要求变量的使用要严格符合规定，搜易变量都必须先定义后才能使用

public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int unm1=10;  //常用
        byte num2=20;
        short num3=30;
        long num4=30L; //Long 类型要在数字后面加上个L

        //小数：浮点数
        float num5=50.1F;//Lfloat 类型要在数字后面加上L
        double num6=3.14159265354;

        //字符
        char name='A';
        //字符串，string不是关键字，类

        //布尔值 :是非
        boolean flag=true;
        //boolean flag=false;

    }
}

 数据类型扩展

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 16
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
//====================================================================
        //浮点数拓展    银行业务怎么表示？  钱
        //BigDecimal  数学工具类
        //float 有限 离散 舍入误差  大约  接近但不等于
        //最好完全使用浮点数进行比较
        float f=0.1f; //0.1
        double d=1.0/10; //0.1
        System.out.println(f==d);//false

        float d1=23131312312312313f;
        float  d2=d1+1;
        System.out.println(d1==d2);//ture
        
        //==============================================
        char c1='a';
        char  c2='中';
        System.out.println(c1);
        System.out.println((int)c1);//强制换行
        System.out.println(c2);
        System.out.println((int)c2);//强制换行

        //所有的字符本质还是数字
        //编码 Unicode 表：(97=a  65=A)  2字节  0-6536  EXCEL
       //U0000  UFFFF
        char c3='\u0061';
        System.out.println(c3);//a

        // 转义字符
        // \t   制表符
        // \n    换行符
        System.out.println("Hello\tWorld");
        System.out.println("==============");
        String sa=new String("hello world");
        String  sb=new String("hello world");
        System.out.println(sa==sb);

        String sc="hello world";
        String sd="hello world";
        System.out.println(sc==sd);
        //对象  内存分析

        //布尔值扩展
        boolean flag=true;
        if (flag==true){}//新手写法
        if (flag){} //老手写法
        //Less is More!  代码要精简易读

    }
}

三.类型转换

由于Java是强类型语言，运算中不同的数据先转化为同一类型，然后进行运算

public class Demo04 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte) i; //内存溢出

        //强制转换  （类型）变量名   高----低
        //自动转换    低到高

        System.out.println(i);
        System.out.println(b);

        /*
        注意点：
        1.不能对布尔值转换
        2.不能把对象类型转化为不相干的类型
        3.把高容量转换为低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题
         */
        System.out.println("==============");
        System.out.println((int)23.7);//23
        System.out.println((int)-45.89f); //-45

        System.out.println("=============");
        char c='a';
        int  d=c+1;
        System.out.println(d);
        System.out.println((char) d);
    }
}

public class Demo06 {
    public static void main(String[] args) {
        //操作比较打的数时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money =10_0000_0000;
        System.out.println(money);
        int years=20;
        int total =money*years;
        long total2=money*years;//默认interesting，转换之前已经存在问题
        long total3=money*((long)years);//先把一个数转化成long
        System.out.println(total3);
    }
}

四.变量、常量

（一）变量

      变量：就是可以改变的量。

                 Java变量是程序中最基本的存储单元，变量的要素包括：变量类型，变量名以及作用域。

• 例子：int 表示能存储整数类型的数据类型。 int a;表示你定义了一个存储整数的变量。a就是你的变量名；int a = 10;表示你给这个变量赋的值为10;

　变量的命名规范

• 所有变量、方法、类名：见名知意；
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_SALARY
• 类名：首字母大写和驼峰原则：Man,GoodMan
• 方法名：首字母小写和驼峰原则：run() ,runRun()

    变量的使用规则：

1. Java 中的变量需要先声明后使用；（Java是一种强类型，每种变量必须声明变量类型）
2. 变量使用时，可以声明变量的同时进行初始化,也可以先声明后赋值；String love="imooc";或者String love;love="I love imooc";
3. 变量中每次只能赋一个值，但可以修改多次；
4. main 方法中定义的变量必须先赋值，然后才能输出；
5. 变量必须是合法的标识字符；
6. 变量声明是一条完整的语句，必须以分号结尾。

public class Demo08 {
    //类变量 static
    static double salary=8000;

    //属性：变量

    //实例变量：从属与对象,如果不自行初始化，这个类型的默认值0 0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;
   
    
    //main 方法
    public static void main(String[] args) {
        //局部变量：必须声明初始化值
        int i=10;
        System.out.println(i);
        //变量类型  变量名字
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);
        //类变量
        System.out.println(salary);

    }

    //其他方法
    public void  add(){

    }
}

 （二）常量

常量：初始化后不能再改变的值，所谓常量，可以理解成一种特殊的变量，它的值设定后，在程序运行过程中不被改变。

//final 常量名=常量值

public class Demo09 {

    //修饰符，不存在先后顺序
    static final double PI=3.14;
    
    public static void main(String[] args) {
        System.out.println(PI);

    }
}

五.运算符

Java 语言中常用的运算符可分为如下几种：

Ø 算术运算符：+ ，- , * , / ， % ，++ , --

Ø 赋值运算符: =

Ø 关系运算符:> ,< ,>= ,<= ,== ,!= instanceof

Ø 逻辑运算符:&& ,|| ,!

Ø位运算符：& ，| ，<< ,>>   (了解）

Ø 条件运算符: ? ,:  (了解）

Ø 扩展赋值运算符：+= ，-= ，*= ，/=  (了解）

 (一)算术运算符

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        int a=10;
        int b=20;
        int c=25;
        int d=25;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println((double)a/b);

    }
}

public class Demo04 {
    public static void main(String[] args) {
        //++自增，--自减，一元运算符
        int a=2;
        int b=a++; //a++ 等于a=a+1,先把a的值赋给b,a再进行自增
        int c=++a;// ++a 等于a=a+1,a先自增，然后把a的值赋给c
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算。很多运算是使用工具去算
        double pow=Math.pow(3,2);
        System.out.println(pow);

    }
}

（二）赋值运算符

（三）关系运算符

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符的返回出结果：ture false
        int a=2;
        int b=5;
        int c=21;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%b);//模运算，也就是取余

    }
}

 （四）逻辑运算

public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算
        boolean a=true;
        boolean b=false;
        System.out.println("a&&b" +(a&&b));//逻辑与运算，两个变量都为真，结果才为真
        System.out.println("a||b" +(a||b));//逻辑运算，两个变量只要一个为真，结果就为真
        System.out.println("!(a||b)" +(a&&b));//如果变量为真，则假；如果变量为假，则结果为真

        //短路运算
        int c=5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);

    }
}

(五)位运算

public class Demo06 {
    public static void main(String[] args) {
     /*效率极高
     <<  *2
     >>  /2
     2*8最快的算法  2*2*2*2
      */

        System.out.println(2<<3);

    }
}

 （六）条件运算

public class Demo07 {
    public static void main(String[] args) {

        int a=10;
        int b=20;
        //a+=b 就是a=a+b
        //a-=b 就是a=a-b
        System.out.println(a+=b);
        System.out.println(a-=b);

        //字符串连接符
        System.out.println(" "+a+b);//连接符在运算的前面，起拼接作用
        System.out.println(a+b+" ");//连接符在运算的后面，先计算公式

    }
}

（七）扩展

public class Demo08 {
    public static void main(String[] args) {
        // x? y:z
        //如果x==ture,则结果为y,否则为z
        int score=80;
        String type= score<60 ?"不及格":"及格";
        System.out.println(type);
    }
}

六.包机制、JavaDoc

使用命令行生成帮助文档

1. 使用文档注释 /** */

2. 打开代码所在位置（右键.java文件，在文件中给打开）

3. 打开命令行,cd到代码所在文件夹，运行：

   javadoc -encoding UTF-8 -charset UTF-8 程序名.java

   -encoding utf-8 -charset utf-8 为了能够显示中文

4. 生成帮助文档   

使用IDEA生成帮助文档

• Tools --> Generate JavaDoc

•