Java基础语法

注释

注释并不会被执行，书写注释是一个非常好的习惯

1. 单行注释

//单行注释

2. 多行注释

/*
 多行注释
 多行注释
*/

3. 文档注释

/**
 * @Description:文档注释
 */

IDEA更改注释颜色：Setting->Editor->Color Scheme->Java->Comments

标识符

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

注意点：

1. 所有的标识符都应该以A-Z或a-z，美元符$、下划线_开始
2. 首字母之后可以是字母A-Z或a-z，美元符$、下划线_或数字的任何字符组合
3. 不能使用关键字作为变量名或方法名
4. 标识符是大小写敏感的
5. 合法标识符：age、$salary、_value、__1_value
6. 非法标识符：123abc、-salary、#abc
7. 可以使用中文名命名，但是不建议

数据类型

1. 强类型语言

要求变量的使用必须严格符合规定，所有变量必须先定义后使用

2. 弱类型语言

Java数据类型的分类

1. 基本类型
2. 引用类型

public class Demo {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1=10;//最常用
        byte num2=20;
        short num3=30;
        long num=40L;//Long要在数字后加L

        //小数
        float num5=50.1F;//float要在数字后加F
        double num6=3.1415926;

        //字符
        char name='A';//一个字

        //字符串 String不是关键字是类
        String namea="q";

        //布尔值
        boolean flag=true;
        //boolean flag=false;
    }
}

字节

扩展

1. 整数

进制：二进制、十进制、八进制、十六进制，其中八进制以0开头，十六进制以0x开头

2. 浮点数

float有限、离散、舍入误差、大约、接近但不等于

最好完全避免使用浮点数进行比较

3. 字符

所有的字符本质还是数字

4. 转义字符

   \t 制表符 \n换行

5. 布尔值

boolean flag=true;
if(flag==true){}
if(flag){}//和上行意思相同，但通常简便书写

类型转换

由于Java是强类型语言，运算时不同数据类型先转换为同一类型再运算

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

1. 强制类型转换（高->低）
2. 自动类型转换（低->高）

注意点

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量时强制转换
4. 转换时可能存在溢出和精度问题

变量

每个变量都必须声明数据类型

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

作用域

1. 类变量
2. 实例变量
3. 局部变量

public class Demo02 {
    //属性：变量

    //类变量 static
    static  double salary=2500;
    //实例变量：从属于对象;不自行初始化，类型默认值0 0.0
    //布尔值默认false，除基本类型其余都是null
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化
        int i=10;
        System.out.println(i);
        //变量类型 变量名=new Demo02()
        Demo02 demo02=new Demo02();
        System.out.println(demo02.age);
        System.out.println(salary);
    }
    //其他方法
    public void add(){
    }
}

常量

初始化后不能改变值

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改修

final 常量名=值;
final double PI=3.14;//常量名一般使用大写字符

public class Demo03 {
    //修饰符，不区分先后顺序
    static final double PI=3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

1. 所有变量、方法、、类名：见名知义
2. 类成员变量：首字母小写和驼峰原则monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线MAX_VALUE
5. 类名：首字母大写和驼峰原则Man，GoodMan
6. 方法名：首字母小写和驼峰原则run（），runRun（）

运算符

算数运算符：

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

    }
}

赋值运算符：

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a=12521627112L;
        int b=123;
        short c=10;
        byte d=8;
        System.out.println(a+b+c+d);//有一个为long则为long
        System.out.println(b+c+d);//输出结果默认为int
        System.out.println(c+d);
    }
}

关系运算符

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

自增自减：

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++自增  --自减  一元运算符
        int a=3;
        int b=a++;//执行完这行代码先给b赋值再自增
        //a=a+1;
        System.out.println(a);
        //a=a+1;
        int c=++a;//执行完这行代码先自增再给c赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        //幂运算
        double pow=Math.pow(2,3);
        System.out.println(pow);
    }
}

逻辑运算符：

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));//取反

        //短路运算:&&前为假，后面不会执行
        int c=5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

位运算符：

package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B=0000 1100 两个都是1才是11
        A|B=0011 1101 两个都是0才是0
        A^B=0011 0001 相同为0
        ~B =1111 0010 取反


        ex.2*8怎样计算最快？
        <<左移 把数字*2
        >>右移 把数字/2
         */
    }
}

扩展赋值运算符：

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);
        System.out.println(""+a+b);//""String在前，后面会转换成String类型进行拼接
        System.out.println(a+b+"");//""String在后，前面会依旧进行计算
    }
}

条件运算符：

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

包机制

为了更好地组织类，包机制用于区别类名的命名空间

语法格式：

package pkg

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

为了能够使用某一包的成员，我们要在Java中明确导入该包，使用import完成

推荐阅读《阿里巴巴Java开发手册》

Java Doc生成文档

JavaSE17 API

参数信息：

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

package com.cloud.base;

/**
 * @author cloud
 * @version 17
 * @since 17
 */
public class Doc {
    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name)throws Exception{
        return name;
    }
}

使用IDEA查找生成的JavaDoc文档：