java从入门到精通视频笔记

Java从入门到精通笔记

第o讲开山篇

1.JavaseJ2se桌面

JavaeeJ2ee网络

JavameJ2me手机

2.SQLserverMysqlOracle

3.学习软件编程的注意事项

1.高效愉快学习

2.先建立一个整体框架然后细节

3.用什么再学习什么

4.先知道how,再知道why

5.软件编程是一门“做中学”学科，做了才会

6.适当囱冏吞枣

7.琢磨别人怎么做，不是我认为这么做

第1讲

1.课程包括：java面向对象编程，java图形界面，java数据库编程，java文件i/o流，java网

络编程，java的多线程

2.Java历史：1990sun启动绿色计划

1992创建oak语言一＞java

1994gosling参加硅谷大会演示java功能震惊世界

1995sun正式发布java第一个版本，目前最新的是jdk7.0

3.java开发工具：i己事本，jcreator,jbuilder,netbean,eclipse

4.jdk包括：jre（java运行环境）

java的类库：3600多个，常用的150多个

5.第一个程序:

//阿贵

〃功能：显示“HelloWorld”

//public:表示类是公共的，一个文件中只有一个public类

//class:表示这个是一个类

//HelloWorld:类名（公共类的类名，必须和文件名一样）

publicclassHelloWorld

（

〃一个主函数，程序的入口

publicstaticvoidmain（Stringargs[]）

（

〃执行语句

）

6.Java源程序（.java文件）----＞java字节码文件（.class文件）----＞由解释执行器

（java.exe）将字节码文件加载到java虚拟机（jvm）------＞字节码文件（.class）就会在java

虚拟机中执行

第2讲变量.数据类型

1.在java里面int占4个字节，long占8个字节

2.Java基本数据类型：

整数：（byte一个字节：-128—127int四个字节：-2147483648—+2147483647

short两个字节：-32768—+32767long八个字节：）

小数（浮点）：floatdouble

布尔：boolean

字符：char（两个字节，可以存放汉字,chartestl='中引申到字符串

（类）

3.在java中对char进行运算的时候，直接是当做ASCII码对应的整数

4.数据不能从高精度到低精度的转换Byte<short<int<long<float<double

floata=3.4；是过不去的，在java中小数默认是double(双精度)的

应该写成是floata=3.4f；

不过可以强制转换：inta=(int)1.2;intb=(int)1.9

5.inta=Lintb=a+1.2;a先是往高精度转换,然后赋给b,就报错改成inta=l;double

b=a+1.2;或者inta=l;floatb=a+1.2f;就解决了

第4讲流程控制

1.switchcase语句中，switch条件表达式的数据类型应该和后面case的类型一致

2.switchcase语句中，可用的数据类型主要是：byteshortintcharenum

3.当型循环：for和while循环

4.直到型循环：dowhile循环

第5讲类与对象

1.面向对象编程■类与对象

类名首字母大写

类里面的元素叫类的成员变量/属性

2.类的定义

package包名；

class类名extends父类implements

接口名

(

成员变量；

构造方法；

成员方法；

)

3.如何创建对象：

先声明再创建Catcatl；catl=newCat();

—步到位Catcatl=newCat();

4.引用传递类似于指针一样

第6讲成员属性成员方法

1.对象总是在内存中的

2.类成员方法：方法就是指某些行为，表示为函数

public返回数据类型方法名（参数列表）

（

语句；〃方法（函数）主题

3.类名首字母大写方法名首字母小写驼峰法（匈牙利法）下划线

法

4.指针是存储地址的，不因为它的指向的数据的类型而改变大小。

第7讲成员方法（函数）构造方法

1.类的成员方法声明

访问修饰符数据类型函数名（参数列表）；

2.方法的参数列表是多个的，参数列表的数据类型是任意的

3.在调用某个成员方法的时候给出的具体数值的个数和类型要相匹配

4.方法可以没有返回值

5.先设计类，然后根据类创建对象

6.构造方法（构造函数）：完成对新对象的初始化：

方法名和类名相同

没有返回值

在创建一个类的新对象时，系统会自动调用该类的构造方法完成对新对象的初始化

一个类可以定义多个不同的构造方法

每个类都有一个默认的构造方法

第8讲this类变量

1.this属于类的对象的而不是属于类的

2.5this不能在类的外部使用，只能在类定义时候使用！

3.可以用类名直接访问静态变量

第9讲类方法封装

1.类变量是该类的所有对象共享的对象，一改全改了

2.定义语法：访问修饰符static数据类型变量名

3.publicclassDemo9

(

staticinti=l;

static

(

i++；

}〃会自动执行一次，也只有一次

publicDemo9()

i

i++；

)

publicstaticvoidmain(Stringargs[])

(

Demo9tl=newDemo9();

Demo9t2=newDemo9();

4.类方法(静态方法、静态函数)：属于所有对象实例的

5.Java中:类变量(static)原则上用类方法(static)去访问；类方法中不能访问非静态变量

,就是非类变量，但是普通的成员方法可以访问静态变量（类变量）

使用：类名.类方法名对象名.类方法名

6.非类变量就是实例变量，属于每个对象自己的

7.Java面向对象编程的三（四）大特征：封装、继承、多态（、抽象）

8.抽象：把一类事物的共有的属性和行为提取出来，形成一个物理模板，此研究问题的方法就

是抽象

9.封装：把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分

只有通过被授权的操作（成员方法），才能对数据进行操作。

10.封装的访问控制修饰符

11.四种访问控制符：

公开级别：public

受保护级别：对子类和同一个包中的类公开

默认级别：没有修饰符，向同一个包的类公开，子类不可以访问类中默认级别的元素的

私有级别：用private修饰，只有类本身才能访问

公开〉受保护>默认〉私有

12.

Qlicrojief*PaveiPoiait-I■三I

J文静⑺1®IUD<X>

•1«•«/UBAd-3由ItiHTJtlli"

javaa&旬对象编秋（2）大

・封装-访问控制修饰将

4料访问纵射的访问总留

工游翳涮那丽聚的穆柳

区册傩出JJJJ

protectedJJJt

pLRil髓嘟j/xx

cr:-

要理解四种控制级被需要举例说明,但是我们还没有抄

包和子集，所以只有等一下.大东先拿一会吧.

・岛此登星

*1JOSBB40l.'HS♦1•&•=曰■■・

BtWKUM-

13.包的三大作用：区分相同名字的类当类很多的时候可以很好的管理类控制访问范围

14.包的打包命令：packagecom.xiaoming一般放在文件的开始的地方

15.引包命令：improt包名

第10讲访问修饰符重载覆盖

1.一个文家中如果只有public类，那么这个public类可以不用主函数

2.不想被继承就设为protected

3.子类最多只能继承一个父类，Java里面不允许一个子类继承多个父类，C++却可以，如Java

中一定要呢，就用接口吧

4.Java的所有类都是Object的子类，继承层次数没有限制

6.在做开发的时候多使用JDK帮助文档

7.方法重载：类的同一种功能的多种实现方式，取决于调用者传递的参数

8.方法重载注意事项：

方法名相同

方法的参数类型，个数，顺序至少有一项不同

方法的修饰符可以不同

方法的返回类型可以不同

另外：

只是返回类型不一样并不构成重载

只是控制访问修饰符不一样不构成重载

第11讲约瑟夫问题(丢手帕问题)

1.方法覆盖的：子类有一个方法和父类的某个方法名称、返回类型、参数一样

2.方法覆盖注意：

子类的方法的返回类型、参数、方法名称要和父类的一样，否则编译出错

子类方法不能缩小父类方法的访问权限，但是扩大是可以的

3.丢手帕问题：

第十二讲多态

1.多态性:访问子类可以通过访问父类:

Animalcat=newCat();

Animaldog=newDog();

2.在使用多态的时候，如果有使用覆盖函数，那么被覆盖的方法(即是父类中的的那个相应的

方法)是要存在的。

3.多态：一个引用(类型)在不同情况下的多种状态，可使代码更加灵活

4.java允许父类的引用变量引用它子类的实例，是自动完成的

代码：

packagecom.agui;

publicclassDemo5{

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Dog2ddd=newDog2();

ddd.cry();

Cat2ccc=newCat2();

ccc.cry();

Animal2an=newCat2();

an.cry();

Masterxxx=newMasterQ;

xxx.feed(newDog2(),newBoneQ);

〃动物类

classAnimal2

(

Stringname;

intage;

publicStringgetName(){

returnname;

1

publicvoidsetName(Stringname){

=name;

publicintgetAge(){

returnage;

publicvoidsetAge(intage){

this,age=age;

classFood

(

Stringname;

publicvoidshowNameQ

classFishextendsFood

(

publicvoidshowName()

第十三讲抽象类接口（难点重点）

1.父类方法的不确定性，用抽象类修饰这个方法，abstract。

2.抽象类还是可以一样被继承

3.当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现

4.用abstract关键词来修饰的时候，一定是抽象类和抽象方法

5.在使用中不多，公司笔试的时候考很多

6.抽象类不能被实例化，只有被继承以后再去实例化

7.抽象类不一定要包含abstract方法，就算没有abstract方法，也不能实例化它

8.一旦类包含了abstract方法，这个类必须声明为abstract

9.抽象方法不能有主体“｛广

packagecom.sl;

publicclassDemol{

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

abstractclassAnimal

(

Stringname;

intage;

abstractpublicvoidcry();

〃当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现

classCatextendsAnimal

(

publicvoidcry()

(

//donothing

System。”1.printing口苗嘀叫");

)

10.接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，再根据具体情

况把这些方法写出来，语法：

class类名implements接口

方法;

变量;

packagecom.sl;

publicclassDemo2{

publicstaticvoidmain(String[]args)

(

Computercomputer=newComputer();

Cameracamera=newCamera();

Phonephone=newPhone();

computer.useUsb(camera);

computer.useUsb(phone);

interfaceUsb

(

〃声明了两个方法

〃开始工作

publicvoidstart();

〃停止工作

publicvoidstop();

//照相机.实现Usb接口

〃一个类实现接口就要把所有的类全部实现!

classCameraimplementsUsb

publicvoidstart()

(

System.oMf.println("我是照相机我开始工作了！");

)

publicvoidstop()

(

System.oi/f.println("我是照相机，我停止工作了！)

)

)

〃手机类

classPhoneimplementsUsb

(

publicvoidstart()

{

System.o"Aprintln("我是手机，我开始工作了！")；

)

publicvoidstop()

System.oat.println（"我是手机，我停止工作了！"）;

〃计算机

classComputer

〃开始使用USB接口

publicvoiduseUsb(Usbusb)〃体现多态

(

usb.start();

usb.stopQ;

)

)

11.接口不能被实例化

12.接口中的所有方法都不能有主体

13.抽象类里面是可以有实现了的方法的

14.接口中的所有方法都不能有主体，即都不能被实现

15.接口是更加抽象的抽象类！！！！

16.一个类继承抽象类或是使用接口，那么就要实现所有的抽象方法

17.一个类可以实现多个接口

18.接口中可以有变量(但是不能用private,protected修饰)

19.接口中的变量本质上都是静态的，而且是final,不管你加不加static,所以可以直接使用：

接口名.变量名

20.在java开发中，经常把常用的变量定义在接口中作为全局变量使用

访问形式：接口名.变量名

21.一个接口不能继承其它的类，但是可以继承别的接口

22.接口体现了程序设计的多态和高内聚低耦合的思想

第十四课final作业评讲

1.实现接口和继承父类的区别：

2.java是单继承，一个类只允许继承一个父类，这种单继承的机制可以保证类的纯洁性，比

C++的多继承机制简洁

3.实现接口可以看做是对单继承的一种补充

4.继承是层次式的，不太灵活，修改某个类就会打破这种继承的平衡，但是接口就不会，因为

只针对实现接口的类才起作用

5.用接口体现多态：

6.前期绑定：在程序运行之前就进行绑定，由编译器和连接程序实现，又叫静态绑定，如static

方法和final方法，包括private方法，它是隐式final的

7.后期绑定：在运行的时候根据对象的类型进行绑定，由方法调用机制实现，因此又叫动态绑

定，或是运行时绑定，除前期绑定外的所有方法都属于后期绑定

8.

〃展示接口实现多态的概念

packagecom.s2;

〃汽车接口

interfaceCar

(

StringgetName。;//获得名字

intgetPrice。;//获得价格

)

〃宝马

classBMWimplementsCar

(

publicStringgetNameQ

(

return"我日,宝马啊”；

)

publicintgetPrice()

(

return800000;

classQQimplementsCar

publicStringgetNameQ

return”没意思的，qqH;

publicintgetPrice()

(

return20000;

)

)

publicclassCarShop

(

〃售车的收入

privateintmoney=0;

〃卖出一部车

publicvoidsellCar(Carcar)

(

System.。〃力printin(“车型：”+car.getName()+”价格是：,,+car.getPrice());

money+=car,getPrice();

)

publicintgetMoneyO

(

returnmoney;

)

publicstaticvoidmain(String[]args)

CarShopa=newCarShopQ;

〃卖出宝马

a.sellCar(newBMW());

//卖出qq

a.sellCar(newQQ());

System.ow?.println("总收入是："+a.getMoney());

9.final概念：final可以修饰变量和方法

当不希望父类的某些方法被子类覆盖的时，可以用final修饰

当不希望类的某个变量的值被修改，可以用final修饰

当不希望类被继承时，可以用final修饰

lO.final修饰的变量一般用下划线书写

11.如果一个变量是final的，那么定义时候必须赋初值

12.final修饰的变量又叫常量，一般用XX_XX_XX命名

13.final什么时候用：

处于安全的考虑，类的某个方法不允许修改

类不会被其它的类继承

某些变量值是固定不变的，比如pi

第15讲讲题目

1.switch只能对int、short>byte以及枚举类型进行判断，case后面只能是常量表达是

2.猜拳的java程序设计：

有个人Tom设计他的成员变量，成员方法，和电脑猜拳，电脑每次都产生一个随机

数0,1,2,0表示石头，1表示剪刀，2表示布。请实现：

第16讲数组

1.数组是可以存放多个同一类型的数据

2.用法：

程序员用法：数组定义：数据类型数组名[]=new数据类型[大小];

如：intarr[]=newint[5];

或者是int口arr=newint[5];

或者是int[]arr=newint[5];

数组引用：数组名[下标]

没事找事用法：数组定义：intarrn；arr=newint15];

或者是int口arr;arr=new

或者是int[]arr;arr=newint[5];

数组引用：数组名[下标]

古板用法：inta口={1,2,3,4,5,6,7,890};

数组引用：数组名[下标]

3.知道数组的大小：arr.length(成员属性)

4.引用在栈里面，对象在堆里面

5.对象数组：

packagecom.testl;

import

publicclassDemno5_2{

publicstaticvoidmain(String[]args)throwsIOException{

Dogdog[]=newDog[4];

InputStreamReaderisr=newInputstreamReader(System.m);

BufferedReaderbr=newBufferedReader(isr);

for(inti=0;i<4;i++)

(

dog[i]=newDog();

System.oMprintln("请输入第”+(i+l)+”只狗名字)

〃输入狗名

//try{

Stringname=br.readLine();〃将名字赋给对象

//}catch(Exceptione){

//TODOAuto-generatedcatchblock

//e.printStackTrace();

//}

dog[i].setName(name);

System.—.printin("请输入第”+(i+l)+”只狗的体重:

Strings_weight=br.readLine();

floatweight=Float.parseF7oR(s_weight);

//将名字赋给对象

dog[i].setWeight(weight);

)

floatallWeight=O;

for(inti=0;i<4;i++)

(

allWeight+=dog[i].getWeight();

)

floatavgWeight=allWeight/dog.length;

System。”/.printin(“狗总体重:"+allWeight+”狗平均体重:"+avgWeight);

)

)

〃定义一个狗类

classDog

(

privateStringname;

privatefloatweight;

publicvoidsetName(Stringname)

(

this,name=name;

)

publicvoidsetWeight(floatweight)

this,weight=weight;

publicfloatgetWeightQ

returnthis.weight;

4.对象、字符串的很多不能用“=="，用的话是表示地址相等，比较字符串的内容是否相等是用

equals方法

5.数组可存放同一类型数据

简单数据类型(intfoat)数组，可以直接赋值

对象数组在定义后，赋值时候需要再次为每个对象分配空间【即是：new对象】

数组大小必须事先指定，如：intx;inta口=newint[x];是可以的

数组名可以理解为指向数组首地址的引用

数组的下标是从0开始标号的

6.排序的介绍：排序是将一群数据依据一定的顺序进行排列的过程

分类：

内部排序：将要排序的所有数据都加在到内存里面进行排序，包括交换式排序法、选择式排序

法和插入式排序法

外部排序：数据量过大，无法全部加载到内存，包括合并排序法和直接合并排序法

7.交换式排序法属于内部排序法，是运用数据值比较后，依判断规则对数据的位置进行交换，

已达到排序的目的，它包括：冒泡排序法(Bubblesort)和快速排序法(Quicksort)

8.冒泡排序法：

第一次写法：

packagecom.test1;

publicclassDemo5_3{

publicstaticvoidmain(String[]args)

intarr[]={l,6,0,-l,9,4,5,l,-5,4,7);

〃排序开始

//

for(inti=O;i<arr.length-l;i++)

(

〃内层循环开始逐一比较，如果发现前一个数比后一个数大，就交换

for(intj=O;j<arr.length-i-l;j++)

(

if(arr[j]>arr[j+l])

(

arr[j]=arr[j]Aarr[j+1];

arr[j+l]=arr|j]Aarr[j+l];

arr[j]=arr[j]Aarr[j+l];

for(inti=O;i<=arr.length-l;i++)

(

System.^wZ.print(arr[i]+n");

)

System.oMprint("总长度是"+arr.length);

我们进行改进，进行封装试试看:

packagecom.testl;

publicclassDemo5_3{

publicstaticvoidmain(String[]args)

intarr[]={l,6,0,-l,9,4,5,l,-5,4,7);

Bubblebubble=newBubble();

bubble,set(arr);

〃排序开始

//

classBubble

(

publicvoidset(intarr[])

i

for(inti=O;i<arr.length-1;i++)

(

//内层循环开始逐一比较，如果发现前一个数比后一个数大，就交换

for(intj=O;j<arr.length-i-l;j++)

(

if(arr[j]>arr[j+l])

(

arr[j]=arr[j]Aarr[j+1];

arr[j+l]=arr[j]Aarr[j+l];

arr[j]=arr[j]Aarr[j+1];

for(inti=O;i<=arr.length-l;i++)

System.OMf.print(arr[i]+"");

)

System.。加.print("总长度是"+arr.length);

)

)

9.注意：新建一个类的对象而且调用了类的方法时候，虚拟机会在主栈的外面给调用的这个方

法分配一个相应的栈，在外面的这个栈里面对数组或者对象的操作就是对主栈的相应的数组或

者对象的操作，但是不是针对所有的类型，如果是int等简单类型就不行。

10.选择式排序法：选择排序法(快于冒泡排序法)：

选择排序法(selectsorting)也是一种简单的排序方法，第一次从R[0kR[n-1]中寻选

取最小值，与R[0]交换，第二次从中选取最小值，与R[l]交换，第三次从

R[2卜R[n-1]中选取最小值与R[2]交换...总共(n-1)次。

第十八讲排序查找

1.插入式排序法分为：

插入排序法(InsertionSort)

谢尔排序法(shellsort)

二叉树排序法(Binary-treesort)

2.插入式排序法一插入排序法(InsertionSorting)

基本思想：把n个待排序的元素看成是一个有序表和一个无序表，开始时候有序表只包含一个

元素，无序表中包含有n-l个元素，排序过程中每次从无序表中取出一个元素，把她的排序吗

一次和有序表元素的排序码进行比较，将它插入到有序表的适当位置，使之成为新的有序表。

3.插入法的实现：

packagecom.testl;

publicclassDemo5_4{

publicstaticvoidmain(String[]args)

(

intarr[]={1,6,3,10,8,7,9,0,0,-199,9);

Insertinsert=newInsert();

insert,sort(arr);

)

classInsert

(

publicvoidsort(intarr[])

(

for(inti=l;i<arr.length;i++)

(

intinsertVal=arr[i];

//insertVal准备和前一个数比较

intindex=i-l;

while(index>=O&&insertVal<arr[index])

(

〃将要把型[index]向后移动

arr[index+1]=arr[index];

〃让index向前移动

index";

)

〃将indexVal插入到适当位置

arr[index+l]=insertVal;

)

System.oMprintln("结果是:")；

for(intp=O;p<=arr.length-l;p++)

(

System。"力print(arr[p]+"")；

)

)

)

4.交换式排序法——快速排序法

快速排序(Quicksort)是对冒泡排序法的改进，1962年提出的，使用递归思想。

5.希尔排序法

6.合并排序法：外部排序法最常用的方法，如果数据量太大无法一次完全加载，可使用外部辅

助内存来处理数据，主要应用在文件排序。

7.查找：顺序查找和二分查找(使用二分查找前提是先排好序)

packagecom.test1;

publicclassDemo5_5

(

publicstaticvoidmain(String[]args)

(

intarr[]={2,5,7,12,15);

BinaryFindbf=newBinaryFindQ;

bf.find(O,arr.length-1,3,arr);

bf.find(O,arr.length-1,12,arr);

)

)

classBinaryFind

(

publicvoidfind(intleftindex,intrightindex,intval,intarr[])

(

〃首先找到中间的数

intmidIndex=(rightIndex+leftIndex)/2;

intmidVal=arr[midIndex];

if(rightlndex>=leftlndex)

(

〃如果要找的数比midVai小

if(midVal>val)

(

find(leftlndex,midIndex-1,val,arr);

)

)

第十九讲多维数组

1.多维数组，定义：

语法：类型数组名口口=new类型[大小][大小]inta口口=newint[2][3]

2.

publicclassDemo5_6

publicstaticvoidmain(String[]args)

(

inta[][]=newint[4][6];

a[l][2]=l;

a[2][l]=2;

a[2][3]=3;

for(inti=0;i<4;i++)

(

〃列

for(intj=O;j<3;j++)

System.o〃1.print(a[i][j]+"");

System.o〃println();

)

第二十讲二进制位运算移位计算

1.0的反码和补码都是0

2.我们只会针对有符号的数才讲反码补码

3.java没有无符号数，换言之，java中的数都是有符号的

4.在计算机运算的时候，都是以补码的方式运算的

5.按位与&或|异或八取反~

6.--2=-3(00000010->11111101->11111100->10000011)

7.2&3=000000102|3=00000011~-5=(10000101->11111010->111110110bW>00000100)4

8.有3个移位运算符：

>>算术右移：低位溢出，符号位不变，并用符号位补由于移动而空出的高位

<<算术左移：符号位不变，地位补0

>>>逻辑右移：

9.记住：对负数操作就要先找补码！！！正数也是，只不过不边罢了。得到的结果如果是正数

就结束，如果是负数就再折腾一下，转变成原码才行。

10.-1移动任意位都是-1

相当于是*4)=4,相当于是*4)=-4

12.而对于有符号数，其左移操作还是逻辑左移，但右移操作是采用逻辑右移还是算术右移就

取决于机器了！(算术右移和逻辑右移的区别是：算术右移不右移符号位，即最高位，右移后

前补0还是1取决于符号位的值;逻辑右移执行时将移动符号位，右移后前补0)

第21讲集合

1.集合类泛型异常的处理

2.解决方法：链表或者集合类(可以动态的改变)，请熟悉常用的集合类

3.集合类分类：

List结构的集合类：

ArrayList类，LinkedList类，Vector类，Stack类

Map结构的集合类

HashMap类,HashTable类

Set结构的集合类

HashSet类，TreeSet类

Queue结构的集合类

Queue接口

4.Java中所有的对象都是从Object继承下来的

5.子类交给父类，可以自动转换，反过来就要强制转换

6.ArrayList中可以多次存放同样的人，ArrayList本质是存放引用

7.AArryList中删除对象

packagecom.test1_1;

import

publicclassDemo5

(

publicstaticvoidmain(String[]args)

ArrayListal=newArrayList。;

System.o"Z.println(“al大小：M+al.size());

〃向辿中加入数据(类型Object)

〃创建一个职员

Clerkclerkl=newClerk(“老大”,50,1000);

Clerkclerk2=newClerk(“老二”,45,1000);

Clerkclerk3=newClerk(“老三”,35,1000);

〃将clerkl加入al中

al.add(clerkl);

al.add(clerk2);

al.add(clerk3);

〃可不可以放入同样的人？

System.o“/.println(”al大小：n+al.size());

〃如何访问al中的对象(数据)

〃访问第一个对象

//Clerktemp=(Clerk)al.get(2)：//al.get(0)返回object类型，要强制转换

〃遍历所有的对象

for(inti=0;i<al.size();i++)

(

Clerktemp=(Clerk)al.get(i);

System.。"力println("第"+(i+l)+"个人是："+temp.getName());

)

〃如何在al中删除一个对象

al.remove(l);

System.。"%.printin("第2个人被删除了，现在呢？看看下面的：”);

for(inti=0;i<al.size();i++)

Clerktemp=(Clerk)al.get(i);

System.。加.printin("第"+(i+l)+"个人是:"+temp.getName());

)

)

)

classClerk

(

publicStringgetName()

(

returnname;

)

publicfloatgetSal()

(

returnsal;

)

publicintgetAge()

(

returnage;

)

Stringname;

privatefloatsal;

intage;

publicClerk(Stringname,intage,floatsal)

(

=name;

this.sal=sal;

this,age=age;

第22讲集合

1.字符串相等是地址相等而不是内容相等！

2.雇员管理系统程序的编写（自己改进了一点，不完全，继续改进……）

3.LinkedList

addFirst表示把元素加在链表的最前面（类似于栈一样）

addLast表示把元素加在链表的最后面（类似于队列一样）

getFirst

getLast

remove

removeFirst

removeLast

4.Vector:

5.Stack用法：（加的时候是在前加的）

第二十三讲集合

1.HashMap

HashMaphm=newHashMapO;

Empemp=newEmp（“s001",''aaa",3.4f）;

2.HashMap可以存放空置但是HashTable不能存放空值。

3.Hashtable是基于陈旧的Dictionary的，HashMap是Javal.2弓|进的Map接口的一个实现

4.Hashtable是线程同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的。而

HashMap是异步的，因而HapMap中的对象并不是线程安全的。因为同步的要求会影响执行的

效率，所以如果你不需要线程安全的集合那么使用HashMap是一个很好的选择，这样可以避

免由于同步而带来的不必要的性能开销，从而提高效率。

5.值：HashMap可以让你将空值作为一个表的条目的key或value,但是Hashtable是不能放入

空值的(null)

6.HashTable由于是同步的，有锁，因此是存在等待的，HashMap允许

7.ArrayList和Vector区别：

Vector是同步的，是线程安全的，更安全

ArrayList是异步的，不是线程安全的，没有Vector安全

数据增长：Vector缺省情况下是自动增长原来一倍的数组长度，适合保存大量的数据；

ArrayList是原来的50%

8.如果要求线程安全，使用Vector、Hashtable,否则ArrayList、LinkedList、HashMap

9.如果要求键值对，使用HashMap、Hashtable

10.如果数据量大又考虑线程安全，使用Vector

第二十四讲集合补充

HashMap和Hashtable都是实现Map的接口的，ArrayList和LinkedList都是实现List的接口的

第二十五讲泛型异常

2.Java引入泛型的好处就是安全简单，可以在开始的时候就约束集合的类型

3.泛型的好处就是在编译的时候检查类型的安全，并且所有的强制转换都是自动和隐式的，提

高代码重用率

packagecom.test1_1;

import

publicclassDemo7_4{

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

ArrayList<Dog>al=newArrayList<Dog>();

Dogdogl=newDog();

al.add(dogl);

//Dogtemp=(Dog)al.get(0);

//Cattemp1=(Cat)al.get(O);

Dog也说=al.get(0);〃这个时候就不需要强制类型转换

)

)

4.Java的反射机制:拿到一个类的很多信息！好处是：编写一些灵活性更好的代码

packagecom.testl_l;

publicclassDemo7_5

(

publicstaticvoidmain(String[]args)

(

//Gen<Integer>genl=newGen<Integer>(2);〃我们这个时候调用了构造函数，注意新建

的时候都是调用了构造函数

//gen1.showTypeName();

Gen<Bird>gen2=newGen<Bird>(newBird());

gen2.showTypeName();

)

〃定义一个鸟类Bird

classBird

publicvoidtest1()

(

)

publicvoidcount(inta,intb)

(

)

)

〃定义一个类

classGen<T>

(

privateTo;

〃构造函数

publicGen(Ta)〃构造函数

(

o=a;

)

//得到T的类型的名称

publicvoidshowTypeName()

(

〃通过反射机制，我们可以得到T这个类型的很多信息，比如得到成员函数名

Method口m=o.getClass().getDedaredMethods();〃函数的一些信息

〃打印

for(inti=O;i<m.length;i++)

)

5.使用泛型的优点(GJ表示泛型Java)：类型安全

向后兼容

层次清晰

性能较高

6.异常处理：当出现程序无法控制的外部环境问题的时候(用户提供的文件不存在，文件内容

损坏，网络不可用……)，JAVA就会用异常对象来描述

7.JAVA中用2种方法处理异常

1.在发生异常的地方直接处理

2.将异常抛给调用者，让调用者自己处理

8.异常分类：

顶层都是Throwable

9.检查异常举例：

10.tracert(traceroute)查看路由信息

11.routeprint：路由表信息打印出来

12.netstat-an：谁连接到你的电脑上的

第二十六讲异常和异常的处理

1.异常处理：

Try...catch：程序运行产生异常时候，将从异常发生点中断程序并向外抛出异常信息

2.设置了捕获，而且真的捕获到了异常，后面的异常就检测不到，遵循一个先后的顺序，但是

程序还是会继续执行，正常程序和e.printStackTrace。;执行后显示的顺序貌似有点乱了，所以

书上推荐用System.oaf.println("message:="+e.getMessage());显示顺序不会乱

3.在出现异常的地方就中止执行代码，然后直接进入到catch语句，如果有多个catch语句，

就进入匹配异常的那个catch语句

4.try

FileReaderfr=newFileReader(Md:\\l2334.txt");

)

catch(Exceptione)//或者Exceptione,Exceptione是捕获所有的

(

System.0w^println("message:=n+e.getMessage());

e.printStackTrace();

)

5.finally:如果把finally块置try...catch语句后，finally块一般都会得到执行，相当于一个万能

的保险，即使前面的try块发生异常，而又没有对应异常的catch块，finally块将马上执行

6.文件被打开一直没有关闭是很恐怖的！所以就有了finally语句，不管有没有异常都会执行,

一般说，把需要关闭的资源「文件，连接，内存……1

7.以下情况finally将不被执行：

Finally块中发生了异常

程序所在的线程死亡了

使用了System.exit(-l)

关闭CPU

8.

packagecom.testl_l;

import

import.*;

publicclassDemo7_6

(

publicstaticvoidmain(String[]args)

(

〃检查异常1.打开文件

FileReaderfr=null;

try

(

〃在出现异常的地方就中止执行代码，然后直接进入到catch语句

〃如果有多个catch语句，就进入匹配异常的那个catch语句

fr=newFileReader("d:\\1234.txt");〃如果找不到咋办啊？你必须处理

)

catch(Exceptione)//或者Exceptione,Exceptione是捕获所有的

(

〃要输出异常的信息，利于排错

System.^wAprintln("message:=H+e.getMessage());

e.printStackTrace();

//处理

)

//catch(lOExceptione2)

//{

//e2.printStackTrace();

//)

finally

(

System。”%.printin(“进入finally");

〃这个语句块，不管有没有异常，都会执行

〃一般说，把需要关闭的资源[文件，连接，内存……]

if(fr!=null)

(

try(

fr.close();

}catch(lOExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

//

System.。〃力println("kankan");

他的端口号：4567

〃运行异常

//inta=4/0;

〃数组越界

//intarr[]={1,2,3}；

arr[23]);

)

)

9.抛出异常：

packagecom.testl_l;

import

publicclassDemo7_7

(

publicstaticvoidmain(String[]args)throwsException

(

Fatherfather=newFather();

father,test1();

classFather

privateSonson;

publicFatherQ

(

son=newSon();

)

publicvoidtest1()throwsException

(

System.0w^println(,'l");

try(

son.test2();

}catch(Exceptione){

System.oMprintln("父亲)

e.printStackTrace();

classSon

(

publicvoidtest2()throwsException

(

FileReaderfr=null;

fr=newFileReader("d:\\l23d4.txt");

)

)

10.泛型可以更安全和提高代码重用率，泛型可以利用反射机制拿到类的一系列信息，从而提

高代码的优越性。

第二十七讲作业讲评

跳水成绩打分系统

第二十八讲作业讲评

1.静态变量不给初值也是可以的，默认为0,如果前面有final就一定要赋值了

2.布尔值之间可以用“一"号

3.if（i==l&j==2）〃由于"i==l”返回了布尔值，所以就可以过去，否则就不行，但是c中就没

有这样的顾虑，c会自动转换成boolen

4.继承中不能缩减被继承的父类中函数的范围（针对函数的参数的范围）

5.Math.floor-＞取一个比某数小的最大整数

Math.round-＞四舍五入

Math,ceil-＞取一个比某数大的最小整数//ceil:天花板

Math.min-＞需要两个数被操作

6.substring（beginlndex,endindex）-----＞起始索引包括，结束索引不包括

7.字符串的序数也是从0开始计数

8.Java的内存区分为：代码区、栈区和堆区

9.普通变量定义和初始化的时候直接放在栈区，不是普通变量的引用在栈区，对象在堆区

10.类中含有静态变量（函数）时候：直接在数据区（申请空间）

11.堆区中有字符串引用池（stringpool）,它存放字符串的引用，当字符池发现有字符时就指

向字符，字符是存放在堆区中的。相同的字符串指向相同的地址，但是如果要用new来初始

化，地址就不一样了，因为new是直接去开辟堆区的空间的。

12.对于对象来讲，==是比较地址

14.如果希望在子类中调用父类的构造函数，那么一般要求在子类的构造函数中调用

15.super表示当前正要调用该类它父类的变量或方法。

第二十九讲满汉楼.swing介绍开始进入图形界面）

l.gui-＞gooe（读音）Graphicuserinterface

2.AWT（抽象窗口工具集）AbstractWindowToolKit

------＞swing,解决了awt存在的led问题，是awt的继承和发展

——＞IBM认为swing比较消耗内存，就创建了一个新的GUI库，叫SWT

—＞IBM为了开发方便，又开发了更易用，功能强大的JFace

3.

Eclipse最早是IBM附属公司oti开发的，一共投入了4000万美金，后来捐献给开源社区

Eclipse是一个开源的、可扩展的集成开发环境，已经成为最流行的java开发工具

Eclipse安装就可以开发Javase,不能开发javaee项目，要安装MyEclipse或者lomboz

4.IDE：集成开发环境，比如jereator、vs2005

5.sun公司开发的netbean,波兰的公司的Jbuilder,还有更早的Jcreator,IBM的J2SE开发

+Myeclipse

6.swing组件：

7.JFrame是Frame的子类

属于容器类组件，顶层容器

JFrame有一些常用的方法

8.JButton组件(也是一种容器)：是AbstractButton的子类，可以加入别的组件

9.由于组件会很多，以后就现在类的开始声明，然后再在构造函数里面先创建，再添加！

第三十讲布局管理器

1.布局管理器：

概念：组件在容器中的位置和大小是由布局管理器来决定的，所有的容器都会使用一个布局管

理器，通过它来自动进行组件的布局管理

种类：java提供了五种布局管理器：流式布局管理器(FlowLayout)；边界布局管理器

(BorderLayout)；网格布局管理器(GridLayout)；卡片布局管理器(CardLayout)、网格包

布局管理器(GridBagLayout),前三种最常见

2.边界布局将容器简单的划分为东南西北中5个区域，中间区域最大

3.JFrame和JDialog窗体默认是边界布局

如：

packagecom.GUI;

import

import

publicclassDemo82extendsJFrame

JButtonjbl,jb2,jb3,jb4,jb5;

publicstaticvoidmain(String[]args)

Demo8_2demo82=newDemo8_2();

)

publicDemo8_2()

(

jbl=newJButton("中部)

jb2=newJButton("北部”)；

jb3=newJButton("东部)

jb4=newJButton("南部)

jb5=newJButton("西部)

〃添加各个组件

this.add(jbl,BorderLayout.CENTER);

this.add(jb2,BorderLayoutWOT?TH);

this.add(jb3,BorderLayout.EAST);

this.add(jb4,BorderLayout.SOUTH);

this.add(jb5,BorderLayout.WEST);

//设置窗体属性

this.setTitle("边界布局”)；

this.setSize(200,200);

this.setLocation(200,200);

this.setDefaultCloseOperation(JFrame.EX/71_OALC£(9S£);

〃显示窗体

this.setVisible(true);

)

4.流式布局：HowLayout,按照组件的添加次序将按钮组件(当然也可以是别的组件)从左到

右放到容器中，当到达容器的边界时，组件放置到下一行中，Fl