JAVA基础

02Java基础语法

一、标识符规范

1、标识符

通俗的说就是给各种事物起名字的符号。

专业的说就是有效的字符序列。

字符：

zhangsan

我爱祖国

张三丰

，。、？

空格

换行

012

常见的标识符：文件名、项目名、类名、方法名、变量名，参数名==。

标识符是程序员随意定义的，但是有语法规范。

2、语法规范

只能使用英文字母、数字、下划线_、美元符号$构成，且不能以数字开头。

不能使用关键字和保留字。

严格区别大小写。

长度没有限制。

3、行业要求：

（1）望文生义

英语

拼音

（2）驼峰命名法

如果有多个单词构成一个标识符，从第二个单词起首字母大写。

studentCount

除了类名，类名所有单词首字母大写。

StudentManger

除了常量，所有字母都大写。

PI

MAXAGE

4、判断是否合法：

this This class Class 123 "1 2" _123 $123 a1

3、关键字和保留字

Java是区别大小写的，关键字和保留字是清一色**小写**。

只要有一个字母大写，就不是关键字或保留字。

 

关键字48个：在语法中有特殊的用途。

保留字2个：还没有具体的用途，留作以后成为关键字。const，goto。

二、数据类型和变量

1、数据类型

（1）数据

数据就是数值，也就是我们通过观察、实验或计算得出的结果。数据有很多种，最简单的就是数字。数据也可以是文字、图像、声音等。数据可以用于科学研究、设计、查证、数学等。

（2）数据类型

数据所属的分类名称，我们叫数据类型。

（3）两大类

基本数据类型

引用数据类型

（4）基本数据类型

细分为8种。

整数类型4个：

byte 字节整型

1B=8bit(二进制位)

B=byte

1KB=1024B

1MB=1024KB

1GB=1024MB

1TB=1024GB

...

包含整数，存储空间是1个字节，8个二进制位。

 

8个二进制位能够存储或者包含的最大整数是+127；最小-128 。

byte的存储整数范围（取值范围）：-128 到 +127.

计算公式：-2的7次方 到 （2的7次方）-1

 

short 短整型

包含整数，存储空间是2B。

取值范围：-2的15次方 到 （2的15次方）-1

int 整型

包含整数，存储空间是4B。

取值范围：-2的31次方 到 （2的31次方）-1

long 长整型

包含整数，存储空间8B。

取值范围：-2的63次方 到 （2的63次方）-1

特点：在Java代码中，数据后加l或L。

为什么要搞4个整数类型？
​
提高内存空间的利用率，建议选择最小的空间来存储指定的数据。
​
但是，我们真正写代码的时候，很少去关注空间问题，一般都使用int，偶尔long。

浮点类型2个：

float 单精度浮点数

包含小数，存储空间4B，小数位最多保留7到8位。

取值范围：自查

特点：在Java代码中，float类型的数据后面需要加f或F。

double 双精度浮点数

包含小数，存储空间8B，小数位最多保留15到16位。

取值范围：自查

特点：在Java代码中，后面不加f或F，表示double类型的浮点数。

字符类型1个：

char 字符类型 存储空间2B

包含单个字符，有且仅有一个字符。

特点：在Java语言中，字符类型的数据必须使用单引号引起来。

比如：'男' '女' '人' 'a' '1' ' ' '\n'

字符类型是否可以存储一个汉字？
首先一个汉字是单个字符。
其次，汉字所占空间是2B，而char类型正好2B，可以存下。
​
补充：一个英文字符占1B.

布尔类型1个： boolean 布尔类型 存储空间1B或1bit。

表示逻辑结果，两种对立的情况。比如真假，男女，是否，对错==

特点：只有两个值，true和false。

（5）引用类型

数组

类：String 字符串类型

接口

String 类型：

可以存储一连串的字符（0到多个）。

特点：在Java语言中，数据使用双引号引起来。

比如： "" "12345" "abcdef" "我爱祖国" "北京东欧会"

注意：String不是基本类型，是引用类型。String不是关键字。

2、数据类型练习

public class DataTypeDemo {
​
​
    public static void main(String[] args) {
​
        //打印语句：打印数据到控制台
        System.out.println(11);
        System.out.println(11L);
        System.out.println(11.1f);
        System.out.println(11.1);
​
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
​
        System.out.println("hello,world!");
        System.out.println("冬奥会没有我不精彩");
    }
}

3、变量

(1)概念

变量是存储数据的容器。

特点：存储的数据是可以改变的。

（2）声明变量

创建一个变量容器。

语法：数据类型 变量名;

举例：

int age;

int a;

long b;

double height;

char sex;

boolean isDeath;

String name;

（3）变量的赋值

往变量容器中存放数据。

语法：变量名=数据;

举例：

age=20；

height=183;

isDeath=false;

sex='男';

name="王";

注意：赋值时，数据的类型必须和声明的类型一致！！！！

（4）变量的变化

每个变量中可以存储一条数据。

存储的数据是可以修改的。

重新赋值时，会先将老数据清除，再放入新数据。

public class VarDemo {
    public static void main(String[] args) {
​
//      声明变量
        int  age;
        double  height;
        char  sex;
        boolean   isDeath;
        String  name;
​
​
//        变量赋值
        age=36;
        height=183.5;
        sex='男';
        isDeath=false;
        name="xiaojun";
​
​
//         变量容器中存储的数据可以变化
        name="张三";
​
    }
}

（5）获取变量中的数据

通过变量名找到变量容器，从容器中取数据即可。

public class VarDemo {
    public static void main(String[] args) {
​
//      声明变量
        int  age;
        double  height;
        char  sex;
        boolean   isDeath;
        String  name;
​
​
//        变量赋值
        age=36;
        height=183.5;
        sex='男';
        isDeath=false;
        name="xiaojun";
        System.out.println(name);
​
//         变量容器中存储的数据可以变化
        name="张三";
        System.out.println(name);
​
    }
}

注意：直接使用变量名获取数据即可，不能加双引号。

4、简写

（1）分解操作

声明：int a;

赋值：a=23;

取值：System.out.println(a);

(2)简写1

声明和初始化（第一次赋值）合并成一句话。

int a=23; //第一次赋值

a=24; //第二次赋值

（3）简写2

多个变量的类型相同，可以共享类型。

int a=1;

int b;

int c=2;

简化：

int a=1,b,c=2;

5、数据类型和变量的关系

(1)变量的声明语法

数据类型 变量名;

(2)数据类型对变量的作用

int a;

在内存中开辟空间，空间大小4B。只能存储整数，取值范围：-2的31次方 到 2的31次方 -1 .

double b;

char c;

boolean d;

String s;

同理：创建变量，在内存中开辟的空间大小由数据类型决定，变量中能够存储哪些数据以及数据的范围也是由数据类型决定。

6、变量内存分配

每声明一个变量，都是在内存中开辟一块空间。

 

7、变量的作用域

一个变量可以在什么地方访问。

变量的作用域：从声明该变量开始，一直到所在的语句组结束。

语句组：{包含若干条语句}

语句组可以相互嵌套。

栈内存：后进先出

压栈和弹栈

 

两个变量一般不能重名。

如果两个变量的作用域没有交集，可以重名。

{
int  a=1;
{
    int  b=2;
    //int  a=4;    //有交集
}
​
int  b=3;      //没有交集
}

 

8、数据类型转换

（1）赋值语法要求

数据的类型必须和变量的类型一致。

（2）问题

如果数据的类型和变量的类型不一样怎么办？

无法赋值。

如果想要完成赋值，需要将数据的类型进行转换，转成和变量的类型一致，然后就可以赋值了。

（3）数据类型转换

有两种方式：

自动类型转换，由系统自动完成，无需代码。

强制类型转换，需要程序员手写代码转换。

（4）自动类型转换

小类型转大类型，系统自动完成。

int   a=1;
​
double  b=a;
//b是double   ,  a是int   ，类型不一致。
//系统将int类型的1转为double类型1.0,然后赋给b

byte-->short int long float double

short -->int long float double

int --> long float double

long --> float double

float --> double

并不是所有类型都可以相互转换，必须由转换的依据。

特殊情况：

char --> int

转换的依据是ascii码表。

//        char-->int
        char  c='a';
        int   d=c;
        System.out.println(d);

（5）强制类型转换

大类型转小类型，需要手动完成。

        double   b2=1;
        int   a2=(int)b2;
        //b2  是  double   ，a2  是  int
        //大类型转小类型会丢失精度，需要手动完成。
//        手动代码：在数据前加小括号，小括号里写上你想要的类型

注意：大类型转小类型会丢失精度，需要手动完成。

三、运算符

运算符是有优先级的，先算优先级高的，再算优先级低的，同级别从左往右算。

1、算术运算符

+   -  *   /   %
+   -
前++和后++     前--和后--
字符串拼接+

算数运算的结果：

（1）如果参与运算全是整数，有long结果为long，否则为int。

（2）如果参与运算的有小数，有double结果为double，否则float。

（3）在算数运算中，常量整数默认为int，常量小数默认为double。

  int  a=10,b=20;
        //先a+b ，然后打印结果
        System.out.println(a+b);  //10+20=30
        System.out.println(a-b);  //10-20=-10
        System.out.println(a*b);  //10*20=200
//        java是整除
        System.out.println(a/b);  //10/20=0
        System.out.println(a%b);  //10%20=10

        double   c=12,d=5;
        System.out.println(c+d);  //12.0+5.0=17.0
        System.out.println(c-d);  //12.0-5.0=7.0
        System.out.println(c*d);  //12.0*5.0=60.0
//        此处没有整除
        System.out.println(c/d);  //12.0/5.0=2.4
        System.out.println(c%d);  //12.0%5.0=2.0

特殊情况：

byte+byte=int

short+short=int

byte+short=int

。。。

正负号：

//        正负号
        int   f=10;
        System.out.println(+f);
        System.out.println(-f);

前++和后++，以及前--和后--：

总结：
前++和后++都实现了变量的递增1，但是优先级不同。前++优先级比较高，后++优先级低。
--同理。

//        前++和后++，以及前--和后--
        int  m=10;
//        m++;    //m=m+1
//        System.out.println(m);

//        ++m;      //m=m+1
//        System.out.println(m);

//        int   n=m++;      //  n=m=10    m++  m=11
//        System.out.println(m);
//        System.out.println(n);

        int   n=++m;      //m++  m=11   n=m=11
        System.out.println(m);
        System.out.println(n);

字符串拼接：+

其中一个数据肯定是String类型。运算结果是String类型。

//        字符串拼接：
        String  s11="abcd";
        String  s22="1234";

        System.out.println(s11+s22);
        int  a11=12;
        System.out.println(s11+a11);
        double  b11=12.5;
        System.out.println(s11+b11);
        char   c11='g';
        System.out.println(s11+c11);
        boolean  d11=true;
        System.out.println(s11+d11);

//        特殊1
        int  m1=1,m2=2;
        System.out.println(m1+m2+s11);   //3+"abcd"="3abcd"
        System.out.println(s11+m1+m2);   //"abcd1"+2="abcd12"

2、赋值运算符

用来给变量赋值

=   +=  -=  *=   /=   %=

        int  a=1;
        int  b=2;

        b+=a;   //b=b+a;   b=3
        b-=a;   //b=b-a;   b=2
        b*=a;   //b=b*a;   b=2
        b/=a;   //b=b/a;   b=2
        b%=a;   //b=b%a;   b=0

        System.out.println(a);
        System.out.println(b);


//        特殊1
        short   s1=2;
        short   s2=3;


//        算数运算，运算结果是int
        s2=(short)(s2+s1);
//        赋值运算，都是short
        s2+=s1;


//        算数运算，运算结果是int
        s2=(short)(s1+1);
//        赋值运算，都是short
        s2+=1;

3、比较运算符

（1）作用

比较大小。byte short int long float double char

比较是否相等。所有类型都可以，但是两个数据的类型必须相同。

（2）符号

>   >=    <   <=

==   !=

运算结果：boolean。

（3）案例

        int  a=4,b=5;

        System.out.println(a>b);
        System.out.println(a>=b);
        System.out.println(a<b);
        System.out.println(a<=b);

        System.out.println(a==b);
        System.out.println(a!=b);


//        特殊1  char
        System.out.println('a'<'b');   //'a'=97   'b'=98   97<98   true

4、逻辑运算符

（1）作用

计算多个条件的逻辑结果。

（2）符号

&&   ||   ！

&    |

运算规则：

&&和&：条件1&&条件2

如果两个条件都成立，返回true；否则false。

||和| ：条件1||条件2

如果两个条件有一个成立，返回true；否则false。

！ ： ！条件1

真变假，假变真。

注意：

条件必须是boolean，运算结果也是boolean！！！

（3）案例

System.out.println(   3>2&&4<5     );
//3>2=true   4<5=true   true&&true=true   打印true
System.out.println(   3>2&4<5     );

System.out.println(   3>2||4<5   );
System.out.println(   3>2|4<5   );

System.out.println(  !(3>2) );
System.out.println(  !(3<2) );

（4）&&和&的区别

&&：短路与，只要第一个条件为false，直接结果为false，不再看第二个条件。

&：普通与，两个条件都看，然后再计算结果。

||和|区别同理。

||：短路或，只要第一个条件为true，直接结果为true，不再看第二个条件。

|：普通或，两个条件都看，然后再计算结果。

我们建议使用&&和||。

（5）按位运算符

&和|还可以作为二进制的与运算和或运算。

参与运算的必须是数字。

//        按位运算符：二进制与运算和或运算
        //5=101   4=100
        System.out.println(5&4);
        //101&100=100=4
        System.out.println(5|4);
        //101|100=101=5

（6）错误案例

//        错误案例

//        1>2=false   false>3
//        System.out.println(  1>2>3  );
//        1>2=false  2>3=false  false&&false=false
        System.out.println(1>2 &&  2>3);

5、三目运算符

（1）语法

（boolean条件)?语句1:语句2

组合：?和:共同构成

（2）执行流程

首先执行boolean条件。

条件为true，执行语句1；

条件为false，执行语句2。

运算结果：可以是各种类型。

（3）案例

System.out.println(   3>2?3:2   );
System.out.println(   3<2?3:2   );


System.out.println(3>2?1+1:2+2);

System.out.println(3>2?"1111":"2222");