Java题型分布：
选择（20*1'）
填空（20*1'）
程序阅读（5*3'）
程序填空（10*2'）
简答（3*3'）
编程（8'+4'+4'）(包含一道面向对象和2道算法题目)
考点1：
1、Java程序的组成、结构
Java程序的源程序文件结构如下:
1.package语句，0～1句，必须放在文件开始，作用是把当前文件放入所指向的包中。
2. import语句，0～多句，必须放在所有类定义之前，用来引入标准类或已有类。
3.公共类的声明，0～1句，文件名必须与公共类的类名完全相同。其他类的声明，0～多句，类定义的个数不受限制。
4.接口的声明，0～多句，接口定义的个数不受限制。
2、Java Application程序执行的入口点
main方法是程序执行的入口点，一个Java Application程序只能有一个入口点。
方法头必须按照下面的格式书写
public static void main(String args [])
3、Java标示符的合法非法判断
标识符要满足如下的规定
标识符可以由字母、数字和下划线(_)、美元符号($)组合而成
标识符必须以字母、下划线或美元符号开头，不能以数字开头
4、Java的数据类型
注：String 字符串类变量未初始化时为NULL
5、各种数据类型定义变量，并赋初值。
boolean b = false;
char c = 'A';
int i =3;
long i = 3L;
float f = 3.14f;
double d = 3.14; 或double d = 3.14d or D;
String s ="a string";
byte b = 10 (byte值域被定义为-128~127，也就是signed byte) 6、循环结构
(a)while语句：
while语句的一般语法格式如下
while ( 条件表达式)
循环体
注：
1.其中条件表达式的返回值为布尔型，循环体可以是单个语句，也可以是复合
语句块
2.while语句的执行过程是先判断条件表达式的值
若为真，则执行循环体，循环体执行完之后再无条件转向条件表达式再做计算与判断
3.当计算出条件表达式为假时，跳过循环体执行while语句后面的语句
(b)do-while语句：
do-while语句的一般语法结构如下
do
循环体
while ( 条件表达式);
注：
1.do-while语句的使用与while语句很类似，不同的是它不像while语句是先计算条件表达式的值，而是无条件地先执行一遍循环体，再来判断条件表达式。
2.若表达式的值为真，则再运行循环体，否则跳出do-while循环，执行下面的语句。
3.do-while语句的特点是它的循环体将至少被执行一次。
(c)for语句：
for语句的一般语法格式如下
for (表达式1; 表达式2; 表达式3)
循环体
注：
1.表达式2是返回布尔值的条件表达式，用来判断循环是否继续
2.表达式1完成初始化循环变量和其他变量的工作
3.表达式3用来修整循环变量，改变循环条件
4.三个表达式之间用分号隔开
for语句的执行过程
1.首先计算表达式1，完成必要的初始化工作
2.再判断表达式2的值
3.若为真，则执行循环体，执行完循环体后再返回表达式3，计算并修改循环条件，
这样一轮循环就结束
4.第二轮循环从计算并判断表达式2开始
5.若表达式的值仍为真，则继续循环，否则跳出整个for语句执行下面的句子
6.for语句的三个表达式都可以为空，但若表达式2也为空，则表示当前循环是一
个无限循环，需要在循环体中书写另外的跳转语句终止循环
7、声明类的对象并初始化，访问类的属性域和方法的方式。
创建类对象：
类名新建对象名＝new 构造函数( )；
访问类的属性域和方法：
对象名.属性名和对象名.方法名
8、System.in /System.out
System.in “标准”输入流。(public static final InputStream in)
System.out “标准”输出流。(public static final PrintStream out)
9、Java Applet 需加载java.applet.Applet,图形界面需加载java.awt.*,图形界面事件的处理需要加载java.awt.event。
10、一个Applet执行中，必须有的属性项CODE、WIDTH、HEIGHT。
11、Java.io包中实现DataInput和DataOutput接口的类
实现DataInput接口的类：
DataInputStream、ObjectInputStream、RandomAccessFile
实现DataOutput接口的类：
DataOutputStream、ObjectOutputStream、RandomAccessFile
12、Java Applet和Java Application的区别
（1）运行方式不同。Java Application是完整的程序，可以独立运行；Java Applet 程序不能单独运行，它必须嵌入到用HTML语言编写的Web页面中，通过与Java兼容的浏览器来控制执行。
（2）运行工具不同。Java Application程序被编译以后，用普通的Java解释器就可以使其边解释边执行，而Java Applet必须通过网络浏览器或者Applet观察器才能执行。
（3）程序结构不同。每个Java Application程序必定含有一个并且只有一个main 方法，程序执行时，首先寻找main方法，并以此为入口点开始运行。含有main方法的那个类，常被称为主类，也就是说，Java Application程序都含有一个主类。而Applet程序则没有含main方法的主类，这也正是Applet程序不能独立运行的原因。
13、子类继承父类的非私有的属性和方法
Java中的继承是通过extends关键字来实现的，在定义类时使用extends关键字指明新定义类的父类，就在两个类之间建立了继承关系
定义形式
class SubClass extends SuperClass
{ ……}
注：
如果没有extends子句，则该类默认为https://www.doczj.com/doc/5a10898778.html,ng.Object的子类。所以，Java中，所有的类都是通过直接或间接地继承https://www.doczj.com/doc/5a10898778.html,ng.Object得到的。
新定义的类称为子类，它可以从父类那里继承所有非private的属性和方法作为自己的成员。
14、算术运算符、关系运算符、逻辑运算符的综合使用。
算术运算符: +，-，*，/，%，++，--
关系运算符: >，<，>=，<=，==，!=
逻辑运算符: !，& , | , ^ , &&，||
位运算符: &，|，^，~ ，<< ，>> ，>>>
赋值运算符: = , 扩展赋值运算符:+=，-=，*=，/=等
条件运算符: ?: (例：z=a>0?a:-a)
字符串连接运算符: +
15、数组的定义及引用数组元素，尤其是最后一个数组元素。
一维数组：
1.一维数组的声明方式
type var[] 或type[] var；
type指定数组的基本类型，如
int a[]; int[] a1; double b[]; Mydate []c;
2.Java语言中声明数组时不能指定其长度(数组中元素的个数)，例如
int a[5]; //非法
3.所有的数组下标从零开始
一维数组初始化：
1、动态初始化
1.数组定义与为数组元素分配空间并赋值的操作分开进行
2.使用运算符new来为数组所要存储的数据分配内存，并将它们分配给数组变量
int a[] = new int[3];
a[0] = 3;
a[1] = 9;
a[2] = 8;
2、静态初始化
int a[] = { 3, 9, 8};
MyDate dates[] = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)
};
数组元素的引用
1.定义并用运算符new为之分配空间后后，才可以引用数组中的每个元素
2.数组元素的引用方式：arrayName[index]
index为数组元素下标，可以是整型常量或整型表达式，如a[3] , b[i] , c[6*i]
数组元素下标从0开始；长度为n的数组合法下标取值范围：0 ~ n-1
3.每个数组都有一个属性length指明它的长度，例如
a.length 指明数组a的长度(元素个数)
多维数组
多维数组实际上就是“数组的数组”
定义多维数组变量时，要将每维数放在各自的方括号中，例如，下面的语句声明了一名为twoD的二维数组变量
int twoD[][] = new int[4][5];
该语句分配一个4行5列数组并把它分配给数组twoD
实际上这个矩阵表示了int类型数组的实现过程
当给多维数组分配内存时，只需指定第一个（即最左边）维数的内存即可，可单独地对余下的维数进行内存分配
例如，下面的程序在数组twoD被定义时给它的第一个维数分配内存，对第二维则是手工分配内存
int twoD[][] = new int[4][];
int t1[][] = new int [][4]; //非法
twoD[0] = new int[5];
twoD[1] = new int[5];
twoD[2] = new int[5];
twoD[3] = new int[5];
Java中多维数组不必须是规则矩阵形式
int[][] tt = new int[4][];
tt[0] = new int[2];
tt[1] = new int[4];
tt[2] = new int[6];
tt[3] = new int[8];
一般不推荐使用不规则的多维数组，因为如果把握不好运行过程中可能出错。
多维数组初始化
静态初始化
int intArray[][] = {{1, 2}, {2, 3}, {3, 4, 5}};
int intArray1[3][2] = {{1, 2}, {2, 3}, {4, 5}}; //illegal
动态初始化
int a[][] = new int[4][5];
int b[][] = new int[3][];
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[5];
16、类中方法的重载和覆盖(重写)
方法重载具体规范
1、方法的名称必须相同。
2、方法的参数必须不同，这里的不同分三种情况：
a、参数个数不同，类型无限制；
b、参数个数相同，但是参数类型不同；
c、参数个数和类型都相同，但是参数的顺序不同；
3、方法的返回类型和修饰符可以相同，也可以不同。
方法覆盖：如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
?子类的方法名称返回类型及参数签名必须与父类的一致
?子类方法不能缩小父类方法的访问权限
?子类方法不能抛出比父类方法更多的异常
?方法覆盖只存在于子类和父类之间，同一个类中只能重载
?父类的非静态方法不能被子类覆盖为静态方法
?父类的私有方法不能被子类覆盖
?父类的抽象方法可以被子类通过两种途径覆盖（即实现和覆盖）
?父类的非抽象方法可以被覆盖为抽象方法
17、构造方法，构造函数的说法
构造函数是一种特殊的方法主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们。即构造函数的重载。
使用构造函数时需要记住：
1.构造函数必须与类同名（如果一个源文件中有多个类，那么构造函数必须与公共类同名）
2.每个类可以有一个以上的构造函数
3.构造函数可以有0个、1个或1个以上的参数
4.构造函数没有返回值
5.构造函数总是伴随着new操作一起调用
18、修饰符上的访问控制符public private protected
类的修饰符分为访问控制符和非访问控制符两大类。
非访问控制符：abstract，final
类有两个非访问控制符,abstract 和final
1.abstract类称为抽象类是它所有子类公共属性集合,所以使用抽象类提高开发效率和易维护。
不能创建abstract 类的实例,然而可以创建一个变量,其类型是一个抽象类并让它指向具体子类的一个实例。
2.final 类称为最终类,说明这个类不可能有子类,通常用来定义有固定作用,用来完成某种标准功能的类。
拓展：
1. final 修饰的变量为最终域，程序中常需要定义各种类型的常量，可以final 来修饰。它在取值在程序的整个执行过程中都不会过变，想改变final变量的值会导致一个编译错误。
2.abstract 和final 不能同时修饰一个类,因为abstract 类自身没有具体对象,需要派生子类后再创建对象，而final 类没有子类.同时修饰就没有意义。
3. final 修饰的变量为最终域，程序中常需要定义各种类型的常量，可以final 来修饰。它在取值在程序的整个执行过程中都不会过变，想改变final变量的值会导致一个编译错误。
4.抽象方法仅有方法头、没有具体方法体的实现，如
abstract void performDial ( ) ;
abstract方法只有方法头的声明，而用一个分号来代替方法体的定义。方法体的具体实现，留到各子类在各自的类定义中完成。
abstract方法隐藏具体的细节信息，使调用该方法的程序不必过分关注类及其子类内部的具体状况。
注意：
所有抽象方法都必须存在于抽象类之中。
但抽象类不一定只能拥有抽象方法，可以包含非抽象的方法。
5. final在方法之前，防止该方法被覆盖。
final在类之前，标是该类不能被继承。
final在变量之前，定义一个常量。
6. abstract不能与final并列修饰同一个类。
abstract不能与private，static，final或native并列修饰同一个方法。
abstract类中不能有private的成员(包括属性和方法)。
abstract方法必须在abstract类中。
7. static用在变量或方法之前，表明它们是属于类的。
static修饰的方法为类方法（静态方法），修饰的变量为类变量（静态变量）。
类变量
生存期不依赖于对象，无需创建实例对象，可以直接通过类名访问。
也可以通过该类的实例对象访问
任何一个类的实例访问或操作这个成员，都是对这同一个内存单元的访问和操作类方法
可以直接通过类名访问
只能访问该类的类变量和类方法，不能直接访问实例的变量和方法。
19、抽象类与接口的区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final 类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
20、throws的作用：
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。
格式是：方法名（参数）throws 异常类1，异常类2，.....
java异常处理的throw和throws的区别
1. 区别
throws是用来声明一个方法可能抛出的所有异常信息，而throw则是指抛出的一个具体的异常类型。此外throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。
2.分别介绍
throws：用于声明异常，例如，如果一个方法里面不想有任何的异常处理，则在没有任何代码进行异常处理的时候，必须对这个方法进行声明有可能产生的所有异常（其实就是，不想自己处理，那就交给别人吧，告诉别人我会出现什么异常，报自己的错，让别人处理去吧）。
throw：就是自己进行异常处理，处理的时候有两种方式，要么自己捕获异常（也就
是try catch进行捕捉），要么声明抛出一个异常（就是throws 异常）。注意：throw一旦进入被执行，程序立即会转入异常处理阶段，后面的语句就不再执行，而且所在的方法不再返回有意义的值。
21、小应用程序执行
java applet程序必须嵌入到html文件中才能够执行，因此必须编写相应的html文件。下面为Hello.html文件的内容：
然后可以通过JDK所提供的命令"appletviewer"，在命令行下面执行java applet程序。如果是在windows操作系统中，就可以在"命令提示符"下敲入"appletviewer Hello.html。
Java Applet生命周期：
init()、start()、stop()、destroy()方法都是Applet类中已经定义的方法，系统根据上述规则自动执行Applet的生命周期。
---------------------------------------------------------------------------------------------------------------------- 考点2：
1、Java关键字
2、Java变量的作用域：
1.成员变量：
在类体中定义
在整个类中都有效
2.局部变量：
在方法中定义
方法体中声明
方法中的形参
只在本方法中有效
注意：
局部变量与类的成员变量同名，则局部变量会隐藏成员变量，称为名字隐藏。
若要访问被隐藏的成员变量，则必须使用thi s来访问。
this
用于代表当前正在使用或访问的对象。
每一个对象内部都有一个this变量，用于指明自身地址。
3、Java语言编译执行过程
执行分为两个阶段
1.编译
产生一个与机器无关的字节码文件（*.class）
2.运行
加载字节码，由Java的类装载器
校验字节码
执行代码
4、java运算符与表达式
包含：
算术运算符: +，-，*，/，%，++，--
关系运算符: >，<，>=，<=，==，!=
逻辑运算符: !，& , | , ^ , &&，||
位运算符: &，|，^，~ ，<< ，>> ，>>>
赋值运算符: = , 扩展赋值运算符:+=，-=，*=，/=等
字符串连接运算符: +
运算符的优先次序
注意：
1. 自增,自减运算符++,--
++x,--x表示在使用x之前,先使x的值加，减1 .
x++,x-- 表示在使用x之后,使x的值加，减1.
2. 算术混合运算的精度
1.精度从”底”到”高”排列的顺序是：
byte short int long float double
2.Java将按运算符两边的操作元的最高精度保留结果的精度,
例如：
5/2的结果是2,要想得到2.5,必须写成5.0/2或5.0f/2。
char型数据和整型数据运算结果的精度是int。
5、流程控制
任何程序都可以且只能由三种基本流程结构构成，即顺序结构、选择结构和循环结构。
6、抽象类
抽象类(abstract修饰的类)
抽象类必须被继承。
抽象类不能被直接实例化(new 创建对象)，抽象类对象可以引用其子类实例对象。
只能作为其它类的父类
抽象方法(abstract修饰的方法)
抽象方法必须被重写
抽象方法只有声明，不能有实现。
定义了抽象方法的类必须是抽象类。
抽象类的一个例子：
abstract class Person{
public Person(String n){
name = n;
}
public abstract String getDescription();
public String getName(){
return name;
}
private String name;
}
7、接口
接口(interface)是抽象方法和常量值得定义的集合。
从本质上讲，接口第一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。其主要作用是可以帮助实现类似于类的多继承的功能。
接口定义举例：
public interface Calculate {
final float PI=3.14159f; //定义用于表示圆周率的常量PI
float getArea(float r); //定义一个用于计算面积的方法getArea()
float getCircumference(float r); //定义一个用于计算周长的方法getCircumference()
}
接口特性：
多个无关的类可以实现同一个接口。
一个类可以实现多个无关的接口。
与继承关系类似，接口与实现类之间存在多态性。
实现上述接口的例子：
public class Cire implements Calculate {
public float getArea(float r) {
float area=PI*r*r; //计算圆面积并赋值给变量area
return area; //返回计算后的圆面积
}
public float getCircumference(float r) {
float circumference=2*PI*r; //计算圆周长并赋值给变量circumference
return circumference; //返回计算后的圆周长
}
}
8、异常
1.Java异常是Java提供的用于处理程序中错误的一种机制。所谓错误，是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻碍程序的正常运行。
为了加强程序的健壮性和容错性，程序设计时，应充分考虑可能发生的异常事件并作出相应的处理。
2.Java通过面向对象的方法来处理异常。（各种不同的异常事件进行分类，把异常事件当成对象来处理）
把生成异常对象并把它提交给运行时系统的过程称为抛出(throw)一个异常。
运行时系统从生成异常的方法开始进行回溯，直到找到包含相应异常处理的方法为止，这一个过程称为捕获(catch)一个异常。
3.异常的分类：
4.声明异常
一个方法不处理它产生的异常，而是沿着调用层次向上传递，由调用它的方法来处理这些异常，叫声明异常。
声明异常的方法
在可能产生异常的方法名后加上要抛出(throws)的异常的列表。
例子：
public class exception1 {
static void Proc(int sel) throws ArithmeticException,
ArrayIndexOutOfBoundsException { //声明异常的方法
System.out.println(“In Situation" + sel );
if (sel==0) {
System.out.println("no Exception caught");
return;
}else if(sel==1) {
int iArray[]=new int[4];
iArray[10]=3;
}
}
public static void main(String args[]) {
try {
Proc(0); //此处调用Proc方法要处理异常
Proc(1);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Catch"+e);
}
}
}
5.抛出异常
1.所有系统定义的运行异常都可以由系统自动抛出。
2.用户程序自定义的异常不可能依靠系统自动抛出，必须借助于throw语句来定义何种情况产生此种异常对应的错误，并应抛出这个异常类的新对象。
例子：
自定义异常类：
声明并抛出异常：
6. 异常捕获和处理
形式：
例子：
9、字符流与字节流（Java中包含了多个流类型来实现输入/输出功能）
字节流：
Java中所有流类型都在java.io包中，分别继承以下四种抽象流类型。
字节流字符流
输入流InputStream Reader
输出流OutputStream Writer
1. 字节流是一个字节序列(数据在内存中的存储形式)，它与外部设备中的字节存在着一一对应关系，也就是说，传输过程不存在字符的转换，被读写字节的个数与外部设备中的字节个数是相同的。
2. 字符流是一个字符序列，用于存储和获取文本，还可以用于读取非Java语言生成的文本文件。在字符流中，可按需要进行某些字符的转换，在被读写字符和外部设备中的字符之间不存在一一对应关系，被读写字符的个数可能与外部设备中的字符个数不一样。我们在操作字符流的时候，不关闭流，我们写入的数据是无法保存的。所以在操作字符流的时候一定要记得关闭流。
字符流与字节流的区别：
操作字节流操作时本身不会用到缓冲区，是文件本身直接操作，而字节流在操作时就使用到了缓冲区。
字节流在操作的时候是直接与文件本身关联，不使用缓冲区,字节直接存到文件中；字符流在操作的时候是通过缓冲区与文件操作，字符到缓冲区然后再到文件中，所以字符流中存在一个flush()方法来刷新缓冲区。
字符流：
10、编译与运行
javac hello.java --编译
java hello --运行
11、强制类型转换
强制类型转换，又叫造型。分为基本数据类型和引用数据类型两种情况。
1.对于引用类型来说，什么是强制类型转换呢？简单地说，就是把父类型转换为子类型，也叫向下转型。
例子：
假设Student类是Person类的子类。
Student stu＝new Student();
Person p1＝stu;// 父类Person的引用变量引用子类Student的对象（向上转型）
Student s＝（Student）p1；//父类对象赋给子类变量（向下转型）
向下转型，必须确保该父类变量目前引用的是子类对象；必须使用强制类型转换。拓展：对象转型
2.在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为：(byte，short，char，int，long，float，double)。对于boolean类型，是不可以转换为其它的数据类型的。byte，short，char之间是不会相互转化的，它们三者在计算时首先会转换为int 类型，再计算。
简单数据类型之间的转换又可以分为：
1、低级到高级的自动类型转换
例子：byte b;
int i=b;
long l=b;
2、高级到低级的强制类型转换
例子：int i = 99;
byte b =(byte)i;
char c = (char)i;
12、包（package）
用途：
1.管理类名空间
2.解决类名重复冲突
13、输入流与输出流
Java中把不同的输入、输出源（键盘、文件、网络连接等）抽象表述为“流”（stream）。
1.两种基本流：
输入流：只能从中读取数据，不能向其写入数据。
输出流：只能向其写入数据，不能从中读取数据。
2.输入输出流的基类
InputStream和OutputStream。它们是抽象类，不能直接使用。
InputStream类的方法
read()：从流中读入数据，提供三种从流中读数据方法
int read()：读一个整数
int read(byte b[])：读多个字节到数组中
int read(byte b[], int off, int len):将输入流中最多len个数据字节读入byte 数组。
skip()：跳过流中若干字节数
available()：返回流中可用字节数
mark()：在流中标记一个位置
reset()：返回标记过得位置
markSupport()：测试此输入流是否支持标记和复位操作
close():关闭流
OutputStream类的方法
write(int b)：将一个整数输出到流中
write(byte b[])：将数组中的数据输出到流中
write(byte b[], int off, int len)：将数组b中从off指定的位置开始len长度的数据输出到流中
flush()：将缓冲区中的数据强制送出
close()：关闭流
PrintStream类的方法有
write, flush, checkError,print, println,close
其中println，不属于OutputStream类，可以输出多种形式的数据，例如
println(String s), println(char c)等。
3.文件I/O：
File fp=new File(“tempfile.txt”);
对文件操作要定义文件流
FileInputStream类用来打开一个输入文件
FileInputStream in=new FileInputStream(fp);
FileOutputStream类用来打开一个输出文件
FileOutputStream out= new FileOutputStream(fp);
例子：
import java.io.*;
public class filestream {
public static void main(String args[]) {
try{
File inFile=new File(”file1.txt");
File outFile=new File(”file2.txt");
FileInputStream fis=new FileInputStream(inFile);
FileOutputStream fos=new FileOutputStream(outFile);
int c;
while((c=fis.read())!=-1)
fos.write(c);
fis.close();
fos.close();
}catch(FileNotFoundException e) {
System.out.println("FileStreamsTest: "+e);
总结一：javaweb课程总结刚开始学的时候，感觉这两门课程好高大上的样子，因为自从学软件工程这个专业以来，一直都是学的理论性、框架性的东西，就没有接触到编程的实质性的部分，终于开始学编程了，感觉蛮兴奋的，也是精神饱满，信心十足，怀着一腔热血来听课。 由于JAVAWEB和JSP两门课是同时上的，而且每次都是一整上午，上课时间很长，老师一直有条不紊的讲着，虽然时间很长，但是每当大家上完课，心中都是有一种充实的感觉，大家都觉得有所收获，所以也就不曾觉得累了。 JAVAWEB这门课让我认识了以前见所未见闻所未闻的专业术语，Web应用程序的概述。我从中了解到Web应用程序的三层体系结构：表示层、业务层、数据存取层。从而想到了学数据库设计时的数据库设计三大范式，它们同是叙述在编写代码时应做的规划和应遵循的规则，这种规划在以后的学习中时有出现，说明编程并不是一味地进行循环判断、死记硬背，而需要在技术上有所加强、在效率上有所提高。做任何事都是如此，事先必须有目标、有计划，有统筹，这样执行时才不会盲目，才不会事倍功半。学习编程对综合能力都是一种培养。 接下来是JSP知识。要学JSP，就必须会HTML，如果HTML学不通，这对以后的学习都是一个瓶颈。基础一定要打扎实，吃透，否则上层建筑的建起就不会很顺利甚至没法起步。然后是JavaBean。以下是个人对JavaBean的一点学习体会。JavaBean里有set()和get()方法，用这些方法能很容易地传值，逻辑上更标准，代码看起来也更规范。但set()和get()方法只是用来对属性进行操作的，所以如果是进行复杂的逻辑或对数据库进行操作等，那么就不要写成set()和get()方法，只用一个有返回值的方法就足以。这样直观方便，且符合规范。总之，set()和get()方法不要没有效率地滥定义。 接着是Servlet。Servlet是一个用Java编写的应用程序，在服务器上运行，用来处理请求和响应，也可以单独做为一个Web页面。然后讲的是标签，包括自定义标签和JSP标准标签库。用一般的Java代码都几乎能实现它们的功能。它们的好处是提高了代码的重用性。 我们需要配置的坏境有JDK，Tomcat，还要用到Myeclips这一基础的编程工具。在学习JSP之前，由于没有网页编程的基础，便学习了HTML这种文本标记语言，自己试着去做简单的静态网站。后来学做JSP动态网站时，就涉及到了多方面的知识，JSP内部对象及内部对象所涉及的方法，JSP与数据库连接，如何去引用数据库。这门课更是巩固了JAVA 这一基础编程语言，要求对JAVA掌握的要透彻，每门语言要学扎实，深入理解，都要花费很大的功夫，不是容易的事情。 Jsp与servlet有一定的区别，Servlet可以看作是HTML的Java代码，而JSP可看作是包含Java代码的HTML。共同点：JSP和Servlet实际上是一回事。JSP页面最终要转换成Servlet，并进行编译，在请求期间执行的实际上是编译后的Servlet。因此，JSP页面不过是编写Servlet的另一种方式。各自应用的范围：Servlet比较适合于做处理任务，如做业务逻辑；JSP适合于表示任务，如网页制作，生成动态网页。 对JAVAWEB和JSP课程的知识就简单介绍到这里，本学期的这两门课程让我对软件工程这门课有了一个全新的认识，我真切的学到了能用的东西，大学里的很多课是浪费时间，而
https://www.doczj.com/doc/5a10898778.html,ng.Object 类，是所有类的根父类！ 2.Object类仅有一个空参的构造器public Object(){ } 3.关于方法： ①equals(Object obj) public boolean equals(Object obj) { return (this == obj); } // == // 1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，反之返回false // 注：两端数据类型可以不同，在不同的情况下，也可以返回true。 // 2.引用数据类型：比较引用类型变量的地址值是否相等。 //equals(): >①只能处理引用类型变量②在Object类，发现equals()仍然比较的两个引用变量的地址值是否相等 >像String 包装类File类Date类这些重写Object类的equals()方法，比较是两个对象的 //"实体内容"是否完全相同。 >若我们自定义一个类，希望比较两个对象的属性值都相同的情况下返回true的话，就需要重写Object类的 equals(Object obj)方法 ②toString()方法
当我们输出一个对象的引用时，会调用toString()方法。 1.public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } 当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置 2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。 3.像String类、Date、File类、包装类都重写了toString()方法。 1. String类：不可变的字符序列（如：String str = "atguigu"; str += "javaEE"） 1.关注于String常用的方法！ 2.String类与基本数据类型、包装类；与字符数组、字节数组； * 1.字符串与基本数据类型、包装类之间转换 * ①字符串--->基本数据类型、包装类:调用相应的包装类的parseXxx(String str); * ①基本数据类型、包装类--->字符串:调用字符串的重载的valueOf()方法 *
一级建造师《工程经济》考点整理 2017年一级建造师《工程经济》考点整理 期间费用的核算 施工企业的期间费用主要包括管理费用和财务费用 管理费用是指企业行政管理部门为管理和组织经营活动而发生的各项费用。(口诀:管办差固工、劳工职财税、其他) 具体包括:1管理人员工资2办公费3差旅交通费4固定资产使用费5工具用具使用费6劳动保险费7工会经费8职工教育经费9财产保险费10税金(指企业按规定缴纳的房产税、车船使用税、土地使用税、印花税等)11其他。 财务费用包括:1利息支出2汇总损失3相关手续费4其他财务费用 会计等式的应用 静态会计等式(编制资产负债表的重要依据)：资产=负债+所有者权益(财务状况) 动态会计等式(编制损益表的重要依据)：收入-费用=利润(经营成果) 会计等式(会计平衡公式、会计方程式)是复试记账、试算平衡和编制会计报表的理论依据。 新技术、新方案选择原则： ①技术上先进、可靠、适用、合理②经济上合理(主要原则) (1)常用的静态分析方法：年折算费用法、增量投资分析法及综合总费用法。
(2)常用的动态分析方法：净现值(费用现值)、净年值(年成本) 法 增量投资分析法公式：(R>基准投资收益率=可行，反之不可行) 提高价值的途径 价值工程V=F/C(功能/寿命周期成本,也叫性价比)“价值”是一 个相对概念，功能/费用，不是使用价值，也不是交换价值，而是对 象的比较价值。C----寿命周期成本。 价值工程三要素：价值、功能、寿命周期成本。 (一)价值工程的目标，以最低寿命周期成本，使产品具备必须具备的功能。 产品的寿命周期成本=生产成本+使用及维护成本组成 (1)产品生产成本：是指发生在生产企业内部的成本，也是用户 购买产品的费用,包括产品的'科研、实验、设计、试制、生产、销 售等费用及税金等 (2)产品使用及维护成本：是指用户在使用过程中支付的各种费 用的总和，它包括使用过程中的能耗费用、维修费用、人工费用、 管理费用等，有时还包括报废拆除所需费用(扣除残值)。 (二)价值工程的核心，对产品进行功能分析。首先不是分析结构，而是先分析功能，再研究结构。 (三)价值工程将产品价值、功能和成本作为一个整体同时来考虑 (四)价值工程强调不断改革和创新 (五)价值工程要求将功能定量化 (六)价值工程是以集体智慧开展的有计划、有组织、有领导的管理活动。 提高价值工程的途径：1双向型F增，C减;2改进型F增，C不变;3节约型F不变，C变小;4投资型F大提高，C小提高5牺牲型
多选 1.如何处理单元测试产生的数据，下列哪些说法是正确的？ABC A .测试数据入库时加特殊前缀标识。 B .测试数据使用独立的测试库。 C .自动回滚单元测试产生的脏数据。 D .无须区别，统一在业务代码中进行判断和识别。 多选 2.关于并发处理，下列哪些说法符合《阿里巴巴Java开发手册》：ABC A .线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 B .同步处理时，能锁部分代码区块的情况下不要锁整个方法；高并发时，同步调用应该考虑到性能损耗。 C .创建线程或线程池时，推荐给线程指定一个有意义的名称，方便出错时回溯。 D .推荐使用Executors.newFixedThreadPool(int x)生成指定大小的线程池。(线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式) 多选 3.下列哪些说法符合《阿里巴巴Java开发手册》：ACD A .对于“明确停止使用的代码和配置”，如方法、变量、类、配置文件、动态配置属性等要坚决从程序中清理出去，避免造成过多垃圾。 B .永久弃用的代码段注释掉即可，即不用加任何注释。 C .对于暂时被注释掉，后续可能恢复使用的代码片断，在注释代码上方，统一规定使用三个斜杠(///)来说明注释掉代码的理由。 D .不要在视图模板中加入任何复杂的逻辑。 多选 4.关于分页查询，下列哪些说法符合《阿里巴巴Java开发手册》：ABC A .分页查询，当统计的count为0时，应该直接返回，不要再执行分页查询语句。 B .iBATIS自带的queryForList(String statementName,int start,int size)分页接口有性能隐患，不允许使用。 C .定义明确的sql查询语句，通过传入参数start和size来实现分页逻辑。 D .可使用存储过程写分页逻辑，提高效率。
目录 第一章Jaｖa入门2? 第二章 Java基础5? 第三章条件转移1?４ 第四章循环语句20? 第五章方法 ............................................... ２6 第六章数组33? 第七章面向对象........................................... 4２第八章异常63? ? 第一章Jaｖａ入门 知识点汇总 1、JAVA 三大体系 ?Jａva ＳE：（J2SE，Jａva2 Plａtｆｏrm Ｓｔandaｒd Edｉtion,标准版），三个 平台中最核心的部分，包含Jaｖa最核 心的类库。?JａvaEＥ:(J2EＥ，Jａva 2 Platfｏｒｍ, EｎteｒpｒisｅEditiｏｎ，企业版）, 开发、装配、部署企业级应用，包含 Servlet、ＪSP、ＪａｖａＢeａn、ＪDB Ｃ、ＥJＢ、Web Ｓerｖice等。 ?Java ＭE:（J2ＭE,Jａva 2 Pｌaｔfｏr ｍMicｒo Ediｔiｏn，微型版），用于 小型电子设备上的软件开发。
2、JDK，JRＥ,JＶＭ的作用及关系 作用 ★JVM：保证Jaｖａ语言跨平台 ★JRＥ：Javａ程序的运行环境 ★ＪＤK:Jaｖa程序的开发环境 关系 ★JDK:JRE+工具 ★JRE:ＪＶM+类库 3、ＪDＫ环境变量配置 ?pａtｈ环境变量:存放可执行文件的存 放路径,路径之间用逗号隔开 ?classpａth环境变量：类的运行路径,J ＶＭ在运行时通过cｌasspａth加载需 要的类 4、重点掌握两个程序 ?javac．eｘe:Java编译器工具，可以将 编写好的Ｊava文件（．jａva）编译成 Ｊava字节码文件（．cｌaｓs）； ?javａ.ｅxe:Jaｖa运行工具，启动Jaｖa 虚拟机进程，运行编译器生成的字节 码文件(．ｃlass） 5、一切程序运行的入口 puｂｌｉｃstaｔic vｏiｄmain(Strｉng aｒgs []）｛ Syｓtem．out.ｐriｎtｌｎ（“Hel ｌo Ｗorld!”）； } 课堂笔记 练习题 一、填空题 1、Java的三个技术平台分别是（J2SE )、（Ｊ2EE)、(J2ME）。 2、Sun公司针对领域不同，提供了三个Jaｖa版本,其中对于个人计算机程序开发的是( Ｊ2SE ), 对于企业开发应用的是（J2EE)，对于嵌入式设备应用开发的是( J２ＭＥ )。 （ｃｌasｓｐａth )。 3、建立Java开发环境，安装ＪＤK,一般需要设置环境变量（path）、 4、编写一个Jａva源程序,其文件名为Teｓt．java，则编译该源程序的命令为（javac )，运行 该程序的命令为( java），生成文档注释的命令为( javadoc)。 5、Java程序的运行环境简称之为( JRE)。
1、工程经济学 定义：在有限资源的条件下，运用有效的方法，对各种工程项目进行评价和选择，以确定出最佳方案，从而为实现正确的投资决策提供科学依据的一门应用性经济学科。 研究对象（P2）：工程项目的经济性（一个项目具有独立的功能和明确的费用投入）出发点：企业或投资者角度，以市场价格作为参照的财务评价； 地区或国家角度，综合考虑资源配置效率的国民经济评价； 考虑到就业率、分配公平和社会稳定等方面的社会评价。 研究特点（P3）：边缘性：自然科学和社会经济科学之间的边缘性学科； （编英语综述）应用性：对具体问题进行分析评价，为将要采取的行动提出决策的依据； 预测性：在问题决策之前进行的，有科学的依据才能有科学的决策； 综合性：研究处理技术经济问题需要运用多学科知识进行综合分析与评价； 数量性：为科学准确评价方案的经济效果，工程经济学采用许多定量分析。 2、时间价值 定义：资金时间价值是指资金在扩大再生产及其循环周转过程中，随着时间变化而产生的增值。 产生增值的两个条件： （1）货币作为资本或资金参加社会周转； （2）经历一定的时间。 影响增值的因素主要包括： （1）资金数量和投入的时间； （2）资金的周转速度； （3）资金效益高低； （4）资金使用代价的计算方式及利率高低等。 现金流量（现金流入、现金流出及净现金流量的统称） 三要素：大小、流向、发生时间 六个基本公式 已知量未知量系数表达式系数计算式P F （F/P，i，n）F=P×(1+i)n F P （P/F，i，n） P=F× 1 (1+i)n A F （F/A，i，n） F=A×(1+i)n?1 i F A （A/F，i，n） A=F× i (1+i)n?1 A P （P/A，i，n） P=A×(1+i)n?1 i×(1+i)n P A （A/P，i，n） A=P×i×(1+i)n (1+i)n?1 3、投资的估算固定资产投资估算增值形式 （1）借贷中的利息；（2）生产经营中的利润；（3）投资的收益； （4）占用资源的代价。
阿里校园招聘历年经典面试题汇总：算法工程师 （1）、jvm 原理 （2）、minor GC 与 Full GC （3）、HashMap 实现原理 （4）、java.util.concurrent 包下使用过哪些 （5）、concurrentMap 和 HashMap 区别 （6）、信号量是什么，怎么使用？ （7）、阻塞队列了解吗？怎么使用？ （8）、JAVA NIO 是什么？ （9）、类加载机制是怎样的 （10）、什么是幂等性 （11）、有哪些 JVM 调优经验 （12）、分布式 CAP 了解吗？ （13）、hdfs怎么添加Datanode,添加后hdfs会有什么操作？ （14）、Hbase 跟关系数据库对比优缺点？为什么 Hbase 索引速度快 （15）、Hbase 大压缩与小压缩区别 （16）、Hive 与 Hbase 的使用场景 （17）、简单说说Spark功能，spark 与hive有无依赖关系？ （18）、zookeeper 有什么应用场景，怎么选举的？3 个节点挂掉一个能正常工作吗？ （19）、Hbase 中 zookeaper 作用 （20）、Hbase 写操作什么时候返回 （21）、mysql 有哪些存储引擎？各自特点 （22）、用过哪些设计模式？怎样实现线程安全单例模式？ （23）、用过哪些RPC框架？ （24）、什么是AOP？ （25）、决策树算法怎么实现的？ （26）、java垃圾回收会出现不可回收的对象吗？怎么解决内存泄露问题？怎么
定位问题源？ （27）、终止线程有几种方式？终止线程标记变量为什么是 valotile 类型？（28）、用过哪些并发的数据结构？ cyclicBarrier 什么功能？信号量作用？数据库读写阻塞怎么解决？ （29）、乐观锁与悲观锁，怎么实现乐观锁？ （30）、开发过分布式框架？怎么实现分布式事务？ （31）、spark streaming与storm区别？ （32）、找到最大子数组的 start,和end下标 （33）、用过 CDH中什么任务调度？ （34）、spark streaming时间间隔设置很小会出现什么状况？ （35）、搜索引擎了解多少？你认为搜索引擎的难点在哪里？ （36）、RPC 了解吗？怎么监控 RPC 状态，找出出现问题的 RPC 连接？（37）、spring 框架了解多少？ （38）、flume应用场景 （39）、找出一串字符中第一个不重复字符的下标。 点击查看详细面经〉〉〉〉〉〉〉〉〉〉〉〉 更多精品干货>>>>>>>>>>> 更多阿里机器学习/数据挖掘经典面试题 其他名企机器学习/数据挖掘经典面试题
第一章Web开发基础知识（简单描述）表单(续) 表单元素