Java基础语法

注释

平时编写代码，当代码量比较少的时候，还是可以看得懂自己写的，但是当结构复杂起来，代码量变多的时候，就必须要写注释了。

注释并不会被执行，是写给开发者们看的。

写注释是一个非常好，非常重要的习惯。比如说，代码写的很好，程序跑起来也没问题。但是过个几星期或者几个月，再回过头来看自己以前写的代码，看不懂。那么再好的代码也白搭......还有如果过了很长一段时间，有别的人来运行自己的代码，这个时候别人看不懂，不知道这个代码在做什么，也白搭（大概率会被人骂的......）

别人看不懂的代码，就是烂代码，不管效率有多高。好的代码应该让人一目了然，最起码要让人知道这行代码是做什么的，同行都看不懂的代码，不是好代码

注释有三种

1. 单行注释
2. 多行注释
3. JavaDoc文档注释

//单行注释

/*
	多行注释
*/

/**
*	文档注释
*	
*/

数据类型

• 强类型语言

  • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。Java就是一种强类型语言
  • 安全性好，速度可能慢点

• 弱类型语言

  • 速度快，写法比较随便，安全性就可能差一点

  两种语言各有各的好，具体用啥还得具体分析。

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

• 基本类型（primitive type）
  • 数值类型
    • 整数类型：byte，short，int，long（使用时后面加L）
    • 浮点类型：float，占4个字节（使用时后面加F）；double，占8个字节（这个常用）
    • 字符类型：char，占2个字节
  • boolean类型：占1位，只有true和false两个值
• 引用类型（reference type）：除基本类型外都是引用类型。比如，String、对象、数组、枚举等。

//整数
int num = 20; //这个很常用
short num1 = 0.3;
byte num2 = 20;
long num3 = 7686L; //后面一定要加L，可以跟int区分开

//小数：浮点数
float num4 = 40.2F; //这个后面一定要加F
double num5 = 3.141592653589793238462643;

//字符
char name = '懵';

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

补充：什么是字节

• 位（bit）：计算机内部数据储存的最小单位
• 字节（byte）：计算机中数据处理的基本单位，习惯上用B表示
• 1B（byte字节）= 8bit（位）
• 字符：指计算机中使用的字母、数字、字和符号

换算

• 1bit表示1位
• 1Byte表示一个字节 1B = 8b
• 1024B = 1KB
• 1024KB = 1M
• 1024M = 1G
• 1024G = 1TB

拓展

//整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i1 = 010; //八进制0
int i2 = 0x10; //十六进制0x 0~9 A~F 16
System.out.println(i); //输出10
System.out.println(i1); //输出8
System.out.println(i2); //输出16

//浮点数拓展
//浮点型，有舍入误差，接近但不等于
//少用浮点数进行比较
//如果要准确的计算而且不要有误差，用BigDecimal：数学工具类
float f = 0.1f; //0.1
double d = 1.0/10; //0.1
System.out.println(f==d); //false

float d1 = 234234f;
float d2 = d1 + 1;
System.out.println(d1==d2); //true

//字符拓展
//所有的字符本质还是数字
char c = '中';
char c1 = 'a';
System.out.println(c); //a
System.out.println((int)c); //97

System.out.println(c1); //中
System.out.println((int)c1); //20013

//转义字符
// \t：制表符，相当于tab键的效果
// \n：换行，相当于enter键的效果

//布尔值扩展 以下两行代码的效果是一样的
boolean x = true;
if(x==true){执行代码...}
if(x){执行代码...}

类型转换

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

低 ---------------------------------------------> 高
byte,short,char -> int -> long -> float -> double
浮点类型优先于整数类型

运算中，不同类型的数据进行运算，需要先转化为同一类型

//强制转换 (类型)变量名 由高到低 高-->低
int i = 128;//正常输出128
byte b = (byte)i;//输出-128 内存溢出

//自动转换 由低到高 低-->高
int i1 = 128;//正常输出128
double d = i;//输出128.0 由于double变成了小数，所以...

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

扩展一下

//处理比较大的数时，注意溢出问题
//JDK7新特性 数字之间可以用下划线(_)分割
int i = 10_0000_0000;
int a = 20;
long all = i*a; //结果：-1474836480 乘完之后默认是int，转换之前已经有问题了
//转换方法：先把一个数转为long
long all1 = i*(long)a;//结果：20000000000

变量、常量、作用域

变量：

就是可以变化的量，代表一块空间，这个空间的位置是确定的，但是里面放什么、有什么，是不确定的。

Java是一种强类型语言，每个变量都必须声明其类型。

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

type varName = value;
//数据类型 变量名 = 值;

注：

• 每个变量都有类型，可以是基本类型，也可以是引用类型。
• 变量名必须是合法的标识符。
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结尾
• 声明多个变量，变量之间可以用逗号分开，但不推荐

int a = 20;
String name = "宋智孝";

编写代码需要注重可读性

常量：

初始化后不能再改变值！不会变动的值。

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

final 数据类型 常量名 = 值;
final double PI = 3.14;

常量名一般使用大写字母命名。

//例：
//修饰符，不区分前后
static final double PI = 3.14;
public static void main(String[] args) {
    System.out.println(PI);
}

变量的命名规范如下：

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：myName 除了第一个单词外，后面的单词首字母大写
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则
• 方法名：首字母小写和驼峰原则

变量作用域

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

//例：
package com.qmcl;

public class Demo03 {
    static double salary = 2500;
    //属性：变量
    //实例变量：从属于对象,如果不自行初始化,整数默认值0,小数默认值0.0;
    //布尔默认值：false
    //除了基本类型,其余都是null
    String name;
    int age;
    public static void main(String[] args) {
        //局部变量：必须声明和初始化，只在当前方法内有效
        int i = 0;
        System.out.println(i);
        //实例变量
        Demo03 demo03 = new Demo03();
        System.out.println(demo03.age);
        System.out.println(demo03.name);
        //类变量 static 可以由类直接调用
        System.out.println(Demo03.salary);
    }

}

运算符

Java语言支持如下运算符：

• 算术运算符：+、-、*、/（模）、%（取余）、++、--

// 算术运算符(二元运算符)
int a = 10;
int b = 20;
int c = 25;
int d = 10;
System.out.println(a+b); //30
System.out.println(a-b); //-10
System.out.println(a*b); //200
System.out.println(a/b); //0
System.out.println(a/(double)b); //0.5
System.out.println(c/d); //5 相当于：25 / 10 = 2.5 后面小数不要
System.out.println(c%d); //2 相当于：25 / 10 = 2...5 只要余数

//++、--：自增、自减 一元运算符(用自身运算),--和++同理
int a = 10;
int b = a++; //先把a赋值给b(此时b为10),然后a++(a = a + 1),此时a为11
int c = ++a; //先把a+1(此时a为12),然后把a赋值给c(此时c为12)
System.out.println(a);//12
System.out.println(b);//10
System.out.println(c);//12
System.out.println(a);//12

• 赋值运算符：=

// 赋值运算符
int e = 20; //把20赋给变量e

• 关系运算符：>、<、>=、<=、== 、!=、instanceof

// 关系运算符 要么对要么错 结果是true或false
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

• 逻辑运算符：&&、||、!

// &&与(and) ||或(or) !非(取反)
boolean a = true;
boolean b = false;
System.out.println("a && b：" + (a && b)); //逻辑与运算：两个变量都为true，结果才为true
System.out.println("a || b：" + (a || b)); //逻辑或运算：两个变量有一个为true，结果就为true
System.out.println("!(a && b)：" + !(a && b)); //取反运算：如果是false，那么结果为true;如果是true，那么结果为false
// 逻辑运算符中 &&有一个短路功能,比如上面的a&&b,如果a为false,那么后面的b不判断

• 位运算符：&、|、^、~、>>、<<、>>>（了解即可）

/*
    位运算符：
        A = 0011 1100
        B = 0000 1101
        ----------------------------------------------
        A&B:0000 1100 (都是1才为1,否则为0)
        A|B:0011 1101 (都是0才为0,否则为1)
        A^B:0011 0001 (如果两个位置值相同则为0,否则为1)
        ~B:1111 0010 (取反,是0为1,是1为0)
        ----------------------------------------------
        <<:左移  *2
        >>:右移  /2
        原因：
            0000 0000 --> 0
            0000 0001 --> 1
            0000 0010 --> 2
            0000 0011 --> 3
            0000 0100 --> 4
            0000 1000 --> 8
            0001 0000 --> 16
        可以看到：2向左移1位是4，移2位是8，移3位就是16了，用位运算的话效率很高！
 */
System.out.println(2<<3); //16

• 条件运算符（三元运算符）？：

// x ? y : z
//如果x为true,那么结果为y,反之为z
int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type);

• 扩展赋值运算符：+=、-=、*=、/=

int a = 10;
int b = 20;
a += b; // a = a + b;
a -= b; // a = a - b;
a *= b; // a = a * b;
a /= b; // a = a / b;

拓展一下

//幂运算 2^3 2*2*2=8 java中没有这种写法,很多运算会使用一些工具类来操作,比如:
double pow = Math.pow(2,3);
System.out.println(pow); //8
//字符串连接符：+  如果+号两端有任何一边是String类型，那么结果为String类型，需要注意的是：
int a = 10;
int b = 20;
System.out.println(""+a+b); //1020：先变成了String类型,所以后面就都是拼接为字符串
System.out.println(a+b+""); //30：先进行了计算,结果为30,但是最终类型是字符串类型
System.out.println(""+(a+b)); //30：利用小括号先进行计算,但是最终类型依然是字符串类型

包机制

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

包语句的语法格式为：

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

一般用公司域名倒写作为包名，比如：com.baidu.www

为了能够使用某个包下的某个类，需要在java程序中明确导入该包。使用import完成次功能：

import pkg1[.pkg2].(classname);
//使用*号通配符,导入该包下所有类
import pkg1.*;

更多规范参考：

链接：https://pan.baidu.com/s/1WqRk-Ve8ijDL_As-RE2maA
提取码：qmcl

JavaDoc

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

参数信息：

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

package com.qmcl.demo;

/**
 * @author qmcl
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

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

如何生成doc和查看

使用命令行生成doc

• 打开cmd
• 切换到对应文件夹位置
• 输入javadoc -encoding utf-8 -charset utf-8 类名.java
• 完成后打开文件位置，找到index.html（这个就是生成后的doc首页）

使用idea生成doc

• idea顶部中找到：Tools -- > Generate JavaDoc
• 选中Output directory --> 选择对应文件夹
• Locale中输入：zh_CN -- > 表示语言使用中文
• Other command line arguments 中输入：-encoding utf-8 -charset utf-8 -- > 设置编码为utf-8
• 出现："javadoc" finished with exit code 0 表示生成完毕
• 最后在对应文件夹中找到 index.html ，打开就能看到API文档了。

以上，基础部分就结束了。