java开发之javaSE基本语法

Posted 2021-01-14

java开发之javaSE基本语法

1.关键字与保留字

关键字定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所有字母都为小写

java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

2.标识符与名称命名规范

1）标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

• 由26个英文字母大小写，0-9 ，_或 $ 组成
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• ava中严格区分大小写，长度无限制。
• 标识符不能包含空格。

注意：在起名字时，为了提高阅读行，要尽量有意义，“见名知意”。

2）名称命名规范

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

3.变量

1）变量的概念

内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）
Java中每个变量必须先声明，后使用
该区域的数据可以在同一类型范围内不断变化
使用变量注意：
变量的作用域：一对{ }之间有效
初始化值
定义变量的格式：数据类型 变量名 = 初始化值

变量是通过使用变量名来访问这块区域的

2）变量的基本类型

• 整数类型：byte,short,int,long
• 浮点类型：float,double
• 字符型：char
• 布尔型：boolean
• 类：class
• 接口：interface
• 数组：[]

Java的整型常量默认为int型，声明long型常量须后加‘l‘和‘L’

Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’

布尔类型： boolean 只能取值为true 或者false，不能取值null。不可以0或非 0 的整数替代false和true。

3.类型转换

/*变量之间的运算：（不考虑boolean。剩下：char byte short int long float double）
1、自动类型转换
2、强制类型转换
*/
class test
{
    public static void main(String[] args)
    {
        //1.自动类型转换
        int i1 = 12;
        short s1 = 2;
        int i2 = i1+s1;//自动类型转换，容量小的数据类型自动转换成容量大的数据类型
        float f1 = 12.3F;
        float f2 = f1 +i2;//自动类型转换
        double d1 = f2 + 12.3;//12.3是一个double类型数据，所以转换成double类型。

        long l = 12;//将容量小的数据类型可以赋值给容量大的数据类型。
        float f3 = 1;
        System.out.println(i2);
        System.out.println(f2);
        System.out.println(d1);

        char c1 = ‘a‘;
        int i3 = c1 +1;//将char类型自动转换为int类型
        System.out.println(i3);

        //需要注意的：当charyteshort之间做运算时，默认的结果为int类型
        short ss1 = 12;
        byte bb1 = 1;
        char cc1 = ‘a‘;
        //short ss2 = ss1 + bb1;是错误的
        int ii1 = ss1 + bb1;
        //char cc2 = cc1 +bb1;
        int ii2 = cc1 + bb1;
        System.out.println(ii1);
        System.out.println(ii2);

        //2.强制类型转换：容量大的转换位容量小的数据类型，要使用强制类型转换符：（）
        //强制类型转换的问题：导致精度的损失
        long l1 = 123456L;
        //int m1 = l1; 是错误的
        int m1 = (int)l1;
        System.out.println(m1);

        byte by1 = (byte)m1;
        System.out.println(by1);//产生了精度损失

        //平时常用的字符串，也是一种数据类型：String
        String nation = "I am XiJian";
        System.out.println(nation);
        //字符串与基本数据类型之间的运算：只能是连接运算：+，得到的仍然是一个字符串
        String str = "abc";
        String str1 = str + m1;
        System.out.println(str1);//abc12345 

    }
}

4.运算符

1)算术运算符

//测试算术运算符：+ - + - * / % ++ -- +
class TestAri 
{
    public static void main(String[] args) 
    {
        //除：/
        int i = 12；
        int j = i/5;
        double d = i / 5;
        System.out.println(j);//j的值为2
        System.out.println(d);//d的值为2.0
        double d1 = i/5.0;//d1的值为2.4
        //取模：% ,结果的符号取决于被摸数
        int i1 = i % 5;//i1 = 2
        int i2 = -12 % 5;//i2=-2
        int i3 = 12 %(-5);//i3=2
        int 14 = -12 % (-5);//i4=-2
        //前++：先加一后做运算
        //后++：先做运算后加一

        int myInt1 = 10;
        int myInt2 = myInt1++;//后++
        System.out.println(myInt1);//11
        System.out.println(myInt2);//10

        int myInt3 = 10;
        int myInt4 = ++myInt3;//后++
        System.out.println(myInt3);//11
        System.out.println(myInt4);//11
        //前--：先减一后做运算
        //后--：先做运算后减一

    }
}

2）赋值运算符

//赋值运算符： += -= *= /= %=  ，不会改变原有数据类型
class GetValue
{
    public static void main(String[] args) 
    {
        int i1 = 10;
        i1 += 3;//i1 = i1 +3

        short s = 10;
        s = s+3;//编译不通过，自动类型转换为int型，但s为short型
        s = (short)(s + 3);//只能这样实现
        s+=3;//既可以实现运算，又不会改变s的数据类型

    }
}

3）比较运算符

4)逻辑运算符

&—逻辑与 | —逻辑或 ！—逻辑非

&& —短路与 || —短路或 ^ —逻辑异或

//逻辑运算符： & && | || ！ ^
class TestLogic 
{
    public static void main(String[] args) 
    {
        boolean a = true;
        boolean b = false;
        //&与&&的区别：&:不管左边是true还是false，右端都会进行运算。
        //             &&:当左端为false时，右端不会进行运算，这就是短路运算。
        //使用时，建议使用&&
        int i1 = 10;
        if(b&(i1++)>0)
        {
            System.out.println("今天天气很晴朗");
        }
        else
        {
            System.out.println("难得没有雾霾");
        }
        System.out.println(i1);//11
        int i2 = 10;
        if(b&&(i2++)>0)
        {
            System.out.println("今天天气很晴朗");
        }
        else
        {
            System.out.println("难得没有雾霾");
        }
        System.out.println(i2);//10

        //| 与 || 的区别：|:左端为true时，右端正常进行运算
        //                ||：左端为true时，右端不进行运算
        int i3 = 10;
        if(a | (i3++)>0)
        {
            System.out.println("今天天气很晴朗");
        }
        else
        {
            System.out.println("难得没有雾霾");
        }
        System.out.println(i3);//11
        int i4 = 10;
        if(a || (i4++)>0)
        {
            System.out.println("今天天气很晴朗");
        }
        else
        {
            System.out.println("难得没有雾霾");
        }
        System.out.println(i4);//10
    }
}

5)三元运算符

/*
三元运算符：(条件表达式)? 表达式1 : 表达式2;
要求表达式1与表达式2为同一数据类型。
        既然是运算符，就一定会有运算的结果，结果的数据类型与表达式1，2的类型一致
*/
class TestSanYuan 
{
    public static void main(String[] args) 
    {
        int i = 10;
        int j = 20;
        //此时max记录了i与j的较大值
        int max = (i > j)? i : j;

        String str = (i > j)? "i大" : "j大";
        //String str = (i>j)? i : "j大";    错误
        String str1 = (i > j)?"i大" : (i == j)? "相等": "j大" ;

        System.out.println(max);
        System.out.println(str);
        System.out.println(str1);
    }
}