Java基础语法（注释、标识符、数据类型、变量常量、命名规范）

基础语法

注释

单行注释

用两个//即可

多行注释

/*
我是多行注释
我是多行注释
我是多行注释
我是多行注释
 */

文档注释

/** */

标识符

包括类名 变量名 以及方法名 都被称为标识符

标识符只能以字母 美元符下划线 开头，不能以数字

标识符为字母下划线美元符以及数字的组合

注意：

• 大小写敏感

• 不能用关键字用作关键字

• 数字、字母大小写、美元符、下划线

数据类型

java c++ 等 强类型语言，要求使用严格符合规定，所有变量都必须先定义后才能使用

string （S为大写）用于定义字符串变量，int用于定义整型变量，分号结尾

基本类型

数值类型

• 整数类型

  byte 占1个字节 可表示：-128~127

  short 占2个字节 可表示：-32768~32767

  int 占4个字节 可表示：-2147483648~-2147483647

  long 占8个字节 可表示：-9223372036854775808-9223372036854775807

  小注意事项：在数据后面尽量加L而不加l,小写容易被认成数字1

• 浮点类型

  float 占 4 个字节

  double 占 8 个字节

• 字符类型

  char 占2个字节

Boolean类型

占1位 其值只有true和false两个

引用类型

类 接口 数组

拓展

整数拓展

进制 二进制 0b 八进制0 十六进制0x

了解转换方法

int i = 10;
int i2 = 010;   //八进制0
int i3 = 0x10;  //十六进制 0x
​
接果
10
8
16

浮点数拓展

银行业务？

！！！！！！！！！！！！！！！！！！！！！！！！

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

//===============================================================================
//浮点数拓展？
//float 有限 离散 舍入误差 大约 接近但不等于
//===============================================================================
​
float f = 0.1f;
double d = 1.0/10;
​
System.out.println(f==d);
System.out.println(f);
System.out.println(d);
​
​
结果
false
0.1
0.1
​

字符串拓展

//字符拓展？
​
char c1 = 'a';
char c2 = '中';
​
System.out.println((int)c1);
System.out.println((int)c2);
​
// 强制转换

• 强制转化

• 所有的字符本质还是数字

• 编码 Unicode ASCII码 0~65536 2字节

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

转义字符

\t table 字表符

\n 换行

涉及底层的拓展

//关于底层的拓展
System.out.println("===========================================");
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa==sb);
​
String sc = "hello world";
String sd = "hello world" ;
System.out.println(sc==sd);
​
结果
===========================================
false
true

布尔值拓展

//布尔值拓展
boolean flag = true;
if (flag==true){}     //新手
if (flag){}           //老手

类型转换

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

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

低到高 自动转换

高到低 强制转换

public class demo4 {
    public static void main(String[] args) {
        int i =128 ;
        byte b = (byte)i;  //内存溢出
​
​
        System.out.println(i); //128
        System.out.println(b); //一个负数，发生了溢出
​
        //强制转换   （类型）变量名 高-低
        //自动转换    低-高
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型 转换为不相干的类型
        3.在高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出问题，或者精度问题
         */
​
        System.out.println("=================");
        System.out.println((int)23.7);       //double类型  23
        System.out.println((int)-45.89f);    //float类型   -45
​
​
        char c = 'a';
        int d= c+1;    //自动转换
        System.out.println(d); //98
        System.out.println((char)d);  //强制转换 b
​
    }
}

System.out.println("===============================");
int money = 10_0000_0000;
int years = 20;
int total = money*years;
System.out.println(total); //输出-1474836480，200亿不在int可表示的范围内（21亿左右），发生溢出
//如进行一下修改？
long total2 = money*years;  
//money*years其实也为int类型，在乘法结束时，已经发生了溢出，其值已为-1474836480
System.out.println(total2);//仍然输出-1474836480，
​
//解决方案
long total3 = money*((long)years);   //int类型与long类型相乘时，得到long类型
System.out.println(total3);

变量

可以变化的量

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

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

type varName [=value];

变量作用域

• 类变量

• 实例变量

• 局部变量

public class demo08 {
​
    //类变量 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);
​
​
        //
        demo08 Demo08 = new demo08();
        System.out.println(Demo08.age);
        System.out.println(Demo08.name);
​
        //类变量 static
        System.out.println(salary);
​
    }
​
​
​
    //其他方法
    public void add(){
​
    }
}

常量

final

public class demo09 {
​
    //final 为修饰符 在static前后均可
    final static double PI = 3.14;
​
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

量的命名规范

• 见名知义

• 类成员变量、局部变量、方法名：驼峰原则 首字母小写 后面单词首字母大写

• 类名：每个单词首字母都大写

• 常量：全大写与下划线

运算符

• 算数：+， - ，* ， / ，%， ++ ，--

• 赋值：=

• 关系：> , < ,==,!=

• 逻辑：&& ， ||， ！ 与，或，非

• 位运算符：&，|，^, ~,>>,<<，>>> (了解)

• 条件：？：

• 拓展赋值：+=，-=，*=，/=

算数运算符

自增与自减

//一元运算符： ++ -- 自增自减    a++，++a 执行时间不同
int a = 3;
​
int b = a ++;   //执行这行代码后，先给b赋值(将a的值赋给b)，a再自增
//a++ 表示 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);
​
输出结果
4
5
3
5

逻辑运算符

boolean a = true;
boolean b = false;
​
System.out.println("a&&b:"+(a&&b));       //与，and
System.out.println("a||b:"+(a||b));       //或，or
System.out.println("!(a&&b):"+!(a&&b));   //非，not
​
//短路运算
//a&&b 若a为假，直接返回假，不执行&&运算符及其后面语句
//短路运算测试
int c = 5 ;
boolean d = (c<4)&&(c++<4);   //判断c<4，即为假，后面若继续执行，c将执行自增变为6，但结果为6，说明未自增，即未执行
​
System.out.println(c);
System.out.println(d);
​
​
结果
a&&b:false
a||b:true
!(a&&b):true
5 
false

位运算符

/*
A = 0011 1100
B = 0000 1101
​
A&B = 0000 1100  #位置对应相乘，有0即为0，无0为1
A|B = 0011 1101  #有1即为1,其余为0
A^B = 0011 0001  #相同为0，相反为1 异或
~B  = 1111 0010  #与B相反
   */
​
/*左移右移相关问题
<<  表示*2
>>  表示/2
​
0000 0000    0
0000 0001    1
0000 0010    2
0000 0100    4
0000 1000    8
0001 0000    16
​
一道算法题！
求2*8的最快求法
= 2*2*2*2
​
 */
System.out.println(2<<3);

拓展运算符以及字符串连接

int a = 10;
int b = 20;
​
a+=b;  //即为a=a+b
​
System.out.println(a);
​
//字符串连接符   +， String
System.out.println(""+a+b);    //""在前面，后面的a,b均变为字符串连接
System.out.println(a+b+"");    //""在后面，先运算 a+b
System.out.println(a+""+b);    //""在后面，先运算 a+b
​
结果
30
3020
50
3020
​

三元运算符

public class demo8 {
    public static void main(String[] args) {
        // x ? y :z
        // 如果x==true,则结果为y，否则结果为z
        int score = 80 ;
        String type = score < 60 ? "不及格":"及格";     // 必须掌握
        System.out.println(type);
    }
}

优先级

多使用（）