基础语法

Java 基础语法

嘿嘿嘿，有趣的注释

注释、标识符、关键字
数据类型
类型转换
变量，常量
运算符
包机制、JavaDoc

注释、标识符、关键字

注释

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

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

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

java 注释有三种：

单行注释 //单行注释
多行注释 /* 多行注释 */
文本注释 /** 文本注释 */

关键字

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

标识符注意点

所有的标识符都应该以字母（A-Z或a-z）,$,_开始
首字符之后可以是字母A-Z或a-z）,$,_或数字的任何字符组合
不能使用关键字做为变量名或者方法
标识符是大小写敏感的
合法标识符
非法标识符
可以使用中文名，但是一般不建议去使用，也不建议使用拼音，很low

数据类型

强类型语言 (java)

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（安全性高，速度慢）

弱类型语言（php js）

Java 的数据类型分为两类

第一类、整数类型 byte：8 位，用于表示最小数据单位，如文件中数据，-128~127 short：16 位，很少用，-32768 ~ 32767 int：32 位、最常用，-2^31-1~2^31 （21 亿） long：64 位、次常用

第二类、浮点数类型 float:单精度类型，32 位，后缀 F 或 f，1 位符号位，8 位指数，23 位有效尾数。

double：64 位，最常用，后缀 D 或 d，1 位符号位，11 位指数，52 位有效尾数。

第三类、字符类型

char:16位，java字符使用Unicode编码，

第四类、布尔类型

boolean：true 真和 false 假

//整数扩展     进制  二进制 十进制 八进制 十六进制
        int i = 10;
        int i2 = 010;//八进制 0~8
        int i3 = 0x10;//十六进制  0·9 A-F

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

        System.out.println("-------------------------------------------");

        // 浮点数扩展
        // 用BigDecimal 数学工具类比较
        // float 有限  离散 舍入误差 接近但不等于
        // double
        // 最好避免使用浮点数进行比较
        float f = 0.1f;
        double d = 1.0/10;

        System.out.println(f==d);

        float f1 = 2322323265521232132f;
        float d2 = f1 + 1;

        System.out.println(f1 == d2);

        System.out.println("-------------------------------------------");
        // 字符串扩展
        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字节  65536 excel(最大) 2^16 = 65536

        // U0000 - UFFFF
        char c3 = '\u0061';
        System.out.println(c3);

        System.out.println("-------------------------------------------");

        // 转义字符   --底下扩展
        // \t 制表符
        // \n换行
        System.out.println("Hello\tWorld");

        System.out.println("-------------------------------------------");

        // 字符串
        String sa = new String("hello world");  //堆内存
        String sb = new String("hello world");
        String sc = "hello world";//常量池
        String sd = "hello world";
        // 对象从内存中分析
        System.out.println(sa == sb); //false
        System.out.println(sa == sd); //false
        System.out.println(sc == sd); //true
        System.out.println(sa.equals(sb)); //true
        System.out.println(sa.equals(sd));  //true
        System.out.println(sc.equals(sd)); //true
        


        // 布尔值扩展
        boolean flag =true;
        if(flag == true){}//新手
        if(flag) {}//老手
        // less is morel 代码要精简易读

所有的转义字符和所对应的意义：

转义字符	意义	ASCII码值（十进制）

\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\	代表一个反斜线字符'''	092
'	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
\0	空字符(NULL)	000
\ddd	1到3位八进制数所代表的任意字符	三位八进制
\uhhhh	1到2位十六进制所代表的任意字符	二位十六进制

类型转换

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

int i = 128;
        byte b = (byte) i;
        double c = i;
        //强制转换 （类型）变量名  高--低
        //自动转换   低---高
        System.out.println(i);
        System.out.println(b);//内存溢出
        System.out.println(c);
        /*
            注意点:
            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 d = 'a';
        int e = d + 1;

        System.out.println(e);//98
        System.out.println((char) e);//b

        //操作比较打的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years;//-1474836480 计算的时候溢出
        long total2 = money * years;//默认是int 转换之前已经存在问题了？

        long total3 = money*(long)years;//先把一个数转换为long
        System.out.println(money);//1000000000
        System.out.println(total);//-1474836480
        System.out.println(total3);//20000000000

变量

变量：可以变化的量

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

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

注意事项

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

常量的命名规则：

所有变量、方法、类名：见面知意
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以为，后面的单词首字母大写 lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man,GoodMan
方法名：首字母小写和驼峰原则：run() 、runRun()

类变量

// 类变量 static
static  double salary = 2500;
public static void main(String[] args) {
        // 类变量
        System.out.println(salary);

    }

局部变量

public static void main(String[] args) {
        // 局部变量 ： 必须声明和初始化值
        int i = 0;
        System.out.println(i);//0
    }

实例变量

    // 实例变量：从属于对象。
    // 如果不自行初始化（赋值），这个类型的默认值 0   0.0
    // 布尔值：默认是false
    // 除了基本类型，其余的默认值都是null
    String name;
    int age;
    float f;

    // main方法
    public static void main(String[] args) {
        // 变量类型  变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println( demo08.age); // 0
        System.out.println( demo08.name);// null
        System.out.println( demo08.f);// 0.0

    }

常量

常量：初始化后不能再改变值！不会变动的值
所谓常量可以理解成一种特殊的变量，设定后，在程序运行是不允许被改变，用final修饰
常量名一般使用大写字符

Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符
非访问修饰符

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

非访问修饰符

static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。

    // 修饰符，不存在先后顺序
    static  final  double PI = 3.14;
    final static  double PI1 = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(PI1);
    }

运算符

Java的运算符，分为四类：优先级

　　算数运算符、关系运算符、逻辑运算符、位运算符。

　　算数运算符(9)：+ - * / % ++ --

　　关系运算符(6)：== != > >= < <= instanceof

　　逻辑运算符(6)：&& || ! ^ & |

　位运算符(7)：& | ~ ^ >> << >>>

条件运算符: ?:

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

算数运算符

        // 二元运算符
        // ctrl + d : 复制当前行到下一行
        int a =10;
        int b =20;
        int c =25;
        int d =25;

        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

        // ++  -- 自增  自减  一元运算符
        int a = 3;
        int b = a++;// a++   a = a+1 执行完这行代码后，先给赋值，再自增
        int c = ++a;// ++a  先自增，再给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

//幂运算 2^3  2*2*2  很多运算，我们会使用工具类来操作
        double pow = Math.pow(3,2);
        System.out.println(pow);

关系运算符

//关系运算符返回的结果： true ,false   布尔值
//if
int a = 10;
int b = 20;
int c = 22;

System.out.println(c%a);//2

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));//a && b :false 两个都为真，结果才为真
        System.out.println("a || b :"+  (a || b));//a || b :true 两个变量有一个为真，则结果为真
        System.out.println("!(a && b) :"+  !(a && b));//!(a && b) :true 如果是真

        int c = 5;
        boolean d = (c < 4) && (c++ < 4);
        System.out.println(d);//false
        System.out.println(c);//5

位运算符

        /*
        a = 0011 1100
        b = 0000 1101
        --------------------------------
        a&b  = 0000 1100
        a|b  = 0011 1101
        a^b  = 0011 0001
        ~b = 1111 0010

        2*8 = 16   2*2*2
        <<左移  *2   >>右移  /2
        效率高
         */
        System.out.println(2<<3);
        System.out.println(16>>2);

条件运算符:

// 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-=b;
        System.out.println(a);//10

        System.out.println(a+b);//30
        //字符串连接符 + ， String
        System.out.println("" + a + b);//1020
        System.out.println(a + b + "" + a + b);//301020

扩展优先级：

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、--	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	\|	从左向右
11	&&	从左向右
12	\|\|	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、\|=、^=、~=、«=、»=、>>>=	从右向左

包机制

包的本质是文件夹

为了更好的组织类，java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：
```
package operator;
```
一般利用公司域名倒置作为包名；如com.baidu.www
为了能够使用某一个包的成员，我们需要在java程序中明确导入该包，使用"inport"
```
import java.util.Date;
import java.util.*;//导入这个包下所有的类
```

javaDoc

javadoc命令是用来生成自己api文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

生成Doc文档命令

用命令行cmd ,在指定文件夹下 javadoc java 文件

> javadoc -encoding UTF-8 -charset UTF-8 Doc.java

用idea 生成javaDoc文件

首先新建一个文件夹，用于存放要生成的Javadoc文档。

接下来点击IntelliJ IDEA顶部的Tools菜单，选择Generate JavaDoc选项，如下图所示

然后在弹出的界面中我们点击Output directory输入框后面的按钮，如下图所示

如图所示

在弹出的选择文件夹界面中选择刚才新建的文件夹接下来在底部的Locale输入框配置语言和编码集，如下图所示，语言用zh_CN，代表中文 -encoding utf-8 -charset utf-8