Java语言基础 Java基础语法 1.关键字 关键字概述：
关键字特点：
注意事项：
2.标识符 标识符概述：
组成规则：
注意事项：
不能以数字开头 不能是Java中的关键字 区分大小写
3.标识符的常见命名规则 注意事项：
包：
类或者接口：
一个单词：单词的首字母必须大写,举例：Student，Dog 多个单词：每个单词的首字母必须大写，举例：HelloWorld，StudentName
方法或者变量：
一个单词：单词的首字母小写，举例：main，age 多个单词：从第二个单词开始，每个单词的首字母大写，举例：studentAge,showAllNames
常量：
一个单词组成：全部大写，举例：PI 多个单词组成：每个字母都大写，用_隔开，举例：STUDENT_MAX_AGE
4.注释概述及其分类 注释概述：
Java中注释分类格式：
单行注释：格式：//注释文字 多行注释：格式：/星 注释文字 星/，注意：多行不可以嵌套使用，而单行是可以的 文档注释：格式：/星星 注释文字 星/
5.HelloWorld案例加入注释 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 /* 需求：我准备写一个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"); } }
6.注释的作用 略过，在Eclipse Jee 2018-12程序中编写Java代码时，有错误的话，编译器会提示。
7.常量的概述和使用 常量概述：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 /* 常量： 在程序执行过程中，其值不发生改变的量。 分类： 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); } }
8.进制概述以及二进制、八进制、十六进制图解
二进制->八进制：
二进制->十六进制：
规则：进制越大，表现形式越短
9.不同进制数据的表现形式 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 /* 不同进制的数据表现： 二进制：由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); //十六进制 } }
10.任意进制到十进制的转换
系数：每一个位上的数据值本身就是系数。
基数：x进制的基数就是x。
权：我们针对每一个位上的数据进行编号，从右边，并且是从0开始编号，这个编号就是该位上数据的权值。
PS：每一个位上的系数x基数^权次幂相加。
11.十进制到任意进制的转换 方法：这个数对基数依次取余，将余数倒序输出，在倒序输出余数之前正序输出最后一次的商。（这个方法是很简单的一种方式，可以大大的节省时间）。
将十进制转成八进制：
先输出最后一次计算的商，然后倒序从下到上输出余数
12.快速的进制转换法 8421码
13.原码、反码、补码的讲解 在探求为何机器要使用补码之前, 让我们先了解原码, 反码和补码的概念.对于一个数, 计算机要使用一定的编码方式进行存储. 原码, 反码, 补码是机器存储一个具体数字的编码方式。
原码：
[+1]原 = 0000 0001
[-1]原 = 1000 0001
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:[1111 1111 , 0111 1111]即[-127 , 127]，原码是人脑最容易理解和计算的表示方式。
反码：
[+1] = [00000001]原 = [00000001]反
[-1] = [10000001]原 = [11111110]反
可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。
补码：
[+1] = [00000001]原 = [00000001]反 = [00000001]补
[-1] = [10000001]原 = [11111110]反 = [11111111]补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值。
14.变量的概述及格式 变量的概念：
变量定义格式：
注意：格式是固定的，记住格式，以不变应万变
15.数据类型的概述和分类和定义不同数据类型的变量 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 /* 数据类型：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); } }
16.使用变量的注意事项 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 /* 使用变量的时候要注意的问题： A:作用域 变量定义在哪个大括号内，它就在这个大括号内有效。 并且，在同一个大括号内不能同时定义同名的变量。 B:初始化值 没有初始化值的变量不能直接使用。 你只要在使用前给值就行，不一定非要在定义的时候立即给值。 推荐在定义的时候给值。 定义变量的格式： a:数据类型 变量名 = 初始化值; b:数据类型 变量名; 变量名 = 初始化值; C:在一行上建议只定义一个变量 可以定义多个，但是不建议 */ class DataTypeDemo2 { public static void main(String[] args) { //定义变量 int x = 100; //错误，不能有同名的 //int x = 200; //定义变量必须给值 //int y; //System.out.println(y); int z; z = 100; System.out.println(z); //在一行上定义多个变量 //int a = 10; int b = 20; int c = 30; //上面的写法可以，但是不建议。 int a = 10; int b = 20; int c = 30; //int d, e; //d = 40; //e = 50; //int f,int g; //错误 //int h; int i; //正确 } }
17.数据类型转换默认转换 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 /* +是一个运算符(我们等会讲解)。做加法运算的。 一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。 注意： boolean类型不能转换为其他的数据类型 默认转换(从小到大的转换) A:byte,short,char—int—long—float—double B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型 */ class DataTypeDemo3 { public static void main(String[] args) { //直接输出的方式做加法 //System.out.println(3 + 4); //两个int类型做加法 int x = 3; int y = 4; int z = x + y; System.out.println(z); //定义一个byte类型，一个int类型，做加法 byte a = 3; int b = 4; System.out.println(a + b); //可能损失精度 //byte c = a + b; int c = a + b; System.out.println(c); } }
18.数据类型转换强制转换 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 /* 强制转换： 从大的数据类型到小的数据类型。 格式： 目标数据类型 变量 = (目标数据类型) (被转换的数据); 注意： 不要随意的去使用强制转换，因为它隐含了精度损失问题。 */ class DataTypeDemo4 { public static void main(String[] args) { byte a = 3; int b = 4; //这个肯定没有问题 //int c = a + b; //byte c = 7; //这个是有问题的 //byte c = a + b; //用强制类型转换改进 byte c = (byte) (a + b); System.out.println(c); } }
19.强制转换的思考题 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 /* 思考题1：请问下面这个有没有问题 double d = 12.345; float f = d; 思考题2：看看下面两个定义有没有区别呢? float f1 = (float)12.345; float f2 = 12.345f; f1其实是通过一个double类型转换过来的。 而f2本身就是一个float类型。 */ class DataTypeDemo5 { public static void main(String[] args) { //把double赋值给float，加了强制类型转换 double d = 12.345; float f = (float)d; //看看下面两个定义有没有区别呢? float f1 = (float)12.345; float f2 = 12.345F; } }
20.变量相加和常量相加的面试题 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 /* 面试题： 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的范围内，如果在就不报错。 } }
21.强制转换数据溢出后的结果怎么算 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 /* byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢? 练习：byte b = (byte)300; */ class DataTypeDemo7 { public static void main(String[] args) { //因为byte的范围是：-128到127。 //而130不在此范围内，所以报错。 //byte b = 130; //我们可以使用强制类型转换 byte b = (byte) 130; //结果是多少呢? System.out.println(b); } } /* 分析过程： 我们要想知道结果是什么，就应该知道是如何进行计算的。 而我们又知道计算机中数据的运算都是补码进行的。 而要得到补码，首先要计算出数据的二进制。 A:获取130这个数据的二进制。 00000000 00000000 00000000 10000010 这是130的原码，也是反码，还是补码。 B:做截取操作，截成byte类型的了。 10000010 这个结果是补码。 C:已知补码求原码。 符号位 数值位 补码： 1 0000010 反码： 1 0000001 原码： 1 1111110 */
22.字符数据参与运算 常用字符与ASCII代码对照表
23.字符串参与运算 1 2 3 4 5 6 7 8 9 10 11 12 13 14 /* 看程序写结果 字符串数据和其他数据做+，结果是字符串类型。 这里的+不是加法运算，而是字符串连接符。 */ class DataTypeDemo9 { public static void main(String[] args) { System.out.println("hello"+'a'+1); //helloa1，因为有优先级 System.out.println('a'+1+"hello"); //98hello System.out.println("5+5="+5+5); //5+5=55 System.out.println(5+5+"=5+5"); //10=5+5 } }
运算符优先级
