这篇博客详细介绍了JAVA基础代码的练习，包括关键字、标识符、注释、常量、进制、数据类型、运算符等内容。通过实例展示了各种概念的使用，如关键字的规则、标识符的命名规范、字符串和整数常量的输出、数据类型的转换、运算符（如算术、赋值、比较、逻辑、位运算）的用法。此外，还涵盖了位运算的原理和位移操作，以及三目运算符和流程控制语句（if、switch）。
基本代码练习
DAY 01
package HELLOWORD案例;
public class HelloWorld {
public static void main(String [] args){
System.out.println("HElloworld");
}
}
Day 02
1、关键字
package day_02;
public class KeyWordDemo {
/*
* 关键字： 被JAVA 语言赋予特定含义的单词
* 特点 ： 组成关键字单词的字母全部小写
* 注意：
* A：goto 与 const 是保留字
* B： 类似NOTEpad++这样的高级记事本针对关键字有特殊的颜色标记
*/
}
2、标识符
package day_02;
/*
* 标识符：就是给类，接口，方法，变量等起名字
* 组成规则：
* A、英文字母大小写
* B、数字字符
* C、&和_
* 注意事项：
* A:不能以数字开头
* B:不能是JAVA中的关键字
* C：JAVA语言严格区分大小写
* 常见的命名规则:
* 举例：我要定义一个学生类
* class Student{}
* class S{}
* 包：其实就是文件夹，用于把相同的类名进行区分
* 全部小写
* 单级： zhanghe
* 多级： cn.itcast
* 类或者接口：
* 一个单词：单词的首字母必须大写
* 多个单词：每个单词的首字母必须大写
* 方法或者变量:
* 一个单词：单词的首字母小写
* 多个单词：从第二个单词开始，每个单词的首字母大写
* 常量：
* 一个单词：全部大写
* 多个单词：每个单词都要大写，用_隔开
*/
public class MakeNameDemo {
public static void main(String [] args){
//正确做法
int X = 100;
//不能以数字开头
//int 1y =100;
int y1=100;
//不能是JAVA中的关键字
//int public = 100;
int Public = 100;
}
}
注释
注释的作用:
A：解释说明程序，提高程序的阅读性
B：可以帮助我们调试程序。
后面我们会讲解更高级的调试（Debug）
多行注释 /* */
单行注释 //
文档注释：被javadoc 工具解析生成一个说明书
常量
package day_02;
/*
* 常量:
* 在程序执行的过程中，其值不发生改变
* 分类：
* A：字面值常量
* B：自定义常量
*
* 字面值常量：
* A：字符串常量 用双引号括起来的内容 “HELLO”
* B：整数常量 所有整数
* 举例：100、200
* C：小数常量 所有小数
* 举例：10.23 110.11
* D：字符常量 用单引号括起来的内容
* 举例 ： 'a' 'B' '0'
* E:布尔常量
* 只有 TRUE FALSE
* F：空常量
* 举例：NULL
*/
public class ConstantDemo {
public static void main(String [] args){
//字符串常量的输出
System.out.println("hello");
//整数常量的输出
System.out.println(100);
//小数常量的输出
System.out.println(100.01);
//字符常量
System.out.println('a');
//这个是有问题的
//System.out.println('ab');
//布尔常量
System.out.println(true);
}
}
5、进制
package day_02;
/*
不同进制的数据表现:
二进制：由0，1组成。以0b开头 //MyEclipse中不用加0b 直接0100
八进制 0——7组成 以 0 开头
十进制0——9组成 默认整数是十进制
十六进制 0——f 组成。以0X开头
*/
public class JinZhiDemo {
public static void main(String [] args){
System.out.println(0x100);
System.out.println(0100);
System.out.println(00100);
}
}
6、原码反码补码
数据类型
/*
* 数据类型: java是一种强类型的语言，针对每一种数据都定义了明确的数据类型
* 数据类型的分类：
* A：基本数据类型
* a、整数 占用字节数
* byte 1
* short 2
* int 4
* long 8
* b、浮点数
* float 4
* double 8
* c、字符
* char 2
* d、布尔
* boolean 1
* 注意：
* 整数默认是 INT
* 浮点数默认是:double
* 长整型后缀用L或者l 标记
* 单精度浮点数用 F或者f 标记
* B：引用数据类型（类，接口，数值）
* 使用变量的时候需要注意的问题:
* A:作用域
* 变量定义在哪个大括号内就在哪个大括号内有效
* 并且，在同一个大括号内不能同时定义同名的变量
* B：初始化
* 没有初始化值的变量可以被定义但是不能使用
* 你只要在使用前给值就行
* 定义变量的格式：
* a: 数据类型 变量名 = 初始化值；
* b: 数据类型 变量名;
* 变量名 = 初始值;
* C:在一行上可以定义多个变量 中间用;隔开 但是不建议
*
* 数据类型之间的转换 ：
* byte,short,char -> int->long->float->double
* 前三个之间不能转换 boolean 不转换
* 强制数据类型转换：
* 从大的到小得数据类型
* 格式：
* 目标数据类型 变量名 = （目标数据类型）（被转换的数据）
* 注意：
* 隐含了精度损失的问题
* 面试题：
* byte b1=3,b2=4,b;
* b=b1+b2;
* b=3+4;
* 哪句编译失败？为什么？
* b=b1+b2;有问题
* 因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题
* 常量相加，首先做加法，然后看结果是否在赋值的数据类型的范围内，如果不是就报错。
*/
public class DataTypeDemo {
public static void main(String[] args) {
//定义变量的格式
//数据类型 变量名 = 初始值；
byte x=3;
int b = 4;
System.out.println(x+b);
int c = x+b;
System.out.println(c);
byte b1=3,b2=4,d;
//d=b1+b2;这个是类型提升，所以有问题
d=3+4;
byte aa = (byte)130;
System.out.println(aa);
}
}
/*
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
*/
8、Ascall 码
'a' 97
'A' 65
'0' 48
为了便于查询，以下列出ASCII码表：第128～255号为扩展字符（不常用）
|
|||||||
ASCII码 |
键盘 |
ASCII 码 |
键盘 |
ASCII 码 |
键盘 |
ASCII 码 |
键盘 |
27 |
ESC |
32 |
SPACE |
33 |
! |
34 |
" |
35 |
# |
36 |
$ |
37 |
% |
38 |
& |
39 |
' |
40 |
( |
41 |
) |
42 |
* |
43 |
+ |
44 |
' |
45 |
- |
46 |
. |
47 |
/ |
48 |
0 |
49 |
1 |
50 |
2 |
51 |
3 |
52 |
4 |
53 |
5 |
54 |
6 |
55 |
7 |
56 |
8 |
57 |
9 |
58 |
: |
59 |
; |
60 |
< |
61 |
= |
62 |
> |
63 |
? |
64 |
@ |
65 |
A |
66 |
B |
67 |
C |
68 |
D |
69 |
E |
70 |
F |
71 |
G |
72 |
H |
73 |
I |
74 |
J |
75 |
K |
76 |
L |
77 |
M |
78 |
N |
79 |
O |
80 |
P |
81 |
Q |
82 |
R |
83 |
S |
84 |
T |
85 |
U |
86 |
V |
87 |
W |
88 |
X |
89 |
Y |
90 |
Z |
91 |
[ |
92 |
\ |
93 |
] |
94 |
^ |
95 |
_ |
96 |
` |
97 |
a |
98 |
b |
99 |
c |
100 |
d |
101 |
e |
102 |
f |
103 |
g |
104 |
h |
105 |
i |
106 |
j |
107 |
k |
108 |
l |
109 |
m |
110 |
n |
111 |
o |
112 |
p |
113 |
q |
114 |
r |
115 |
s |
116 |
t |
117 |
u |
118 |
v |
119 |
w |
120 |
x |
121 |
y |
122 |
z |
123 |
{ |
124 |
| |
125 |
} |
126 |
~ |
Day 03
1、运算符：
就是对常量和变量进行操作的符号。
分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三目运算符
算术运算符：
+,-,*,/,%,++,--
++,--运算符的使用：
单独使用：
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
参与运算使用：
放在操作数的前面，先自增或者自减，然后再参与运算。
放在操作数的后面，先参与运算，再自增或者自减。
作用：就是对变量进行自增1或者自减1。
+的用法：
A:加法
B:正号
C:字符串连接符
2、赋值运算符：
基本的赋值运算符：=
把=右边的数据赋值给左边。
扩展的赋值运算符：+=,-=,*=,/=,%=
+= 把左边和右边做加法，然后赋值给左边
面试题：
short s=1;s = s+1;
short s=1;s+=1;
上面两个代码有没有问题，如果有，那里有问题。
为什么第二个木有问题呢?
扩展的赋值运算符其实隐含了一个强制类型转换。
s += 1;
不是等价于 s = s + 1;
而是等价于 s = (s的数据类型)(s + 1);
3、比较运算符：
==,!=,>,>=,<,<=
特点：
无论你的操作是简单还是复杂，结果是boolean类型。
注意事项：
"=="不能写成"="。
4、逻辑运算符：
&,|,^,!
&&,||
特点：
逻辑运算符一般用于连接boolean类型的表达式或者值。
表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b
结论：
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
举例：情侣关系。男男,男女,女男,女女
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。
&&和&的区别? 同理||和|的区别?
A:最终结果一样。
B:&&具有短路效果。左边是false，右边不执行。
开发中常用的逻辑运算符：
&&,||,!
5、位运算符：
&,|,^,~
<<,>>,>>>
注意：
要做位运算，首先要把数据转换为二进制。
class OperatorDemo {
public static void main(String[] args) {
//&,|,^,~
int a = 3;
int b = 4;
System.out.println(3 & 4);
System.out.println(3 | 4);
System.out.println(3 ^ 4);
System.out.println(~3);
}
}
/*
分析：因为是位运算，所以我们必须先把数据换算成二进制。
3的二进制：11
00000000 00000000 00000000 00000011
4的二进制：100
00000000 00000000 00000000 00000100
&位与运算：有0则0。
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000000
结果是：0
|位或运算：有1则1。
00000000 00000000 00000000 00000011
|00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是：7
^位异或运算：相同则0，不同则1。
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是：7
~按位取反运算符：0变1，1变0
^的特点：一个数据对另一个数据位异或两次，该数本身不变
00000000 00000000 00000000 00000011
~11111111 11111111 11111111 11111100 (补码)
补码：11111111 11111111 11111111 11111100
反码：11111111 11111111 11111111 11111101
<<:左移 左边最高位丢弃，右边补齐0
>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:无符号右移 无论最高位是0还是1，左边补齐0
面试题：
请用最有效率的方式写出计算2乘以8的结果?
2 * 8
2 << 3
面试题：
请自己实现两个整数变量的交换
注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
*/
class OperatorTest {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b);
//方式1：使用第三方变量(开发中用的)
/*
int c = a;
a = b;
b = c;
System.out.println("a:"+a+",b:"+b);
System.out.println("------------");
*/
//方式2：用位异或实现(面试用)
//左边：a,b,a
//右边：a ^ b
/*
a = a ^ b;
b = a ^ b; //a ^ b ^ b = a
a = a ^ b; //a ^ b ^ a = b
System.out.println("a:"+a+",b:"+b);
*/
//方式3：用变量相加的做法
/*
a = a + b; //a=30
b = a - b; //b=10
a = a - b; //a=20
System.out.println("a:"+a+",b:"+b);
*/
//方式4：一句话搞定
b = (a+b) - (a=b); //b=30-20=10,a=20
System.out.println("a:"+a+",b:"+b);
}
}
5、三目运算符：
格式：比较表达式?表达式1:表达式2;
比较表达式:结果是一个boolean类型。
执行流程：
根据比较表达式的计算返回一个true或者false。
如果是true，就把表达式1作为结果。
如果是false，就把表达式2作为结果。
键盘录入 Scanner 类
流程控制语句：可以控制程序的执行流程。
分类：
顺序结构
选择结构
循环结构
顺序结构：
从上往下，依次执行。
选择结构：
if语句
switch语句
if语句：
格式1
格式2
格式3
if语句的格式1：
if(比较表达式) {
语句体;
}
执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体；
if语句格式2：
if(比较表达式) {
语句体1;
}else {
语句体2;
}
执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
注意：else后面是没有比较表达式的，只有if后面有。
if语句的格式3：
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
执行流程：
首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
...
如果都是false，就执行语句体n+1。
*/
7、switch语句格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
格式的解释：
switch:表示这是switch选择结构
表达式:这个地方的取值是有限定的
byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case:后面跟的是要和表达式进行比较的值
语句体:要执行的代码
break:表示中断，结束的意思，可以控制switch语句的结束。
default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。
面试题：
byte可以作为switch的表达式吗?
long可以作为switch的表达式吗?
String可以作为switch的表达式吗?
switch语句的注意事项：
A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
B:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：
case就可以把值固定。
A,B,C,D
C:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
D:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
E:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了
8、循环语句：for循环,while循环,do...while循环。
for循环格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程：
最低0.47元/天 解锁文章
扫一扫
111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
