一、关键字和保留字
1.1关键字
定义：被Java 语言赋予了特殊含义，用做专门用途的字符串
特点：关键字中所有字母都为小写
用于定义数据类型的关键字 ：class、interface、 enum 、byte 、short 、int 、long、 float、 double、 char 、boolean、 void
用于定义流程控制的关键字 ：if 、else 、switch、 case、 default、 while 、do、 for 、break、 continue 、return
用于定义访问权限修饰符的关键字 ： private、 protected、 public
用于定义类，函数，变量修饰符的关键字 ：abstract 、final 、static 、synchronized
用于定义类与类之间关系的关键字 ： extends、 implements
用于定义建立实例及引用实例，判断实例的关键字 ：new 、this、 super、 instanceof
用于异常处理的关键字 ：try 、catch 、finally、 throw、 throws
用于包的关键字 ：package 、import
其他修饰符关键字 ：native 、strictfp、 transient 、volatile、 asser
用于定义数据类型值的字面值 ：true、 false、 null
1.2保留字
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使 用。自己命名标识符时要避免使用这些保留字 包含如下2个：goto 、const
二、标识符
2.1定义合法标识符的规则
- 标识符就是名称的意思，所有的名字都统称为标识符
- Java 中经常要定义类、方法、变量等，在定义的时候需要给它们取名字，这些名字就是标识符
- 只有字母（区分大小写），下划线 (_)，美元符号 ($) 和数字组成，长度不受限制
- 第一个字母不能是数字,不能用数字开头
- 不能是关键字
- 不能是 true、false、null (尽管三个都不是关键字，而是常量标识)
2.2命名规范
- 包名：多单词组成时所有字母都小写： xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写： XxxYyyZzz、StudentBoy
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个 单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ 注意：见名知意 驼峰命名法 尽量不要用拼音
- 使用驼峰命名法： **小驼峰 **一般用于变量名，方法名 。首字母小写，之后的每一个单词首字母大写，譬如：bookName； **大驼峰 **一般用于类名，接口名 。所有单词首字母大写 譬如：HelloWorld
//包名：多单词组成时所有字母都小写
package com.cctv.user;
//类名大驼峰
public class Test1 {
//常量名：所有字母都大写,每个单词用下划线连接
int MY_AGE = 0;
//方法名小驼峰
public static void main(String[] args) {
//变量名小驼峰
int zhangSan;
}
}
三、变量
3.1变量概述
变量：在程序中可以变化的量称为变量，譬如：
int clothesPrice ;
clothesPrice = 89;
Java中要求一个变量每次只能保存一个数据，并且要明确变量的数据类型。
3.2java语言中数据类型
数据类型分为2大类：
- 基本数据类型
- 引用数据类型
String str = "abc";
我们都知道java有8种基本数据类型，随着后续学习，我们还将学习引用数据类型。此时我们要了解其中一个最常用的引用数据类型-字符串（String），字符串变量的一种定义方式与基本数据类型一致：
// 数据类型 变量名 = 初始化值；
String str = "中国";
System.out.println(str);
// 其中String为数据类型，str为变量名（符合标识符规则即可），"中国"是我们学习的字符串常量值。
- 基本数据类型（4类8种）
- 布尔类型：
boolean，占1个字节，数值只有2个：true，false
- 字符类型：
char，2个字节(16bit)
- 整数类型：
byte，字节型。1字节(8bit)
short，短整型。2字节(16bit)
int，整型。(默认类型)。4字节(32bit)
long，长整型。加L或l。8个字节(64bit)
- 浮点类型(小数)：
float，单精度。加f或F。4个字节(32bit)
double，双精度。(默认类型)。8个字节(64bit)
- 基本数据类型是Java 语言中内置的类型。
- 布尔类型、字符类型、整数类型、浮点类型这四类是最基础的类型
【注】：
char 里面只能放一个字符。
long类型：建议数据后加L表示。
float类型：建议数据后加F表示。 
什么是字节
字节是计算机中最小存储单元，计算机存储任何的数据，都是以字节的形式存储。8个bit（二进制位） 0000-0000表示为1个字节，字节单位：byte 或者 B
1 B = 8 bit
1 KB = 1024 B
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
3.3变量定义
变量：计算机内存中的一块存储空间，是存储数据的基本单元。
变量包括三个要素：数据类型、变量名、数据值。 数据类型 变量名= 数据值
public class Test2 {
public static void main(String[] args) {
/*
变量定义例子
变量包括三个要素： 数据类型 、 变量名 、 数据值 。
*/
boolean isMan = false;
char c = 'a';//存数据
byte b = 1;
short s = 100;
int i = 200;//(默认类型)
long l = 1000L;
float f = 1.2F;
double d = 5.6;//双精度。(默认类型)
System.out.println(isMan);
System.out.println(c);//取数据
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println("-------------------");
int aaa;
aaa = 1000;
System.out.println(aaa);
}
}
【注】：
Java中每个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的作用域：在一对{ }内，变量只有在其作用域内才有效
同一个作用域内，不能定义重名的变量
联合输出字符串和变量：
public class Test3 {
public static void main(String[] args) {
/*
变量定义例子
变量包括三个要素： 数据类型 、 变量名 、 数据值 。
*/
boolean isMan = false;
char c = 'a';//存数据
byte b = 1;
short s = 100;
int i = 200;//(默认类型)
long l = 1000L;
float f = 1.2F;
double d = 5.6;//双精度。(默认类型)
System.out.println("是不是男人："+isMan);
System.out.println("char的值是："+c);//取数据
System.out.println("byte的值是："+b);
System.out.println("short的值是："+s);
System.out.println("int的值是："+i);
System.out.println("long的值是："+l);
System.out.println("float的值是："+f);
System.out.println("double的值是："+d);
}
}
什么是ASCII
ASCII(American Standard Code for Information Interchange)，美国标准信息交换码
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如 空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）
注意：128个符号（包括32个不能打印出来的控制符号）
ASCII的用途
主要用于定义字符的时候使用，如下：
public class Test4 {
public static void main(String[] args) {
//通过''描述为字符赋值
char c1 = 'A';
//通过十进制数65在字符集中对应的字符赋值
char c2 = 65;
System.out.println("ch1 = " + c1);
System.out.println("ch2 = " + c2);
}
}
转义字符
如某些字符（ “” ）不能直接输出，为了能够输出这些字符，必须使用转义字符
public class Test5 {
public static void main(String[] args) {
//输出"hello,world"
System.out.println("\"hello,world\"");
//输出'hello,world'
System.out.println("\'hello,world\'");
}
}
3.4基本数据类型的转换
Java允许程序员在一定程度上进行数据类型的转换。
8种基本数据类型中7种数值类型可以参加转换：byte，short，char，int，long，float，double（boolean不参加）。
- 显式转换
显式转换(也叫强制转换)：取值范围大的转为取值范围小的。
**语法：**小范围数据类型变量 = (小范围数据类型变量)大范围数据类型; int n = (int)6.7;
public class Test6 {
public static void main(String[] args) {
//强制转换
int n = (int)6.9;
System.out.println("n = " + n);
double d = 11.3;
//强制转换
int i = (int)d;
System.out.println("i = " + i);
}
}
- 隐式转换
隐式转换(也叫自动转换)：取值范围小的转为取值范围大的。
**语法：**大范围数据类型变量 = 小范围的数据类型（double d = 1）
数据范围从大到小： double >float>long>int>short>byte
public class Test7 {
public static void main(String[] args) {
//隐式转换
double price = 20;
//隐式转换
int i = 'c';
System.out.println("price = " + price);
System.out.println("i = " + i);
}
}
四、运算符
4.1算术运算符
+，-，*, / , %，++，– -
+：加
-：减
*：乘
/：取商
取余或者取模（%）
尤其注意：取模有个特点，就是 a % n ，那么结果一定是在 [0,n]之间 譬如： 1 % 1024 ，结果一定是在 [0,1024] 之间，这个特性一定要记住
public class Test8 {
public static void main(String[] args) {
int myInt1 = 10;
int myInt2 = 3;
/*
* java中的加减乘除
* */
int myInt3 = 10 + 1;
int myInt4 = 10 - 1;
int myInt5 = 10 * 2;
//这里就发生了隐式转换
int myInt6 = 10 / 3;
System.out.println("10 + 1 = " + myInt3);
System.out.println("10 - 1 = " + myInt4);
System.out.println("10 * 2 = " + myInt5);
System.out.println("10 / 3 = " + myInt6);
System.out.println("---------------------------");
int myInt7 = 5 % 1024;
System.out.println("5 % 1024 = " + myInt7);
int myInt8 = 10 % 2;
System.out.println("10 % 2 = " + myInt8);
}
}
10 + 1 = 11
10 - 1 = 9
10 * 2 = 20
10 / 3 = 3
---------------------------
5 % 1024 = 5
10 % 2 = 0
自增自减运算
-
自增1 譬如：i++和++i
-
变量在独立运算时， 前 ++ 和 后 ++ 没有区别
-
和其他变量放在一起， 前 ++ 和 后 ++ 就产生了不同
int a = i++，给i加1，**(先赋值，后加1) **
int b = ++i，给i加1，(先加1，再赋值)
- 自减1 譬如：i-–和–-i
i-–，给i减1，**(先赋值，后减1) **
–-i，给i减1，(先减1，再赋值)
public class Test9 {
public static void main(String[] args) {
int i = 5;
int myInt10 = i++; //先赋值，后加1
System.out.println("i++的结果：" + myInt10);
System.out.println("i的结果："+ i);
System.out.println("---------------------------");
int j = 5;
int myInt11 = ++j;//先加1，再赋值
System.out.println("++j的结果：" + myInt11);
System.out.println("j的结果："+ j);
System.out.println("---------------------------");
int a = 5;
int myInt12 = a--; //先赋值，后加1
System.out.println("a--的结果：" + myInt12);
System.out.println("a的结果："+ a);
System.out.println("---------------------------");
int b = 5;
int myInt13 = --b;//先加1，再赋值
System.out.println("--b的结果：" + myInt13);
System.out.println("b的结果："+ b);
}
}
i++的结果：5
i的结果：6
---------------------------
++j的结果：6
j的结果：6
---------------------------
a--的结果：5
a的结果：4
---------------------------
--b的结果：4
b的结果：4
4.2赋值运算符
赋值运算符： =右侧的数据，赋值给=左边的变量
赋值运算符变种： +=，-=，*=,/=,%=
+= 相当于 a = a + b;
譬如：
public class Test10 {
public static void main(String[] args) {
/*
* 赋值运算符
* */
//赋值运算符，相当于把右边的值赋值给左边的变量
int i = 2;
//赋值运算符变种：+= ，相当于i = i+2;
i += 2;
System.out.println(i);
//赋值运算符变种：-= ，相当于i = i-2;
i -= 2;
System.out.println(i);
//赋值运算符变种：*= ，相当于i = i*2;
i *= 2;
System.out.println(i);
//赋值运算符变种：/= ，相当于i = i/2;
i /=2 ;
System.out.println(i);
//赋值运算符变种：%= i ，相当于i%2;
i %=2;
System.out.println(i);
}
}
4.3关系运算符
用于比较两个数的关系，结果是boolean类型的，包括： >,< ,>=, <=, ==, !=
== 判断两个数是否相等，
- 和=的区别： = 赋值运算符 ；== 比较数值是否相等
!= 判断两个数是否不相等
public class Test11 {
//关系运算符
public static void main(String[] args) {
System.out.println(1 == 1);//true
System.out.println(1 == 2);//false
System.out.println(5 > 3);//true
System.out.println(6 < 8);//true
System.out.println(5 >= 5);//true
System.out.println(6 <= 3);//false
System.out.println(7 != 8);//true
}
}
4.4逻辑运算符（重点）
操作数是boolean类型，结果也是boolean类型
& 与操作 规则：操作数都是true，结果才是true，有一个是false就为false。 一假则假，全真才真
| 或操作 规则：操作数都是false，结果才是false，有一个是true，就是true 一真则真，全假才假
**&& 短路与 ** 规则：遇到一个false就直接返回结果为false，后面的不再参加计算了。
**|| 短路或 ** 规则：遇到一个true就直接返回结果为true，后面不再计算了
**! 取非，取反 ** 规则：true 取反就是 false， 反之 false 取反就是 true
例1：
/**
* 逻辑运算符：操作的是布尔值之间的运算
*/
public class Test12 {
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
boolean b3 = true;
boolean b4 = false;
boolean result1 = b1 & b2 & b3;//逻辑与运算，只有有一个false,那么就返回false
System.out.println("result1 = "+ result1);
boolean result2 = b1 | b2; //逻辑或运算 ，只有一个true ,就返回true;
System.out.println("result2 = " + result2);
boolean result3 = b2 | b4; //两个都是false,才返回false;
System.out.println("result3 = " + result3);
boolean result4 = b2 && b3; ///短路&&，遇到一个false,就返回false,后面的不再执行
System.out.println("result4 = " + result4);
boolean result5 = b1 || b2; //短路||，遇到一个true,就返回true,后面的不再执行
System.out.println("result5 = " + result5);
boolean result6 = !(b1 & b2 & b3);
System.out.println("result6 = "+ result6);
}
}
例2：
/**
* 逻辑运算符
* */
public class Test13 {
public static void main(String[] args) {
int salary = 800;
//订金
int deposit = 4000;
System.out.println(salary > 1000 & deposit > 5000); //&：与操作
System.out.println(salary > 1000 | deposit > 5000); //|：或操作
System.out.println(salary > 1000 && deposit > 5000); // 短路与
System.out.println(salary > 1000 || deposit > 5000); //短路或
System.out.println(!(salary > 1000)); //取反
}
}
五、程序流程控制
程序的流程结构：顺序结构，选择结构，循环结构
5.1选择结构
选择结构通过分支语句实现：if，switch
- if语句
简单if语句语法： if (条件){ 执行语句 }
/**
* if(布尔表达式)
* {
* 如果布尔表达式为 true 将执行的语句
* }
*/
public class TestIf {
public static void main(String[] args) {
int source = 20;
if(source >= 60){
System.out.println("小明成绩及格");
}
if(true){
System.out.println("我是布尔运算符");
}
if(false){
System.out.println("这里会不会执行");
}
}
}
- if else语句
if (条件){ 执行语句1 }else{ 执行语句2 }
/**
* if.....else.....结构
* if(布尔表达式){
* 如果布尔表达式为 true 将执行的语句
* }else{
* 如果布尔表达式为 false 将执行这里的语句
* }
*/
public class TestIfElse {
public static void main(String[] args) {
int source = 50;
if( source >= 60 ){
System.out.println("考试及格了");
}else {
System.out.println("考试考砸了");
}
}
}
- 使用逻辑运算符进行判断,一般实际工作当中我们使用的是 短路与 && 不会使用 &
/**
* 使用逻辑运算符进行判断
* 一般实际工作当中我们使用的是 短路与 && 不会使用 &
*/
public class TestIfElse2 {
public static void main(String[] args) {
int ywSource = 60;
int sxSource = 70;
if(ywSource >=60 && sxSource >= 80){
System.out.println("小明真优秀");
}else{
System.out.println("小明真一般");
}
}
}
- if的嵌套
if (条件1){ 执行语句1 }else if(条件2){ 执行语句2 }else …
public class TestIfElseIf {
public static void main(String[] args) {
int source = 52;
if (source > 90) {
System.out.println("小明真优秀");
} else if (source > 80) {
System.out.println("小明还不错");
} else if (source > 60) {
System.out.println("小明考试及格了");
} else {
System.out.println("小明真差劲");
}
}
}
- switch语句
同样也可以实现选择结构
语法： switch( 变量 ){ case 常量值1: 分支1; break; case 常量值2: 分支2; break; … default: }
注意事项：
- 变量必须是 int类型，byte，short，int,char，String，枚举 之一
- case后的数值必须唯一
- case可以无序
- break用于防止switch的穿透
- default是可选的语句
public class TestSwitch {
public static void main(String[] args) {
int source = 50;
switch (source) {
case 80:
System.out.println("小明真普通");
break; // 可选
case 90:
System.out.println("小明真优秀");
break; // 可选
// 你可以有任意数量的 case 语句
case 70:
System.out.println("小明考试及格了");
break; // 可选
default:
System.out.println("小明真差劲");
}
// if(source == 90){
// System.out.println("小明真优秀");
// }else if(source == 80){
// System.out.println("小明真普通");
// }else if(source == 70 ){
// System.out.println("小明考试及格了");
// }else {
// System.out.println("小明真差劲");
// }
}
}
5.2三元运算符
数据类型 变量名称 = 条件判断 ? 表达式A ： 表达式B； 你有钱吗 ? 买汽车 : 买单车
流程： 首先判断条件是否成立； 如果成立为true，那么将表达式A的值赋值给左边的变量； 如果不成立为false，那么将表达式B的值赋值给左边的变量。 二者选其一。
public class TestTernaryOperator {
public static void main(String[] args) {
int result = 3 > 4 ? 3 : 4;
System.out.println("result = " + result);
int money = 100;
String str = money > 100 ? "买汽车" : "买单车";
System.out.println("str = " + str);
if (money > 100) {
System.out.println("买汽车");
} else {
System.out.println("买单车");
}
}
}
5.3循环结构
条件结构：条件满足，代码才会被执行。 执行次数：0,1。
循环结构：条件满足，代码会被反复的多次执行，直到条件不满足。 执行次数：0，1，多次 譬如：要在屏幕打印100次HelloWorld，这时必须使用循环结构
- for循环
语法： for (初始化表达式; 循环条件; 操作表达式) {执行语句; … }
普通for循环
public class TestFor {
public static void main(String[] args) {
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
/**
* for满足循环的条件就反复执行 一旦条件不满足就推出循环
* */
for (int i = 0; i < 10; i++) {
System.out.println("Hello World");
}
}
}
- for循环语句和条件分支语句的结合（打印出1-100之内的偶数）
public class TestFor2 {
public static void main(String[] args) {
//打印出1-100之内的偶数
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
- For循环的嵌套（嵌套For循环最多2层） 嵌套For循环打印出图案
public class TestFor3 {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
for (int j = 0; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
- while循环
语法： while(循环条件){ 循环体； } 先判断循环条件，如果满足，就执行里面的循环体；然后再来判断条件是否依然成立，如果成立继续执行，否则结束循环。
public class TestWhile {
public static void main(String[] args) {
int i = 0;
while (i < 10) {
System.out.println("Hello World");
i++; //没有这个条件就是死循环
}
}
}
- While循环和条件判决的结合
/**
* 使用while循环打印出1-100之内的偶数
* */
public class TestWhile2 {
public static void main(String[] args) {
int i = 0;
while (i < 100) {
if (i % 2 == 0) {
System.out.println(i);
}
i++;
}
}
}
- do-while循环
do{
循环体； }while(条件);
先执行循环体，然后判断条件，如果满足，再执行循环体，再判断条件，如果不满足就结束了循环。
注意：do-while循环至少执行1次。 while：先判断，再执行； do-while：先执行，再判断
public class TestDoWhile {
public static void main(String[] args) {
int i = 200;
do {
System.out.println("Hello World");
i++;
} while (i < 10);
}
}
- Break（强制手动退出循环）
用法1：在switch中，用于防止穿透。
用法2：在循环中：for，while，do-while，用于强制结束循环。终止。 break示例
public class TestBreak {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("Hello World");
if (i == 2) {
break;
}
}
}
}
continue：词意：继续 只是结束某一次循环，循环下次继续的。跳过本次循环
public class TestContinue {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
//单 i==2 跳过本次循环
if (i == 2) {
continue;
}
System.out.println("Hello world");
}
}
}
六、java中Scanner的用法
- 先导⼊Java.util.Scanner包
- 创建Scanner类的对象
- 创建⼀个变量来接收数据
import java.util.Scanner;
/**
* 1. 先导⼊Java.util.Scanner包
* 2. 创建Scanner类的对象
* 3. 创建⼀个变量来接收数据
*/
public class Test01 {
public static void main(String[] args) {
//从键盘接收数据
Scanner sc=new Scanner(System.in);
System.out.println("请输⼊⼀个数字");
int i = sc.nextInt();//需要输⼊⼀个整数
System.out.println("输⼊的数字：" + i);
System.out.println("请输⼊⼀个⼩数");
double v = sc.nextDouble();//需要输⼊⼀个⼩数
System.out.println("输⼊的⼩数：" + v);
System.out.println("请输⼊⼀个字符串");
String next = sc.next();
System.out.println("输⼊的字符串：" + next);
}
}
扫一扫
7601
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
