黑马程序员——Java基础语法一
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
一、关键字
定义：被Java赋予了特殊含义的单词。
特点：体现上都是英文小写。
| 用于定义数据类型的关键字 |
||||
| class(类) |
interface(接口) |
( 整数类型)byte |
short |
int |
| long |
(浮点类型)float |
double |
(字符类型)char |
(布尔型)boolean |
| void(函数上表示无返回值类型) |
|
|
|
|
| 用于定义数据类型值的关键字 |
||||
| true(真) |
false(假) |
null(空) |
|
|
| 用于定义流程控制的关键字 |
||||
| (判断)if |
else |
switch |
case |
default |
| (循环)while |
do |
for |
break(结束循环或选择结构) |
continue(继续循环) |
| return(返回) |
|
|
|
|
| 用于定义访问权限修饰符的关键字 |
||||
| private(私有的) |
public(共有的) |
protected(受保护的) |
|
|
| 用于定义类，函数，变量修饰符的关键字 |
||||
| abstract(抽象) |
final(最终) |
static(静态的) |
synchronized(同步的) |
enum(枚举)
|
| 用于定义类与类之间关系的关键字 |
||||
| synchronized(同步的) |
implements(实现) |
|
|
|
| 用于定义建立实例及引用实例，判断实例的关键字 |
||||
| new(建立实例) |
this(当前引用) |
super(父类引用) |
instanceof(判断对象类型) |
|
| 用于异常处理的关键字 |
||||
| try(检查异常) |
catch(捕获异常) |
finally(最终执行) |
throw(抛出异常) |
throws(抛出异常) |
| 用于包的关键字 |
||||
| package(创建包) |
import(导入包) |
|
|
|
| 其他修饰符关键字 |
||||
| native(本地) |
strictfp(精确浮点) |
transient(变量修饰符) |
volatile(类型修饰符) |
assert(断言) |
注：main不是关键字，却是被虚拟机所识别的一个名称。
二、标识符
就是给类,接口,方法,变量等起名字时使用的字符序列。它由26个英文字母大小写，数字0-9，符号 _ 和$组成。
定义合法标识符的规则：
1、 数字不可以开头。
2、 不可以使用关键字。
注：Java中严格区分标识符的大小写。在起名字的时候，为了提高阅读性，要尽量有意义。秉承着见名知意的原则.
Java中的名称规范：
包名：多单词组成时所有字母都小写。
单级:
helloword
多级:
com.baidu.waimai cn.itcast.helloworld
类名接口名：多单词组成时，所有单词的首字母大写。
一个单词:
Demo
多个单词:
HelloWorld
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。
一个单词:
main(),show(),eat()
多个单词:
getName(),getAge()
常量名：所有字母都大写。多单词时每个单词用下划线连接。
一个单词:
PI
多个单词:
COUNTRY_AREA
三、注释
用于解释说明程序的文字,是一个程序员必须要具有的良好编程习惯。注释的作用为解释说明程序，提高程序的阅读性;可以帮助我们排错。
Java中注释分类及格式:
单行注释
格式： //注释文字
多行注释
格式： /* 注释文字 */
文档注释
格式：/** 注释文字 */
四、常量
定义：在程序运行过程,其值不发生改变的量。
Java中常量可分为字面值常量和自定义常量两类,其中字面值常量的分类：
1，整数常量。所有整数。
2，小数常量。所有小数。
3，布尔型常量。较为特有，只有两个数值。true false。
4，字符常量。将一个数字字母或者符号用单引号( ' ' )标识。
5，字符串常量。将一个或者多个字符用双引号(“”)标识。
6，null常量。只有一个数值就是：null。
对于整数，Java有三种表现形式：
五、进制
进制就是认为规定的进位方式。x进制,就是逢x进一。这在我们的生活中是十分常见的,比如我们最常见的时间计时秒进分,分进时,时进天,天进月等就是分别采用了60,60,24,30等作为进制计算的。而在计算机中进制只有四种,分别为:二进制、四进制、八进制、十六进制。
二进制的由来在于早期利用开关的开关状态记录事件,由于开关只有开和关两种状态,可变化量太少,所以人们就采用八个这样的状态为一组作为一个基本的数据单位字节,byte。但是由于二进制的存储太长,所以就产生了分组记录的方式,以三个为一组,就出现了八进制;以4个为一组就出现了十六进制。
表达方式分别为:
1. 二进制:0b开头 0,1 满2进1
2. 八进制:0开头 0~7 满8进1
3. 十进制:默认生活中一样
4. 十六进制:0x开头 0~9 ,abcedf 满16进1
规律: 同样的数字符号,进制越大,数值越大
进制的基本转换：
十进制转换为——>二进制：如9的二进制，算法
9/2 = 4 ...1
4/2 = 2 ...0
2/2 = 1 ...0
1/2 = 0 ...1
结果就为：0b1001。注意：用所给数据对2进行整除直到商为0,再将余数按照从后到前的顺序读出就是最后的结果。二进制转成十进制还可以利用8421码,用所给数据减去最近的8421码值,然后再将余数按照相同的方式计算直至结果我零,将用到的8421码值记录下来转换成二进制形式。如:9-8 = 1....8
1-1 = 0....1,用到了1,8也就是2^0和2^3,最后的结果就是:0b1001。
十进制转成八进制和十六进制的方法同十进制转二进制的算法.
二进制转化为——>十进制：如1100的十进制等于
23*1+22*1+21*0+20*0=12。
可以理解为:系数*基数^权值 之和,这可以理解我其他进制转成十进制的公式。
系数:数位上的那个值
基数:进制就是那个基数
权值:就是那个基数上次幂,从右向左,从0开始数.
八进制 0100
基数8
结果 = 1*8^2 + 0 + 0 = 64
十六进制 0x100
基数16
结果 = 1*16^2 + 0 + 0 = 256
进制转成其他进制还有一种方法,那就是分组的方法,三个二进制位表示一个八进制位,例如:0b1001 0101
000--0 100--4
001--1 101--5
010--2 110--6
011--3 111--7
010 010 101
--- --- ---
2 2 5
所以最后的结果为:0225。要注意的是分组从最右侧开始,当左侧的位数不足时要在最左侧补0。二进制转成十六进制方法同上,要注意的是一个十六进制位要由四个二进制位来表示。
有符号的表示方式:
1. 原码: 符号位 和 数值位 0 1
2. 反码: 符号位不变,数值位取反
3. 补码: 反码的基础上补1
4. 正数 原反补都一样
5. 负数 需要原反补转换
6. 因为计算机运算的都采用补码去运算
带符号数据的表示方法:
分为三种:原码 反码 补码
原码 : 最高位 为符号位,其他位为 数值位 , 0 表示正数, 1表示负数
如1100 1110
符号位 数值位
1 1001110
反码: 正数跟原码一样
负数,符号位不变,数值位取反 0变1 1变0
符号位 数值位
1 0110001
补码: 正数跟原码一样
负数,在反码的基础上补1
符号位 数值位
1 0110010
已知某数X的补码为1110 1110B，试求其原码。
符号位 数值位
补码: 1 110 1110
反码: 1 110 1101
原码: 1 001 0010-- > -18
六、变量
概念：在程序运行过程,其值在一定范围内可以发生改变的量。原理为在内存中开辟一个存储空间。有自己的名称（变量名）和类型（数据类型）。
作用：用来不断的存放同一类型的数据，并可以重复使用。
定义变量的格式：数据类型 变量名 = 初始化值;
数据类型：
Java中有两种数据类型：1、基本数据类型；2、引用数据类型。
而数据类型的作用是限制初始化值的范围。
其中基本数据类型可以理解为四类八种,即:
类型 字节 范围
整数 byte 1 -128~127
short 2 -32768~32767
int 4 -2^31 - 2^31-1
-2147483648-2147383647
long 8 -2^63 - 2^63-1
浮点数 float 4 -3.4*10^38-3.4*10^38
double 8 -1.7*10^308-1.7*10^308
字符 char 2 0-65535
布尔 boolean 1 true false
要注意的是:(1)在定义变量的时候,虚拟机默认接收整数是int类型,如果你想赋值long类型的数,需要在数值后面加 l 或者 L。
(2)在定义变量的时候,虚拟机默认接收浮点数是double类型,如果你想赋值float类型的数,需要在数值后面加 f 或者 F。
类型的自动提升：
在运算中，当低类型数据与高类型数据进行计算时，系统会自动将表达式中的低类型数据提升到高类型。如：
byte b = 3 ; int c;
c= b + 2; //b会自动提升为int类型进行运算。
强制类型转换：
1、 隐式转换
整数在做运算的时候,会有一个默认数据类型向上提升
(1) byte,short,char-->int-->long-->float-->double
(2) byte,short,char相互之间不转换，他们参与运算首先转换为int类型;boolean类型不参与转换
2、显示转换(强制转换)
(1) 格式: 数据类型 变量名 = (目标数据类型)(数据);
(2) 隐含了可能损失精度
当程序中，数据类型需要变换时，可以进行强制转换。如：
注意:
下面这个有没有问题
double d =12.345;
float f =d ;// 有问题,将double类型的值赋值给float,可能会丢失精度
下面两句有没有区别?
float f = (float) 12.345; // 隐含了可能损失精度
float f =12.345f; // 直接赋值
下面语句哪句是编译失败的呢？为什么呢？
byte b1=3,b2=4,b;
b=b1+b2; //失败,b1与b2为byte类型的值,在运算过程中会被转换成int类型,所以b1+b2的结果为int类型,将int类型的值赋值给byte类型可能 会导致精度丢失
b=3+4;//成功,本身为赋值
字符和字符串的运算
(1) 字符类型-->自动提升,具体的值可查阅ASCII码表
(2) 字符串 -->拼接字符串(拼串儿)
例如:
System.out.println('a'); //a
System.out.println('a'+1); //98 字符 a 对应97
System.out.println("5+5="+5+5); //"5+5=55"
System.out.println( 5+5+"=5+5"); // "10=5+5"
使用变量的注意事项
1.作用域
指的是有效的使用范围,一个变量只能声明一次,即相同作用域中不能定义两个同名变量
2.初始化值
在使用变量前赋值,没有初始化值不能直接使用
3.一行一变量
一行定义一个变量
七、运算符
1、算术运算符
| 运算符 |
运算 |
范例 |
结果 |
| + |
正 |
+3 |
3 |
| - |
负 |
b=4;-b |
-4 |
| + |
加 |
5+5 |
10 |
| - |
减 |
6-4 |
2 |
| * |
乘 |
3*4 |
12 |
| / |
除 |
5/5 |
1 |
| % |
取模 |
5%5 |
0 |
| ++ |
自增（前） |
a=2;b=++a |
a=3;b=3 |
| ++ |
自增（后） |
a=2;b=a++ |
a=3;b=2 |
| -- |
自减（前） |
a=2;b=--a |
a=1;b=1 |
| -- |
自减（后） |
a=2;b=a-- |
a=1;b=2 |
| + |
字符串相加 |
“he”+”llo” |
“hello” |
注：（1）进行取模运算时，如果有负数，运算结果取决于运算左边有没有负数。字符串数据和任何数据使用 +都是相连接，最终都会变成字符串。整数做运算,结果还是整数，要记得区分’＋‘的正、连、加。
（2）自增与自减
单独使用
在前面和后面是没有区别的
参与运算
有区别
++在前面,先++,再运算
++在后面,先运算,再++
自增自减运算隐藏了一个强制转换。
请分别计算出 a, b ,c 的值?
int a = 10;
int b = 10;
int c = 10;
a = b++; a 10 b 11
c = --a; a 9 c 9
b = ++a; a 10 b 10
a = c--; a 9 c 8
B:案例演示 :运算符的优先级
请分别计算出x,y的值?
int x = 4;
int y = (x++)+(++x)+(x*10);
4 6 6*10 = 70
5 6
2、赋值运算符
| 运算符 |
运算 |
范例 |
结果 |
| = |
把右边赋值给左边 |
x = 4 |
4 |
| += |
左边和右边做加法运算，再赋值给左边 |
x = 4;x += 2 |
6 |
| -= |
左边和右边做减法运算，再赋值给左边 |
x = 4;x -= 2 |
2 |
| *= |
左边和右边做乘法运算，再赋值给左边 |
x = 4;x *= 2 |
8 |
| /= |
左边和右边做除法运算，再赋值给左边 |
x = 4;x /= 2 |
2 |
| %= |
左边和右边做取模运算，再赋值给左边 |
x = 4;x %= 2 |
0 |
演示例题：看下面的程序是否有问题，如果有问题，请指出并说明理由。
short s=1;s = s+1;//有问题，可能会丢失精度
short s=1;s += 1; //没有问题，原因见下
s += 1; <==> s = (short) s + 1;
原因: += 赋值运算符隐含了一个强制转换 .
3、比较运算符
| 运算符 |
运算 |
范例 |
结果 |
| == |
相等于 |
4==3 |
false |
| != |
不等于 |
4!=3 |
true |
| < |
小于 |
4<3 |
false |
| > |
大于 |
4>3 |
true |
| <= |
小于等于 |
4<=3 |
false |
| >= |
大于等于 |
4>=3 |
false |
| instanceof |
检查是否是类对象 |
“hello” instanceof String |
true |
注：1、比较运算符的结果都是boolean型，也就是要么是true，要么是false。
2、比较运算符“==”不能误写成“=”，会造成不兼容的类型的错误。
4、逻辑运算符
逻辑运算符用于连接boolean类型的表达式。
| 运算符 |
运算 |
范例 |
结果 |
| & |
AND(与) |
false&true |
false |
| | |
OR(或) |
false|true |
true |
| ^ |
XOR(异或) |
false^true |
true |
| ! |
NOT(非) |
!true |
false |
| && |
AND(短路) |
false&&true |
false |
| || |
OR(短路) |
false||true |
true |
&：只要两边的boolean表达式结果，有一个为false，那么结果就是false。只有两边都为true，结果为true。
|：两边只要有一个为true，结果为true；只有两边都为false，结果为false。
^：两边相同结果是false，两边不同结果是true。
&和&&的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
演示事例：
第一题
int x = 1,y = 1;
if(x++==2 & ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);
结果为：x = 2,y = 2
---------------------------------------------------
第二题
int x = 1,y = 1;
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);
结果为：x = 2,y = 1
---------------------------------------------------
第三题
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);
结果为：x = 7,y = 2
---------------------------------------------------
第四题
int x = 1,y = 1;
if(x++==1 || ++y==1)
{
x =7;
}
System.out.println("x="+x+",y="+y);
结果为：x = 7,y = 1
5、位运算符:操作的是二进制位
| 运算符 |
运算 |
范例 |
结果 |
细节 |
| << |
左移 |
6<<2 |
24 |
空位补0，被移除的高位丢弃，空缺位补0。 |
| >> |
右移 |
6>>1 |
3 |
被移位的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。 |
| >>> |
无符号右移 |
6>>>1 |
3 |
被移位二进制最高位无论是0或者是1，空缺位都用0补。 |
| & |
与运算 |
6&3 |
2 |
任何二进制位和0进行&运算，结果是0； 和1进行&运算结果是原值。 |
| | |
或运算 |
6|3 |
7 |
任何二进制位和0进行 | 运算，结果是原值； 和1进行 | 运算结果是1。 |
| ^ |
异或运算 |
6^3 |
5 |
任何相同二进制位进行 ^ 运算，结果是0； 不相同二进制位 ^ 运算结果是1。 |
| ~ |
按位取反 |
~6 |
-7 |
对二进制进行取反。 |
异或： ^；任何相同二进制位进行 ^运算，结果是0；1^1=0 , 0^0=0。
不相同二进制位 ^运算结果是1。1^0=1 , 0^1=1。一个数位^另外一个数两次,其值不发生改变
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
逻辑运算符用于连接布尔型表达式，在Java中
不可以写成3
0000 0011
& 0000 0100
----------------
0000 0000
0000 0011
| 0000 0100
---------------
0000 0111
0000 0011
^ 0000 0100
---------------
0000 0111
& :有0则0(类似 false)
| :有1则1(类似 true)
^ :相同为0,不同为1
演示事例：
实现两个整数变量的交换:
int a =10;
int b =20;
int c;
c = a;
a = b;
b = c;
--------------------------------------
a = a ^ b; // a 30
b = a ^ b; // b 30^20 (a ^ b) ^b
a = a ^ b; // a 30^10 a ^ (a ^ b)
位移 :二进制位
<< 左移 : 移动一位,就是扩大2倍,右边空的位置补0
>> 右移 : 移动一位,就是缩小2倍,左边的位置,最高位为0,补0;最高位为1,补1
>>> 无符号右移 :移动一位,左边无论是什么,都补0
0000 1000
00 100000
10000000 00000000 00000000 00001000
>>> 0010000000 00000000 00000000 000010
6、 三元运算符
格式：
(条件表达式)?表达式1：表达式2；
a)如果条件为true，运算后的结果是表达式1；
b)如果条件为false，运算后的结果是表达式2；
示例：
获取两个数中大数。
int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数。
获取三个整数中的最大值
max = (x>((y>z)?y:z))?x:((y>z)?y:z);
运算符的优先级：
运算符优先级表
| 优先级 |
运算符 |
结合性 |
| 1 |
() [] . |
从左到右 |
| 2 |
! +(正) -(负) ~ ++ -- |
从右向左 |
| 3 |
* / % |
从左向右 |
| 4 |
+(加) -(减) |
从左向右 |
| 5 |
<< >> >>> |
从左向右 |
| 6 |
< <= > >= instanceof |
从左向右 |
| 7 |
== != |
从左向右 |
| 8 |
&(按位与) |
从左向右 |
| 9 |
^ |
从左向右 |
| 10 |
| |
从左向右 |
| 11 |
&& |
从左向右 |
| 12 |
|| |
从左向右 |
| 13 |
?: |
从右向左 |
| 14 |
= += -= *= /= %= &= |= ^= ~= <<= >>= >>>= |
从右向左 |
八、键盘录入
键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，我准备把数据改进为键盘录入，提高程序的灵活性。
三步步骤
1. 导包 import java.util.Scanner;
2. 创建对象 Scanner sc = new Scanner(System.in);
3. 接收数据 sc.nextInt(); sc.nextLine();
4. 在控制台输入,方便我们运行程序
案例演示
键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
import java.util.Scanner;
class ScannerTest1{
public static void main(String[] args){
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字,我会计算两个数的和");
//接收数据
System.out.println("请输入第一个数字...");
int a = sc.nextInt();
System.out.println("请输入第二个数字...");
int b = sc.nextInt();
//求和
int result = a+b;
//输出
System.out.println("您输出数字我算出来了,结果为:" + result);
}
}
九、转义字符
概念：通过 \ 来转变后面字母或符号的含义。
常用转义字符：
\b：退格
\n：换行
\t：制表符，相当于tab键
\r：回车
\\：表示反斜杠
\'：表示单引号
\"：表示双引号
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------