2-1 关键字与保留字
关键字(keyword)
保留字(reserved word)
2-2 标识符(Identifier)
案例
class Test{
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
class _9Hello{
}
class Public{
}
class publicstatic{
}
class PublicStatic{
}
class XinXi{
String xingMing;
}
2-3 变量
案例
/**
变量的声明和使用
1.定义：在一定范围内取值不断变化的量。
2.格式：数据类型 变量名 = 初始化值
3.注意点：
①先声明，后使用
②变量的作用域即为其声明所在的{}内。
*/
public class VariableTest {
public static void main(String[] args) {
int number1;
number1 = 10;
int number2;
number2 = 20;
int number3;
number3 = number1 + number2;
System.out.println("Number3 = " + number3);
int number4 = 50;
int number5 = number4 - number3;
System.out.println("Number5 = " + number5);
}
}
数据类型案例
/**
1.角度一：按照数据类型来分
①基本数据类型：整型：byte / short / int / long
浮点型：float / double
字符型：char
布尔型：boolean
②引用数据类型：类 / 接口 / 数组
注意：String 属于引用数据类型
2.(了解)角度二：按照在类中声明的位置的不同来分：成员变量 vs 局部变量
*/
class VariableTest1{
public static void main(String[] args) {
//1.整型：byte (1字节:-128~127) / short (2字节) / int (4字节) / long(8字节)
//通常，我们将一个整型变量定义为int。
//如果定义log型变量，必须后缀为：l或L
byte b1 = 3;
//b1 = 128;
int i1 = 23152;
//i1 = 234254363575325243635;
long l1 = 1243252323545L;
System.out.println(b1);
System.out.println(i1);
//2.浮点型：float (4字节)/ double (8字节)
//①从存储数据的表数范围上讲：float的范围比long要大。
//②如果定义float型变量，必须后缀为:f或F
//③通常，我们将一个浮点型变量定义为double.
double d1 = 12.3;
float f1 = 12.3f;
f1 = 12.5F;
System.out.println(f1);//12.5
//3.字符型：char (2字节)
//①通常情况下，声明一个字符，使用一对''
//②char的不同表示方式：1.声明一个字符 2.声明转义字符 3.使用Unicode码（了解）
char c1 = 'a';
char c2 = '中';
char c3 = 'ネ';
char c4 = '4';
//char c5 = 43;//编译可以通过的
char c6 = '\n';
char c7 = '\t';
System.out.println("Hello" + c7 + "world");
char c8 = '\u0023';
//4.布尔型：boolean
//只能保存true 或 false. 不能取值为null.
//常常在条件判断、循环中，使用boolean型变量
boolean isMarried = true;
if(isMarried){
System.out.println("你不能参加单身party了！");
}else{
System.out.println("可以多谈谈女朋友");
}
}
}
基本数据类型转换案例
/**
基本数据类型变量间的运算规则
适用范围：除了boolean之外，其他7种基本数据类型都适用
1.自动类型提升：容量小的数据类型和容量大的数据类型的变量做运算，运算的结果为容量大的数据类型。
byte 、short 、char --> int --> long --> float --> double
特别地，byte、short、char三者之间做运算，结果为int型。
2.强制类型转换：自动类型提升的逆过程。见<VariableTest3.java>
说明：此时的容量的大小指的是存储数据范围的大小，而非内存存储空间的大小。
*/
class VariableTest2{
public static void main(String[] args) {
int num1 = 10;
short s1 = 10;
int num2 = num1 + s1;
boolean b1 = true;
//b1 + num1;
long l1 = 123L;
float f1 = 12.2f;
float f2 = l1 + f1;
//long l2 = l1 + f1;//编译不通过
System.out.println(f2);
double d1 = num1 + s1;
System.out.println(d1);//20.0
//********************************
//字符char的运算
char c1 = 'A';
int num3 = 0;
int num4 = c1 + num3;
System.out.println(num4);//65
//********************************
//特别的情况：
byte by1 = 10;
short ss1 = 10;
//short ss2 = by1 + ss1;//编译不通过
int i1 = by1 + ss1;
short ss2 = 10;
//short ss3 = ss1 + ss2;//编译不通过
byte by2 = 10;
//byte by3 = by1 + by2;//编译不通过
char c2 = 'a';
//short ss4 = by1 + c2;//编译不通过
//********************************
//整型的常量，默认为int型。
int n1 = 10;
int n2 = n1 + 2;
//浮点型的常量，默认为double型
//float ff = n1 + 12.3;//编译不通过
//**********************************
long ll1 = 1234;//可以理解为自动类型提升
System.out.println(ll1);
long ll2 = 1234235234233L;
System.out.println(ll2);
//float ff1 = 12.3;//12.3默认为double,此时编译不通过
}
}
强制类型转换案例
/**
强制类型转换：
1.自动类型提升的逆过程。
2.容量大的数据类型的变量如果想转换为容量小的数据类型的变量,就需要使用强制类型符进行转换。
3.强制类型转换符：()
注意点：强转过程中，有可能出现精度损失的情况。
*/
class VariableTest3 {
public static void main(String[] args) {
int num1 = 12;
short s1 = (short)num1;
System.out.println(s1);
//强转过程中，有可能出现精度损失的情况。
//举例一：
double d1 = 12.6;
int num2 = (int)d1;
System.out.println(num2);
//举例二：
int num3 = 128;
byte b1 = (byte)num3;
System.out.println(b1);//-128
}
}
String案例
/**
String类与基本数据类型(8种)变量之间的运算
1.String类属于引用数据类型的变量
2.String类型的变量值使用一对""括起来表示。
3.String类与基本数据类型(8种)变量之间只能做连接运算：+
4.String类与基本数据类型(8种)变量做运算的结果为:String类型
*/
class StringTest {
public static void main(String[] args) {
String s1 = "Hello World!";
System.out.println(s1);
System.out.println("s1");
//System.out.println(s2);//编译不通过
int num1 = 10;
String s3 = s1 + num1;
s3 = s3 + true;
System.out.println(s3);
//练习1：
int n = 1;
char c = 'a';
String str = "beijing";
System.out.println(n + c + str);//98beijing
System.out.println(n + (c + str));//1abeijing
System.out.println(str + n + c);//beijing1a
//练习2：
//* *
System.out.println("* *");
System.out.println("*" + "\t" + "*");
System.out.println('*' + "\t" + "*");
System.out.println('*' + '\t' + "*");//51*
System.out.println('*' + '\t' + '*');//93
char c1 = 'a';
char c2 = 97;
System.out.println(c2);
//************************
int i = 10;
//String str1 = i;//编译不通过
String str2 = i + "";
System.out.println(str2);//"10"
//int j = str2;//编译不通过
//int j = (int)str2;//编译不通过
//了解：使用包装类才能使得String---->int
int j = Integer.parseInt(str2);
System.out.println(j);
}
}
练习1
String str1 = 4; //判断对错：no
String str2 = 3.5f + “”; //判断str2对错：yes
System.out.println(str2); //输出：3.5
System.out .println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1
练习2
判断是否能通过编译
1）short s = 5;
s = s-2; //判断：no
2） byte b = 3;
b = b + 4; //判断：no
b = (byte)(b+4); //判断：yes
3）char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes
4） byte b = 5;
short s = 3;
short t = s + b; //判断：no
进制案例
/*
对于整数，有四种表示方式：
二进制：0,1 ，满2进1.以0b或0B开头。
十进制：0-9 ，满10进1.
八进制：0-7 ，满8进1. 以数字0开头表示。
十六进制：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
如：0x21AF +1= 0X21B0
*/
class BinarySystemTest{
public static void main(String[] args) {
int num1 = 0b1010;//二进制
int num2 = 0754;//八进制
int num3 = 0x12AB;//十六进制
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
}
}
练习
将以下十进制数转换为十六进制和二进制
123 256 87 62
7b/1111011 100/100000000 57/1010111 3e/111110
将以下十六进制数转换为十进制和二进制
0x123 0x25F 0x38 0x62
291/100100011 607/1001011111 56/111000 98/1100010
2-4 运算符
算术运算符案例
/**
算术运算符的使用：
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
class AriTest {
public static void main(String[] args) {
// 除： /
int num1 = 10;
num1 = 12;
int num2 = 5;
int num3 = num1 / num2 * num2;
System.out.println(num3);
double d1 = num1 / num2;
System.out.println(d1);//2.0
double d2 = (double)num1 / num2;
System.out.println(d2);//2.4
System.out.println(num1 / num2);
// 取余：% : 余数的符号与被模数的符号相同
int n1 = 12;
int m1 = 5;
System.out.println(n1 % m1);//2
int n2 = -12;
int m2 = 5;
System.out.println(n2 % m2);//-2
int n3 = 12;
int m3 = -5;
System.out.println(n3 % m3);//2
int n4 = -12;
int m4 = -5;
System.out.println(n4 % m4);//-2
//(前)++ :先自增1，然后再运算
//(后)++ :先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);//a1:11 b1:11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2:11 b2:10
//(前)-- :先自减1，然后再运算
//(后)-- :先运算，后自减1
int a3 = 10;
int b3 = --a3;
System.out.println("a3 = " + a3 + ",b3 = " + b3);//
int a4 = 10;
int b4 = a4--;
System.out.println("a4 = " + a4 + ",b4 = " + b4);//
short s1 = 10;
//s1 = s1 - 1;//编译不通过
//s1 = (short)(s1 - 1);//9
//或者
//自增1，或自减1,不会改变其数据类型。
s1--;
System.out.println(s1);
}
}
练习
public class TestSign{
public static void main(String[] args){
int i1 = 10;int i2 = 20;
int i = i1++;
System.out.print(“i=”+i);
System.out.println(“i1=”+i1);
i = ++i1;
System.out.print(“i=”+i);
System.out.println(“i1=”+i1);
i = i2--;
System.out.print(“i=”+i);
System.out.println(“i2=”+i2);
i = --i2;
System.out.print(“i=”+i);
System.out.println(“i2=”+i2);
}
}
输出：
i=10 i1=11
i=12 i1=12
i=20 i2=19
i=18 i2=18
赋值运算符案例
/**
2.赋值运算符： = += -= *= /= %=
*/
class SetValueTest {
public static void main(String[] args) {
int i = 10;
int num1,num2;//int num1;int num2;
num1 = num2 = 1;//连续赋值
System.out.println("num1 = " + num1 + ",num2 = " + num2);
// +=:
int num = 10;
num += 2;//与num = num + 2"相似"
System.out.println("num = " + num);
num *= 3;// num = num * 3
System.out.println("num = " + num);
//举例1：运算完以后，不会改变变量的数据类型。
short s = 10;
s += 3;// s = (short)(s + 3).
System.out.println("s = " + s);
//举例2：
int j = 1;
j *= 0.1;
System.out.println(j);//0
j++;
System.out.println(j);//1
//真正开发中，如果我们希望一个变量自增1.我们如何写？
//方式一： i = i + 1; 方式二：i += 1; 方式三： i++;(推荐)
//真正开发中，如果我们希望一个变量自增2.我们如何写？
//方式一： i = i + 2; 方式二：i += 2; (推荐)
//算术运算符再举例：
int n = 10;
int m = (n++) + (++n); //10 + 12
System.out.println("m = " + m);//22
//(m++)++;
}
}
比较运算符案例
/**
3.比较运算符： == != > < >= <= instanceof
结论：1.比较运算符的结果都是boolean类型
2.区别 == 与 =
*/
class CompareTest{
public static void main(String[] args) {
int i = 10;
int j = 5;
System.out.println(i == j);
System.out.println(i = j);//不报错
System.out.println(4 == 3);
//System.out.println(4 = 3);//报错
boolean b1 = false;
//区分好==和=的区别。
if(b1 = true)
System.out.println("结果为真");
else
System.out.println("结果为假");
}
}
案例
/**
4.逻辑运算符： & && | || ! ^
结论：1.运算符操作的是boolean型变量，运算的结果也为boolean类型
*/
class LogicTest{
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
System.out.println("b1 && b2 ：" + (b1 && b2) );
System.out.println("b1 & b2 ：" + (b1 & b2) );
System.out.println("b1 | b2 ：" + (b1 | b2) );
System.out.println("b1 || b2 ：" + (b1 || b2) );
System.out.println("b1 ^ b2 ：" + (b1 ^ b2) );
System.out.println("!b1 ：" + !b1 );
//& 与 && : 两个符号判断以后的结果是相同的。
//相同点：如果符号左边的值为true,两个运算符都要执行符号右边的运算。
//不同点：如果符号左边的值为false,&:仍然要执行符号右边的运算。&&：不在执行符号右边的运算
//开发中：习惯于使用：&&
boolean isFlag1 = false;
int num1 = 10;
if(isFlag1 & (num1++ > 0)){
System.out.println("小明很帅");
}else{
System.out.println("德玛很美");
}
System.out.println("num1 = " + num1);
boolean isFlag2 = false;
int num2 = 10;
if(isFlag2 && (num2++ > 0)){
System.out.println("小明很帅");
}else{
System.out.println("德玛很美");
}
System.out.println("num2 = " + num2);
// | 与 ||：两个符号判断以后的结果是相同的。
//相同点：如果符号左边的值为false,两个运算符都要执行符号右边的运算。
//不同点：如果符号左边的值为true,&:仍然要执行符号右边的运算。&&：不在执行符号右边的运算
//开发中：习惯于使用：||
boolean isFlag3 = true;
int num3 = 10;
if(isFlag3 | (num3++ > 0)){
System.out.println("李栋很帅");
}else{
System.out.println("李栋很美");
}
System.out.println("num3 = " + num3);
boolean isFlag4 = true;
int num4 = 10;
if(isFlag4 || (num4++ > 0)){
System.out.println("李栋很帅");
}else{
System.out.println("李栋很美");
}
System.out.println("num4 = " + num4);
}
}
练习
1题
int x = 1;
int y=1;
if(x++==2 & ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);
2 2
2题
int x = 1,y = 1;
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);
2 1
3题
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);
7 2
4题
int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);
7 1
5题
1． class Test4 {
2. public static void main (String [] args) {
3． boolean x=true;
4． boolean y=false;
5． short z=42;
6． //if(y = true)
7. if((z++==42)&&(y=true))z++;
8. if((x=false) || (++z==45)) z++;
9．
10. System. out.println(“z=”+z);
11. }
12. }
结果为：z= 46
案例
/**
5.位元素符： << >> >>> & | ^ ~
结论：1.操作的都是数值型变量
2. << : 在一定范围内，每左移一位，相当于数值 * 2 ：过犹不及
>> : 在一定范围内，每右移一位，相当于数值 / 2
>>>:右移以后，最高位拿0补。
*/
class BitTest {
public static void main(String[] args) {
System.out.println("15 << 2 : " + (15 << 2));
System.out.println("-15 << 2 : " + (-15 << 2));
System.out.println("15 << 28 : " + (15 << 28));
System.out.println("15 >> 2 : " + (15 >> 2));
System.out.println("-15 >> 2 : " + (-15 >> 2));
System.out.println("-15 >> 2 : " + (-15 >>> 2));
//练习1：
int m = 10;
int n = 5;
System.out.println("m = " + m + ",n = " + n);
//交换m和n的数值
//方式一：更通用。
//int temp = m;
// m = n;
// n = temp;
//方式二：好处：不需要额外定义临时变量。 缺点：①有可能运算时溢出。②适用数据类型有限制
//m = m + n;// 15 = 10 + 5
//n = m - n;// n = 15 - 5;
//m = m - n;// m = 15 - 10;
//方式三：好处：相较于方式二，不会溢出。 缺点：适用数据类型有限制
m = m ^ n; //(m ^ n) ^ n => m
n = m ^ n;
m = m ^ n;
System.out.println("m = " + m + ",n = " + n);
//练习2：手动实现60的二进制到十六进制的转换。
int num = 60;
String binary = Integer.toBinaryString(num);
System.out.println(binary);
String hex = Integer.toHexString(num);
System.out.println(hex);
System.out.println();
int temp1 = num & 15;
String s1 = (temp1 >= 10)? (char)(temp1 - 10 + 'a') + "" : temp1 + "";
//System.out.println(s1);
num = num >> 4;
int temp2 = num & 15;
String s2 = (temp2 >= 10)? (char)(temp2 - 10 + 'a') + "" : temp2 + "";
//....
System.out.println(s2 + s1);
/*
String s = "abc";
s += "cde";//s = s + "cde";
System.out.println(s);
//abcdefg ---> abfedcg
*/
}
}
案例
/*
6.三元运算符： (条件表达式)? 表达式1 : 表达式2;
说明：1.条件表达式的结果为boolean.
2.根据boolean类型的值，决定执行表达式1 (true) 还是表达式2 (false).
3.表达式1 与 表达式2 要保持一致！
4.三元运算符可以相互嵌套
5.三元运算符一定可以转换为使用if-else实现。反之，不成立。
如果既可以使用三元运算符，又可以使用if-else,建议使用三元运算符。因为：简单，执行效率高。
*/
class SanYuanFu {
public static void main(String[] args) {
//获取两个整数的较大值
int m = 10,n = 10;
int max = (m > n)? m : n;
System.out.println("较大值为：" + max);
//三元运算符可以相互嵌套
String s = (m > n)? "m大" : (m == n)? "m和n相等" : "n大";
System.out.println(s);
//表达式1 与 表达式2 要保持一致！不一定要相同
double temp = (m > n)? 4 : 1.2;
System.out.println(temp);
//获取三个整数的最大值
int num1 = 23,num2 = 44,num3 = 2;
//int max1 = (num1 > num2)? num1 : num2;
//int max2 = (max1 > num3)? max1 : num3;
//方式二：
int max2 = (((num1 > num2)? num1 : num2) > num3)? ((num1 > num2)? num1 : num2) : num3;
System.out.println(max2);
//使用if-else获取两个整数的较大值
int n1 = 10,n2 = 4;
if(n1 > n2){
System.out.println(n1);
}else{
System.out.println(n2);
}
}
}