JavaSE基础教程.docx
《JavaSE基础教程.docx》由会员分享，可在线阅读，更多相关《JavaSE基础教程.docx（69页珍藏版）》请在冰豆网上搜索。
JavaSE基础教程
JavaSE
一、java语言概述
1.软件：
系统软件vs应用软件
2.人与计算机做交互：
使用计算机语言。
图形化界面vs命令行方式dirmdrdcdcd..cd/delexit
3.语言的分类：
第一代：
机器语言第二代：
汇编语言第三代：
高级语言（面向过程---面向对象）
4.java语言的特性：
①面向对象性②健壮性③跨平台性（writeonce，runanywhere）---JVM
5.安装JDK及配置path环境变量
1）傻瓜式安装JDK。
2）path:
window操作系统在执行命令时所要搜寻的路径。
我们需要将jdk中bin目录所在的路径：
D:
\Java\jdk1.7.0_07\bin保存在path环境变量下。
3）测试：
在命令行窗口，任意的文件目录下，执行javac.exe或者java.exe都可以调用成功。
>河床好比操作底层，jdk好比是河水，java应用程序好比是船。
注意：
JDKJREJVM
6.如何编写并运行第一个java程序
【过程】编写----编译----运行
1）编写：
每一个java文件都是.java结尾的，称为源文件【HelloWorld.java】。
java程序就存在于源文件中
publicclassHelloWorld{
//程序的主方法，是程序的入口
publicstaticvoidmain（Stringargs[]）{
//要执行的代码
System.out.println（"HelloWorld"）;
}
}
注意点：
Java源文件以“java”为扩展名。
源文件的基本组成部分是类（class），如本类中的HelloWorld类。
一个源文件中最多只能有一个public类。
其它类的个数不限，如果源文件包含一个public类，则文件名必须按该类名命名。
Java应用程序的执行入口是main（）方法。
它有固定的书写格式：
publicstaticvoidmain（String[]args）{...}
Java语言严格区分大小写。
Java方法由一条条语句构成，每个语句以“;”结束。
大括号都是成对出现的，缺一不可。
2）编译：
在源文件所在的目录下，执行javac.exe源文件名.java;生成诸多个.class结尾的字节码文件
3）运行：
生成的字节码文件通过java.exe解释执行
7.会调试程序中出现的问题
8.注释：
①单行注释//②多行注释/**/（多行注释不能够嵌套）
③文档注释/***/javadoc-d文件目录名-author-version源文件名.java;
9.JDK提供的关于旗下所有的包、类的文档:
API
二、基本语法
（一）关键字&标识符
关键字：
被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
保留字：
标识符：
凡是自己可以起名字的地方都叫标识符
命名的规则：
（一定要遵守，不遵守就会报编译的错误）
由26个英文字母大小写，0-9，_或$组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
Java中的名称命名规范：
（不遵守，也不会出现编译的错误）
包名：
多单词组成时所有字母都小写：
xxxyyyzzz
类名、接口名：
多单词组成时，所有单词的首字母大写：
XxxYyyZzz
变量名、方法名：
多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：
xxxYyyZzz
常量名：
所有字母都大写。
多单词时每个单词用下划线连接：
XXX_YYY_ZZZ
（二）变量
1.java中变量按照数据类型来分类：
基本数据类型vs引用数据类型（数组类接口）
>基本数据类型：
整型：
byte（8bit）shortint（默认类型）long
浮点型：
floatdouble（默认类型）
字符型：
char（‘’）
布尔类型：
boolean（只能取值为true或false，不能取null）
补充：
按照在类中存在的位置的不同：
成员变量vs局部变量
2.进制（了解）
十进制二进制八进制十六进制
二进制：
计算机底层都是用二进制来存储、运算。
>二进制与十进制之间的转换。
>二进制在底层存储：
正数、负数都是以补码的形式存储的。
（原码、反码、补码）
>四种进制间的转换
3.变量的运算：
①自动类型转换：
容量小的数据类型自动转换为容量大的数据类型。
shorts=12;
inti=s+2;
注意：
byteshortchar之间做运算，结果为int型！
②强制类型转换：
是①的逆过程。
使用“（）”实现强转。
（三）运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符：
+-+-*/%++--+
注意：
1）/:
inti=12;i=i/5;
2）%：
最后的符号只跟被模数相同
3）前++：
先+1，后运算后++：
先运算，后+1
4）+：
String字符串与其他数据类型只能做连接运算，且结果为String类型。
sysout（'*'+'\t'+'*'）;vssysout（"*"+'\t'+'*'）;
赋值运算符：
=+=-=*=/=%=
inti=12；
i=i*5;
i*=5;//与上一行代码同样的意思
【特别地】
shorts=10;
s=s+5;//报编译的异常
s=（short）（s+5）;
s+=5;//s=s+5，但是结果不会改变s的数据类型。
比较运算符（关系运算符）
==><>=<=instanceof
【注意】区分==与=区别。
进行比较运算操作以后，返回一个boolean类型的值
4>=3表达的是4>3或者4=3.结果是true。
if（i>1&&i<10）{}
不能写为：
if（1逻辑运算符（运算符的两端是boolean值）
&&&|||^!
【注意】区分&与&&的区别，以及|与||的区别
我们使用的时候，选择&&，||
位运算符（两端是数值类型的数据）
<<>>>>>&|^~
【例子】1.如何交换m=12和n=5的值
2.将60转换为十六进制输出。
三元运算符
（条件表达式）？
表达式1：
表达式2；
1）既然是运算符，一定会返回一个结果，并且结果的数据类型与表达式1，2的类型一致
2）表达式1与表达式2的数据类型一致。
3）使用三元运算符的，一定可以转换为if-else。
反之不一定成立。
例子：
获取两个数的较大值；获取三个数的最大值。
（四）流程控制
1.顺序结构
>程序从上往下的顺序执行
2.分支结构：
if-else
switch-case
3.循环结构：
while（）{}
do{}while（）
for（;;）{}
4.1分支结构
1.条件判断:
①if（条件表达式）{}
②if（条件表达式）{
//执行的语句1；
}else{
//执行的语句2；
}
③if（条件表达式1）{
//执行的语句1；
}elseif（条件表达式2）{
//执行的语句2；
}elseif（条件表达式3）{
//执行的语句3；
}...
}else{
//执行的语句；
}
【注意】
1.一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。
2.如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序
如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。
2.选择结构
switch（变量）{
case值1:
//break;
case值2:
//break;
...
default:
break;
}
【注意】
1.变量可以为如下的数据类型：
byteshortintchar枚举String
2.case后只能填写变量的值，不能写范围。
3.default是可以省略的。
并且其位置也是灵活的，但是通常将其放在case语句之后。
4.一旦满足某个case语句，则进入执行其操作。
直至遇到break或者程序终止。
5.若要判断的语句的条件满足switch变量的数据类型，且值不多的情况下，建议选择switch-case.
除此之外，选择if-else.
4.2循环结构
1.格式：
①初始化条件
②循环条件
③迭代部分
④循环体
for（①;②;③）{
④
}
①
while（②）{
④
③
}
①
do{
④
③
}while（②）;
注：
1.不同的循环结构之间可以相互转换
2.while和do-while的区别：
do-while程序至少会执行一次
2.嵌套循环：
循环结构还可以声明循环。
让内层循环结构整体充当外层循环的循环体。
若外层循环执行m次，内层循环执行n次，整个程序执行m*n次。
【题目】
******
******
******
for（inti=0;i<3;i++）{
for（intj=0;j<6;j++）{
System.out.print（"*"）;
}
System.out.println（）;
}
说明：
外层循环控制行数，内层循环控制列数
【例题】1.九九乘法表2.输出100内的质数。
（两种）
3.无限循环结构
for（;;）{
...
if（）{
break;
}
...
}
或者
while（true）{
...
if（）{
break;
}
...
}
往往我们在无限循环结构内部提供循环的终止条件，使用break关键字。
否则，此循环将无限制的执行下去，形成死循环！
死循环是我们要避免的。
4.3break&continue
break:
>使用switch-case结构或者循环结构中
>在循环结构中，一旦执行到break，就跳出当前循环。
continue:
使用在循环结构中
>一旦执行到continue，就跳出当次循环。
for（inti=1;i<=10;i++）{
if（i%4==0）{
//break;//123
continue;//123567910
}
System.out.print（i）;
}
在嵌套循环中，使用带标签的break和continue。
label:
for（inti=1;i<5;i++）{
for（intj=1;j<=10;j++）{
if（j%4==0）{
//break;
//continue;
//breaklabel;
continuelabel;
}
System.out.print（j）;
}
System.out.println（）;
}
（五）数组
二维数组
数组的常见异常
//1.数组下标越界的异常:
java.lang.ArrayIndexOutOfBoundsException
int[]i=newint[10];
//i[0]=90;
//i[10]=99;
//for（intm=0;m<=i.length;m++）{
//System.out.println（i[m]）;
//}
//2.空指针的异常：
NullPointerException
//第一种：
//boolean[]b=newboolean[3];
//b=null;
//System.out.println（b[0]）;
//第二种：
//String[]str=newString[4];
////str[3]=newString（"AA"）;//str[3]="AA";
//System.out.println（str[3].toString（））;
//第三种：
int[][]j=newint[3][];
j[2][0]=12;
数组的常用的算法问题
1.求数组元素的最大值、最小值、和、平均数
2.数组的复制和反转
情况1：
情况2：
（如何实现复制）
数组的反转：
//数组元素的反转
//for（inti=0;i//inttemp=arr[i];
//arr[i]=arr[arr.length-1-i];
//arr[arr.length-1-i]=temp;
//}
for（intx=0,y=arr.length-1;xinttemp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
拓展:
Stringstr="abcdefg";
数组的排序：
插入排序
直接插入排序、折半插入排序、Shell排序
交换排序
冒泡排序、快速排序（或分区交换排序）
选择排序
简单选择排序、堆排序
归并排序
基数排序
//使用冒泡排序使数组元素从小到大排列
//for（inti=0;i//for（intj=0;j//if（arr[j]>arr[j+1]）{
//inttemp=arr[j];
//arr[j]=arr[j+1];
//arr[j+1]=temp;
//}
//}
//}
////使用直接选择排序使数组元素从小到大排列
//for（inti=0;i//intt=i;//默认i处是最小的
//for（intj=i;j////一旦在i后发现存在比其小的元素，就记录那个元素的下角标
//if（arr[t]>arr[j]）{
//t=j;
//}
//}
//if（t!
=i）{
//inttemp=arr[t];
//arr[t]=arr[i];
//arr[i]=temp;
//}
//}
还可以调用：
Arrays工具类：
Arrays.sort（arr）;
三、面向对象
（一）
1.类及对象
1.关于于类的设计
2.类的组成成分：
1）属性（成员变量，Field）
2）方法（成员方法，函数，Method）
2.1属性：
*成员变量vs局部变量
*相同点：
1.遵循变量声明的格式：
数据类型变量名=初始化值
*2.都有作用域
*不同点：
1.声明的位置的不同：
成员变量：
声明在类里，方法外
*局部变量：
声明在方法内，方法的形参部分，代码块内
*2.成员变量的修饰符有四个：
publicprivateprotected缺省
*局部变量没有修饰符，与所在的方法修饰符相同。
*3.初始化值：
一定会有初始化值。
*成员变量:
如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
*byteshortintlong==>0
*floatdouble==>0.0
*char==>空格
*boolean==>false
*引用类型变量==>null
*局部变量：
一定要显式的赋值。
（局部变量没有默认初始化值）
*4.二者在内存中存放的位置不同:
成员变量存在于堆空间中；局部变量：
栈空间中
*
*总结：
关于变量的分类：
1）按照数据类型的不同：
基本数据类型（8种）&引用数据类型
*2）按照声明的位置的不同：
成员变量&局部变量
2.2方法：
提供某种功能的实现
*1）实例：
publicvoideat（）{//方法体}
*publicStringgetName（）{}
*publicvoidsetName（Stringn）{}
*格式：
权限修饰符返回值类型（void:
无返回值/具体的返回值）方法名（形参）{}
*
*2）关于返回值类型：
void：
表明此方法不需要返回值
*有返回值的方法：
在方法的最后一定有return+返回值类型对应的变量
*记忆：
void与return不可以同时出现一个方法内。
像一对“冤家”。
*
*3）方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！
3.面向对象编程的思想的落地法则一：
1）设计并创建类及类的成分
2）实例化类的对象
3）通过“对象.属性”或"对象.方法"的形式完成某项功能
4.类的初始化的内存解析
4.1内存划分的结构：
栈（stack）:
局部变量、对象的引用名、数组的引用名
堆（heap）:
new出来的“东西”（如：
对象的实体，数组的实体），含成员变量
方法区:
含字符串常量
静态域：
声明为static的变量
4.2理解的基础上，学会基本的创建的类的对象在内存中的运行。
2.方法的重载
*方法的重载（overload）
*要求：
1.同一个类中2.方法名必须相同3.方法的参数列表不同（①参数的个数不同②参数类型不同）
*补充：
方法的重载与方法的返回值类型没有关系！
//如下的四个方法构成重载
//定义两个int型变量的和
publicintgetSum（inti,intj）{
returni+j;
}
//定义三个int型变量的和
publicintgetSum（inti,intj,intk）{
returni+j+k;
}
//定义两个double型数据的和
publicdoublegetSum（doubled1,doubled2）{
returnd1+d2;
}
//定义三个double型数组的和
publicvoidgetSum（doubled1,doubled2,doubled3）{
System.out.println（d1+d2+d3）;
}
//不能与如上的几个方法构成重载
//publicintgetSum1（inti,intj,intk）{
//returni+j+k;
//}
//publicvoidgetSum（inti,intj,intk）{
//System.out.println（i+j+k）;
//}
//以下的两个方法构成重载。
publicvoidmethod1（inti,Stringstr）{
}
publicvoidmethod1（Stringstr1,intj）{
}
3.可变个数的形参的方法
*可变个数的形参的方法：
*1.格式：
对于方法的形参：
数据类型...形参名
*2.可变个数的形参的方法与同名的方法之间构成重载
*3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
*4.使用可变多个形参的方法与方法的形参使用数组是一致的。
*5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
*6.在一个方法中，最多声明一个可变个数的形参。
//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后，如下的两个方法可以省略
//publicvoidsayHello（）{
//System.out.println（"helloworld!
"）;
//}
//publicvoidsayHello（Stringstr1）{
//System.out.println（"hello"+str1）;
//}
//可变个数的形参的方法
publicvoidsayHello（String...args）{
for（inti=0;iSystem.out.println（args[i]+"$"）;
}
//System.out.println（"====="）;
}
publicvoidsayHello（inti,String...args）{
//publicvoidsayHello（String...args,inti）{
System.out.println（i）;
for（intj=0;jSystem.out.println（args[j]+"$"）;
}
}
publicvoidsayHello1（String[]args）{
for（inti=0;iSystem.out.println（args[i]）;
}
}
4.java的值传递机制
重点、难点
*方法的参数传递（重点、难点）
*1.形参：
方法声明时，方法小括号内的参数
*实参：
调用方法时，实际传入的参数的值
*
*2.规则：
java中的参数传递机制：
值传递机制
*1）形参是基本数据类型的：
将实参的值传递给形参的基本数据类型的变量
*2）形参是引用数据类型的：
将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。
【典型例题1】
publicstaticvoidmain（String[]args）{
TestArgsTransfertt=newTestArgsTransfer（）;
inti=10;
intj=5;
System.out.println（"i:
"+i+"j:
"+j）;//
升级会员 