标签：String Study System Day 运算符 println public out

# 变量

- 就是可以变化的量

- 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文件

可以生成一个文档

标签：String,Study,System,Day,运算符,println,public,out
来源： https://blog.csdn.net/Koite/article/details/122074920

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。