Java教程

Study Day 3

本文主要是介绍Study Day 3,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

# 变量

- 就是可以变化的量

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

可以生成一个文档

这篇关于Study Day 3的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!