Java语法基础-1

2017-03-14  本文已影响0人  JackChen1024

1. 关键字

1.1 关键字概述

被Java语言赋予特定含义的单词

1.2 关键字特点

组成关键字的字母全部小写

1.3 关键字注意事项

用于定义数据类型的关键字
用于定义访问权限修饰符的关键字

2. 标识符

2.1 标识符概述

就是给类,接口,方法,变量等起名字时使用的字符序列

2.2 组成规则

由英文大小写字母、数字字符、$(美元符号)、_(下划线)组成

2.3 注意事项

2.4 标识符常见命名规则:见名知意

2.4.1 包

其实就是文件夹,用于把相同的类名进行区分,全部小写,单级:liuyi,多级:cn.itcast

2.4.2 类或者接口

一个单词:单词的首字母必须大写,举例:Student,Dog
多个单词:每个单词的首字母必须大写举例:HelloWorld,StudentName

2.4.3 方法和变量

一个单词:单词的首字母小写,举例:main,age
多个单词:从第二个单词开始,每个单词的首字母大写,举例:studentAge,showAllNames()

2.4.4 常量

一个单词:全部大写,举例:PI
多个单词:每个字母都大写,用_隔开,举例:STUDENT_MAX_AGE

3. 注释

3.1 注释概述

用于解释说明程序的文字

3.2 Java中注释分类格式

/*
    注释:用于解释说明程序的文字

    Java中注释的分类及格式
        单行注释://
        多行注释:/星 星/
            注意:多行不可以嵌套使用,而单行是可以的
        文档注释:被javadoc工具解析生成一个说明书,面向对象部分讲解。
*/

//这是我的注释案例
class ZhuShiDemo {
    //main方法是主方法
    //是程序的入口
    //被jvm调用
    public static void main(String[] args) {
        System.out.println("好好学习,天天向上");
    }
}
/*
    需求:我准备写一个java程序,把"HelloWorld"这句话输出在控制台

    分析:
        A:要写一个Java程序,必须定义类
        B:把数据能够输出,说明我们的程序是可以独立运行的,而程序要独立运行,必须定义main方法
        C:把数据输出在控制台,必须使用输出语句

    实现:
        A:java语言提供了一个关键字:class用来定义类,后面跟的是类名
        B:main方法的格式是固定的:
            public static void main(String[] args) {

            }
        C:输出语句的格式是固定的:
            System.out.println("HelloWorld");
            "HelloWorld"这个内容是可以改变的
*/

//这是我的HelloWorld案例
class HelloWorld {
    /*
        为了程序能够独立运行,定义main方法
        main方法是程序的入口
        被jvm自动调用
    */
    public static void main(String[] args) {
        //为了把数据显示在控制台,我们就使用了输出语句
        System.out.println("HelloWorld");
    }
}

4. 常量、进制和进制转换

4.1 常量概述

在程序执行的过程中其值不可以发生改变

4.2 Java中常量分类

4.2.1 字面值常量

4.2.2 自定义常量

/*
    常量:
        在程序执行过程中,其值不发生改变的量。

    分类:
        A:字面值常量
        B:自定义常量(后面讲)

    字面值常量
        A:字符串常量 用双引号括起来的内容。
            举例:"hello","world","HelloWorld"
        B:整数常量  所有的整数
            举例:100,200
        C:小数常量  所有的小数
            举例:10.23,110.11
        D:字符常量  用单引号括起来的内容
            举例:'a','A','0'
            错误的:'ab'
        E:布尔常量  比较特殊
            举例:true,false
        F:空常量   后面讲
            举例:null
*/
class ConstantDemo {
    public static void main(String[] args) {
        //字符串常量的输出
        System.out.println("hello");

        //整数常量的输出
        System.out.println(100);

        //小数常量的输出
        System.out.println(100.10);

        //字符常量的输出
        System.out.println('a');
        System.out.println('A');
        System.out.println('0');
        //这个是有问题的
        //System.out.println('ab');

        //布尔常量的输出
        System.out.println(true);
        System.out.println(false);
    }
}

4.3 Java针对整数常量提供了4种表现形式

二进制,八进制,十进制,十六进制

4.4 进制概述

进制:就是进位制,是人们规定的一种进位方法。 对于任何一种进制--X进制,就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一,八进制是逢八进一,十进制是逢十进一,十六进制是逢十六进一。

PS:
二进制的由来:任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。

一个整数在内存中一样也是二进制的,但是使用一大串的1或者0组成的数值进行使用很麻烦。所以就想把一大串缩短点,将二进制中的三位用一位表示。这三位可以取到的最大值就是7超过7就进位了,这就是八进制。但是对于过长的二进制变成八进制还是较长,所以出现的用4个二进制位表示一位的情况,四个二进制位最大是15,这就是十六进制。

规律:进制越大,表现形式越短。

4.5 不同进制的数据组成

/*
    不同进制的数据表现:
        二进制:由0,1组成。以0b开头。
        八进制:由0,1,...7组成。以0开头。
        十进制:由0,1,...9组成。默认整数是十进制。
        十六进制:由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
*/
class JinZhiDemo {
    public static void main(String[] args) {
        System.out.println(100); //十进制

        System.out.println(0b100); //二进制
        System.out.println(0100); //八进制
        System.out.println(0x100); //十六进制
    }
}

运行结果

4.6 进制转换

PS:
1、其他进制到十进制

2、十进制到其他进制
除基取余,直到商为0,余数反转。

4.7 有符号数据表示法

在计算机内,有符号数有3种表示法:原码、反码和补码。所有数据的运算都是采用补码进行的

4.8 练习

4.8.1 得到下面数据的十进制值

0b10101
   =12^4 + 12^2 + 1*2^0
   =16 + 4 + 1
   =21

0123
   =18^2 + 28^1 + 3*8^0
   =64 + 16 + 3
   =83

0x3c
   =316^1 + c16^0
   =48 + 12
   =60

4.8.2 得到下面数据的二进制,十进制,十六进制

52分别得到二进制,十进制,十六进制

得到二进制:

   52 / 2 = 26      0
   26 / 2 = 13      0
   13 / 2 = 6       1
   6  / 2 = 3       0
   3  / 2 = 1       1
   1  / 2 = 0       1
   0b110100

得到八进制:

   52 / 8 = 6     4
   6  / 8 = 0    6
   064

得到十六进制:

   52 / 16 = 3   4
   3  / 16 = 0  3
   0x34

4.8.3 有符号数据表示法的练习

A:已知某数X的原码为10110100B,试求X的补码和反码。

符号位 数值位
原码:10110100
反码:11001011
补码:11001100

B:已知某数X的补码11101110B,试求其原码

符号位 数值位
补码: 11101110
反码: 11101101
原码: 10010010

5. 变量

5.1 变量概述

在程序执行的过程中,在某个范围内其值可以发生改变的量,理解:如同数学中的未知数

5.2 变量定义格式

数据类型 变量名 = 初始化值;
注意:格式是固定的,记住格式,以不变应万变

5.3 变量的组成规则

1、从本质上讲,变量其实是内存中的一小块区域,使用变量名来访问这块区域,因此,每一个变量使用前必须要先申请(声明),然后必须进行赋值(填充内容),才能使用。通过画图说明一个变量的组成部分

​ 数据类型,变量名,变量值

2、为什么要定义变量呢?用来不断的存放同一类型的常量,并可以重复使用

6. 数据类型和类型转换

6.1 数据类型

6.1.1 Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存总分配了不同大小的内存空间

6.1.2 所谓有效数字:具体地说,是指在分析工作中实际能够测量到的数字。所谓能够测量到的是包括最后一位估计的,不确定的数字。对于一个近似数,从左边第一个不是0的数字起,到精确到的位数止,所有的数字都叫做这个数的有效数字。

6.1.3 Java 各整数类型有固定的表数范围和字段长度,其不受具体操作系统的影响,以保证Java程序的可移植性。

/*
    数据类型:Java是一种强类型的语言,针对每一种数据都定义了明确的数据类型。

    数据类型分类:
        A:基本数据类型
        B:引用数据类型(类,接口,数值)

    基本数据类型:4类8种
        A:整数            占用字节数
            byte            1
            short           2
            int             4
            long            8

        B:浮点数
            float           4
            double          8

        C:字符
            char            2
        D:布尔
            boolean         1

        注意:
            整数默认是int类型
            浮点数默认是double类型。

            长整型后缀用L或者l标记。建议使用L。
            单精度浮点数用F或者f标记。建议使用F。
*/
class DataTypeDemo {
    public static void main(String[] args) {
        //定义变量的格式:
        //数据类型 变量名 = 初始化值;

        //定义一个字节变量
        byte b = 10;
        System.out.println(10);
        System.out.println(b);

        //定义一个短整型变量
        short s = 100;
        System.out.println(s);

        //定义一个整型变量
        int i = 1000;
        System.out.println(i);

        //超过了int的范围
        //int j = 1000000000000;
        long j = 1000000000000L;
        //long j = 100L;
        System.out.println(j);

        //定义浮点数据变量
        float f = 12.345F;
        System.out.println(f);

        double d = 12.345;
        System.out.println(d);

        //定义字符变量
        char ch = 'a';
        System.out.println(ch);

        //定义布尔变量
        boolean flag = true;
        System.out.println(flag);
    }
}

运行结果:

6.1.4 使用变量的时候要注意的问题:

A:作用域
变量定义在哪个大括号内,它就在这个大括号内有效。
并且,在同一个大括号内不能同时定义同名的变量。

B:初始化值
没有初始化值的变量不能直接使用。
你只要在使用前给值就行,不一定非要在定义的时候立即给值。
推荐在定义的时候给值。

定义变量的格式:
​ a:数据类型 变量名 = 初始化值;
​ b:数据类型 变量名;
变量名 = 初始化值;
C:在一行上建议只定义一个变量
​ 可以定义多个,但是不建议

6.2 类型转换

6.2.2 默认转换(从小到大的转换)

A:byte,short,char—int—long—float—double
B:byte,short,char相互之间不转换,他们参与运算首先转换为int类型

6.2.2 强制转换:

从大的数据类型到小的数据类型
格式:目标数据类型 变量 = (目标数据类型) (被转换的数据);
注意:不要随意的去使用强制转换,因为它隐含了精度损失问题

/*
    面试题:
        byte b1=3,b2=4,b;
        b=b1+b2;
        b=3+4;
        哪句是编译失败的呢?为什么呢?
        b = b1 + b2;是有问题的。
        因为变量相加,会首先看类型问题,最终把结果赋值的也会考虑类型问题。
        常量相加,首先做加法,然后看结果是否在赋值的数据类型范围内,如果不是,才报错。
*/
class DataTypeDemo6 {
    public static void main(String[] args) {
        //定义了三个byte类型的变量,b1,b2,b3
        //b1的值是3,b2的值是4,b没有值
        byte b1 = 3,b2 = 4,b;

        //b = b1 + b2; //这个是类型提升,所有有问题

        b = 3 + 4; //常量,先把结果计算出来,然后看是否在byte的范围内,如果在就不报错。
    }
}

1、在定义Long或者Float类型变量的时候,要加L或者f。
​ 整数默认是int类型,浮点数默认是double。
​ byte,short在定义的时候,他们接收的其实是一个int类型的值。
​ 这个是自己做了一个数据检测的,如果不再它们的范围内,就报错。

2、byte值的问题

byte b1 = 127;
byte b2 = (byte)128; //-128
byte b3 = (byte)129; //-127
byte b4 = (byte)130; //-126
byte的范围:-128 ~ 127
128:10000000
-128:10000000 (这里的1即是符号位,也是数值位)

3、数据类型转换之默认转换
byte,short,char -- int -- long -- float -- double
long:8个字节
float:4个字节
A:它们底层的存储结构不同
B:float表示的数据范围比long的范围要大
long:2^63-1
float:3.410^38 > 210^38 > 28^38 = 22338 = 2*2^114 > 2^63-1

4、Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
​ 可以。因为java语言中的字符占用两个字节。Java语言采用的是Unicode编码。

7. 运算符

7.1 运算符

举例:int a = 3 + 4;
这是做了一个加法运算,+就是运算符,是算术运算符,我们还有其他很多的运算符,3和4就是参与运算的操作数据,3 + 4整体其实就是一个算数表达式

7.2 算术运算符

算术运算符

除法的时候要注意一个问题,整数相除,只能得到整数,要想得到小数,可以*1.0

运算符的优先级

7.3 赋值运算符

基本的赋值运算符:=,把=右边的数据赋值给左边。
扩展的赋值运算符:+=、-=,*=,/=,%=,+= 把左边和右边做加法,然后赋值给左边。

7.4 关系运算符

关系运算符

7.5 逻辑运算符

逻辑运算符

7.6 位运算符

位运算是直接对二进制进行运算

位运算符 位运算符的细节
/*
    位运算符:
        &,|,^,~
        <<,>>,>>>

    注意:
        要做位运算,首先要把数据转换为二进制。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //&,|,^,~

        int a = 3;
        int b = 4;

        System.out.println(3 & 4);
        System.out.println(3 | 4);
        System.out.println(3 ^ 4);
        System.out.println(~3);
    }
}
/*
    分析:因为是位运算,所以我们必须先把数据换算成二进制。

    3的二进制:11
        00000000 00000000 00000000 00000011
    4的二进制:100
        00000000 00000000 00000000 00000100

    &位与运算:有0则0。
        00000000 00000000 00000000 00000011
        &00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000000
        结果是:0

    |位或运算:有1则1。
        00000000 00000000 00000000 00000011
        |00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000111
        结果是:7

    ^位异或运算:相同则0,不同则1。
        00000000 00000000 00000000 00000011
        &00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000111
        结果是:7

    ~按位取反运算符:0变1,1变0
        00000000 00000000 00000000 00000011
       ~11111111 11111111 11111111 11111100 (补码)

       补码:11111111 11111111 11111111 11111100
       反码:11111111 11111111 11111111 11111011
       原码:10000000 00000000 00000000 00000100
       结果是:-4
*/

7.7 三目运算符

int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数。
上一篇下一篇

猜你喜欢

热点阅读