Java的基础语法

Java基础语法

注释

注释分为单行注释，多行注释，文档注释

注释是用来解释代码的，并不参与程序的执行

1. 单行注释：// 注释
2. 多行注释：/* 注释 */
3. 文档注释：/** 注释 */

一些有趣的注释代码~~：

https://blog.csdn.net/ydk888888/article/details/81563608

标识符

标识符也就是已经规定好的一些关键词

标识符的一些使用规则：

1. 所有的标识符都应该以字母（A-Z或者a-z）,美元符号($),或者下划线（_）开始
2. 首字符之后可以是字母（A-Z或者a-z），美元符号($)，下划线（_）或数字的任何字符组成
3. 不能使用关键字作为变量名或方法！！！
4. 标识符时大小写敏感的

合法的标识符举例：age $salary _value _1_value

非法的标识符举例：123abc（不可以以数字开头！） -salary（其中含有特殊符号“-”） #abc(含有特殊符号#)

Ps:可以使用中文名，但是不建议，也不建议使用拼音，很Low !

数据类型

​ Java是一种强类型语言，要求变量的使用要严格符合规定，所有的变量必须先定义后使用

​ Java的数据类型分为两大类：基本数据类型，引用数据类型

基本数据类型（数值类型，布尔类型）

引用数据类型

字节

变量定义

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

        //整数
        int num1 = 10;  //最常用
        byte num2 = 20;
        short num3 = 30;
        long  num4 = 30L;  //Long类型要在数字后面加个L

        //小数 浮点数
        float num5 = 50.1F; //Float类型要在数字后面加个F
        double num6 = 3.141592653;

        //字符
        char name = 'A'; //字符是一个字
        //字符串 String  不是关键字，而是一个类
        String namea = "小明";

        //布尔值  是非
        boolean flag = true;
        boolean flag1 = false;
    }
}

数据类型的一些细节

public class Dom2 {
    public static void main(String[] args) {
        //关于面试的一些题

        //整数拓展     进制   二进制0b    十进制   八进制0   十六进制0
        int i = 10;
        int i2 = 010;  //八进制
        int i3 = 0x10; //十六进制

        System.out.println(i);    //10
        System.out.println(i2);   //8
        System.out.println(i3);  //16
        System.out.println("=========================================");


        //============================================================================
        //浮点数拓展   比如银行业务   BigDecimal类  数学工具类
        //float
        //double
        //最好完全使用浮点数来比较！！！

        float f = 0.1f; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d);   //false

        float d1 = 1564648965456f;
        float d2 = d1 + 1;

        System.out.println(d1==d2);   //true
        System.out.println("=========================================");

        //============================================================================
        //字符拓展
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);   //a
        System.out.println((int)c1);  //强制转换  97
        System.out.println(c2);  //中
        System.out.println((int)c2);  //强制转换  20013

        //所有的字符本质还是数字
        //编码  Unicode  2字节   0-65536  Excel    2 16 = 65536
        //U0000  UFFFF

        char c3 = '\u0061';
        System.out.println(c3);   //a

        //转义字符
        //\t   制表符
        //\n   换行
        //还有很多。。。

        System.out.println("Hello\tWorld");//Hello World
        System.out.println("Hello\nWorld");
        //Hello
        //World

        String sa = new String("Hello world");
        String sb = new String("Hello world");
        System.out.println(sa==sb); //false

        String sc = "Hello world";
        String sd = "Hello world";
        System.out.println(sc==sd);  //true
        //对象 从内存分析
        System.out.println("=========================================");


        //布尔值扩展
        boolean flag = true;
        if (flag == true){}//新手   这个地方默认的flag=true
        if (flag){}//老手
        //Less is mord   代码要精简易读
    }
}

结果：

类型转换

由于Java使强类型语言，所以要进行有些运算的时候，需要进行类型转换。

低---------------------------------------------------------->高

byte,short,char---->int—>long—>float—>double

在运算中，不同类型的数据先转换为同一类型，然后进行运算。

• 强制类型转换
• 自动类型转换

public class Dom3 {
    public static void main(String[] args) {
        //强制转换    （类型）变量名   高-->低
        int i = 128;
        byte b = (byte)i;  //内存溢出

        System.out.println(i);
        System.out.println(b);
        System.out.println("===========================");
        //自动转换       低-->高
        int i2 = 128;
        double d = i2;
        System.out.println(i2);
        System.out.println(d);

        /*注意点
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.把高容量转换为到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者转换精度问题！
         */

        System.out.println("==============");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);  //45

        System.out.println("==============");
        char c = 'a';
        int i3 =c + 1;

        System.out.println(i3);
        System.out.println((char)i3);
        System.out.println("===============");


        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;
        long total2 = money*years;
        long total3 = money*((long)years);
        System.out.println(total);//负数，计算时候溢出了
        System.out.println(total2);//默认是int  转换之前就存在问题了
        System.out.println(total3);//先把一个数转换为Long

    }
}

结果：

变量，常量，作用域

变量

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

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

注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
• 变量名必须是合法的标识符
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

public class Dom4 {
    public static void main(String[] args) {
       // int a,b,c;    不建议这样
       // int a = 1,b = 2, c = 3;   这样不好，建议下面这样
        int a = 1;
        int b = 2;
        int c = 3;
        
        String name = "xiaoming";
        char x = 'X';
        double pi = 3.14;
    }
}

• 变量分为：类变量，实例变量，局部变量

public class Dom5 {
    //属性：变量
    
    //类变量  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  Dom5();
        Dom5 dom5 = new Dom5();
        System.out.println(dom5.age);
        System.out.println(dom5.name);
        
        //类变量
        System.out.println(salary);
    }

    //其他方法
    public void add() {
        //System.out.println(i);// 输出不了i,因为i是局部变量
    }
}

变量命名规范：

1. 所有变量，方法，类名：见名知意
2. 类成员变量：首字母小写和驼峰原则：eg monthSalary 除了第一个单词外，其他单词首字母大写
3. 局部变量：首字母小写和驼峰原则
4. 常量:大写字母和下划线 MAX_VALUE
5. 类名：首字母大写和驼峰原则
6. 方法名：首字母小写和驼峰原则：run()

常量

常量是初始化之后不会变动的值，是一种特殊的变量，他的值在设定后，在程序运行过程中不允许被改变

定义：

final 常量名 = 值；

eg: final PI = 3.14;

常量名一般使用大写字符。

基本运算符

• 算术运算符：+，-，*，/，%（取余或者模），++，–
• 赋值运算符：=
• 关系运算符：>, <, >=, <=, !=(不等于) ， instanceof
• 逻辑运算符：&&（与）,||（或）,！（非）
• 位运算符：|，^, ~, >>, <<, >>>(了解！！！)
• 条件运算符：？，：
• 扩展运算符：+=，-=，*=，/=

        //二元运算符
        //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);  //本来等于0.5  因为是int型，所以得到0 ，进行强制类型转换后得到0.5

=====================================================================

 double a = 3.1415926;
        float b = 51523f;
        long c = 12311312313321L;
        int d =123;
        short e = 10;
        byte f = 8;

        System.out.println(a+b+c+d+e+f);//结果为double
        System.out.println(b+c+d+e+f); //结果为float
        System.out.println(c+d+e+f);//结果为long
        System.out.println((d+e+f));//结果为int
        System.out.println(e+f); //结果为int
        //有一个是double 则结果是double
        //没有double 有一个float 则结果是float
        //没有double和float 有一个long  最后结果为long型
        // 没有double和float 没有long 最后结果为int型
        //看一个高低级的问题
        //低------------------------------------------------>高
        //byte,short,char---->int--->long--->float--->double

=====================================================================

//关系运算符返回结果： 正确，错误   布尔值
        //一般与if结合

        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a>b);  //false
        System.out.println(a<b);  //true
        System.out.println(a==b);  //false
        System.out.println(a!=b);  //true
        //取余，模运算
        System.out.println(c%a);  //c/a   21/10=2.....1
=====================================================================
    
 //重要！！！！！！！！！！
 //++  --  自增 自减  一元运算符
        int a = 3;

        int b = a++;  //执行完这行代码后，先给b赋值，再自增
        // a++  a=a+1
        System.out.println(a);  //a=4
        System.out.println(b);  //b=3
        //++a  a=a+1
        int c = ++a;   //执行完这行代码前，先自增  再给b赋值

        System.out.println(a);   //a=5
        System.out.println(b);   //b=3
        System.out.println(c);   //c=5

=====================================================================

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

=====================================================================
    
 //位运算符
    package Operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011  1100
        B = 0000  1101
        -------------------
        A&B = 0000  1100   两个都为1才是1
        A|B = 0011  1101   两个中有一个为1，结果就是1
        A^B = 0011  0011   两个位置相同就是0，不相同是1
        ~B  = 1111  0010   正好与原来相反

        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); //二进制情况下将1左移3位得到16
    }
}
=====================================================================

        int a = 10;
        int b = 20;

        a+=b;  //a=a+b
        System.out.println(a);  //30

        a-=b;  //a=a-b
        System.out.println(a);  //10

        //字符串连接符    +
        System.out.println(a+b);  //30
        System.out.println(""+a+b);  //1020
        System.out.println(a+b+"");  //30
        //如果在”+“运算符前面有String类型的，则剩余的部分也会转化成String类型
        //如果在”+“运算符后面有String类型的，则前面的会进行计算

=====================================================================
        //三元运算符
        //x ? y : z
        //如果x==true,则结果为y，否则结果为z

        int score = 50;
        String type = score<60?"不及格":"及格";
        System.out.println(type);  //不及格

JavaDoc

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