# 变量

- 就是可以变化的量

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

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

  - 变量包含类变量，实例变量，局部变量

- 注意事项

  1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型

  2. 变量名必须是合法的标识符

  3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束；

```java
public class demo2 {
    /*实例变量：从属于对象，如果不自行初始化，会变成这个类型默认值。所有数值类型初始化一般都是0或0.0.16位的初始化为u0000，
     布尔值默认值为false。除了基本类型其它的默认值都是null；     */
    String name;
    int age;

    //类变量：static
    static double salary = 2500;

    //main方法，
    public static void main(String[] args) {
        //局部变量（在中括号之间）：必须声明和初始化值

        //变量类型：变量名字=new demo2();
        demo2 demo2 = new demo2();
        System.out.println(demo2.age);
        System.out.println(demo2.name);

        //类变量
        System.out.println(salary);

    }

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

    }

}

```

# 常量

- 初始化后不能再改变值，不会变动的值
- 所谓常量可以理解成一种特殊的变量，他的值被设定后，在程序运行过程中不允许被改变
- 常量名一般使用大写字符
  1. final    常量名=值；
  2. final double PI=3.14；

```jav
public class demo3 {
    //fnial是修饰符，不存在先后顺序
    static final double PI = 3.14;

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

```

# 变量命名规范

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

# 运算符

- 算数运算符：+，-，*，/，%（模运算），++，--

- 赋值运算符：=

- 关系运算符：>,<,>=,<=,==（等于）,!=instanceof（不等于）

- 逻辑运算符：&&（与and），||（或or），！（取反）

- 位运算符：&，|,^,~,>>,<<,>>>    (了解就行)

- 条件运算符：  ？ ：

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

  ```java
  package operator;
  
  public class Demo01 {
      public static void main(String[] args) {
          //二元运算符
          //ctrl d  复制本行到下一行
          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(a/(double)b);
      }
  }
  
  ```

```java
package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);//计算中有long类型，结果也为long类型，若无long类型，则结果为int类型，有double，则结果必为double
        System.out.println(b+c+d);
        System.out.println(c+d);

    }
}
```

```java
    package operator;

    public class Demo03 {
        public static void main(String[] args) {
            //关系运算符返回的结果：正确，错误（布尔值）
            int a = 10;
            int b = 20;
            int c = 21;
            System.out.println(c%a);//结果只会输出余数，模运算

            System.out.println(a>b);
            System.out.println(a<b);
            System.out.println(a==b);
            System.out.println(a!=b);
            //结果只会输出布尔值
        }

    }

```

```java
package operator;

public class Demo04 {
    public static void main(String[] args) {
        //  ++   --   自增 自减  一元运算符
        int a = 5;

        int b = a++;    // a++  a = a + 1  a++先赋值在运算
        System.out.println(a);

        int c = ++a;   // ++a  a = a + 1  ==a先运算在赋值

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

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

    }
}

```

```java
package operator;

//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {

        //与（and）  或（or）  非（取反）
        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));//如果是真，则结果为假，如果是假则为真

    }

}

```

- 位运算

  效率极高

```java
package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        ----------------------------------------------------
        A&B = 0000 1100      两个相同则同样，两个相反则为0
        A|B = 0011 1101      两个相同则同样，相反则为1
        A^B = 1111 0010      相同则为0，不同则为1
         ~B = 1111 0010      和B完全相反

         2*8 = 16   2*2*2*2
         <<把数字*2
         >>把数字/2
          二进制
          0000 0000 0
          0000 0001 1
          0000 0010 2
          0000 0011 3
          0000 0100 4
          0000 1000 8
          0001 0000 16

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

    }
}

```

- 扩展赋值运算符

```java
package operator;

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);

        //字符串连接符 + ，String类型
        System.out.println(""+a+b);//前面加String类型会吧后面直接连接起来
        System.out.println(a+b+"");//后面加会先运算前面
    }
}

```

- 条件运算符

```java
package operator;
//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true，则结果为y，否则为z
        int score = 80;
        String type = score <60 ? "不及格" : "及格";//必须掌握！
        
        System.out.println(type);
    }
}

```

# 包机制

- 为了更好地组织类，java提供了包机制，用于区别类名的命名空间
- 一般利用公司域名倒置作为包名
- 为了能够使用某一个包的成员，我们需要在java程序中明确导入该包，使用“import”语句可完成此功能

```java
 如import com.L.base.Demo01；
     import com.L.base.*；//代表导入这个包下所有的类
```

# JavaDoc

- 文档注释（加在类之上就是类的注释，加在方法上面就是方法的注释）
  - @author 作者名
  - @version 版本号
  - @since 知名需要最早使用的jdk版本
  - @param 参数名
  - @return 返回值情况
  - @throws 异常抛出情况

```java
package com.L.base;

/**
 * @author L
 * @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;
    }
}

```

cmd  — javadoc — 参数   — java文件

可以生成一个文档