Java基础语法

本文主要介绍Java中的一些基本语法，没学习一门基础语言，其基本语法是相当重要的，就好像建造房子一样根基一定要牢固。下面就来价绍Java中的基础语法。

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

注释

/***
 * ┌───┐   ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┐
 * │Esc│   │ F1│ F2│ F3│ F4│ │ F5│ F6│ F7│ F8│ │ F9│F10│F11│F12│ │P/S│S L│P/B│  ┌┐    ┌┐    ┌┐
 * └───┘   └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┘  └┘    └┘    └┘
 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ ┌───┬───┬───┐ ┌───┬───┬───┬───┐
 * │~ `│! 1│@ 2│# 3│$ 4│% 5│^ 6│& 7│* 8│( 9│) 0│_ -│+ =│ BacSp │ │Ins│Hom│PUp│ │N L│ / │ * │ - │
 * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ ├───┼───┼───┤ ├───┼───┼───┼───┤
 * │ Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │{ [│} ]│ | \ │ │Del│End│PDn│ │ 7 │ 8 │ 9 │   │
 * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ └───┴───┴───┘ ├───┼───┼───┤ + │
 * │ Caps │ A │ S │ D │ F │ G │ H │ J │ K │ L │: ;│" '│ Enter  │               │ 4 │ 5 │ 6 │   │
 * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤     ┌───┐     ├───┼───┼───┼───┤
 * │ Shift  │ Z │ X │ C │ V │ B │ N │ M │< ,│> .│? /│  Shift   │     │ ↑ │     │ 1 │ 2 │ 3 │   │
 * ├─────┬──┴─┬─┴──┬┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ ┌───┼───┼───┐ ├───┴───┼───┤ E││
 * │ Ctrl│    │Alt │         Space         │ Alt│    │    │Ctrl│ │ ← │ ↓ │ → │ │   0   │ . │←─┘│
 * └─────┴────┴────┴───────────────────────┴────┴────┴────┴────┘ └───┴───┴───┘ └───────┴───┴───┘
 */

————————————————
/***
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'\____
 *              .   ' \\| |// `.
 *               / \\||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\\ - /// | |
 *             | \_| ''\---/'' | |
 *              \ .-\__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *        ."" '< `.___\_<|>_/___.' >'"".
 *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */

————————————————

平常我们编写代码的，在代码量比较少的时候还可以看得懂自己写的，但当项目结构一旦复杂起来，我们就需要用到注释了。

注释并不会被执行，是给我们写代码的人看的

书写注释是一个非常好的习惯！！！

平时写代码一定要注意规范。

关于代码上面的注释，大家可以在网上搜索有趣的代码注释，有很多有趣的注释。

Java中的注释有三种：

• 单行注释

  • //单行注释 只能注释一行
    

• 多行注释

  • /*多行注释*/ 可以注释多行
    

• 文档注释

  • /**文档注释*/ 也称为JavaDOC /** */ 可以加参数
    

更改注释颜色：

public class Hello {
    public static void main(String[] args) {
        //单行注释  //开头
        //输出一个Hello World!
        System.out.println("Hello World!");
        /*多行注释
        我是多行注释
        */
        /**
         * 文档注释
         * @Description Hello //描述
         * @Author 作者
         **/
    }
}

标识符

关键字

Java中所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

这些关键字是不能用来，给变量、方法起名字的！

标识符注意点

• 所有的标识符都应该以字母（A-Z或者a-z），美元（$）、或者下划线（_）开始

• 首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或者数字的任何字符组合

• 不能使用关键字作为变量名

• 标识符是大小写敏感的，也就是严格区分大小写

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

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

  • public static void main(String[] ages){
        String 王者荣耀="王者荣耀";//可以使用但不推荐
        System.out.print(王者荣耀);
    }
    

• 可以使用中文命名，但是一般不建议这样使用，也不建议是用拼音，很low!!

2、数据类型

Java是强类型语言

​与之相同的还有C/C++都是强类型语言，强类型语言要求变量的使用要严格符合规定，所有的变量都必须先定义后才能使用。

强类型语言的好处就是安全性高，必须定义之后才能使用。缺点就是速度相对来说略有逊色。

public static void main(String[] ages){
    String a;
    System.out.print(a);//这样书写就会报错，提示必须给a初始化一个值
}

-----
public static void main(String[] ages){
    String a=10;//同样会报错，因为String为字符串类型，不能赋值int类型的数据。
    System.out.print(a);
}
-----
    //正确写法，数据类型要对应
public static void main(String[] ages){
    String a ="Hello World";
    System.out.print(a);
}

弱类型语言：

​VB、JS都属于弱类型语言，它与强类型语言正好相反，速度相对较快，但是安全性稍微不足。

Java的数据类型分为两个大类：

1. 基本类型（primitive type）
2. 引用类型（reference type）

基本类型又分为：

• 数值类型
  • 整数类型
    • byte占一个字节范围：-128~127
    • short占两个字节范围：-32768~32767
    • int占四个字节范围：-2147483648~2147483647
    • long占八个字节范围：-9223372036854775808~9223372036854775807
  • 浮点类型
    • float占四个字节
    • double占八个字节
  • 字符类型char占两个字节
• Boolean类型：占一位其值只有true和false两个

引用数据类型：

• 类
• 接口
• 数组

public static void main(String[] ages){
    //八大基本数据类型
    int num1 = 10;//最常用
    byte num2 = 10;
    short num3 = 30;
    long num4=100000L;//Long类型要在数字的后面加上L，来区分
    //小数，浮点数
    float num5 = 40.1F;//float类型也需要在数字后面加上F来与double区分,
    double num6 = 40.11;


    //字符类型
    char name = 'A';//只能写一个字符，如果写多个就会报错，一般用单引号括起来

    //String 不是关键字，是类
    String str = "你好！";//可以存放字符串类型

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

如果说你不懂什么是字节，这里九好评好看看吧！

拓展：

public class Dome01 {
    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);
        System.out.println(i2);
        System.out.println(i3);
        //=====================================
        //浮点数扩展 银行业务如何标识？钱
        //BigDecimal 数学工具类
        //=====================================
        //float 有限 离散 舍入误差 大约 接近但不等于
        //double
        //最好完全不要使用浮点数进行比较
        //最好完全不要使用浮点数进行比较
        //最好完全不要使用浮点数进行比较

        float f = 0.1f;//0.1
        double d = 1.0/10;//0.1

         System.out.println(f==d);//输出为false
         System.out.println(f);//0.1
         System.out.println(d);//0.1
        float d1 = 23232332323232f;
        float d2 = d1 + 1;
         System.out.println(d1==d2);//true

        //=====================================
        //字符扩展
        //=====================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换

        System.out.println(c2);
        System.out.println((int)c2);

        //所有的字符的本质还是数字
        //编码 Unicode 表中对应字符和数字 2字节 0-65536 Excel 最长只有 2的16次方
        char c3='\u0061';
        System.out.println(c3);//a
        //转义字符
        //\t 制表符
        //\n 换行
        // ··· 自行查找
        String sa = new String("Hello World");
        String sb = new String("Hello World");
        System.out.println(sa==sb);//false

        String sc = "Hello World";
        String sd = "Hello World";
        System.out.println(sc==sd);//true
        //对象 从内存分析

        //布尔值扩展
        boolean flag = true;
        if(flag==true){}//if为判断条件如果的意思，后面细讲
        if(flag){}这两行代码相同
         //Less is More! 代码要精简易读
    }
}

3、类型转换

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

低<--------------------------------------------->高
    byte,short,char->int->long->float->double

小数的优先级一定大于整数！所以float大于long

运算中，不同类型的数据先转化为同一类型，然后进行运算。

问题：

public class Demo05{
    public static void main(String[] ages){
        int i = 128;
        byte b = (byte)i;//强制类型转换，内存溢出

        //强制转换 格式（类型）变量名；

        System.out.println(b);//输出-128？
        //这是因为byte本身最高只能为127，赋值128后出现溢出现象
    }
}

强制类型转换

格式：（类型）变量名

由高到低 强制类型转换 （类型）变量名 高--低

自动类型转换

自动转换 低--高

public class Dome01{
    public static void main(String[] ages){
        int i = 128;
        double d = i;//自动类型转换 低--高
        System.out.println(d);
        /*
        注意：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型，
        3.再把大容量转化为低容量的时候--强制转换
        4.转换的时候可能会出现内存溢出，或精度问题！
        5.
        */
        //精度问题
        System.out.println((int)23.7);//23
        System.out.println((int)-45.89);//45
        //==============================
        char c = 'a';
        int d = c+1;
        Systerm.out.println(d);//98
        Systerm.out.println((char)d);//b
    }
}

溢出问题

public class Dome02{
    public static void main(String[] ages){
        //操作比较大的数的时候，注意溢出问题
        //JDK7的新特性，数字之间可以使用下划线分割，为了更方便的观察
        int money=10_0000_0000;//下滑线并不会被输出
        System.out.println(money);
        int years = 20;
        int total = money*years;
        Systerm.out.println(total);//-1474836480,出现溢出现象，超过了int的最大数值
        //即便是在计算的时候转换为long，依然会出现错误
        long total2 = money*years;//默认是int，在转换之前已经溢出。
        //解决方案，在计算前就改变类型
        long total3 = money*((long)years);
        Systerm.out.println(total3);//正确输出

        //另外 在写long数据类型的时候，后缀的L尽量大写，以防认为是1/l
    }
}

4、变量、常量

变量

变量是什么：就是可以变化的量！

变量就是只内存空间的一小个位置，我们创建变量就好像在内存空间中申请了一小块位置空间，而空间中存放的东西我们是不确定的。

Java是一种强类型语言，每隔变量都必须生命其类型。

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

type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。但是不建议。

注意事项：

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

public class Dome03{
    public static void main(String[] ages){
        //int a,b,c;不建议
        //int a=0,b=2,b=3;//这种写法程序可读性较差，建议分开来写
        String name="Hello";
        char x = 'x';
        double pi = 3.14;
    }
}

变量的作用域

1. 类变量
   1. 要求需要加上关键词static。在方法之外，类之内
2. 实例变量
   1. 没有关键词，在方法之外，类之内
3. 局部变量

public class Dome03{
    //属性：变量
    static int allClicks=0;//类变量

    String str="Hello World";//实例变量：从属于对象；
    //如果不进行初始化，会输出这个类型的默认值
    String name;//默认值null
    int age;//默认值 0
    //布尔值默认为false
    //除了基本类型，其余的都是null

    //main:方法
    public static void main(String[] ages){
        int i = 0;//局部变量:必须声明和初始值

        //这里不需要了解很深后面会讲解。
        //变量类型 变量名字 = new Dome03();
        Dome03 dome03 = new Dome03();
        //dome03.name = "Hello";
        Sytem.out.println(dome03.name);

        //类变量可以直接在，本类的方法中使用
        System.out.println(allClicks);//0
    }

    //其他方法
    public void add(){
        //这里无法使用 i输出，需要重新定义
    }
}

常量

常量（Constant）：初始化（initialize）后不能在改变值！不会变动的值；

常量在定义的时候要使用关键字 final

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许修改。

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

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

变量的命名规范：

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则：mouthSalary 除了第一个单词以外，后面的单词第一个字母大写
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Max，GoodMan
6. 方法名：首字母小写和驼峰原则：run()，runRun()

5、运算符

Java语言支持如下运算符：

• 算数运算符：+，-，*，/，%，++，--
  • %取余原运算，在Java中叫做模运算
• 赋值运算符：=
• 关系运算符：>，<,>=,<=,==,!= instanceof
  • instanceof 到面向对象的时候，再深究
• 逻辑运算符：&&，||，!
• 位运算符：&，|，^,~,>>,<<,>>>(了解)
• 条件运算符：？：
  • 也叫三目运算符，后面在讲，先做了解
• 扩展赋值运算符：+=，-=，*=，/=

//运算符 operator
public class Dome01{
    public static void main(String[] ages){
        // 二元运算符
        //IDEA中快捷键：ctrl+d 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//因该等于0.5但是输出为0，这是因为数据类型为int型，会舍去小数部分，所以为0

        //==============================
        long a = 1212312341L;
        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
        //类型转换：byte,short,char用运算符运算后自动转型int类型

        //============================
        //关系运算符，返回结果为Boolean类型
        int a = 10;
        int b = 20;
        int c = 21;

        //取余也叫做模运算
        System.out.println(c%a);//结果为1，余数为1

        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true


        //=============================
        //++ -- 自增，自减 一元运算符
        //a++ = a = a+1 //先运算，a在加一 --相同
        //++a  //a先加1，在运算 --相同
        int a = 3;
        int b = a++; //先给B赋值，在自增
        System.out.println(a);//输出为4
        int c = ++a;//先自增，在给c赋值
        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        //=======================
        //幂运算 2^3 2*2*2 = 8
        //但是Java中没有幂运算，也就是没有^这个符号
        //可以是用Math数学工具类，其中包含许多数学方法可以直接使用
        double pow = Math.pow(2,3);
        System.out.println(pow);//8.0
    }
}

建议一定要多练习两次++，--的操作达到数来能掌握。

剩下的几种运算符：

逻辑运算

public class Dome04{
    public static void main(String[] ages){
        //逻辑运算符 与（and） 或(or) 非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println(a&&b);//false 有假为假 ，只有连个都为真的时候才为真
        System.out.println(a||b);//true 有真为真 ，只有都为假的时候才为假
        System.out.println(!(a&&b));//true //取反，假的变成真，或者真的变成假

        //当a&&b判断 ,a为假,b为真，当判断出a为假之后程序就会短路，也就是不在判断b的真假，直接执行吓一跳指令。
        //验证
        int c = 5;
        boolean d = (c<<4)&&(c++<4);
        System.out.println(c);//5 //如果执行了后面的语句，c因该输出的为6
        System.out.println(d);//false
    }
}

位运算

public class Dome01{
    public static void main(String[] ages){
        /*
        A  = 0011 1100
        B  = 0000 1101

        A&B 按位与运算 0000 1100	有0为0
        A|B 按位或运算 0011 1101	有1为1
        A^B 按位异或运算 0011 0001 相同为0不同为1
        ~B 按位取反	 1111 0010	原来为1取反后为0，原来为0后来为1

        2*8 = 16 2*2*2*2
        效率极高
        <<左移	>>右移
        <<	相当于数字*2
        >>	相当于数字/2
        0000 0000
        0000 0001	1
        0000 0010	2
        0000 0011	3
        0000 0100	4
        ··· ···
        0000 1000	8
        0001 0000	16
        */
        System.out.println(2<<3);//输出16
    }
}

扩展运算符

public class Dome02{
    public static void main(String[] ages){
        int a = 10;
        int b = 20;

        a += b;//先当与a=a+b;
        a -= b;//相当于a=a-b;
        System.out.println(a);//30

        //字符串连接符 +
        System.out.println(a+b);//用作字符运算
        System.out.println(""+a+b);//输出1020
        //如果在加号前边出现""字符类型，那么将会将字符串后的，所有运算数据转化为字符串类型进行连接，前面的运算按照正常进行。
        System.out.println(a+b+"");//30
        //运算过程是从左向右

        //=================================
        //三元运算符//
        //必须掌握，实际开发中经常使用
        //x ? y : z
        //如果x==true,结果为y，否则结果为z

        int score = 80;
        String type = socre < 60? "不及格":"及格了";
        System.out.println(type);//输出及格
    }
}

6、包机制、JavaDoc

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

包的本质：就是文件夹！

包语句的语法格式为：

package pkg1[. pkg2[. pkg3...]];

一般利用公司域名倒置作为包名；例如：com.baidu.www

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import完成此功能

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

导入包的时候的快捷键：ALT+回车

总结：

• 定义包用package
• 导入包用import
• 当一个包中有许多类，可以直接通过*通配符全部导入
  • 例如：com.baidu.www.*

推荐看完这章后，去看一下阿里巴巴开发手册！，百度搜索就行

JavaDoc

传送门：jdk帮助文档

Javadoc命令是用来生成自己API文档的

参数信息

• @author 作者名
• @version 版本号
• @since 指名需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

//加载类上面就是类的注释
/**
 * @author zhao
 * @version 1.0
 * @since 15
 *
 */
public class Dome02 {
    String name;
	//加载方法上面就是方法的注释
    /**
     * @author zhao
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

在IDEA中打开对应的类的文件夹方式：

生成自己Javadoc -API文档的方法，首先一定是在写代码的时候就已经写了文档注释：

通过命令行生成doc文档：

1. 进入对应文档所在的文件夹
2. 保存在路劲在cmd中打开
3. 在cmd中输入javadoc -encoding UTF-8 -charset UTF-8 文件名.java回车即可
   1. 其中encoding为编码格式，为了使中文显示正常，不出现乱码格式
   2. charset 字符编码格式
4. 回到对应文件夹查看即可。

通过IDEA生成Javadoc文档的方法：

3. 说明：

   1. 选择的整个项目还是模块还是单个文件
   2. 文档输出路径
   3. Locale选择地区，这个决定了文档的语言，中文就是zh_CN
   4. 传入JavaDoc的参数，一般写法 -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

学习编程一定要学会，面向百度编程！！