Java基础第二天

2.1回顾

第一个代码：

/**

这是我的第一个java程序

@author zhang

@version v1.0

publicclass HelloJava{

1.源文件以.java结尾

2.源文件中可以有多个class声明的类

3.类中可以有主方法（即main()方法），其格式是固定的：public static void main(String[]args){}

4.main()方法是程序的入口，方法内是程序的执行部分。

5.一个源文件中只能有一个声明为public 的类，同时要求此类的类名与源文件名一致。

6.每个语句都以";"结束

7.执行程序：①编译：javac.exe 编译完，生成诸多个.class字节码文件。②运行：java.exe

8.多行注释不能够嵌套

publicstaticvoid main(String[] args){

System.out.println("Hello World!" +'\n' +"Hello it18zhang.com");

}

2.1 关键字

1关键字的定义和特点

关键字的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所有字母都为小写

保留字

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字
byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

2.2标识符

标识符：

（1）Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

（2）凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

（1）由26个英文字母大小写，0-9 ，_或 $ 组成

（2）数字不可以开头。

（3）不可以使用关键字和保留字，但能包含关键字和保留字

（4）Java中严格区分大小写，长度无限制

（5）标识符不能包含空格

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意

Java中的名称命名规范

（1）包名：多单词组成时所有字母都小写：xxxyyyzzz

（2）类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

（3）变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

（4）常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

案例：

标识符：凡是可以自己命名的地方，都叫标识符。如：类名、方法名、变量名、接口名，。。。

1.标识符命名的规则：(要求严格遵守，否则会报编译性的错误)

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

2.Java中的名称命名规范：(如果不遵守，也不会报错)

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

class TestMarker

{

publicstaticvoid main(String[] args)

{

int static1 = 1;

int myInt = 12;

System.out.println("Hello World!");

}

publicvoid add(){

}

//注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

publicvoid m1(){}

publicvoid m2(){}

}

//class 4Hello

class Static{

}

2.3变量

变量的概念：

（1）内存中的一个存储区域

（2）该区域有自己的名称（变量名）和类型（数据类型）

（3）Java中每个变量必须先声明，后使用

（4）该区域的数据可以在同一类型范围内不断变化

使用变量注意

（1）变量的作用域：一对{ }之间有效

（2）初始化值

定义变量的格式：数据类型变量名 = 初始化值

变量是通过使用变量名来访问这块区域的

变量的分类-按数据类型

对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间

整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。

java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

浮点类型：float、double

（1）与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响

（2）Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

（3）浮点型常量有两种表示形式：

十进制数形式：如：5.12 512.0f .512 (必须有小数点）

科学计数法形式:如：5.12e2 512E2 100E-2

字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)

字符型常量的三种表现形式：

（1）字符常量是用单引号(‘’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = 'a'; char c2 = '中'; char c3= '9';

（2）Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符

（3）直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a表示 \n。

（4）char类型是可以进行运算的。因为它都对应有Unicode码

ASCII 码

在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 11111111。

ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

Unicode 编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码

Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。

Unicode 的缺点：Unicode 只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号

UTF-8

UTF-8 是在互联网上使用最广的一种 Unicode的实现方式。

UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8的编码规则：

（1）对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。

（2）对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

布尔类型：boolean

boolean 类型适于逻辑运算，一般用于程序流程控制

if条件控制语句

while循环控制语句

do-while循环控制语句；

for循环控制语句

boolean类型数据只允许取值true和false，无null。

不可以0或非 0 的整数替代false和true，这点和C语言不同

案例

//变量：基本数据类型（8个） vs 引用数据类型（类、接口、数组）

//1.java中的变量定义的格式：数据类型变量名 = 初始化值

class TestVeriable {

publicstaticvoid main(String[] args) {

//2.变量得先定义，后使用

int myInt1 = 10;

double d = 12.3;

System.out.println(myInt1);

System.out.println(myInt1 + d);

//i1超出了其作用的范围，不可使用。

//System.out.println(i1);

//3.整型：byte(-128~+127) short int（默认类型） long

byte b1 = 12;

//byte b2 = 128;

short s1 = 128;

int i1 = 12;

//定义long型变量，值的末尾加“L”或“l”

long l1 = 2134123351345325L;

System.out.println(l1);

//4.浮点型（带小数点的数值）：float double（默认类型）

double d1 = 12.3;

//声明float类型的浮点型数据，末尾要加“F”或者“f”

float f1 = 12.3F;

System.out.println(f1);

//5.字符型（=两个字节）：char 只能表示一个字符(英文、中文、标点符号、日文、。。。)

char c1 = 'a';

//char c2 = 'ab';

String str = "ab";

char c3 = '中';

String str1 = "中国";

//可以表示转义字符

char c4 = '\t';

char c5 = '\n';

System.out.println("abc" + c5 + "def");

//了解

char c6 = '\u1234';

System.out.println(c6);

//6.布尔类型：boolean 只能够取值为true 或 false 。不能取值null

boolean bool1 = true;

if(bool1){

System.out.println("今天是周五");

}else{

System.out.println("今天明明是周六！");

}

publicvoid method1(){

int i1 = 10;

System.out.println(i1);

}

基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算

byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。

当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。

强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出,格外要注意。

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

如： String a = “43”; int i = Integer.parseInt(a);

boolean类型不可以转换为其它的数据类型。

案例：

变量之间的运算：(不考虑boolean。剩下：char byte short int long floatdouble)

1.自动类型转换

2.强制类型转换

class TestVeriable1{

publicstaticvoid main(String[] args){

//1.自动类型转换:当容量小的数据类型与容量大的数据类型做运算时，容量小的会自动转换为

//容量大的数据类型:char,byte,short ===>int===>long ===>float===double

int i1 = 12;

short s1 = 2;

int i2 = i1 + s1;

float f1 = 12.3F;

float f2 = f1 + i2;

//float d1 = f2 + 12.3;

long l = 12L;

float f3 = l;

System.out.println(i2);

System.out.println(f2);

char c1 = 'a';//97

c1 = 'A';//65

int i3 = c1 + 1;

System.out.println(i3);

//需要注意的：当char\byte\short之间做运算时，默认的结果为int类型

short ss1 = 12;

byte bb1 = 1;

char cc1 = 'a';

//short ss2 = ss1 + bb1;

int ii1 = ss1 + bb1;

//char cc2 = cc1 + bb1;

int ii2 = cc1 + bb1;

short ss2 = 11;

//short ss3 = ss1 + ss2;

//2.强制类型转换：容量大转换为容量小的.要使用强制类型转换符：()

//强制类型转换的问题：导致精度的损失

long l1 = 12345L;

int m1 = (int)l1;

System.out.println(m1);

byte by1 = (byte)m1;

System.out.println(by1);

//平时常用的字符串,也是一种数据类型：String

String nation = "我是一个中国人";

System.out.println(nation);

//字符串与基本数据类型之间的运算:只能是连接运算：+。得到的结果仍为一个字符串

String str = "abc";

String str1 = str +m1;//abc12345

System.out.println(str1);

//题目：

String st1 = "hello";

int myInt1 = 12;

char ch1 = 'a';//97

System.out.println(str1+ myInt1 + ch1);//hello12a

System.out.println(myInt1+ ch1 + str1);//109hello

System.out.println(ch1+ str1 + myInt1);//ahello12

String st2 = "12";

str2 = 12 + "";

}

练习：

String str1 = 4; //判断对错：错

String str2 = 3.5f + “”; //判断str2对错：对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); //输出：Hello!a1

进制

对于整数，有四种表示方式

（1）二进制：0,1 ，满2进1.以0b或0B开头。

（2）十进制：0-9 ，满10进1

（3）八进制：0-7 ，满8进1. 以数字0开头表示

（4）十六进制：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。

（5）如：0x21AF +1=0X21B0

原码、反码、补码

所有数字在计算机底层都以二进制形式存在。

计算机以补码的形式保存所有的整数。

正数的原码、反码、补码都相同

负数的补码是其反码加1。

原码：直接将一个数值换成二进制数。

反码：是对原码按位取反，只是最高位（符号位）确定为1。

Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位

进制间转化

进制的基本转换

十进制二进制互转

（1）二进制转成十进制乘以2的幂数

（2）十进制转成二进制除以2取余数

(3)二进制八进制互转

(4)二进制十六进制互转

(5)十进制八进制互转

(6)十进制十六进制互转

算术运算符

//测试算术运算符： + - + - * / % ++ -- +

class TestAri{

publicstaticvoid main(String[] args){

// 除：/

int i = 12;

int j = i/5;

double d = i / 5;

double d1 = i/5.0;

System.out.println(j);//2

System.out.println(d);//2.0

System.out.println(d1);//2.4

//取模：%：取余数. 结果的符号取决于被模数

int i1 = 12 % 5;

int i2 = -12 % 5;

int i3 = 12 % (-5);

int i4 = -12 % (-5);

System.out.println(i1);

System.out.println(i2);

System.out.println(i3);

System.out.println(i4);

//前++:先自增1，后做运算

//后++:先做运算，后自增1

int myInt1 = 10;

int myInt2 = myInt1++;//后++

System.out.println(myInt1);//11

System.out.println(myInt2);//10

int myInt3 = 10;

int myInt4 = ++myInt3;//前++

System.out.println(myInt3);//11

System.out.println(myInt4);//11

//前--:先自减1，后做运算

//后--:先做运算，后自减1

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

class PrintGrap{

public static void main(String[] args){

System.out.print("\t");

System.out.print("*");

System.out.print("\t");

System.out.println("*");

System.out.print("*");

System.out.print("\t");

//System.out.print("\t");

System.out.print("\t");

System.out.print("I love java");

System.out.print("\t");

System.out.println("*");

System.out.print("\t");

System.out.print("*");

System.out.print("\t");

System.out.println("*");

System.out.print("\t");

System.out.print("*");

System.out.print("\t");

System.out.println("*");

System.out.print("\t");

System.out.print("*");

System.out.print("\t");

System.out.println("*");

System.out.print("\t");

System.out.print("*");

System.out.print("\t");

System.out.println("*");

System.out.print("\t");

//System.out.print("\t");

System.out.print(" ");

System.out.print("*");

}

class Test1

{

public static void main(String[] args)

{

String str1 = "4";

String str2 = 3.5f+"";

System.out.println(str2);

System.out.println(str1);

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); //输出：Hello!a1

}

class TestAri

{

public static void main(String[] args)

{

/*int i = 12;

int j = i/5;

double d = (double)i/5;

double e = i/5.0;

System.out.println(j);

System.out.println(d);

System.out.println(e);

*/

/*int i1 = 12%5;

int i2 = -12%5;

int i3 = 12%(-5);

int i4 = -12%(-5);//取模的符号和百分号前面的数字符号相同。

System.out.println(i1);

System.out.println(i2);

System.out.println(i3);

System.out.println(i4);

*/

/*int myInt1 = 10;

int myInt2 = myInt1++;

System.out.println(myInt1);//11

System.out.println(myInt2);//10

*/

int myInt3 = 10;

int myInt4 = ++myInt3;

System.out.println(myInt3);//11

System.out.println(myInt4);//11

int myInt5 = 10;

int myInt6 = myInt5--;

System.out.println(myInt5);//9

System.out.println(myInt6);//10

int myInt7 = 10;

int myInt8 = --myInt7;

System.out.println(myInt7);//9

System.out.println(myInt8);//9

}

class TestMarker

{

public static void main(String[] args)

{

int myInt = 15;

myInt = 15+1;

System.out.println(myInt);

boolean top = false;

top = true;

System.out.println(top);

//int myByte = 128.01;

float myFloat = 128.01f;

myFloat = 200.0f;

double myDouble = 128;

System.out.println(myFloat);

//System.out.println(myByte);

System.out.println(myDouble);

}

class TestVeriable

{

public static void main(String[] args)

{

int myInt1 = 10;

double d = 12.3;

byte b1 = 12;

short s1 = 128;

int i1 = 12;

long l1 = 213412335134532L;

double d1 =12.3;

float f1 = 12.3F;

char c1 = 'a';

String str1 = "中国";

char c3 = '中';

char c4 = '\t';

char c5 = '\n';

char c6 = '\u1234';

boolean bool1 = true;

if (bool1)

{

System.out.println("今天是周五");

}else{

System.out.println("今天明明是周六！");

}

System.out.println(myInt1);

System.out.println(myInt1+d);

System.out.println(b1);

System.out.println(s1);

System.out.println(i1);

System.out.println(l1);

System.out.println(d1);

System.out.println(f1);

System.out.println("abc"+c5+"def");

System.out.println(c6);

}

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。

2.1 关键字

1关键字的定义和特点

2.2标识符

2.3变 量

变量的分类-按数据类型

整数类型：byte、short、int、long

浮点类型：float、double

字符类型：char

Unicode 编码

UTF-8

布尔类型：boolean

基本数据类型转换

强制类型转换

案例：

进 制

进制间转化

算术运算符

2.3变量

进制