目录
学习内容：
一、关键字
1、定义：
在Java程序中，已经定义好的被预先使用的一些特殊的单词称为关键字 ，一共有50个关键字 (48+2个保留字) ，关键字都是小写的英文单词
2、关键字的分类
- 数据类型关键字
byte ：字节类型， short ： 短整型， int ： 整型， long： 长整型， float ：单精度浮点型
double：双精度浮点型， char： 字符型， boolean ： 布尔类型， void ：空类型， null ：空对象
- 流程控制关键字
if： 条件分支判断， else：条件分支， switch： 条件分支判断， case ： 条件分支其中一种情况
default ： 默认， break： 退出条件 或 循环， continue ： 退出当前循环，继续下一次循环
for ： 循环， do： 循环， while ： 循环， return：方法的返回
- 面向对象关键字
class：定义类， interface ： 定义接口， extends：继承一个类， implements： 实现一个接口
super ： 超级 （用于调用父类的成员）， this： 当前类， instanceof ： 判断一个类的类型
import ： 导入一个类， package ： 定义一个类所在的包， new ： 创建对象
- 修饰符关键字
abstract ：修饰抽象类 、抽象方法， final ： 修饰常量， native： 本地的 ，也用于修饰变量
private ：私有的， protected ： 受保护的， public ： 公共的， static ：静态的
synchronized ：修饰方法或代码块，用于线程安全的， transient ：瞬时状态， volatile ：瞬时状态
- 异常关键字
try：试一试， catch： 捕获异常， finally： 最后执行的代码块 （ 多出的一个）
throws ：定义需要抛出的异常， throw：抛出异常
- 其他关键字
assert ：测试中的断言， strictfp ： 其他， enum：定义枚举
- 保留字
const ， goto
二、标识符
1、定义
在Java程序中，所有由程序员自己命名的元素统称为“标识符”
2、标识符命名规则
-
标识符由数字、字母、下划线和$组成
-
标识符不能以数字开头
-
标识符区分大小写
- 标识符不能是关键字
注意事项：
定义类名的标识符 ：首字母必须大写 ，后面的单词的首字母大写，准寻 大驼峰命名法 （例如 XxxXxx ，UserInfo ，Student）
定义方法 标识符： 首字母尽量小写 ，后面的单词首字母大写，准寻 小驼峰命名法（例如 xxxXxxx ， getUserName() ）
定义变量标识符： 单词全部小写 ( username)
定义包名： 按模板分层级， 使用公司的域名 倒写，（例如 com.softeem.xxx 、com.j2008.xxx）
定义项目名： 尽量使用英文 （Java项目 可以使用中文，JavaWeb项目一定使用英文）
三、常量
1、定义
在Java中，固定不变的数据量称为常量，常量也有内存，常量存放在被称为“常量池”的内存中
常量的修饰符 ： final
final int n = 100 ； // 定义常量的语法 ，n的值只能为 100，不能再次改变 ，其中n就是常量2、常量的分类
整数常量， 小数常量， 字符常量， 字符串常量， 布尔常量， 空常量
四、变量
1、定义
在Java中用于保存一个数据的最小内存单元 称为 “变量” ，变量中每次只能存放一个值 ，变量的数值是可以被改变的 。
在定义变量时，需要明确三要素： 数据类型 、 变量名（标识符）、变量值
2、变量语法：
数据类型 变量名 = 初始值；
或者 数据类型 变量名1 ，变量名2 ；
// 定义一个变量 变量名是n ，数据类型是int ，初始值为100
int n = 100 ；
// 将原有变量名n中的值变更为 110
n=110;3、变量的分类
- 全局变量（global variables）
在Java的类结构中，定义在类中，方法外面的变量， 它的作用范围： 整个类的方法中
public class Test1 {
//定义全局变量 ：定义在类里面，方法的外面
int n = 100;
//定义方法
public void m(){
// 输出一句话 "" 表示输出的内容 + 表示连接两个字符串
System.out.println("n："+n);
}
//定义方法
public void s(){
System.out.println("n:>>>"+n);
}
}- 局部变量（local varibable）
一般声明在方法或代码块（条件语句块，循环语句块，静态语句块等） 中，它的作用范围只能在声明的区域中使用
// 定义run方法
public void run(){
// 局部变量 只能在声明所在的方法中使用
int n=200;
int i =1;
// 当类总存在局部变量和 全局变量同名时， 变量的使用遵循“就近原则”
System.out.println("局部变量n："+ n); // 200
}
// 定义eat方法
public void eat(){
// System.out.println("i---"+i);
}
- 调用方法的语法
public static void main(String [] args){
// 如何调用 这个类的方法呢？ 需要创建对象
// 创建对象的语法： 类名 对象名 = new 类名();
//调用对象的方法语法： 对象名.方法名();
Test1 obj = new Test1();
obj.m();
obj.s();
obj.run();
obj.eat();
}五、数据类型
1、定义
Java是一门强类型的编程语言，它不同于一些弱类型的语言（JavaScript ，php，python），Java在声明变量时必须显示的定义变量的数据类型，变量的类型一旦定义，则不能改变 。 Java中数据类型分为两大类
1、基本数据类型 ： 包括 整数，浮点，字符，布尔类型等
2、引用数据类型 ：包括 类，数组，集合，接口等
2、引用数据类型与基本数据类型的区别
1、创建方式不同 ，基本数据类直接通过定义变量的方式创建， 而引用数据类型需要new一个对象
2、在JVM的内存分配不同， 基本数据类型的内存在栈内存中直接创建 ， 而引用数据类型是在栈内存中定义引用的地址，实际的内存分布在堆内存中
3、引用数据类型 可以调用它的方法， 而基本数据类型没有方法
六、数据类型的转换
1、为什么需要进行数据类型转换
在Java中数据进行计算时 ，必须要求计算的元素的数据类型一致，如果数据类型不一致需要进行转换
2、数据转换分类
-
自动类型转换
转换规则： 范围小的类型向范围大的类型转换（从小到大转换）
byte -> short -> int-> long -> float -> double 其中boolean类型不参与转换
char ->int
转换原理： 类型向上提升
-
强制类型转换
- 整数之间的强转
// int 类型
int i=1;
// byte 类型
byte j=100;
// 由于i和j 不同类型，不能直接计算，程序会自动将j的类型向上提升为 int
// 所以i +j 之后依然是 int 类型
// 此时 int 的内存 大于 byte 的内存，会出现数据溢出的情况 ，JVM不允许
// byte s = i + j ; // 等号两遍类型不匹配
int y = i + j ;
System.out.println(y);
// 如果一定要使用byte赋值，还有一种办法，就是将两遍类型一致
byte s = (byte)(i + j) ; // 两个数在相加时 会先自动提升为int 然后再相加
- 整数与小数之间的强转
// 整数和小数之前 也会丢失精度
int n2 = 100;
double n3 = 3.5;
int n4 = (int)(n2 + n3);
// 相加时先提升为 double ，然后相加后得到 double
// double是8个字节 不能放在4个字节的长度中，
// （这里好比double 为一桶水， int为一杯水，相当于将一桶水往一杯水中放）
// 只能留住一本水的内容，所以 这里 如果强转成int 则小数会丢失，
System.out.println(n4);- 小数和小数之间的强转
// float 与 double 类型
float f1 = 3.14f;
double d2 = 3.5;
double dd = f1+d2;
float ff = (float)(f1 + d2);- 丢失精度的情况
// 强转时会丢失精度
byte n=100;
int m = 30;
byte mm = (byte)( n + m); // 因为最大值为127 再往后就是从最小值开始-128
System.out.println(mm);
// 整数和小数之间 也会丢失精度
int n2 = 100;
double n3 = 3.5;
int n4 = (int)(n2 + n3);
七、运算符
1、定义
在Java中用于程序计算的操作符统称为运算符
2、运算符分类
- 算术运算符
public static void main(String [] args){
// + - * / % 所有运算符在计算式必须保证 数据类型一致
int num1 = 100;
int num2 = 200;
int sum = num1 + num2;
int mul = num1-num2;
int num3 = -num2; // -200
System.out.println("两个数相加" + sum); // + 表示连接符
System.out.println("两个数相减" + mul);
System.out.println( "num2: " + num2+ " ,num3:" + num3 );
System.out.println("num1+num2="+ (num1+num2) );
int sum2 = num1*num2;
int sum3 = num1/num3;
System.out.println(sum3); // 控制台输出的快捷键 sout+ enter
// System.out.println(num1/sum3); //算术异常：ArithmeticException: / by zero
// 取模
System.out.println( 10%2);//0
System.out.println(1%5);// 1
System.out.println(2%5);
}public static void main(String[] args) {
// 自加 自减 ++ -- 只能对整数进行
int i=1;
i++ ; // i = i + 1
System.out.println("i:" + i);
int j=1;
++j; // j = j + 1
System.out.println("j:" + j);
int a =1;
int sum = a++; // 先将a的值赋值给sum ，a再自加1
int sum2 = ++a; // 先将a自加1 ，再将自加后的结果赋值给sum2
System.out.println("sum:" + sum);
System.out.println("sum2:" + sum2 );
System.out.println("a:" +a); // 3
int sum3 = a++ + a++ ;
System.out.println("sum3:"+sum3);
System.out.println("a:"+a);
// -- 操作 与++操作类似
int b=1;
int s1= b--; // b = b -1 s1 的值为 先赋值再自减1 s1 = 1
int s2 = --b; // b = b -1 s2 的值为 先自减1 ，再赋值 s2 = -1
System.out.println("b:"+b);
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
// ++ -- 综合
int x=1;
int y=2;
int s3 = x++ + --x * (y-- + ++x);
System.out.println("x:"+x);// 2
System.out.println("y："+y);// 1
System.out.println("s3:"+s3);// 5
}- 比较运算符
用于比较两个表达式之间的 结果 ， 结果返回true 、false
比较运算符不能单独作为 一行代码运行 ，必须接收结果或者输出
public static void main(String[] args) {
// 比较运算符
int a =1;
int b =2;
// a>b; // 不能单独比较 必须接受结果或输出
System.out.println(a>b); //false
System.out.println(a<b); //true
System.out.println(a==b); //false
System.out.println(a!=b); //true
// 增加逻辑判断
// 如果 if 后面的条件成立， 则执行if里面的语句 ，如果不成立 则只需else语句
if(a>b){
System.out.println("a>b成立");
}else{
System.out.println("不成立");
}
}- 赋值运算符
将表达式 的结果 赋值给一个变量，只能赋值给变量 不能赋值给常量
例如： a = 3
// 赋值运算符 = += -= *= /= %=
int a=2;
a+=2;
System.out.println(a);// 4
a-=3;
System.out.println(a);// 1
a*=2;
System.out.println(a); // 2
a/=4;
System.out.println(a);// 0
a+=a-=3; // a+=（a-=3） -》 a=a +(a=a-3 )
System.out.println("a="+a);
int x=2;
x+=x-=x*=x++;
//x = x +(x = x -( x= x *(x++) ))
// x = 2 + （ x = 2 - （x = 2 * 2））
// x = 2 + ( 2 - 4)
// x = 0
System.out.println("x="+x);
//赋值运算符的优先级最低， 从右往左计算
int y=2;
y*=y+=y; // 也是从右往左计算
// y = y * (y = y + y);
// y = 2 * (2+2)
// y =8;
System.out.println("y="+y);- 逻辑运算符
在Java中用于两个或两个以上的表达式 取逻辑判断的结果 ，通常需要使用逻辑运算符
// 逻辑运算符
System.out.println(true & true); // true
System.out.println(true & false);// false
System.out.println(false & true); // false
System.out.println(false & false);// false
// true&true
System.out.println(1>0 & 3>1);
System.out.println(1>0 && 3>1);
// | 或
System.out.println(true | true); //true
System.out.println(true | false);// true
System.out.println(false | true); // true
System.out.println(false | false);// false
// || 短路或
System.out.println(true || false) ;// true总结： &与&&的区别 |与||的区别？
回答 ：
1、& 对于符号两边的表达式都会执行 && 符号左边为false，则右边不执行
| 对于符号两边的表达式都会执行， || 符号左边为true，则右边不执行
2、 & 、| 两边可以直接写数字， 按位计算 ，短路符号 不能直接运算数字
int a=1;
int b=2;
// System.out.println(a>b && b++>0); // 符号右边的不运算
// System.out.println("b:"+b);
System.out.println(a>b & b++>0); // 符号两边都运行
System.out.println("b:"+b);
// || 与 | 的区别
// System.out.println(a>=1 || a++<0); // a++ 不执行
// System.out.println("a:"+a);
System.out.println(a>=1 | a++<0 ); // a++ 会执行
System.out.println("再次输出a ：" + a);- 位运算符
//正整数的移位 << >> >>>
System.out.println(3<<2); // 12
System.out.println(7<<3); // 7*8=56
// 对于正数的无符号右移和 右移 结果一样
System.out.println(16>>2);// 4
System.out.println(18>>2);// 4
System.out.println(5^9);//12
System.out.println(3>>2);
System.out.println(3>>>2);
System.out.println(~5);
// 负数的移位
// 负数的左移位还是为负数
System.out.println(-4<<2); // -4*2的2次方 =
/**
* -4的原码： 1 0000... 00000100
* * -4的反码： 1 1111... 11111011
* * -4的补码： 1 1111... 11111100
* * 开始移位 2
* 1 1111... 11110000
* 最后结果 = 取反+1
* 1 0000... 00001111 + 1
* ：
* 1 0000... 00010000 =-16
*/
// 补码 = 反码+1
//负数是对于补码 进行移位 -4/2 =-2
System.out.println(-4>>1);
// -16无符号右移2位
System.out.println(-16>>>2); //1073741820
// -16 的补码算出来
/**
* 原码 10000.. 0010000
* 反码 11111.. 1101111
* 补码 11111.. 1110000
* 00111.. 1111100 由于不考虑符号，移动后高位全部补0 变成正数
* 正数原码和补码一致 这个数即为所得
* 1073741820
*/- 三目运算符
表达式 ? 结果1 ： 结果2
当？前面成立时， 整个表达式输出 结果1 ，如果？前面不成立，则输出结果2
// 生成100以内的随机数
int n = (int)(Math.random()*100);
System.out.println("n:"+n);
System.out.println( n%2==0 ?"这个数是偶数":"这个数是奇数");八、条件判断
1、if条件分支
语法：
if(条件){
语句块
}
其他代码解释： 如果条件成立 ，则执行语句块 ，如果条件不成立，则不执行语句块
// 生成一个100以内的随机数 判断它是否为偶数
int n = (int)( Math.random()*100);
if(n%2 == 0){
System.out.println("这是数是偶数");
}
System.out.println("程序结束");2、if...else条件分支
语法：
if(条件){
语句块1
}else{
语句块2
}解释： 如果条件成立， 则执行语句块1 ，如果条件不能力 ，则执行语句块2
int n = (int)(Math.random()*100);
// n<50 需要买西瓜 >50 需要买葡萄
if(n<50){
System.out.println("买了一个大西瓜");
}else{
System.out.println("买了一串葡萄");
}
System.out.println("n->"+n);
System.out.println(" 嗯，程序猿的女朋友很高兴，至少买了水果");3、if...else if ... else 多条件分支
语法：
if(条件1){
语句块1
}else if（条件2）{
语句块2
}else if(条件3){
语句块3
}
...
else{
语句块4
}解释： 从条件1开始依次判断，如果条件1 成立，则执行语句块1 ，其他条件不再执行，如果条件2成立，则执行语句块2，其他条件不再执行。。。 依次类推如果条件都不成立，则执行else语句块。 ，最终只执行其中某一个语句块，
// 随机生成90以内的年龄 整数
int n = (int)(Math.random()*90);
if(n<18){
System.out.println("未成年");
}else if( n<30){
System.out.println("青年");
}else if( n<50){
System.out.println("中年");
}else if( n<70){
System.out.println("老年");
}else{
System.out.println("晚年");
}
System.out.println("n->"+n); 4、嵌套条件判断
语法： 以上3种格式 ，可以同时使用，在一个if语句再次嵌套if 语句
// 接收控制台输入 ， 判断 输入的数 是否能被3整除
// 如果能被3整除，输出这个数除以3的结果，并判断结果能被7整除
// 如果不能被3整除，判断是否为偶数
Scanner sc = new Scanner(System.in);
// 接收控制台输入的整数
int n = sc.nextInt();
if(n%3 == 0 ){
System.out.println("这个数能被3整除");
// 在if语句中继续判断， 就是嵌套条件判断 ，需要往后缩进
int result= n/3;
if(result%7 == 0){
System.out.println("这个结果能被7整除");
}else{
System.out.println("这个结果不能被7整除");
}
}else{
System.out.println("这个数不能被3整除");
if(n%2 ==0){
System.out.println("这个数能2整除");
}else{
System.out.println("这个数不能被2整除");
}
}注意 : 嵌套条件时 为了增强代码的可读性，将条件语句块的分支 往后缩进 ，{}作为一个整体
条件语句块中如果只有一个输出语句， 可以省略{}，但是为了保证代码的可读性，不建议省略{}。
5、选择条件判断
语法:
switch（表达式）{
case 常量值1：
语句块1;
break; // 语句块接收的标记
case 常量值2:
语句块2；
break;
...
default:
语句块3；
break；
}注意: switch 的表达式判断 只能等值比较 ，其中case的常量值 类型位： 整数型（byte short int long ），字符型，字符串型，枚举型
byte n = (byte)(Math.random()*7+1);
switch (n){
case 1 :
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6 :
System.out.println("星期六");
break;
default :
System.out.println("星期天");
break;
}6、case穿透问题
在switch中，如果case后面不写break，将会出现穿透现象，也就是说不会执行下一个case的判断条件直接往后运行，直到遇到break，或整体switch结束
九、循环
1、循环定义
在Java程序中，重复的执行某一段代码 这个过程称之为循环， 为了避免出现死循环，循环分为四部分
1、初始条件
2、循环的判断条件 ，条件为true ，则进入循环体
3、循环体
4、迭代变量
2、while循环
语法：
初始条件
while(判断条件){
循环体
迭代部分 （为了改变循环的判断条件）
}//计算 1到100的累加之和
int sum=0;
int n=1;
while(n<=100){
sum+=n;
n++;
}
System.out.println("n:"+n);
System.out.println("sum:"+sum);3、do...while循环
语法：
初始值1
do{
循环体2
迭代部分3
}while(返回boolean类型的表达式4)；执行顺序： 123-》423 -》423-》423 .。。4 直到条件4为false 则退出循环。
先执行初始值 1，循环体2 ，迭代3
再判断条件4是否成立，成立，继续执行2，3
再判断条件4是否成立，成立，继续执行2，3
...
判断条件4是否成立，不成立，退出
int i=0;
do{
System.out.println("i--"+i);
i++;
}while(i<10);
System.out.println("i===="+i);
/**
* 第一遍： 输出 0 i=1
* 第二遍： 判断 1<10 成立 输出1 i=2
* 第三遍： 判断 2<10 成立 输出2 i=3
* .。。
* 第九遍： 判断8<10 成立 输出8 i=9
* 第十遍：判断 9<10 成立 输出9 i=10
* 第十一遍: 判断 10<10 不成立。退出
*
*
*/while循环与do while循环的区别?
while循环先判断条件是否成立，再执行循环体，do while循环 先执行一遍循环体再判断条件。
4、for循环
for循环的升级版就是 foreach循环
for循环通常在明确循环次数的情况下使用， 它也分为四部分
语法：
for(初始值1 ; 循环判断条件2 ; 迭代部分3 ){
循环体4
}
或者
初始值
for( ; 循环判断条件 ; ){
循环体
迭代部分
}
// 他们的区别是 初始值定义在for的外边，就可以在循环外边使用5、嵌套循环
嵌套循环： 在一个循环语句中，还包含了另一个循环。例如 在一个for循环中还有一个for循环 ，
它的总的循环次数 = 外循环的次数* 内循环的次数
语法：
for(){ // 外层循环
for(){ // 内层循环
}
}执行顺序： 外层循环 循环一次 ，内层循环循环完整的一遍
案例：
打印直角三角形
*
* *
* * *
* * * *
* * * * *
外循环控制打印几行， 内循环控制打印即可* 思路 : 考虑一行打多少个空格 多少个*
一共5 行 空格的个数（5-i） *的个数 （2 * i - 1）
i=1 4 1
i=2 3 3
i=3 2 5
i=4 1 7
i=5 0 9System.out.println("打印正三角形");
for(int i=1;i<=5;i++){
// 先打印空格
for(int k=0;k<5-i;k++){
System.out.print(" ");
}
// 再打印*
for(int j=0;j<2*i-1;j++){
System.out.print("* ");
}
// 换行
System.out.println();
}
十、数组
1、数组定义
它是相同数据类型的有序集合
2、 数组特点
-
数组的长度固定（数组的长度一旦声明，就不能改变）
-
数组中存储的元素数据类型必须相同
-
数组的元素 通过下标访问，且下标默认从0 开始
-
数组类型属于引用数据类型， 数组的元素类型 既可以是基本数据类型，也可以是引用数据类型。
3、创建数组
- 方式一
数组存储的数据类型 [] 数组名 = new 数组存储的数据类型[长度]；详解：
数组存储的数据类型 ：创建数组容器中可以存储什么数据类型 （基本数据类型 ，引用数据类型）
[] : 表示数组
数组名： 给数组起给名字，遵循标识符规则
new ： 创建数组的关键字
[长度] ： 数组的长度 ， 这个长度定义后不可改变
例如
int [] arr = new int[3];- 方式二
数据类型 [] 数组名 = new 数据类型[]{元素1，元素2，元素3...}这里的数组长度根据元素的个数自动分配大小
int [] arr = new int[]{90,88,78,92};
或者
int arr [] = new int[]{90,88,78,92}- 方式三
数据类型 [] 数组名 = {元素1，元素2，元素3...}；注意： 这里的元素类型必须满足 数组的元素数据类型
char [] arr = {'a','b','c'};
或者
char arr [] = {'a','b','c'};4、数组的访问
数组的访问通过索引访问
索引（下标）： 每一个数组的元素都有一个编号，这个编号从0开始 ， 这个编号称为数组的索引，通过数据名[索引] 访问到数组的原始
例如： 访问数组的第二个元素： 数组名[1]
数组的长度： 数组的长度 声明已固定 ，访问数组的长度 ： 数组名.length
数组的最大索引= 数组的长度 -1
数组元素的赋值 ：通过索引可以给元素赋值 数组名[索引] = 值
将数据 赋值给 指定索引的 元素
总结：
这周学的时Java基础，比较入门的知识，相对来说比较简单一点，就是有关循环的一些练习需要多做，要有一个好的逻辑思维。
扫一扫
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
