第3章 语法格式

Posted 2020-10-26

1.1 常量1.1.1 常量概述
– 在程序执行的过程中，其值不可以发生改变的量
1.1.2 常量分类
– 字符串常量 用双引号括起来的内容(“HelloWorld”)
– 整数常量 所有整数(12,-23)
– 小数常量 所有小数(12.34)
– 字符常量 用单引号括起来的内容(‘a’,’A’,’0’)
– 布尔常量 较为特有，只有true和false
– 空常量 null(数组部分讲解)
1.1.3 案例代码四:

/*
        常量：在程序执行的过程中，其值不可以发生改变的量

        常量分类：
                A:字符串常量        "HelloWorld"
                B:整数常量                12,-23
                C:小数常量                12.34
                D:字符常量                ‘a‘,‘0‘
                E:布尔常量                true,false
                F:空常量                null(后面讲解)
*/
public class ChangLiang {
        public static void main(String[] args) {
                //字符串常量
                System.out.println("HelloWorld");

                //整数常量
                System.out.println(12);
                System.out.println(-23);

                //小数常量
                System.out.println(12.34);

                //字符常量
                System.out.println(‘a‘);
                System.out.println(‘0‘);

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

1.1 变量1.1.1 变量概述
– 在程序执行的过程中，在某个范围内其值可以发生改变的量
– 从本质上讲，变量其实是内存中的一小块区域
1.1.2 变量定义格式
– 数据类型 变量名 = 初始化值;
– 注意：格式是固定的，记住格式，以不变应万变
1.1.3 变量图解

1.2 数据类型1.2.1 计算机存储单元
变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：
– 1B（字节） = 8bit
– 1KB = 1024B
– 1MB = 1024KB
– 1GB = 1024MB
– 1TB = 1024GB
1.2.2 数据类型概述和分类
A:为什么有数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
B:Java中数据类型的分类
基本数据类型
引用数据类型
面向对象部分讲解

1.3 标识符1.3.1 标识符概述
A 作用
– 给包,类,方法,变量等起名字
B 组成规则
– 由字符，下划线_，美元符$组成
? 这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
– 注意事项
– 不能以数字开头
– 不能是Java中的关键字
C : 命名原则:见名知意
a包
最好是域名倒过来,要求所有的字母小写
b类或者接口
如果是一个单词首字母大写
如果是多个单词每个单词首字母大写(驼峰标识)
c方法或者变量
如果是一个单词全部小写
如果是多个单词,从第二个单词首字母大写
d常量
如果是一个单词,所有字母大写
如果是多个单词,所有的单词大写,用下划线区分每个单词
1.3.2 案例代码五

/*
        标识符：就是给包,类,方法,变量起名字的符号。

        组成规则：
                A:unicode字符
                        数字字符,英文大小写,汉字(不建议使用汉字)
                B:下划线_
                C:美元符$

        注意事项
                A:不能以数字开头
                B:不能是java中的关键字

        常见命名规则：
                A:基本要求
                        见名知意
                B:常见的命名
                        a:包(其实就是文件夹,用于对类进行管理)
                                全部小写,多级包用.隔开
                                举例：com，com.itheima
                        b:类
                                一个单词首字母大写
                                        举例：Student,Car
                                多个单词每个单词的首字母大写
                                        举例：HelloWorld
                        c:方法和变量
                                一个单词首字母小写
                                        举例：age,show()
                                多个单词从第二个单词开始每个单词的首字母大写
                                        举例：maxAge,getAge()
*/
public class BiaoZhiFu {
        public static void main(String[] args) {
                //定义变量
                //数据类型 变量名 = 初始化值;
                int a = 10;

                //正确
                int b2 = 20;
                //错误
                //int 2b = 30;

                //不能是java中的关键字
                //错误
                //int public = 40;
        }
}

1.1 定义变量1.1.1 基本数据类型变量的定义和使用
变量的定义格式：
数据类型 变量名 = 初始化值;
基本数据类型：
byte,short,int,long,float,double,char,boolean
注意：
整数默认是int类型，定义long类型的数据时，要在数据后面加L。
浮点数默认是double类型，定义float类型的数据时，要在数据后面加F。
1.1.2 案例代码六

public class VariableDemo {
        public static void main(String[] args) {
                //定义byte类型的变量
                byte b = 10;
                System.out.println(10);
                System.out.println(b);

                //定义short类型的变量
                short s = 100;
                System.out.println(s);

                //定义int类型的变量
                int i = 10000;
                System.out.println(i);

                //定义long类型的变量
                long l = 1000000000000000L;
                System.out.println(l);

                //定义float类型的变量
                float f = 12.34F;
                System.out.println(f);

                //定义double类型的变量
                double d = 12.34;
                System.out.println(d);

                //定义char类型的变量
                char c = ‘a‘;
                System.out.println(c);

                //定义boolean类型的变量
                boolean bb = false;
                System.out.println(bb);
        }
}

1.1.1 变量定义的注意事项
? 变量未赋值,不能直接使用
– 引出变量的第二种使用格式
? 变量只在它所属的范围内有效。
– 变量在哪对大括号内，变量就属于哪对大括号
? 一行上可以定义多个变量，但是不建议
1.1.2 案例代码七

/*       
        变量定义注意事项：
                1:变量未赋值,不能直接使用
                2:变量只在它所属的范围内有效
                        变量属于它所在的那对大括号
                3:一行上可以定义多个变量,但是不建议
*/
public class VariableDemo2 {
        public static void main(String[] args) {
                //定义变量
                int a = 10;
                System.out.println(a);

                int b;
                b = 20; //变量在使用前赋值都是可以的
                System.out.println(b);

                {
                        int c = 100;
                        System.out.println(c);
                }
                //System.out.println(c);

                /*
                int aa,bb,cc;
                aa = 10;
                bb = 20;
                cc = 30;
                */

                /*
                int aa = 10;
                int bb = 20;
                int cc = 30;
                */

                int aa=10,bb=20,cc=30;
        }
}

1.1 数据类型转换1.1.1 隐式数据类型转换
取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
1.1.2 案例代码八

/*
        +:是一个运算符，做加法运算的。
        我们在做运算的时候，一般要求参与运算的数据类型必须一致。

        类型转换：
                隐式转换
                强制转换

        隐式转换        
                byte,short,char -- int -- long -- float -- double
*/
public class TypeCastDemo {
        public static void main(String[] args) {
                //直接输出了运算的结果
                System.out.println(3 + 4);

                //定义两个int类型的变量
                int a = 3;
                int b = 4;
                int c = a + b;
                System.out.println(c);

                //定义一个byte类型,定义一个int类型
                byte bb = 2;
                int cc = 5;
                System.out.println(bb + cc);

                //我能不能不直接输出，用一个变量接受呢?
                //用变量接受，这个变量应该有类型
                //可能损失精度
                //byte dd = bb + cc;
                int dd = bb + cc;
                System.out.println(dd);
        }
}

1.1.1 强制类型数据转换
强制转换的格式

• b = (byte)(a + b);
  强制转换的注意事项
• 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
  1.1.2 案例代码九

/*
        强制转换：
                目标类型 变量名 = (目标类型) (被转换的数据);
                不建议强制转换，因为会有精度的损失。
*/
public class TypeCastDemo2 {
        public static void main(String[] args) {
                int a = 3;
                byte b = 4;
                int c = a + b;
                //byte d = a + b;
                byte d = (byte) (a + b);
        }
}