java学习笔记

Java第一天2007年4月23日

1、Java之父Golsling

1995年5月23日Java诞生

1998年12月 1.2版本Java2J2SE J2EE J2ME

2004年12月 1.5版本(5.0)Java JavaSE JavaEE JavaME

2、Java SE---Java标准平台

Java EE---企业级平台

Java ME---微小平台，用在资源受限的平台上

3、（1）跨平台---一次编译，到处运行

（2）简单---简化C++，取消了指针，对指针进行了上层的封装，它保证能够通过这个指针（引用），来访问有效的内存单元。

不允许多继承，使继承关系成树装图，每个类都只能由一个父类。

java语言的开发效率高，但执行效率低。（相当于c++的55%）（3）纯面向对象的语言---都要放在类中

（4）垃圾回收机制---自动垃圾收集，永远不会出现内存泄露的问题

4、虚拟机

java语言是先编译后解释，java源码是通过编译生成一种特殊的.class的中间字节码文件，然后再由JVM进行解释运行。

（编译）（解释）

.java---->.class--->可执行文件

所以效率低，是C++的20倍

5、java源代码中的main方法的定义写法。main方法是程序的入口。

public class Hello{//一个源文件中只能有一个公开类，而且源文件的文件名与公开类的类名完全一致

public static void main(String[]args){//程序入口public static可以调换顺序

System.out.println("He llo world");//打印语句

}

}

编译命令javac xxxx.java源文件的名字，源文件中的一个类会对应编译生成一个.class 文件

运行命令java xxxx类的名字---启动虚拟机

6、环境变量

JAVA_HOME=/opt/jdk1.5.06JDK安装路径---JDK=JRE{JVM(硬件)+编译器（软

件）}+编译器工具+类库

PATH=$Path:$Java_Home/bin:.

ClassPath=.类路径

7、包---分类放置，减少命名空间

包名.类名表示一个类的全限定名

java xxx.xxx.ClassA---运行时要在包结构的上一层目录来运行。

javac-d.xxxx.java---编译的时候，按照包结构存放字节码文件，此命令生成的.class 文件在当前目录

package xxx.xxx，包的定义在一个程序中只能由一个

import xxx.xxx.xxx.ClassA;---在程序中声明ClassA类，使用的时候不需加包名，使用同一包内的类时，不用引入

import p1.p2.p3.p4.p5.*;---声明p5包中所有的类，不能代表其子包

系统会在每个java程序中隐含导入了https://www.wendangku.net/doc/8b4021755.html,ng这个包

8、java中的注释，

单行注释//......

多行注释/*.......*/

文档注释/**........

(换行标签)*/,用javadoc命令可以根据原码中的文档注释生成注释文档（html格式）。文档注释中可以使用html标签。

javadoc-d路径（指定注释文档的保存路径）xxx.java

文档注释一般写在类定义之前，方法之前，属性之前。

在文档注释中可以用@author表示程序的作者，@version表示程序的版本，前两个注释符号要写在类定义之前，用于方法的注释@param对参数进行注释,@return对返回值进行注释@throws对抛出异常的注释。

10、标识符规则---类，方法，变量，同时也是包名的规范

由字母（汉语中的一个汉字是一个字母），数字，下划线和货币符号组成，不能以数字开头。

大小写敏感

没有长度限制，不能有空格

不能使用Java的关键字和保留字

java中的关键字

goto和const在java中虽然不再使用但是还作为保留字存在

java中没有sizeof这个关键字了，java中的boolean类型的值只能用true和false，且这两个也是关键字

enum枚举assert断言

一个标识符尽量符合语义信息，提高程序可读性

类名：每个单词首字母大写，

变量和方法：第一个单词小写，后边的每个单词首字母大写

包名：全部小写

常量：全部大写

11、局部变量：定义在方法中的变量

（1）先赋值后使用

（2）从定义变量的代码块开始到代码块结束

（3）在同一范围内不允许两个局部变量发生命名冲突

Java第二天2007年4月24日

1、Java的数据类型

（1）简单类型---8种有符号的数据类型

a)整型

byte1字节8位-128到127

short2字节16位-2^15到2^15-1-32768到32767

int4字节32位-2^31到2^31-1-2147483648到2147483647整型值存放，正数存放原码（二进制码），负数则存放补码（原码按位取反末位加一）。

long8字节64位-2^63到2^63-1long a=40000l;//在数字的结尾加“l”，表示long类型的字面值

b)浮点类型

float4字节32位float a=1.3f;

double8字节64位double a=1.3;

double和long比较，double表示的数值要大，因为有科学计数法

float a=1.3;//error会造成精度丢失，强转float a=(float)1.3;或者float a=1.3f;

c)字符类型

char2字节16位

d)布尔型

boolean false/true//Java中false与0不能转换

自动类型提升：

a运算符b

a和b中有一个是double,结果就是double

a和b中有一个是float,结果就是float

a和b中有一个是long,结果就是long

除以上之外的情况，结果都是int

char是无符号的16位整数,字面值必须用单引号括起来；‘a’

String是类，一个String的字符串是一个对象，非原始数据类型；

在字符串中使用"+"，表示字符串的连接，系统重载了这个运算符

char类型也可以用通用转译字符，但是不能用ASCII码。可以用“\u0000”(十六进制)这种格式，因为char型中使用的是unicode编码方式。

char c1='a';

char c2=97;

char c3='\u0061';//一个字节用2个十六进制的数字表示

整数除0有异常，double除0没有异常

（2）对象类型

2、java中的运算符（java的运算符的优先级和结合性和c++相同）

***System.out.println(3/2)按整型计算得1***

byte a=1;

a=a+2;//不合法，自动类型提升，赋值丢失精度

a+=2;//不会发生自动类型提升的,合法

a++;//不会发生自动类型提升的

1)>>=前面是零补零，前面是一补一;右移一位比除以2效率高

2)>>>=无符号右移（强制右移都会移进零），

>>=和>>>=对于负数不一样

正数：右移n位等于除以2的n次方

负数：变成正数。

3)&&短路与，前面为假，表达式为假，后面的操作不会进行，&非短路运算符，会对所有条件进行判断。

例：int a=4;

if(a<3&(b=a)==0)b赋值

if(a<3&&(b=a)==0)b不赋值

4)||短路或，前面为真，表达式为真，后面的操作不会进行，|会对所有条件进行判断。

5)instanceof，是用于判断一个对象是否属于某个类型

6)java中的求余运算符“%”可以对两个实型变量求余5%2=1

3、流程控制

（1）控制流

if()

if()….else

if()…..else if()….else

注意：else只是和其上面的同层的最近的if()来配对。

（2）switch(s){

case'a':……..

case1:……break；

default:

…………

}

注意：switch()内数据类型为byte short char int类型，只有以上四种类型的才可以在switch()中使用。

case块中不加break时顺序执行下面的语句。

4、循环语句

for(int i=0;i

while(){}----循环0或多次

do{}while();-----------注意加分号循环1或多次

5、语法

在main方法中要使用全局变量或调用其他方法时，要求全局变量和方法要有static修饰命令行参数java Class a b

args[0]=a

args[0]=b

字符串转成int类型int i=Integer.parseInt(a);

6、数组

内存中的连续空间

数组是一次性定义多个相同类型的变量

Java中一个数组就是一个对象,有属性，没有方法

int[]a;//定义一个数组，变量名就是指向数组首地址的指针

a=new int[10];//为数组分配空间

a.length;//得到数组的长度

数组创建后有初始值：数字类型为0布尔类型为false引用类型为null

String[]默认值null

初始化、创建、和声明在同一时间

int[]i={0,1};//显示初始化

int[]i=new int[]{0,1};//注意：这样显示的初始化的时候，new int[]中括号中必须是空的，不能填数字

Car[]c={new Car(),new Car()};

数组拷贝

System.arrayCopy(Object src,int srcPos,Object dest,int destPos,int length);

src源数组，srcPos从第几位开始拷贝（数组下标，从0开始），dest目标数组，destPos 目标数组放置的起始位置，length，表示要拷贝的长度。拷贝一个数组到另一个数组。

多维数组

1)有效定义

int[][]i1=new int[2][3];（同时给定一维，二维的空间）

int[][]i2=new int[2][];（给定一维的空间，二维空间待定，不规则的二维数组）

i2[0]=new int[2],i2[1]=new int[3];

*C++中int[][]=new int[][3];有效

2)无效定义

int[][]i1=new int[][3];

3)数组长度------------数组的属性length（在二维数组中这个属性只代表第一维的长度）

int[]i=new int[5];

int len=i.length;//len=5;

Student[][]st=new Student[4][6];

len=st.length;//len=4;

len=st[0].length;//len=6;

练习：（1）数组元素的偏移

在使用数组的时候，通常使用一个辅助变量纪录数组中的有效元素的个数，还表示下一个可插入位置的下标

（2）数组元素的轮换

偶数个球队足球比赛，每个队和每个队有且只有一场比赛

把数字按"U"字型摆放，左边最上边的数字不变，其他数字按逆时针旋转（3）有一个奇阶的方阵，填如数字，使得

第一个数一定放在第一行的最中间，第二个放在右上方，行越界，放在此列的另一侧，列越界放在此行的另一侧

行列都越界的时候，退回来，放在原来的数字下边，当要放入的地方有数字的时候，退回来，放在原来的数字下边

（1）

public class ArrayInsertDelete{

static int[]a={1,2,3,4,5,6};

static int index=6;

static void insert(int pos,int value){

if(index==a.length)expand();

for(int i=index;i>pos;i--){

a[i]=a[i-1];

}

a[pos]=value;

index++;

}

static void delete(int pos){

index--;

for(int i=pos;i

a[i]=a[i+1];

}

}

static void expand(){

int[]b=new int[a.length*2];

System.arraycopy(a,0,b,0,a.length);

a=b;

}

static void print(){

for(int i=0;i

System.out.print(a[i]+"\t");

}

System.out.println();

}

public static void main(String[]args){

print();

insert(2,7);//{1,2,7,3,4,5,6}

print();

delete(4);//{1,2,7,3,5,6}

print();

}

}

Java第三天2007年4月25日

1、面向对象的思想

anything is an Object（万物皆对象）

符合人们客观看待世界的规律

2、抽象，从对具体的对象中抽取有用信息。

对象有其固有属性，对象的方法，即对象的行为（对象能做什么）

对象本身是简单的（功能简单），多个对象可以组成复杂的系统（对象之间彼此调用对方的方法）

3、面向对象的优点

1）对象应当是各司其职（功能简单），各尽所能（把自己的功能作到最好）。（弱耦合性实现了前面所述的对象的特点）

2）对象的耦合性，是对象之间的联系，对象和系统之间的联系。

对象的耦合性要尽量的弱，也就是对象之间的联系尽可能的弱，对象和系统之间的联系尽可能的弱。

弱耦合性要通过一个标准来实现

3）可重用性

对象的功能越简单，复用性就越好。（对象的耦合性弱，复用性就比较强）4）可扩展性

系统的可插入性，是在系统中加入新的对象之后的系统稳定性。

对象的可替换性，是在系统中替换原有的对象之后的系统的稳定性。

4、面向过程和面向对象的比较

面向过程是先有算法，后又数据结构---（怎么解决问题）

面向对象是先有对象（数据结构），后有算法（对象间的方法调用）---（用什么做）

5、类的定义

1）属性

类型变量名；-->实例变量，系统赋初始值

默认值使用范围命名冲突

实例变量系统赋初始值在类的内部使用允许实例变量和局部变量发生命名冲突，变量的值->局部优先

局部变量先赋值后使用定义他的代码块同范围内不允许两个局部变量发生命名冲突

2）方法的定义：

不允许方法的声明和实现分开

方法声明的组成：

(a)方法的修饰符（0或多个修饰符出现的顺序无关）|

(b)方法的返回值类型|顺

(c)方法名|序

(d)方法的参数表|向

(e)方法中允许抛出的异常|下

V

6、方法的重载

java中方法的重载（overload）方法名相同，参数表不同（个数，类型，排列顺序），其他部分可以不同。

调用时要给出明确参数并确定调用某一方法。在编译时，编译器会根据参数选择适当的方法，所以重载也叫编译时多态。

**方法的重载可以屏蔽一个对象同一类方法由于参数不同所造成的差异**

向上就近匹配原则

如果方法的参数表中的数据类型和调用时给出的参数类型不尽相同时会根据向上匹配的就近原则。（类型就近向上转化匹配）

public void m(byte a,short b){

System.out.println("m(byte,short)");

}

public void m(short a,byte b){

System.out.println("m(short,byte)");

}

此时若用2个byte作为参数调用m()方法，编译会出错，因为按照向上就近匹配原则，提升哪个都可以，出现语义不明确的错误

7、构造方法

1）方法名与类名相同，无返回值

2）系统提供默认无参的，空的构造方法

3）若自定义一个有参的构造方法，则系统将不提供无参的，空的构造方法

不能手工调用，在一个对象的生命周期中，只会被调用一次

8、对象的创建

Java在堆中创建对象的过程：

1）分配空间

2）初始化属性，若声明实例变量的时候没有初始化，用默认值初始化属性

3）调用某个构造方法（前提：不考虑继承关系）

Student s；//声明一个Student类的对象变量

s=new Student();//调用Student类的无参的构造方法，创建一个对象,把这个对象的地址赋给一个Student类的引用

（引用指向了这个对象，引用中保存对象的首地址，以后都是通过引用访问这个对象的属性和方法）

s.age s引用所指向的对象的age属性

9、变量

包括简单变量（原始数据类型），对象变量。

简单变量传值，对象变量传址！

static void method3(Student s){

s=new Student();//创建一个新对象，把对象的地址赋给形参的引用

s.age=20;//改变新对象的状态

}

Student stu=new Student();

System.out.println(stu.age);//打印出Student类的age属性的初始值

method3(stu);//method3方法返回，形参s指向的被改变的对象已经成为了垃圾对象System.out.println(stu.age);//打印的仍是原来那个对象的age的值

10、this

是一个引用，指向的是自己，即当前对象（哪个对象调用了方法，哪个对象就是当前对象）

可以用来区分实例变量和局部变量。this.age=age;

this(),他表示调用本类其他的构造方法，注，只能写在构造方法的第一行。

项目练习：

项目名称:Bank Account Management System银行账户管理系统简称BAM

项目描述:这是一个基于C/S结构的银行账户在线管理系统,用户可以通过ATM终端界面来操作自己的银行账户.

项目实施方式:这是一个同步练习,随着达内CoreJava课程的深入,这个项目将趋于完整,学员的任务是随着知识点的深入,完成每一个进阶的项目要求.

练习1:

(面向对象基础语法)

写一个账户类(Account)

属性:

id:账户号码长整数

password:账户密码String

name:真实姓名String

personId:身份证号码String

email:客户的电子邮箱String

balance:账户余额double

方法:

deposit:存款方法,参数是double型的金额

withdraw:取款方法,参数是double型的金额

构造方法:

有参和无参,有参构造方法用于设置必要的属性

Java第四天2007年4月25日

1、复习

面向对象思想

符合我们看待客观世界的规律

Everything is an object

对象：客观存在，有什么（属性），能做什么（方法）

每个对象都是简单的，有简单的对象拼装成复杂的系统

面向对象的优点：

1）各司其职，各尽所能

2）弱耦合性

3）可重用性，可扩展性

类：对象共性的抽象，客观对象在人脑中的主观反映

对象的模版

属性：在类里，但在任何方法之外定义的一个变量---实例变量

有默认值，访问范围，至少是本类内部，可以和局部变量发生命名上的冲突，局部优先，this区分

方法：方法定义（声明对象能做什么）/方法实现（怎么做）

定义：修饰符返回值类型方法名（参数表）抛出的异常

重载（Overload）：方法名相同，参数表不同。

编译时多态，编译器根据参数表选择一个方法

为什么要有方法的重载？

屏蔽一个对象同一类方法由于参数表不同所造成的差异

就近向上匹配

构造方法：没有返回值，方法名和类名是相同的，系统提供默认无参的空的构造方法，**建议自己写无参构造

构造对象的过程：

1）分配空间

2）初始化属性

3）调用构造方法

类名引用名=new类名(构造参数);

方法参数传递规则：

简单类型参数：传值

对象类型参数：传引用，实参和形参指向同一个对象

2、面向对象的三大特征：封装、继承、多态。

java中的封装

封装，一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。

（对象的属性应当隐藏），一个对象的内部是透明的，就是把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏。

（封装的属性）java中类的属性的访问权限的默认值不是private，要想隐藏该属性或方法，就可以加private（私有）修饰符，来限制只能够在类的内部进行访问。

对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性。

方法的封装，对于方法的封装，该公开的公开，该隐藏的隐藏。方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化。。

封装会使方法实现的改变对架构的影响最小化。

完全的封装，类的属性全部私有化，并且提供一对方法来访问属性。

Java Bean一种组件规范-->所有属性私有，访问方法按照命名规范setXxx(),getXxx()方法

3、java中的继承

继承，是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父

类。父类的意义在于可以抽取多类事物的共性。

泛化：把共性从子类中抽取出来。

特化：现有父类，再有子类的过程

父类与子类->从一般到特殊的关系

java中的继承要使用extends关键字，并且java中只允许单继承，也就是一个类只能有一个直接的父类。

这样就是继承关系呈树状，体现了java的简单性。

子类只能继承在父类中可以访问的属性和方法（实际上父类中私有的属性和方法也会被继承但子类中无法访问罢了）。

实际上一个子类对象中包含一个父类对象

访问控制修饰符:（可以修饰属性和方法）

private修饰符，表示只有本类内部可以访问，不能继承。

default修饰符，方法不加修饰符，会默认为default，表示在同一个包中可以访问，父子类在同一包中，子类可以继承父类的相应内容。（可以修饰类）

protected（保护）修饰符，表示同一包中可以访问，不同包的子类也可以访问继承。public修饰符，表示公开，在任何地方都可以访问，能继承。（可以修饰类）

修饰符的权限是由上而下逐渐变宽的。

继承的意义，就在于子类可以在父类的基础之上对父类的功能进行发展,继承可以使系统的耦合性降低，也就是使对象间的联系便的松散，使多类对象间的联系用其父类对象代替。

注意：构造方法不能被继承。

父类的属性及方法的确定：要从子类的角度来看子类间的共性，当所有子类都有这个属性时，就应当考虑是否该放在父类中，方法也是如此，方法可以被看作是对象的行为，而类的方法这时这一类对象所共有的行为，所以也应当在方法的确定时注意是不是所有的子类型中都需要有这种方法，并且会根据不同的类型的行为的方式也不同才可以覆盖着个方法。

4、java中方法的覆盖

子类中有和父类中可访问（可继承到子类）的同名同返回类型同参数表的方法，就会覆盖从父类继承来的方法。

在父子类中，出现方法名相同，参数表不同的情况，叫方法的重载

方法覆盖父子类返回值类型也要相同

注意：在jdk1.4以前要求方法的覆盖时，需要方法的返回值，参数表，方法名必须严格相同，而在jdk1.5中方法覆盖，子类的中覆盖的方法的返回值可以是父类中被覆盖的方法的返回值类型的子类型。

注意：子类的方法覆盖父类的方法时，方法的修饰符要么相同，要么子类中的方法的修饰符表示的访问权限要宽于父类。父类中的私有方法，不能被继承到子类，就是说子类中即使将其覆盖了也不会有多态。

注意：父子类中有同名的属性不叫子类覆盖了父类的属性，这种情况较作属性的遮盖（shadow）。

5、super关键字

(1)区分父子类间的属性遮盖和方法覆盖

(2)super()，表示在子类的构造方法中调用父类的构造方法（可以通过这种方法在子类的构造方法中初始化父类中的属性），super()也只能出现在构造方法的第一句上。super(),在子类的构造方中指明构造父类时调用哪一个父类的构造方法构造父类。

super,这里所表示的是一个父类的对象，可以通过super来使用父类中可以访问的方法（可以在父类中定义setXxx()，getXxx()方法来访问父类中的私有属性），super可以屏蔽父子类中同名属性的冲突。

注意：在写类的时候，一定要写默认无参的构造方法，如果一个构造方法的第一句既不是this(),也不是super()时，那么就会在这里隐含的调用他的父类的无参的构造方法，即隐含的有super()。

6、创建对象的过程

1）递归的构造父类的对象，默认调用父类无参的构造方法super()

2）分配本类空间

3）初始化本类实例变量（属性）

4）调用本类的构造方法

7、java中的多态---运行时多态

Animal a=new Dog();//引用类型可以是对象类型的父类

对象类型客观类型

引用类型主观类型

以子类覆盖了父类的方法为前提

1）对象类型不变

2）只能对一个对象调用引用类型中定义的方法

3）运行时会根据对象类型找覆盖之后的方法

Animal a=new Dog();

Dog d=new Dog();

a=d;//把子类引用赋值给父类引用，是合法的

d=(Dog)a;//把父类引用赋值给自类引用，需要强转

引用instanceof类名//判断前面的引用和后面的类是否兼容

可以翻译为“是不是”

a instanceof Dag;//a指向的对象是不是Dog类

一般用在强制类型转换之前，避免转换异常

多态可以使代码变得更通用，以适应需求的变化。也就是定义在父类中的方法，可以在子类中有不同的实现将其覆盖，在为父类型的对象变量赋值相应需要功能的子类的对象实例。

可以屏蔽不同子类的差异

作业：

1.设计一个形状类,方法:求周长和求面积

形状类的子类:Rect(矩形),Circle(圆形)

Rect类的子类:Square(正方形)

不同的子类会有不同的计算周长和面积的方法

创建三个不同的形状对象,放在Shape类型的数组里,分别打印出每个对象的周长和面积

2.某公司的雇员分为以下若干类：

Employee：这是所有员工总的父类，属性：员工的姓名,员工的生日月份。方法：getSalary(int month)根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100元。SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放。属性：每小时的工资、每月工作的小时数

SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定。属性：月销售额、提成率

BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，工资由底薪加上销售提成部分。属性：底薪。

写一个程序，把若干各种类型的员工放在一个Employee数组里，写一个函数，打印出某月每个员工的工资数额。注意：要求把每个类都做成完全封装，不允许非私有化属性。

Java第五天2007年4月26日

一、复习

1、封装

该隐藏隐藏，该公开的公开

属性隐藏，同时提供get/set方法

有些方法应该隐藏

方法声明公开，实现隐藏。实现的改变对架构的影响最小

2、继承

一般－>特殊

单继承：一个类最多只能有一个直接父类。类之间可以形成树状关系

根据访问权限，子类如果可以访问父类的属性和方法，就能继承

private私有不能继承

default本类＋同包同包子类可以继承，不同包子类不能继承

protected本类＋同包＋不同包子类可以继承

public公开可以继承

方法的覆盖（Override）：

方法名相同，参数表相同，返回值相同，访问修饰符比父类相同或更宽，抛出的异常不能比父类更宽

继承关系下对象的构造过程

1）递归的构造父类对象

2）分配本类空间

3）初始化本类属性

4）调用本类的构造方法

super：

super.->父类对象,访问父类被覆盖的方法或者父类被遮盖的属性

super()->用在构造方法时，用来指明调用父类的哪个构造方法，放在构造方法的第一行，默认调用父类无参构造方法

3、多态

编译时多态：方法的重载

运行时多态：

子类对象当作父类对象来用！！！屏蔽同一父类下，不同子类差异

Animal a=new Dog();

允许引用类型和对象类型不同，但要求引用类型是对象类型的父类。

对象类型代表了对象自身客观的实际类型，引用类型代表了主观上把对象当作什么类型来看待。

引用类型：编译时类型，主观类型

对象类型：运行时类型，客观类型

1）对象运行时类型不变

2）只能对对象调用其编译时类型定义的方法

3）运行时根据对象类型去匹配对象类型中覆盖之后的方法

Super s1;

Sub s2;

s1=s2;

s2=s1;//error,s2=(Sub)s2

强制类型转换：当我们把父类的引用赋值给子类引用的时候，需要强制类型转换。强制类型转换失败：类型转换异常.

为了避免类型转换异常，使用instanceof判断

引用instanceof类名引用指向的对象的类型与后面的类名是否兼容

多态的作用：通用编程

我们可以把不同子类的对象都当作父类对象看待，评比不同子类的差异。

二、CARP(组合/聚合复用原则)

实现代码重用最好的方法不是继承

两种复用

白盒复用，也就是继承复用，破坏封装，父类中的可以被子类访问到的就可以被继承，这样会有些不需要的内容被继承下来，所以这种方式不太好。

黑盒复用，也叫组合复用，也就是把要复用代码的类的对象作为本类中的一个属性，然后再通过方法的委托来实现由选择的复用。

方法的委托就是在本类的方法内部通过该类的对象调用要使用类的方法，不破坏封装。

注意：尽量用组合复用替代继承复用。

三、多态

1、多态用于参数，可以在方法的参数中传入其父类类型，在运行时会根据实际的运行时类型来在方法中进行相应的操作。

多态一般用在方法的参数上

void feed(Animal a){

a.eat();

}

调用的时候feed(new Dog());//运行时，调用的是Dog类中覆盖的eat()方法

2、多态用于返回值，可以在方法的返回值类型上是用其实际返回值的父类型，在使用其返回值时也不关心其实际类型。

public static Animal getAnimal(int type){

if(type==0)return new Dog();

else return new Cat();

}

屏蔽子类差异，可扩展（只修改方法的实现，不必修改方法的声明）

3、Animal a=new Dog();

a.age;//访问属性是没有多态的，访问的是引用的age属性

a.eat();//调用Dog类中覆盖Animal类中的eat()方法，多态

4、Animal a=new Dog();

method(a);

运行结果调用参数是Animal类对象的那个method()方法

方法的重载只看引用类型，跟引用指向的对象类型没有关系

四、对象的比较

String s1=new String("abc");

String s2=new String("abc");

s1==s2;->false判断两个引用是否指向同一对象，即地址是否相同

s1.equls(s2);->true判断两个引用指向的对象的内容是否相同

练习：

(继承,多态)

银行的客户分为两类,储蓄账户(SavingAccount)和信用账户(CreditAccount),区别在于储蓄账户不允许透支

而信用账户可以透支,并允许用户设置自己的透支额度.

注意:CreditAccount需要多一个属性ceiling透支额度

为这两种用户编写相关的类

同时要求编写Bank类,属性:

1.当前所有的账户对象的集合,存放在数组中

2.当前账户数量

方法:

1.用户开户,需要的参数:id,密码,密码确认,姓名,身份证号码,邮箱,账户类型,返回新创建的Account对象

提示:用s1.equals(s2)可以比较s1,s2两个字符串的值是否相等.账户类型是一个整数,为0的时候表示储蓄账户,为1的时候表示信用账户

2.用户登录,参数:id,密码返回Account对象

3.用户存款,参数:id,存款数额,返回修改过的Account对象

4.用户取款,参数:id,取款数额,返回修改过的Account对象

5.设置透支额度参数:id,新的额度,返回修改过的Account对象.这个方法需要验证账户是否是信用账户

用户会通过调用Bank对象以上的方法来操作自己的账户,请分析各个方法需要的参数

另外,请为Bank类添加几个统计方法

1.统计银行所有账户余额总数

2.统计所有信用账户透支额度总数

写个主方法测试你写的类

Java第六天2007年4月27日

修饰符

一、static

修饰属性，方法，代码块

1、静态属性：全类公有，称为类变量

那么这个属性就可以用类名.属性名来访问

（共有的类变量与对象无关，只和类有关）

类加载：虚拟机通过I/O流把一个类的信息从字节码文件中读入虚拟机并保存起来一个类只会加载一次

类变量，会在加载时自动初始化，初始化规则和实例变量相同。

注意：类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，类加载的过程是进行一次。也就是类变量只会被创建一次。

2、静态方法：

使这个方法成为整个类所公有的方法，可以用类名.方法名直接访问

注意：static修饰的方法，不能直接访问（可以通过组合方式访问）本类中的非静态(static)成员（包括方法和属性）

本类的非静态（static）方法可以访问本类的静态成员（包括方法和属性），可以调用静态方法。

静态方法要慎重使用。在静态方法中不能出现this关键字，因为这是针对对象而言的。

java中的main方法必须写成static的，因为，在类加载时无法创建对象，静态方法可以不通过对象调用。

所以在类加载时就可以通过main方法入口来运行程序。

注意：父类中是静态方法，子类中不能覆盖为非静态方法。

在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。

使用引用调静态方法，相当于使用引用的类型去调用静态方法。（在使用对象调用静态方法是其实是调用编译时类型的静态方法）

3、初始代码块

在定义属性的位置上，在任何方法之外，定义一个代码块

动态初始代码块：在初始化属性之前调用初始化代码块{……}

静态初始代码块：在类加载时运行static{……}只被运行一次，往往用作一个类的准备工作

二、一个类在什么时候被加载？时机（延迟加载，能不加载就不加载）

（1）new一个对象的时候，加载

（2）没有创建对象，访问类中静态成员（方法和属性），加载

（3）声明一个类的引用，不加载

（4）创建子类，先加载父类，再加载子类

（5）父类中的公开静态方法，子类继承，使用子类的类名调用此方法，加载父类class Super{

public static m(){}

}

class Sub extends Super{}

在主函数中运行以下代码：

Sub.m();//加载了父类之后，虚拟机已经知道m()方法的调用了，就不会再加载子类，延迟加载

（6）没有创建对象，访问类中静态常量（能计算出结果的常量，在编译的时候会用计算出来的结果替换表达式），不加载

没有创建对象，访问类中静态常量（不确定的值），加载

（7）CoreJava day16

三、设计模式（编程套路）

GOF（Group Of Four）四人帮模式23种

1、单例模式Singleton：

class A{

private static A a=new A();//私有静态的实例变量指向自己，在类加载时创建唯一对象

public static A newInstance(){//提供公开静态的访问点，回返唯一实例

return a;

}

private A(){}//私有的构造方法，防止滥用

}

2、不变模式：

便于实例共享，减少对存储空间的消耗

String类采用了不变模式

字符串中的内容是不变的

String a1="123";//系统会先去串池中找"123",找到，就共享使用一个，没找到就在串池中创建一个

String a2=new String("123");//在堆空间中创建"123"

池化的思想，把需要共享的数据放在池中（节省空间，共享数据）

只有String类可以用“”中的字面值创建对象。

在String类中，以字面值创建时，会到串池空间中去查找，如果有就返回串池中字符串的地址，并把这个地址付给对象变量。

如果没有则会在串池里创建一个字符串对象，并返回其地址付购对象变量，当另一个以字面值创建对象时则会重复上述过程。

如果是new在堆空间中创建String类的对象，则不会有上述的过程。

a2=a1.intern();//返回字符串在串池中的引用

消极方面：字符串连接“+”，产生很多的中间对象

StringBuffer类，字符串是可变的

s.append("A");//连接字符串，不创建中间对象

大量字符串连接的时候用StringBuffer取代String

四、final

修饰变量，方法，类

1、修饰变量

被fianl修饰的变量就是常量（常量名大写），一旦赋值不能改变

修饰局部变量：修饰基本数据类型->变量的值不能改变

修饰引用->引用只能指向固定的对象

修饰实例变量：默认值不生效，可以再赋值

有两次赋值机会：初始化变量的时候final int a=20;对于直接在初始化时赋值，final修饰符常和static修饰符一起使用，避免浪费空间

构造方法中设置this.a=a;

但是不能同时使用这两种方法

在一个对象完成创建的时候，对象中的所有final属性必须都完成赋值类变量可以是final的，也有两次赋值机会：定义变量的时候就赋值；静态初始代码块中

2、修饰方法

不能被子类覆盖

从面向对象的角度理解，可以保持操作的稳定性

3、修饰类

不能被继承

在树状单继承关系中，final类是树叶节点

在一个final类中的所有方法，默认都是final的

注意：final，不能用来修饰构造方法。

在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。

静态常量如果其值可以确定，就不会加载该类，如果不能确定则会加载该常量所在的类。

class Super{

private final void m(){}//用final可以证明出private的方法不继承给子类}

class Sub extends Super{

public void m(){}//不是方法的覆盖

}

五、abstract抽象的

修饰类和方法

1、修饰类->抽象类

不能创建对象，可以声明引用，并通过引用调用类中的方法

《Java学习笔记 良葛格》 fuluA word版

《Java学习笔记良葛格》 fuluA word版 介 Ant 简 A Ant 的全名是 Another Neat Tool，是由 James Duncan Davidson 在觉得Make 工具无法满足他的 Java 构建(Build)需求下所编写出来的工具，目前由Apache Software Foundation 持续进行开发。根据官方网站上的 FAQ 中有关什么是 Apache Ant(What is Apache Ant)中的回答：

Ant is a Java-based build tool. In theory, it is kind of like Make, without Make’s wrinkles and with the full portability of pure Java code. 简单地说，Ant 就像是 Make 工具，一个为 Java 应用程序所量身定做的构建工具。 A.1 Ant 设置 对于没有使用过 Make 工具的初学者来说，想象一下如何管理源代码？如何处理 Classpath 的问题？如何将编译过后的文件指定至某个目录？如何 将.class 包装为 .jar 文件？…… 这一切都可以通过 Ant 来完成！您不必重复地使用 javac、copy、cd 和 java 等指令来达到这些目的，只要编写好一个以 XML 组织的构建文件(buildfile)，然后下 ant 指令，上述所有的问题就可轻松地解决。 或许有人会说这些需求一些 IDE 也可以办到，这并不是正确的说法。Ant 并不取代 IDE，它增强了 IDE，也没有 IDE 可以取代 Ant，它们是互补的，不是相互取代的。 简单地归纳一下 Ant 可以自动完成的任务： 编译 Java 源代码 建立 jar、 war、zip 文件

Java课程设计万历

河北科技大学 课程设计报告学生姓名：学号： 专业班级： 课程名称： Java程序设计课程设计 学年学期： 2 014 —2 015 学年第 2 学期指导教师：刘伟 2 0 年月 课程设计成绩评定表

目录 1.课程设计目的................................................................................. .. (1) 2.需求分析................................................................................... (1) 3.总体设计................................................................................... (1) 4.详细设

计................................................................................... (1) 5.软件测试................................................................................... (10) 6.课程设计总结................................................................................... . (11)

一、课程设计目的 (1)熟练使用java语言编写程序，解决实际问题。 (2)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能; (3)学会自己调试程序的方法并掌握一定的技巧。 二、需求分析 本程序的要求为： 1.使用图形用户界面; 2.本程序能够实现日期与星期的查询。 三、总体设计 （1）可以通过图形界面显示日历。 （2）能以月历形式显示日期与星期。 （3）支持用户自己输入年份，可以通过上一年，下一年等按钮来选择年份和月份。 四、详细设计 1.总天数的算法：首先用if语句判断定义年到输入年之间每一年是否为闰年，是闰年，该年的总天数为366，否则，为365。 2.输出月份第一天为星期几的算法：使总天数除以7取余得几既为星期几，若是0，则为星期日。 3.算出输出月份第一天为星期几的算法：算出输出月份第一天为星期几后，把该日期以前的位置用空格补上，并总该日起一次输出天数直到月底，该月中的天数加上该月一日为星期几的数字再除以7得0换行，即可完整的输出该月的日历。 4.查询年份必须为四位有效数字，否则不予显示。 程序源代码： import import import import import

Java基础学习心得笔记

Java基础学习心得笔记 对于很多只会C语言的初学者而言，面对java基础语法学习，反而感觉很难，其实其中最大的问题不是语法难，而是一种编程思想的转变。面向过程就是把你的代码封装成函数，然后依次去做一件事情，面向过程是把你要做的事情抽象成对象，告诉对象去做。所以要想学好java入门，必须知道类和对象的概念。 类是对生活中事物的抽象描述，比如人类，动物类，交通工具类；对象即是对类的具体实例化，比如张三是人，猫是动物，飞机是交通工具（对象-----类）。Java基础入门学习路线可以总结为四步走： 1.java开发环境的搭建； 2.java初级之基础语法学习（80%类似C语言）; 3.java中级之面向对象编程学习(重点)； 4.java中级之应用编程学习。 第一步：JDK软件开发包时java软件开发环境， 包括jre运行环境和jvm虚拟机，在oricle官网下载javaSE版本JDK包；配置好环境变量就可以使用了。 第二步:java初级语法学习， 1.基本数据类型整形，字符型，字节型，长整形，短整形，浮点型，双精度，布尔型；

2.运算符+，-，*，/，%等； 3.控制流（while,switch，if else）; 4.数组的定义方式。 此阶段基本无难度，只要了解练习例题。 第三步:java面向对象学习， 1.类和对象； 2.java语言三大特性，封装、继承、多态； 3.一些关键字学习（static，final，abstract,extends）等。 这是重点，大家根据知识点一步步研究学习才是关键。 第四步：java应用编程， 例如：文件IO，集合（类似C语言数据结构），异常处理，线程，网络，JDBC数据库操作等，都是掌握面向对象以后，在查找不同的类使用类中不同的方法达到应用的效果，所以并不会很难。等基础语法掌握了就可以继续后面框架学习（java web方向，android学习），相信明确思路你会豁然开朗，更有学习动力。 以上没有具体的实例和知识点讲解，分享的只是完全没接触过java的初学者自学java的思路和学习的流程，应该把握的重点，希望大家有所帮助。 如果你想学好Java，找一家靠谱的培训机构，能让你的学习事半功倍。

java经典面试题汇总

Java基础方面: 1、作用域public,private,protected,以及不写时的区别 答：区别如下： 作用域当前类同一package 子孙类其他package public √√√√ protected √√√ × friendly √√ × × private √ × × × 不写时默认为friendly 2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口) 答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现 3、Static Nested Class 和 Inner Class的不同 答：Nested Class （一般是C++的说法），Inner Class (一般是JA V A的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注：静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象 4、&和&&的区别 答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and） 5、Collection 和 Collections的区别 答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List. Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作 6、什么时候用assert 答：assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的 7、String s = new String("xyz");创建了几个String Object 答：两个，一个字符对象，一个字符对象引用对象 8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少 答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor 9、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错 答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译） 10、Java有没有goto 答：java中的保留字，现在没有在java中使用 11、数组有没有length()这个方法? String有没有length()这个方法 答：数组没有length()这个方法，有length的属性。String有有length()这个方法 12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型

java基础学习心得

java基础学习心得 目录 第一篇：java学习需要什么基础 第二篇：java 基础要点总结学习java必看 第三篇：java学习心得笔记 第四篇：java学习心得 第五篇：关于java学习的一点心得体会 正文 第一篇：java学习需要什么基础 java学习需要什么基础 随着java这种语言的广泛运用，越来越多从事开发的人员开始学习接触这门课程，那么，java学习需要什么基础？java刚刚入门应该接触哪些知识呢？java入门应该学习什么内容呢？ 首先要说明的，java有三个大的方向（j2se,j2me,j2ee），走不同的方向可能学的技术和要花费的时间可能有所不同。我是搞web方向的（j2ee），我学java除了以前一些简单的c语言语法外，没有太多的编程基础，我以前一直认为编程要有很强的数学和英语功底，现在看来这也不是必需，只要有一定的逻辑思维能力和掌握一些常见的计算机词汇，还需要具备一定的自学能力，因为软件开发工作是需要不断学习的。

其次，我想说下我的学习过程，我在网上下载了java教学视频，将java基础从头到尾看了一遍，将上面的代码基本上跟着敲了一遍，然后我把java基础的书看了一遍，一本书看完包括上面的习题大概做一遍差不多一个月。这时你对java的语法和基本知识应该都有比较充分的认识和了解了。 然后，再做一些小项目，跟着视频上的步骤做，最好能自己独立再写写，能写多少是多少。一般网上比较新的免费的项目库很不好找，因为项目库是需要实时更新以保证适合市场需要的，而它的升级和更新是需要钱的，所以去报一个培训中心利用它强大的项目库进行实战操作是个很好的选择。 操作一段时间之后，你对java已经有了一定的感觉，就要开始选择你的发展方向了。我选择了j2ee，如果你也是想走这条路，你可以接着看关于j2ee的视频，先是html+js+css,然后jsp+serverlet，再看struts+spring+hibernate等一些框架。同时可以看一些大的培训机构的关于设计模式的视频，最好是it牛人录制的，当然数据库也得学下，然后加上做项目的经验累积，半年就差不多可以出去工作了。 如果你做其他方向的话我不是很了解。再说下我个人的看法， j2me和j2se好像前景没j2ee好，不过我有同事是做android平台开发的，这个不需要j2ee的知识，你可以去买本android的看看，这个方向貌似很有前途，你应该也常听说android平台的手机，如果走这方向可

java课程设计实验报告

一实验目的 加深学生对课堂讲授内容的理解，从计算机语言的基本概念、程序设计的基本方法、语法规则等方面加深理解，打好程序设计、开发软件的良好基础。在上机实验中，提高学生对Java语言各部分内容的综合使用能力，逐步掌握Java语言程序设计的规律与技巧。在对Java 程序的调试过程中，提高学生分析程序中出现的错误和排除这些错误的能力。通过上机实践，加深学生对计算机软件运行环境，以及对操作系统与计算机语言支持系统相互关系的了解。 二、实验要求 (1)问题描述准确、规范； (2)程序结构合理，调试数据准确、有代表性； (3)界面布局整齐，人机交互方便； (4)输出结果正确； (5)正确撰写实验报告。 三、设计内容 1、计算器 计算器要有GUI界面，用户可以输入所需计算的数值，可以进行加、减、乘、除四种最基本的运算和混合运算，可以求一个数值的平方及倒数，可以进行阶乘运算，要能运算小数，并且不会产生精度损失，在必要情况下，可以进行四舍五入的运算。允许正负数间的运算。要求使用Applet实现该计算器，当用浏览器运行程序时，点击网页中的按钮，则计算器弹出，浮在网页上，再次点击按钮时，计算器消失。 2、文本编辑器 可以设置文本的字体、大小、颜色等基本参数，可以读取计算机中TXT文件，可以生成一个新的TXT文件。其他功能参照windows的文本编辑器。

四．实验步骤 (1)上机实验之前，为课程设计的内容作好充分准备。对每次上机需要完成的任务进行认真的分析，画出程序流程图，手工写出符合任务要求的程序清单，准备出调试程序使用的数据，以便提高上机实验的效率。 (2)按照实验目的和实验内容进行上机操作。录入程序，编译调试，反复修改，直到使程序正常运行，得出正确的输出结果为止。 (3)根据实验结果，写出实验报告。 五. 源代码及运行结果 1．计算器源代码 import .*; import .*; import .*; public class jisuanqi extends WindowAdapter { , "=", "+","n!" ,"关闭" }; static double a, sum=1; static String s, str ;rame(); } public void frame() { etBackground; txt = new TextField(""); (false);ddActionListener(new buttonlistener());ddActionListener(new close()); (this); (new BorderLayout());.计算器运行界面（1）计算器主界面

黑马毕向东JAVA基础总结笔记

Java基础知识总结（超级经典） 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况 如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。 一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，javac命令和java命令做什么事情呢？ 要知道java是分两部分的：一个是编译，一个是运行。 javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java 文件进行编译。生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。 java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行. 一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数. ----------------------------------------------------------------------------------------------

JAVA框架面试题汇总

1.SpringMVC Framework的理解： 1、它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件。并且和Spring提供的其他基础结构紧密集成 2、不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的) 3、可以任意使用各种视图技术,而不仅仅局限于JSP 4、支持各种请求资源的映射策略 5、它应是易于扩展的 2.简单的谈一下SpringMVC的工作流程？ 流程? 1、用户发送请求至前端控制器DispatcherServlet? 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。? 3、处理器映射器找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。? 4、DispatcherServlet调用HandlerAdapter处理器适配器? 5、HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。? 6、Controller执行完成返回ModelAndView? 7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet? 8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器? 9、ViewReslover解析后返回具体View? 10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。? 11、DispatcherServlet响应用户 3.如何解决POST请求中文乱码问题，GET的又如何处理呢？ 在web.xml中加入： . .CharacterEncodingFilter . .???? .????????encoding .?????? utf-8

Java学习笔记

Java 程序分类 Java Application：以main()方法作为程序入口，由Java解释器加载执行。 Java Applet：没有main()方法作为程序入口，由浏览器或Appletviewer加载执行。 注释 一行中‘//’后的内容为注释； ‘/*’和‘*/’中的内容是注释； ‘/**’和‘*/’中的内容是注释。 -javac HelloWorld.java 源文件名为HelloWorld.java，由javac编译器编译源程序，产生字节码文件(.class文件)。java HelloWorld由java解释器解释执行。 命名 如果.java 文件包含一个public 类，它必需按该类名命名。Java语言中单词拼写严格区分大小写； 类个数 一个源文件中最多只能有一个public 类。其它类的个数不限。 结构 package 语句//0或1个，必须放在文件开始 import语句//0或多个，必须放在所有类定义之前 public classDefinition //0或1个，文件名必须与该类的类名完全相同classDefinition //0或多个 interfaceDefinition //0或多个

Java开发工具集JDK----Java Development Kits Java编译器 Java运行时解释器 Java应用程序编程接口 Java文档化化工具 其它工具及资源 环境变量 Path ----外部命令搜索路径； CLASSPATH ----类资源位置搜索路径； https://www.wendangku.net/doc/8b4021755.html,ng----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。 java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 java.applet----包含applet运行所需的一些类。 https://www.wendangku.net/doc/8b4021755.html,----包含执行与网络相关的操作的类。 java.io----包含能提供多种输入/输出功能的类。 java.util----包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。 JDK中提供了一个文档自动生成工具javadoc,在自定义类中public的成员前以/**…*/形式加入的注释内容均可被自动提取到生成的说明文档中。 用法：somepath\javadoc source.java Java分隔符组成 分号--“;”、花括号--“{}”、空格--“”

java基础笔记

1什么是变量？ 答:是指代在内存中开辟的储存空间，用于存放运算过程中需要用到的数据。 一个类中不能有2个public以为有pulic要和类名保持一致，有2个的话就不知道是和谁保持一致了，可以用很多类。 2变量的声明 答:当需要使用一个变量的时候，必须要对该变量就行声明，变量的声明包含2点，1是变量的基本数 据类型，2是变量名比如int a ；int是数据类型a是变量名，可以声明多个变量，比如int a，b，c；等 3，变量的初始化 答:有2种初始化方法， 1是在变量声明时初始化，变量类型变量名=初始值，比如int a=0； 2是先声明变量，然后再初始化给变量赋值，，比如int a；a=0； 3.1可以对变量中的值进行存取，操作，变量使用之前，要使用与其变量符合的数据类型。 3.2基本数据类型，8种 1整数类行:byte,short int(常用)，long（常用）2浮点类型:float，double（常用）3，boolean 4 char 类型名称字节空间使用场景 ------------------------------------------------------------------------------------------------------------ byte 丨1字节（8位）丨储存字节数据（较少用） --------------------------------------------------------------------------------------------------------------- short 丨2字节（16位）丨兼容性考虑（很少用） ------------------------------------------------------------------------------------------------------------ int 丨4字节（32位）丨存储普通整数（常用） -------------------------------------------------------------------------------------------------------------- long 丨8字节（64位）丨存储长整数（常用） ------------------------------------------------------------------------------------------------------------- float 丨4字节（32位）丨存储浮动数（不常用） ------------------------------------------------------------------------------------------------------------ double 丨8字节（64位）丨存储双精浮点数（常用） ----------------------------------------------------------------------------------------------------------- boolean 丨1字节（8位）丨存储逻辑变量（true，fales）（常用） --------------------------------------------------------------------------------------------------------------- char 丨2字节（16位）丨存储一个字符（常用） ---------------------------------------------------------------------------------------------------------------

2019最新Java面试题,常见面试题及答案汇总

ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？

14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？

java各知识点详细总结(毕向东笔记整理)

Java基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java 虚拟机)。 3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。 classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况 如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目

JAVA课程设计 时钟

辽宁工业大学 JA V A程序设计课程设计（论文）题目：时钟 院（系）：软件学院 专业班级：软件技术班 学号： 学生姓名： 指导教师：丁宝柱 教师职称：助教 起止时间： 2009.12.1至2009.12.16

程序设计专题（报告）任务及评语

目录 第1章课程设计的目的与要求 (1) 1.1 课程设计目的 (1) 1.2 课程设计的实验环境 (1) 1.3 课程设计的预备知识 (1) 1.4 课程设计要求 (1) 第2章课程设计内容 (2) 2.1课程设计主要内容 (2) 2.2概要设计 (2) 2.2.1自定义类说明 (2) 2.3详细设计 (3) 2.4测试分析 (16) 2.4.1程序运行情况 (16) 2.4.2程序异常处理 (16) 第3章课程设计总结 (17) 参考资料18

第1章课程设计的目的与要求 1.1 课程设计目的 《JA V A程序设计》是计算机相关专业的必修专业基础课程，其实践性、应用性很强。实践教学环节是必不可少的一个重要环节。本课程的程序设计专题实际是计算机相关专业学生学习完《JAVA程序设计》课程后，进行的一次全面的综合训练，JA V A程序设计的设计目的是加深对理论教学内容的理解和掌握，使学生较系统地掌握程序设计及其在网络开发中的广泛应用，基本方法及技巧，为学生综合运用所学知识，利用软件工程为基础进行软件开发、并在实践应用方面打下一定基础。 1.2 课程设计的实验环境 硬件要求能运行Windows 9.X操作系统的微机系统。JAVA程序设计语言及相应的集成开发环境，J2SDK和ECLIPSE开发工具。 1.3 课程设计的预备知识 熟悉JAVA语言及ECLIPSE开发工具。 1.4 课程设计要求 按课程设计指导书提供的课题，要求学生在自行完成各个操作环节，并能实现且达到举一反三的目的，完成一个项目解决一类问题。要求学生能够全面、深入理解和熟练掌握所学内容，并能够用其分析、设计和解答类似问题；对此能够较好地理解和掌握，能够进行简单分析和判断；能编写出具有良好风格的程序；掌握JA V A程序设计的基本技能和面向对象的概念和方法；了解多线程、安全和网络等编程技术。同时培养学生进行分析问题、解决问题的能力；培养学生进行设计分析、设计方法、设计操作与测试、设计过程的观察、理解和归纳能力的提高。

Java笔记汇总

2010.3.11.Java笔记 1、定义一个年份判定这个年是否是闰年： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; publicclass near { publicstaticvoid main(String args[])throws IOException{ int year; String str; BufferedReader buf; buf=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Input the year:"); str=buf.readLine(); year=Integer.parseInt(str); if(year%4==0&&year%100!=0||year%400==0) System.out.println("year"+year+"is a leap year."); else System.out.println("year"+year+"is not a leap year."); } } 2、求出1~100之间的奇数： publicclass qishu { publicstaticvoid main(String args[]){ int i,j; for(i=1;i<=100;i++){ if(i%2!=0){ System.out.print(i+" "); } } } } 3、一段刚才长2000米每天截取一半多少天后长度短于5米publicclass day { publicstaticvoid main(String args[]){ int i ,j=0; for(i=2000;i>0;i--){ if(i/2<5) j++;} System.out.print(j+" "); } } 4、求125的所有因子： publicclass yinzi { publicstaticvoid main(String args[]){ int i; for(i=1;i<=125;i++){ if(125%i==0){

百一测评——Java经典面试题 带答案

职业技能题库&在线云笔试平台https://www.wendangku.net/doc/8b4021755.html, 试卷名称：Java经典面试题带答案 试卷描述：java笔试题目、招聘笔试、微信考试、在线考试 试卷链接：https://www.wendangku.net/doc/8b4021755.html,/store/open/paperInfo/41651 试卷限时：50分 一.单项选择题 每题分值：2.5分 是否题目乱序：是 是否选项乱序：是 是否可回溯：是 难度：中 1.[单选]Java是从（）语言改进重新设计。 A．Ada B．C++ C．Pasacal D．BASIC 答案：B 2.[单选]下列语句哪一个正确（） A．Java程序经编译后会产生machine code B．Java程序经编译后会产生byte code C．Java程序经编译后会产生DLL D．以上都不正确

职业技能题库&在线云笔试平台https://www.wendangku.net/doc/8b4021755.html, 答案：B 3.[单选]下列说法正确的有（） A．class中的constructor不可省略 B．constructor必须与class同名，但方法不能与class同名 C．constructor在一个对象被new时执行 D．一个class只能定义一个constructor 答案：C 4.[单选]提供Java存取数据库能力的包是（） A．java.sql B．java.awt C．https://www.wendangku.net/doc/8b4021755.html,ng D．java.swing 答案：A 5.[单选]下列运算符合法的是（） A．&& B．<> C．if D．:= 答案：A 6.[单选]执行如下程序代码 a=0;c=0;

职业技能题库&在线云笔试平台https://www.wendangku.net/doc/8b4021755.html, do{ --c; a=a-1; }while(a>0); 后，C的值是（） A．0 B．1 C．-1 D．死循环 答案：C 7.[单选]下列哪一种叙述是正确的（） A．abstract修饰符可修饰字段、方法和类 B．抽象方法的body部分必须用一对大括号{}包住 C．声明抽象方法，大括号可有可无 D．声明抽象方法不可写出大括号 答案：D 8.[单选]下列语句正确的是（） A．形式参数可被视为localvariable B．形式参数可被字段修饰符修饰 C．形式参数为方法被调用时，真正被传递的参数 D．形式参数不可以是对象

Java学习笔记(必看经典)_New - 共33页

JAVA -------- EVERYTHING IS OBJECT OOP class Student{

New null public int/void addNumber( ) throw Excepion {} public int addNumber(int a,int b){ } int a,int b public Student s=new Student() Student Student “Student()” () Student s Student public student(string name,int a){ } public student(int a,string name){ }

static void changename(student stu){stu.setName “LUCY”} overloading overriding JAVA overriding overloading Overloading overloading overloading overloading public void teach(){}; public void teach(int a){}; public void teach(String a){} Overloading Byte—short—float—int—long—double this student(){}; student(string n){ this();// student() } student(int a) this(int a) this this This Public void printNum(){ Int number=40 System.out.println(this.number); } This.number this.number (this) number