Java笔记-第1章-基础知识.doc

第二章 Java基础知识
一、标识符：
标识符是由程序员定义的英文单词.要满足以下规则和规范
（1）规则：
a、标识符有字母、数字、下划线、$组成。 //$:与c++不同之处
b、开头不能是数字
c、标识符不能是java的关键字和保留字
d、java的标识符严格区分大小写。

例如：
a_b2c-1 、 2ab、 _abc$d 、 AA_BBc

（2）规范
a、类名、接口名每个单词的首字母要大写
b、方法名、变量名从第二个单词开始首字母大写
c、常量名每个字母都大写，单词组合用下划线。
d、见其名知其意

例如：
定义类名： Person MiddleSchoolStudent
定义方法名：getPersonName()
定义变量名：personName
定义常量名：PI

二、关键字
不熟悉的
abstract：定义抽象类
transient：瞬时对象 不允许序列化
volatile ：多线程中访问变量
synchronized ：线程同步的关键字
assert：断言
enum：枚举类型
native：声明本地方法的关键字

熟悉的
int：整型
short：短整型
boolean ：定义布尔类型
byte:数据类型
char ：字符数据类型
double：双精度的数据类型
long：长整型
float：单精度
if...else: 选择结构
switch...case...default：选择分支
for：循环结构
do...while：循环结构
while：循环结构
break：结束循环 或者跳出switch结构
continue：停止一次循环
void ：无值型
class：定义类的关键字
return：返回
private ：私有的
protected：保护的
public ：公有的
final：定义常量 定义最终的类 定义不允许重写的方法
throw ：产生并抛出异常
throws：通知调用者产生的异常的类型
new 调用构造方法创建对象（分配堆内存）
static：静态
super：父类的
try...catch...finally：异常处理
implements：类实现接口的关键字
import：导包
package：定义包
对象 instanceof 类 :表示判断左边对象是否是右边类或者是子类的对象
interface：定义接口关键字
extends：类继承类或者接口继承接口的关键字
this：本类对象
null:空值
-----------------------------------------
以下都是保留字
const
strictfp
goto

三、基本数据类型：
分为四类八种：
1、整型
类型名 长度 取值范围 其他
long 8字节 -2的63次方~2的63次方-1 可以以L结尾
int 4字节 -2的31次方~2的31次方-1
short 2字节 -2的15次方~2的15次方-1
byte 1字节 -128~127
2、浮点型
double 8字节 小数点后15位
float 4字节 f结尾，小数点后7位
3、字符型：
char 2个字节 '\u0000'~'\uffff'
4、布尔型
boolean 1个字节 true false

基本数据类型数值型类型的排列次序
double--->float--->long--->int--->short--->byte
|
char
注意：在java中boolean型不能与整型做运算 //与c++不同之处

四、变量常量
1、变量：程序运行过程中值可以改变的量。变量的
实质是变量名标识的内存空间的值或者内容可以改变。
变量名是内存空间的标识。

变量的定义语法：
数据类型 变量名【,变量名1【,变量名2...】】；
例如 ：int a;
int m,n,k;
变量的初始化：
定义同时赋值，例如 int a = 5;
定义之后赋值 例如 int m = 5,n,k = 6, n = 4;
注意：实例变量应该初始化，并且局部变量必须初始化。
补充：
字符串连接符号“+”，可以实现字符串和任意类型数据做连接，连接后表示一个新的字符串。
2、常量：
在java中使用 final修饰的变量称为常量。作为局部常量，可以定义后赋值，一旦赋值不可更改。
final 数据类型 常量名 = 值
作为全局常量（类的数据成员），必须定义同时赋值。
转义字符：
\n 换行
\\----\表示一个反斜杠
\"---"表示一个引号
\t----4空格相当于tab键

五、数据类型的转换
1、自动转换（隐含转换）：当较低类型数据赋值给较高类型数据时发生自动转换；在运算过程中不同类型数据做算术运算时自动将较低类型转为较高类型，然后再做运算。
2、强制转换：将较高类型数据赋值给较低类型数据必须要进行强制转换，强制转换的语法：
(较低数据类型)变量名
例如 ：
float f = (float)2.5;

六.运算符
1.算术运算符
+ - * / % ++ --
/: 当两个操作数都是整型时结果取整，且除数不能为0；只要有一个操作数是浮点型，且除数不能为0,结果取精确值；
%:两个整型操作数的余数，且第二个操作数不能为0；
++ --：自增自减运算符，操作数是整型变量分为前置和后置两种。
（1）++ -- 前置：表示运算或者输出前先自增自减1
（2）++ -- 后置：表示运算或者输出后再自增自减1

2、关系运算符：
> >= < <= == !=
关系运算符计算的结果的类型是boolean类型
int a = 6;
int b = 6;
a>=b b==a a<=b a<b a>b a!=b
3、逻辑运算符：
&& || ！
逻辑运算符的操作数必须是boolean,&&和||采用
短路法。
逻辑非运算！操作数的值为true(false)
结果为 false(true)
4、赋值运算符：
= += -= /= %= *=
5、位运算符：是指常量的二进制代码的运算
& | ^ ~ << >>
运算规则:
~: 按位取反
&: 当两个都为1时结果为1,否则为0
|: 只要有一个为1结果就为1,否则为0
^: 相同为0,不同为1
<<: 左移位运算符,在不产生溢出的情况下,每移1位相当于乘以2
>>: 右移位运算符,移位过程中,低位被舍弃
运算符
(1)& 和 &&：都可以对boolean类型操作数做运算结果都是boolean类型。
注意：按位与运算不采用短路法

(2)| 和 ||:都可以对boolean类型操作数做运算结果都是boolean类型。
注意：按位或运算不采用短路法
5、条件运算符：表达式1?表达式2:表达式3
说明：
（1）表达式1值的类型是boolean类型
（2）整个表达式取值：如果表达式1值为true整个表达式取表达式2的值，否则取表达式3的值。（相当于简单的if...else结构）
6..运算符的结合性和优先级
Java语言中大部分运算符也是是从左向右结合的,只有单目运算符,赋值运算符和三目运算符例外,它们是从右向左结合的.
乘法和除法是两个可结合的运算,这两个运算符左右两边的操作符可以互换位置而不会影响结果.
运算符优先级列表:
运算符说明 Java运算符 举例
分隔符 [] () {} , ; if(!(i%j==0))
单目运算符 ++ -- ~ ! while( i-- >3 ) --j;
强制类型转换运算符 (type)
乘法/除法/求余 * / % k = n / 10 % 10
加法/减法 + - if(ch1 + 2 < ch2 ) ++ch1;
移位运算符 << >> >>>
关系运算符 < <= >= > instanceof if( i-1 > j ) i--; else j--;
等价运算符 == != a != 4||b= =1
按位与 &
按位异或 ^
按位或 |
条件与 && x < y & ! ( x < z )
条件或 || x > y || x > z
三目运算符 ? : t1 = x1 > x2 ? x1 : x2
赋值 = += -= *= /= &= |= ^=
%= <<= >>= >>>=

int m=4;
int n=-5;
int k=6;
System.out.println("最大值为:"+(k>( m>n?m:n)?k:(m>n?m:n)));
System.out.println("最小值为:"+(k<( m<n?m:n)?k:(m<n?m:n)));
//判断年份是否是闰年
int year=2001;
System.out.println(year%4==0&&year%100!=0||year%400==0?year+"是闰年":year+"不是闰年");

七.表达式和语句
1.表达式:操作数运算符及方法调用组成的式子就是表达式.
编写java表达式时会经常使用系统预定义的Math类,该类中的方法都是静态的,调用时用
类名.方法名([参数列表])
//输出2到10之间任意一个整数
int D=(int)(Math.random()*(10-2+1)+2); //调用Math类中的randow方法
System.out.println(D);
2.语句:都以分号结束.
(1)空语句
(2)表达式语句
(3)复合语句:用{}将多条语句括起来,表示一条语句
(4)方法调用语句:如果是静态方法,调用方式为:
类名.方法名([参数列表])
如果不是静态方法,调用方式为:
对象名.方法名([参数列表])
(5)跳转语句:流程控制部分的内容
八.java中的注释
(1)行注释//
(2)块注释/* */
(3)文档注释:
/*
*注释内容
*注释内容
*/
文档注释的作用:配合javadoc命令根据java源文件生成的html文档.用于显示类的信息.
类的信息包括:
(1) 用于在类前显示包括作者.版本信息
(2) 用在类的数据成员前对其进行说明
(3) 用于在成员方法前包括返回值.参数
Javadoc命令使用方法:javadoc –version –author Test03_3.java –d e:\javadoc
第三章 程序流程控制
标准输入Scanner
import java.util.Scanner; //import java.util.*;表示包含util类中的所有函数
class Test02_21
{
public static void main(String[] args)
{
System.out.println("输入一个数字");
Scanner sc=new Scanner(System.in);
int year=sc.nextInt(); //另有nextDouble,nextFloat等
if(year%4==0&&year%100!=0||year%400==0)
System.out.println(year+“是闰年”);
else
System.out.println(year+”不是闰年”);

}
}
标准输入字符
char ch;
System.out.println("输入学生成绩档次");
Scanner sc=new Scanner(System.in);
String str=sc.next(); //标准输入字符串
ch=str.charAt(0); //表示取字符串中的第一个字符
一、流程控制结构概述：
1、顺序机构：程序的执行顺序和代码的静态书写顺序一致
2、选择结构：根据某些必要的条件的判断，执行某一部分的
程序段。
3、循环结构：让机器重复的自行某些代码段的结构。
二、选择结构：
1、if结构：
语法：
(1) if(表达式){
语句块；
}
说明：表达式的类型必须是boolean类型，当
表达式的值为true，执行语句块，否则不执行。
(2) if(表达式)
{
语句块
}
else
{
语句块
}
说明：
else不能独立存在，有else分支必须得有一个
无间隔的if分支与之配对，else的隐含条件
和if分支的表达式正好相反。另外，if else
允许嵌套使用。
(3) if(表达式1)//true
{
语句1；
}
else if(表达式2) //true
{
语句2；
}
else if(表达式3)
{
语句3；
}
。。。。
else
{
语句n;
}
说明：多分支单项选择结构
2、switch...case ...default选择分支
语法：
switch(表达式)
{
case 常量标号1：
语句1；
break;
case 常量标号2：
语句2；
break;
...
case 常量标号n：
语句n；
break;
default:
语句;
break;
}
说明：
（1）switch表达式值的类型是非long的整型、字符型、
枚举类型；表达式可以是一个变量也可以是表达式。
（2）case 常量标号的类型必须与表达式类型兼容或
相同，常量标号值必须唯一。
（3）break语句可以省略，当省略了break语句的
case 分支被执行后，仍然会继续向下执行，直到
遇到第一个break为止。
（4）default分支，当所有的case分支都不
执行，执行default分支。
（5）执行过程，首先计算表达式的值，然后寻找
case的常量标号，当表达式的值和case常量标号
的值相等时，该case分支将被执行，如果没有相等
的情况出现，则执行default分支。
（6）当所有的分支都没有省略break语句，case
分支的执行顺序和书写顺序无关。
三、循环结构
***********.......

1、for循环结构：当明确循环次数的时可以使用for循环
(1)普通的for循环语法：
for(表达式1;表达式2;表达式3)
{
循环体；
}
语法说明：
1）表达式1：是循环条件变量的初始值
2）表达式2：循环终止的条件，类型boolean
3）表达式3：循环趋于结束或者表达式2趋于false
的表达式。
4）循环体：如果循环体中就一条语句，{}可以省略
5）循环的执行顺序：
首先计算表达式1的值，然后计算表达式2，
如果表达式2为true,执行循环体语句，之后
计算表达式3，然后再计算表达式2，如果
表达式2为true，循环体重新被执行，否则
跳出循环体，循环终止。
6）表达式1和表达式3都可以在()中省略，省略后
表达式1要出现在for之前，表达式3要出现在
循环体中，分号一个也不能少。
(2)增强的for循环，也称forEach循环。用于快速的
遍历数组或者集合或者可别长度的参数。是jdk1.5新增
功能。
语法： for(数据类型 变量名:数组/集合/可变参数名)
{
循环体内容
}
（3）for循环的嵌套：
能够理解外层循环和内层循环的执行顺序，
外层循环执行一次内层循环执行n次

//遍历数组
int arr[]={1,2,3,4,9,5,6,2,4,8};
for(int temp:arr)
{
System.out.println(temp);
}
//遍历集合
ArrayList<Integer> list =
new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
for(int temp:list)
{
System.out.println(temp);
}
int v1 = test(1,2,3,4,5);
int v2 = test(1,2);
int v3 = test();
//JDK1.5新增功能:可变长度参数
public static int test(int ... args)
{
//3.遍历可变长度参数
int sum = 0;
for(int temp:args)
{
sum+=temp;
}
return sum;
2、while循环：当不明确循环次数时，首选while循环
语法：
while(表达式)
{
循环体
}
同（for(;表达式2;){循环体}）
语法说明：
(1)表达式的类型是boolean
(2)在while之前应该有循环条件变量的初始化
(3)在循环体中应该有使循环结束的语句或者
趋于结束的语句。
(4)while循环执行顺序，首先计算表达式的值
如果为true执行循环体，否则跳过循环体。
3、do...while循环：类似while循环，不同之处是
do...while循环体先执行一次循环体，再判断
while表达式的值，如果为true，继续执行循环体
否则跳出循序体。
语法：
do
{
循环体
}while(表达式);

四、跳转语句：改变程序事先设计好的结构的语句
1、break
（1）break在switch...case语句中用于结束case分支
跳出switch结构。
（2）用于循环结构中，结束循环体的执行，
终止循环。
语法： break或者 break outer
2、continue 强制进入下一次循环
3、return 不是专门用于结束循环语句的,它主要用于结束整个方法,捎带着结束循环. （1）当方法的返回值类型不是void，必须由return 给出一个值返回给调用者。
例如 ：
int add(int a,int b)
{
if(a<0)
return a+b;
return a-b;
}
（2） 当方法的返回值类型是void时，也可以有return语句，语法是return;作用是停止方法的继续执行。
void fun(int a)
{
if(a==0)
{
return;
}
else if(a==1)
{
return;
}
System.out.println(a);
}
（3）在一个方法中可以有多条return，只能有一条 return语句被执行

例如：(错误的写法)
int add(int a,int b)
{
return a+b;
return a-b;
}

4、异常处理语句（后面章节讲解）。

class Ch03_11
{
public static void main(String[] args)
{
e:
for(int i = 0;i<=3;i++)
{
for(int j = 0;j<=3;j++)
{
if(j == 1)
{
break e;
}
System.out.println("Hello World!");
}
}
//打印100以内的偶数
int count = 0;
for(int i = 1;i<=100;i++)
{

if(i%2!=0)
{
continue;
}
count++;
System.out.print(i+" ");
if(count%10==0)
{
System.out.println();
}
}
五、方法：完成某一个功能的程序段，将该程序段按照固定的语法命名并允许执行该程序段时传入参数。
语法：
修饰符 返回值类型 方法名（【形参列表】）
{
方法体语句；
}
第五章 数组
第一节 数组的基本概念
数组：相同数据类型数据的集合。这些数据逻辑相邻的
空间也是相邻的。数组中的数据称为数组中的元素。数组元素
可以用数组名[下标值]表示。当数组中有N个元素，第一个元
素的下标值是0,最后一个元素的下标值是N-1.如果数组名
后跟一个“[]”表示是一维数组。有两个“[]”表示二维数组。
一. 定义和初始化:
1. 一维数组的语法定义：
数据类型 []数组名；
说明：
1）数据类型是任意合法的java类型，包括基本数据类型和复合的数据类型（类、接口、数组）
2）当一次定义一个数组时，[]可放数组名前，也可放数组名后；但是如果一次有多个定义时，放前放后是不同的。
3）定义数组时不能标明数组元素的个数
2. 静态初始化：
//定义一个int数组类型的变量，变量名为intArr
int[] intArr;
//使用静态初始化，初始化数组时只指定数组元素的初始值，不指定长度。
intArr = new int[]{8,6,9,-12};
//定义同时初始化：
int []arr = {1,2,3,4,5};
//定义一个Object数组类型的变量，变量名为object.
Object[] objArr;
//使用静态初始化，初始化数组时数组元素的类型是定义数组元素类型的子类
objArr = new String[]{“Java”,”李刚”};
Object[] objArr2;
//使用静态初始化
objArr2 = new Object[]{“Java”,”李刚”};
简化的静态初始化方法
int[] a = {5,6,7,3,-5};
3. 动态初始化：指只定义数组的长度，由系统为每个数组元素指定初始值。语法格式为：
arrayName = new type[length];
//数组的定义和初始化同时完成
int[] prices = new int[5];
//数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类。
Object[] books = new String[4];
4. 访问数组元素
//输出objArr数组的第二个元素，即字符串“李刚”
System.out.println(objArr[1]);
//为objArr2的第一个元素赋值
objArr2[0]=”Spring”;
注意：如果访问数组时指定的索引小于0或者大于等于数组的长度，编译不会出现错误，但运行时会出现异常：java.lang.ArrayIndexOutOfBoundsException:2(数组索引越界异常)
5. 遍历数组元素
1).用for循环
2).foreach循环，JDK1.5加入的功能
语法格式：for(数据类型 临时变量 ： 数组名)
如：
Sring[] books = {“轻量级J2EE企业应用实战”,”Struts2权威指南”,”基于J2EE的Ajax宝典”};
for(String book : books)
{System.out.println(book);}
临时变量用来临时存储数组内元素的值，然后输出，从语法上讲可以对其赋值，但极易出现错误。同时临时变量对数组内元素无任何影响，所以foreach循环不能用于给数组赋值。
6. 数组元素个数：在java中所有的数组中都有一默认属性length，length的值就是元素的个数。
语法形式：数组名.length
二. 数组元素的拷贝
1. 一个数组的元素的值可以采用另一个数组的元素的值.该方法在System类中定义.
arraycopy(src,srcIndex,dest,destIndex,length)
说明:
src: 源数组
srcIndex: 源数组的元素下标值
dest: 目标数组
destIndex: 目标数组的元素下标值
length: 拷贝的元素的个数
注意: 使用该方法时要注意越界问题
int[] arrSrc={1,2,5,6,3,3};
int[] arrDest=new int[arrSrc.length];
System.arraycopy(arrSrc,0,arrDest,3,2);
for(int temp:arrDest)
{
System.out.print(temp+” ”);
}
}
输出结果:0 0 0 1 2 0
三. 数组的综合练习
1. 定义一个类:ObjectGroup:
（1）数据成员如下：
1）一个整型数组初始空间长度为10；
2）一个整型变量size 用来记录元素个数，初始值0；
（2）完成功能如下：
1）向数组中添加元素的方法add(int value),该方法实现元素添加功能，当初始空间默认值都被添加的新值替换后，该数组的空间扩大为原来的2倍。
2）获得某个索引位置的元素的方法getObject（int index）;
3）获得整个数组的方法int []getObjects();
4)数组空间恢复初始状态 size恢复初始值的方法clear();
5)获得size的方法getSize()
2. 数组作方法的返回值类型和参数类型
（1）作为返回值类型：要求方法的返回值是一个数组
(2)数组作为方法的参数类型：调用方法时实参是
数组名。
3. 对象数组: 定义数组是数组的类型是类或者是接口.
数组元素的初始化使用该类的对象或子类对象或者是实现类对象.
例题:person类
4. 主方法的命令行参数,main(String[] args),args也是数组,在DOS窗口运行主方法时,class文件后跟的字符会存入args数组中.
5. 数组排序: 对数组中的元素按照升序或者是降序排列.
冒泡法排序：相邻的两个元素依次比较，然后判定是否换位。轮数比元素个数少1，每轮的次数是元素个数-轮数
数组综合练习：
（1）定义数组使用冒泡法排序。
（2）定义类按照学生的成绩进行降序排序并显示学生的信息包括编号、姓名、成绩
第二节 多维数组
如果一个数组的元素还是一个数组,如果这个元素是一维数组,那么这个数组称为二维数组.
二维数组和数学上的矩阵具有类似的结构.二维数组的每一个元素对应矩阵中每一行,每一个列相当于二维数组元素(一维数组)中的元素.每个列的元素引用时的语法:
数组名[行索引][列索引]
行列的索引值从0开始.
一. 二维数组的语法定义:
数据类型 [][]数组名 int [][]arr
或者
数据类型 数组名[][] int arr1[][]
或者
数据类型 []数组名[] int []arr2[]
int [][]a,b; 表示定义两个二维数组a,b,int[][]相当于数据类型
int c[][],d; 表示定义一个二维数组和一个整型变量d
int []e[],f; 表示定义一个二维数组e和一个一维数组f
二. 初始化
1. 定义同时初始化
int [][]arr={{1,2,3,},{3,5,4},{4,6,3}};
2. 定义之后初始化
int [][]arr=new int [3][4];
或者
int arr[][] =new int[3][];
如果行列的值都有规律,可以使用循环赋值,否则单个列赋值
数组名[行索引][列索引]=值;
arr[0][0]=10;第一行第一个元素
……….
arr[2][3]=2;第三行第四个元素
作业:
一. 二维数组连连看布局算法
要求:
1. 游戏界面4*8,编程界面6*10,共有32个图形
2. 实现1-8图形随机分配
3. 每种图形出现4次
(2) 选课系统Math类，ArithmeticException类，System类，String类
Math类
1. random方法，随机输出大于等于0小于1的浮点型数
//求2~10之间的一个随机整数
//公式是：Math.random()*(大-小+1)+小
int r = (int)(Math.random()*(10-2+1)+2);
2. 角函数sin，cos，tan等
sin(a),a是以弧度表示的角。如果是普通角，如30度，刚要转换为弧度。如：
Static PI=3.1415926;
System.out.println(PI*30/180);
反三角函数asin,acos,atan等
则a的值为要返回其反三角函数的值。
3. 数与弧度的转换函数
toRadians 把度数转换为弧度，括号内是用度数表示的角
toDegrees 把弧度转换为度数，括号内是用弧度表示的角
4. abs 返回一个数的绝对值
5. cbrt 返回一个值的立方根
6. ceil(a) 返回比a大的最小的整数
floor(a) 返回比a小的最大的整数
7. max(a,b) 返回a，b两个值中较大的一个
min(a,b) 返回a，b两个值中较小的一个
8. pow(a,b) 返回a的b次方