java学习笔记day3【基础语法】

4.变量

变量的命名规范;

• 所有的变量、方法、类名，见名知意

• 局部变量、类成员变量、方法名：首字母小写和驼峰原则：monthSalary,除了第一个单词意外所有的首字母都大写

• 常量：大写字母和下划线：MAX_VALUE

• 类名：首字母大写和驼峰原则：GoodMan

变量定义格式：

数据类型 变量名=值;

注意：

• 每个变量必须有类型，可以是基本类型和引用类型。
• 变量名必须是合法标识符
• 变量声明用分号结束

作用域:

• 类变量:在类里面定义的，在整个类中都有效。定义的时候要用static定义

public class demo07 {
    
    
    static double salary=2500;//类变量，从属于类
    public static void main(String[] args) {
    
    
        System.out.println(salary);//可以直接使用
    }
}
输出：
2500.0

• 实例变量:也叫成员变量，实例化之后才会分配空间

public class demo07 {
    
    
    String name;//这是个实例变量，他从属于对象，可以不用初始化,输出默认值。
    // 数字类型默认值0或者0.0 布尔类型默认输出false
    //除了基本类型，其余默认值都是null
    int age;
    public static void main(String[] args) {
    
    
        //变量类型 变量名字 = new demo07()
        demo07 Demo07=new demo07();//相当于实例化一个对象
        System.out.println(Demo07.name);
        System.out.println(Demo07.age);
    }
}
结果：
null
0

• 局部变量：在方法内部定义和使用，出了方法就没用了,局部变量一定要初始化。

public class demo07 {
    
    
    public static void main(String[] args) {
    
    
        int i=10;//这个是局部变量，在方法里面，只能在方法中使用，并且一定要初始化
        System.out.println(i);
    }
}
输出：
10

补充：

局部变量需要初始化，其他可以不用初始化会输出默认值，数字类型默认值0或者0.0 ，布尔类型默认输出false
除了基本类型，其余默认值都是null

5.常量

常量定义关键字：final

public class demo08 {
    
    
    final static double a=10;//用final来定义常量
    static final double PI=3.14;//这里我们发现final和static的顺序无所谓，因为他俩都是修饰符，
    // 修饰符不存在先后顺序。数据类型前面的都是修饰符
    public static void main(String[] args) {
    
    
        System.out.println(PI);
        System.out.println(a);
    }
}
输出：
    3.14
    10

修饰符：定义变量时在数据类型前面的都叫修饰符，并且修饰符不存在先后顺序

6.运算符

算数运算符	+、-、*、/、%（取余）、++、–
赋值运算符	=
关系运算符	>、<、>=、<=、==、!=
逻辑运算符	&&、||、!
位运算符	&(按位与)、|、^（异或）、~、>>（有符号右移）、<<、>>>（无符号右移）、<<<
条件运算符	? :
扩展赋值运算符	+=、-=、*=、/=

6.1 算数运算符

代码实例：

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //二元运算符
        //ctrl+D复制当前行到下一行
        int a=10;
        int b=20;
        int c=25;
        int d=30;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//算出来应该是0.5但是这是int类型四舍五入取了0
        System.out.println(a/(double)b);
    }
}
输出：
30
-10
200
0
0.5

当不同数值类型的数据相加时，可以理解成自动变成更高的数值类型（不严谨），从下面这个例子去理解：

package operator;

public class Demo02 {
    
    
    public static void main(String[] args) {
    
    
        long a=123456789145L;
        int b=123123;
        short c=100;
        byte d=8;
        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int
        //从输出结果上来看，如果有long结果为long，没有结果都是int，
        // 还有两种数值型float和double，如果有float，那么输出就是float类型，
        // 如果float和double都有那么输出是double
    }
}
输出：
123456912376  long
123231  int
108  int

关于++（自增）–（自减）的理解:

主要注意一下++和变量之间的位置，到底是先加还是先赋值。

public class Demo04 {
    
    
    public static void main(String[] args) {
    
    
        //++ -- 自增、自减 一元运算符
        int a=3;
        int b=a++;//先把值赋给b再自增，这行代码可以拆成两行代码b=a;a=a+1;
        int c=++a;//先自增再把值赋给c，这行代码可以拆成两行代码a=a+1;c=a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        //扩展一个Math类,有很多运算比较常用
        double pow=Math.pow(2,3);
        System.out.println(pow);
    }
}

6.2 关系运算符

public class Demo03 {
    
    
    public static void main(String[] args) {
    
    
        //关系运算符的结果一定是布尔值
        int a=10;
        int b=10;
        int c=21;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%a);
    }
}
输出结果;
false
false
true
false
1

6.3 逻辑运算符

与或非稍微注意一下这里的非!( )

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));
 输出：
a && b:false
a || b:true
!(a && b):true

短路运算：在与运算中，当前面一个已经是假的时候，后面那个就不用算了。

        //短路运算
        int c=5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);//这里c输出为5，说明并没有执行c++<4这句，短路。
输出：
false
5

6.4 位运算符

举例:

A=0011 1100
B=0000 1101

A&B=0000 1100 按位与
A|B=0011 1101 按位或
A^B=0022 0001 异或
~B =1111 0010 取反

补充面试题：

eg：计算2乘以8怎么运算最快？
利用位运算的效率很高
有符号左移 << ： 相当于*2

有符号右移 >> ： 相当于/2

public class Demo06 {
    
    
    public static void main(String[] args) {
    
    
    System.out.println(2<<3);//0000 0010===>0000 1000
    }
}
输出：
8

6.5 三元运算符（条件运算符）

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);
    }
}
输出：
及格

6.6 扩展赋值运算符

public class Demo07 {
    
    
    public static void main(String[] args) {
    
    
        int a=10;
        int b=20;
        a+=b;//a=a+b
        System.out.println(a);
}
输出：
30

字符串连接符

public class Demo07 {
    
    
    public static void main(String[] args) {
    
    
        int a=10;
        int b=20;
        //字符串连接符+  这里只要有一个操作数出现了String类型，
        // 他就会把另外的操作数都转化成String进行连接
        System.out.println(a+b);
        System.out.println(""+a+b);
        System.out.println(a+b+"");
    }
}
输出：
30
1020
30

7.包机制

包机制实际就是文件夹。

命名规范：一般利用公司域名倒置作为包名

导入包语句：import package1[.package2…].classname *；

代码举例：

如图所示我想在operator这个目录下导入base包里的demo02就可以这么操作

8.javaDoc

8.1 文档注释

参数信息：

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

package com.javastudy.operator;

/**
 * @author 郭英虎
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    
    
    String name;
    /**
     * @return
     * @throws Exception
     */
    public String test() throws Exception{
    
    
        return name;
    }
}

注意在写文档注释的时候格式是/**+回车自动跳出来

8.2javaDoc命令用来生成自己的API文档

1. 打开程序文件夹

2. 在该文件目录下用cmd打开命令窗口输入javadoc -encoding UTF-8 -charset UTF-8 Doc.java

3. 再打开文件夹可以看到里面多了一堆东西

4. 打开index那个网页

  5. 会看到如下界面

关于Java的API文档暂时了解到这些