Java基础语法

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

注释：注释不会被执行，是给我们写代码的人看的，书写注释是一个非常好的习惯

 Java中的注释有三种：

• 单行注释：//
• 多行注释：/* */
• 文档注释：/** */

标识符:标识符是用于变量名、方法名、类名等的名称（相当于我们的名字）。

它必须遵循以下规则：

• 合法字符：标识符只能包含字母（A-Z，a-z）、数字（0-9）、美元符号（$)或下划线(_)
• 以字母、下划线或美元符号开头：标识符不能以数字开头。
• 大小写敏感：Java是大小写敏感的，因此variable和Variable会被视为两个不同的标识符。
• 不能使用Java的关键字：不能使用Java已经定义的关键字作为标识符，例如int、class等。

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

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

关键字：关键字是Java语言中已经预定义的词汇，它们有特殊的含义，并用来表示程序或执行某些特定的操作。以下是Java中的一些常见关键字：

2.数据类型

• 强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用，Java是一种强类型语言。
• 弱类型语言：对变量的使用不做要求，比如JavaScript语言。
• Java的数据类型分为两大类

• 基本类型(primitive type)：四类八种，整数型最常用的是int类型

//八大基本数据类型
//整数型
byte num1 = 10;    
short num2 = 20;
int num3 = 30;   //最常用
long num4 = 40L;  //long类型要在数字后面加个L

//小数：浮点型
float num5 = 70.1F;  //float类型要在数字后面加个F
double num6 = 3.1415926;

//字符型
char name = 'A';   //只能写一个
//字符串 String不是关键字，是一个类
String name = '懒洋洋';

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

• • 引用类型(reference type)

数据类型扩展及面试试题：

public class Demo{
    public static void main(String[]args){
    // 整数扩展： 进制   二进制0b   十进制    八进制0     十六进制0x
        int i = 10;     //十进制
        int i2 = 010;   //0开头八进制
        int i3 = 0x10;  //0x开头十六进制  0~9 A~F
        System.out.println(i);    //输出10
        System.out.println(i2);   //输出8
        System.out.println(i3);   //输出16
    //========================================================
    //浮点数扩展   银行业务怎么表示？钱
    //使用BigDecimal 数学工具类
        float f = 0.1f;  //0.1
        double d = 0.1;  //0.1
        System.out.println(f==d);  //判断是否相等 输出结果为false

        float f1 = 1638536f;
        float f2 = f1 + 1;
        System.out.println(f1==f2);  //输出结果为true
    //float 有限 离散 舍入误差 结果是大约数 接近但不等于
    //最好完全避免使用浮点数进行比较
    //=============================================================
    //字符扩展：
        char c1 = 'a'
        char c2 = '中'
        System.out.println(c1);      //输出a
        System.out.println((int)c1); //强制转换，将字符型转换成整型，输出97
        System.out.println(c2);      //输出 中
        System.out.println((int)c2); //强制转换，输出20013
        //所有的字符本质还是数字
        //编码 Unicode表：（97=a 65=A） 2字节 0-65536
        // U0000-UFFFF
        char c3 = '\u0061'
        System.out.println(c3)   //a,字符'a'：Unicode码点是U+61
    //转义字符
    //  \t:制表符    \n:换行
    //===============================================================
    //布尔值扩展
        boolean flag = true;
        if(flag==true){}; //新手
        if(flag){}; //老手
        //Less is More! 代码要精简易读
}

扩展：什么是字节？

• 位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数。
• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示。
• 1B（byte，字节）=8bit（位）
• 字符：是指计算机中使用的字母、数字、字和符号。

1bit表示一位，

1Byte表示一个字节 1B=8b

1024B = 1KB

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

3.类型装换

• 由于Java是强类型语言，所以要进行有些运算时，需要用到类型转换。

byte，short，char——>int——>long——>float——>double

低----------------------------------------------------------->高（优先级）

• 运算中，不同类型的数据先转化为同一类型，然后进行运算
• 强制类型转换（低用高的值）
• 自动类型转换（高用低的值）

        int i = 128;
        byte b = (byte)i;  //内存溢出 byte范围-128~127
        //强制转换  （类型）变量名  
        //自动转换  低到高
        System.out.println(i);  //输出128
        System.out.println(b);  //输出-128

注意点：

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题

//操作比较大的数的时候，注意溢出问题
//jdk7新特性，数字之间可以用下划线分割，不会被输出
int money = 10_0000_0000;
int year = 20;
int total = money * year; //-1474836480,计算的时候溢出了
long total2 = money * year; //默认是int，转换之前已经存在问题了，所以输出还是-1474836480
long total3 = money * ((long)year); //先把一个数转换成long 输出正确 为2000000000

4.变量、常量

变量

• 变量是什么：就是可以变化的量！（相当于数学中的x y）
• Java是一种强类型语言，每个变量都必须声明其类型。
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=value]}];

数据类型 变量名 = 值；可以使用都好隔开来声明多个同类型变量。

注意事项：

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
2. 变量名必须是合法的标识符。
3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量作用域：

• 类变量
• 实例变量
• 局部变量

public class Demo{
    //类变量 static 从属于类 会随着类消失而消失
    static double salary = 2500;
    //实例变量：在方法外面，类里面，从属于对象
    //如果不进行初始化，这个类型的默认值为0 0.0，布尔型默认为false，除了基本类型，其余默认为null
    String name;
    int age;
    //main方法
    public static void main(String[]args){
        //局部变量：在方法里的变量，生命期只在大括号之间，必须声明和初始化
        int i = 1；
        
        //实例变量的使用 必须进行实例化 
        //变量类型 变量名字 = new Demo();
        Demo demo = new Demo();
        System.out.println(demo.name); //null
        System.out.println(demo.age); //0
        
        //类变量  static  可以直接使用
        System.out.println(salary);     
    }
}

常量

• 什么是常量：初始化之后不能再改变值，不会变动的值。
• 所谓常量可以理解为一种特殊的变量，它被设定后，在程序运行过程中不允许被改变。

final 常量名 = 值；

final double PI = 3.14

• 常量名一般使用大写字符。

变量命名规范

• 所有变量、方法、类名：见名如意（使用英文，不要使用拼音）
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run()，runRun()

5.运算符

Java语言支持以下运算符

• 算术运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=，instanceof
• 逻辑运算符：&&（与），||（或），！（非）
• 位运算符：&（按位与），|（按位或），^（异或），~（按位取反），>>（左移），<<（右移）
• 条件运算符：？ ：
• 扩展赋值运算符：+=，-=，*=，/=

public class Demo {
    public static void main(String[] args) {
        //二元算数运算符 + - * / % 
        int a = 10;
        int b = 20;
        long c = 2502781731L;
        short d = 30;
        byte e = 8;
        System.out.println(a + b);  //30
        System.out.println(a - b);  //-10
        System.out.println(a * b);  //200
        System.out.println(a / (double)b); //0.5 a,b是int类型，结果有小数，要进行强转
        System.out.println(a % e);  //2     
        System.out.println("==========================================");
        System.out.println(b+c+d+e); //lone 2502781789
        System.out.println(b+d+e);//int 58
        System.out.println(d+e);//int 38
        //有一个数为long类型结果为long，否则都为int类型，无论是否有int类型参与
        System.out.println("==========================================");
        
        //关系运算符返回的结果：true false  布尔值
        int a1 = 10;
        int a2 = 20;
        System.out.println(a1>a2);  //false
        System.out.println(a1<a2);  //true
        System.out.println(a1==a2); //false
        System.out.println(a1!=a2); //true        
    }
}

public class Demo1 {
    public static void main(String[] args) {
        //一元运算符：++自增、--自减
        int a = 3;
        int b = a++; //执行代码后，先给b赋值，再自增
        //a++  a=a+1  这时a=4
        System.out.println(a);  //4
        //++a  a=a+1  这时a=5
        int c = ++a; //执行代码前，先自增，再给c赋值
        System.out.println(a);  //5
        System.out.println(b);  //3
        System.out.println(c);  //5

        //幂运算 java中使用Math类
        double pow = Math.pow(3,2); //3^2
        System.out.println(pow);  //9
    }
}

public class Demo2 {
    public static void main(String[] args) {
        //逻辑运算符 与&& 或|| 非！(取反）
        boolean a = true;
        boolean b = false;
        System.out.println("a&&b："+(a&&b));  //false 逻辑与运算：两个都为真结果才为真
        System.out.println("a||b："+(a||b));  //true 逻辑或运算：两个都为假结果才为假
        System.out.println("!(a&&b)："+(!(a&&b)));  //true 逻辑非运算：对结果进行取反操作
        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4); //与运算 由于前面的c<4为假，所以整个结果d为false，与运算后面不管是什么都不执行
        System.out.println(c); //结果为5而不是6，就是因为c++没执行
        System.out.println(d); //false
    }
}

/*位运算 & | ^ ~
A = 0011 1100
B = 0000 1101
-------------------------------------------
A&B=0000 1100   与运算：A与B按位进行比较，都为1才取1，否则为0
A|B=0011 1101   或运算：A与B按位进行比较，都为0才取0，否则为1，即只要有一个为1则取1，
A^B=0011 0010   异或运算：A与B按位进行比较，相同则为0，不同则为1
~B= 1111 0010   取反运算：将1取0，将0取1
---------------------------------------------
面试题
2*8怎么算最快 = 2*2*2*2 = 2<<3(2左移3位)  进行位运算 效率极高！

0000 0000  0
0000 0001  1
0000 0010  2
0000 0100  4
0000 1000  8
0001 0000  16

<<左移:相当于把数字*2
>>右移：相当于把数字/2
*/

public class Demo4 {
    public static void main(String[] args) {
        /*三元运算符 ？ :
          x?y:z
          如果x==true,则结果为y，否则结果为z
        */
        int score = 80;
        System.out.println(score <60 ? "不及格" : "及格"); //及格

        //赋值运算符 += -= *= /=
        int a = 10;
        int b = 20;
        a+=b; //a=a+b  30
        a-=b; //a=a-b  -10
        a*=b; //a=a*b  200
        a/=b; //a=a/b  0

        //字符串连接符  +
        System.out.println(a+b);   //30
        System.out.println(""+a+b);  //1020
        // 只要前面或中间有一部分为String类型，就会把后面其他操作数转换为字符串类型进行拼接
        System.out.println(a+b+"");  //30
        //字符串在后面，前面会照常运行
    }
}

运算符优先级

6.包机制

• 为了更好地组织类Java提供了包机制，由于区别类名的命名空间
• 包语句的语法格式为：

package pkg1[. pkg2[. pkg3]];

• 一般利用公司域名倒置作为包名：com.baidu.www
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句。

import package1[.package2...].(classname|*);

7.JavaDoc

• Javados命令是用来生成自己API文档的
• jdk帮助文档 Java Platform SE 8
• 可添加的参数信息

1. @author 作者名
2. @version 版本号
3. @since 指明需要最早使用的jdk版本
4. @param 参数名
5. @return 返回值情况
6. @throws 异常抛出情况

/**
 * @author lanyy
 * @version 1.0
 * @since 1.8
 */
public class Dos {
    String name;

    /**
     * 
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

• 通过命令行方式生产JavaDoc文档 javadoc 参数 Java文件

1.右击Dos项目选择在资源管理器打开

2.在路径里输入cmd

3.输入javadoc命令

4.在项目目录下找到生成的index.html文件，双击打开

• 通过IDEA生成Javadoc文档

1.点击tool工具，点击Generate JavaDoc

2.在JavaDoc作用域中选择需要生成的范围以及选择输出目录和设置参数

3.生成之后会自动跳转到index.html