`

Java SE学习笔记(Ronbay原创)

    博客分类:
  • Java
阅读更多
Java SE笔记
因没有经过系统的培训,总觉得自己在Java基础上很薄弱。加之哥上的是一个二逼大学,常常出现低级丢人的错误。经过两个多月的study,用失去和MM聊QQ的时间,便系统学习了Java SE知识。不管是高级部分的并发还是基础的if语句,都系统的学了遍。我想在技术方面,基础决定一切。对于Java初学者我想有四块难点分别是基础部分的IO流和反射,高级部分的集合和多线程。将笔记总结如下,我想对初学者这些还是用的,若要转载。望您注明出处,不然就骂“你妹”。@author:Ronbay(原创)难免出错 欢迎指正 版权所有
1. 程序结构
程序结构分为(1)顺序结构(2)分支结构(3)循环结构
2. switch
switch操作允许判断类型有数字、字符、byte(jdk1.5之后的枚举)
3. 循环
(1)do…….while   该循环不会轻易被使用;
(2)while 当不知道循环的字数,但确定循环的结束条件;
(3)for 明确知道循环次数的循环。
4.循环的控制可以用break continue
continue 中断一次循环
breake  中断所有循环
4. 重载
方法名相同,参数的类型与个数不同,返回值的类型不能构成重载的条件
5.引用数据类型
数组、类、接口,其默认值是null
6.内存
内存分为两种:(1)堆内存(2)栈内存
堆内存:保存数组具体内容的空间
栈内存:保存一块堆内存的引用地址,可以简单的理解保存数组的名称
7.所谓的引用传递,实际上指的是“一块堆内存同时被多个栈内存所指向的情况”
引用传递的核心,一块堆内存被不同的栈内存所指向,一个栈修改的内容,其他的所有对应的栈内存的数据都要进行修改。
8.数组
   数组的静态初始化,即在数组定义的时候就可将其初始化
   静态初始化
   Int [] data = new int[](){1,2,3};
9.数组的相关操作
(1)在java 中提供了支持“java.util.Arrays.sort(数组名称)”;
(2)数组的拷贝
System.arrayCopy(源数组名称,源数组开始点,目标数组名称,目标数组开始点,拷贝长度)
基础小结
1.基本数据类型
(1) 数值类型
整  型:byte、short、int、long
浮点型:float、double
字符型:char
布尔型:boolean
(2) 引用数据类型
数组、类、接口
2.public class 类名:文件名与类名要相同
Class可以定义多个类,文件名称与类名称可以不一样,但是执行的时间要执行生成的*.class文件,而一个java文件之中可以同时定义多个class。
3.解释一下java实现可移植性原理
   不同的操作系统提供不同版本的虚拟机,有虚拟机负责执行java生成class(字节码文件)
5. 方法:方法是一段被用于重复调用的代码段。
*现在如果由主方法直接调用的方法,定义格式如下
public static 返回值类型 方法名(参数列表){
    return [返回值]
}
6. 方法重载:方法名相同,参数的类型或个数不同,方法重载时,虽然允许不同的返回值,但是尽量要统一,这是减少开发中的麻烦。
7. 方法的递归调用
方法的递归调用一定要考虑到结束条件
8. 数组:是一组相关变量的集合
定义格式:
(1) 动态初始化:先开辟数组空间,之后数组的每一个元素的内容都是默认值。
(2) 静态初始化:直接开辟数组,并为其赋值
9. 数组的引用传递
(1) 数组中的所有内容都保存在堆内存之中,每一块堆内存空间都可以被多个栈内存所指向,而不同的栈内存修改的时候,由于是同一个内存空间,所以所有的内容都会发生改变。
(2) 在使用方法或接收返回数组的时间,只需将参数或返回值类型定义为数组即可,这个也属于引用传递。
10. 数组常用的两个方法
(1) 数组排序:java.util.sort(数组名称)
(2) 数组拷贝:System.arrayCopy(源名称,源数组开始点,目标数组开始点,拷贝长度)
二、
1.
1)面向对象的主要特点
2)类与对象的关系
3)对象的引用传递的初步分析
4)private封装性的实现
5)构造方法的定义与使用
6)String类的特点及常用方法
2.面向对象特点
(1)封装:保护内部的东西对外不可见
(2)继承:扩充类的功能
(3)多肽:在某一范围内,任意的改变所属类的形式
在面向对象之中,除了以上的三个特征之外,还有如下三个开发过程
(1)•OOA:面向对象的分析
(2)•OOD:面向对象的设计
(3)•OOP:面向对象的程序
面向对象的好处就是与现实生活完全接轨的,而且没有太多的意外出现
3.类与对象
(1)类:表示某群体的共同特征,是一个抽象的概念
(2)对象:表示一个个体的特征,收到类的控制,类中可以定义类的操作行为
类主要由两部分所组成
(1) 成员(属性):用于描述不同的特征
(2) 方法:用于完成某些功能的实现
因此在操作的时候先有类再有对象
*类中规定出来了对象的所有操作的方式(属性、方法),而对象是类的具体使用形式。
若能把类比喻成汽车设计图纸的话,那么对象就是一辆辆车。类是对象的操作模板,而对象是真正看得见,摸得着的东西,而类是一个虚的概念。
4.类和对象的基本操作
格式1:声明对实例化对象:类名称.对象名称 = new 类名称();
格式2:分步完成操作
(1) 声明对象     类名称 对象名称 = null;
(2) 实例化对象: 对象 = new 类名称();
5.内存:
   (1)堆内存:保存对象的具体信息,实际就是属性信息
   (2)栈内存:保存了堆内存的地址,简单理解就是对象的名称
声明对象:指已经开辟了栈内存,但是还没内有堆内存空间
实例化对象:已明确的开辟了堆内存空间,则表示可以使用。
*若不实例化,则会出现“NullPointerException”空指向异常,这种异常只发生在引用数据类型之中。表示直接使用了没有开辟堆内存的对象。
6.深入分析引用传递问题
(1)不管是数组也好,还是类也好,其基本的操作流程都是一样的。就是不同的栈指向同一个堆。且记住一点,由于一个栈内存保存的堆内存的地址,只能保存一个地址。即:一个栈只能指向一个堆,但是一个堆可以被多个栈内存所指向。
(2)在Java中,不使用的堆内存空间(没有栈内存所指向)就会成为垃圾。所有的垃圾在默认情况下将等待GC(垃圾收集器)进行不定期的回收。而在实际的开发中,为了代码的性能,所以垃圾的产生越少越好。
三、面向对象:主要围绕着抽象类与接口进行讲解。
   模块1:java集合框架,像数组结构实现均在此部分
   模块2:java的IO操作
   模块3: JDBC,此部分简单但是很重要
1. 请解释Java实现可移植性的原理
Java程序最终通过字节码文件运行,运行的时间字节码需要JVM的支持。但是不同的操作系统有着不同的JVM,程序不关心操作系统,只关心JVM,只要JVM不改变,程序可以在操作系统间任意的移植。
2. 请解释path与classpath的区别
•path是windows的环境变量属性,用于指定可执行命令的属性
•classpath在java程序执行的时间,用于指定类的加载路径
3. Java目前未使用到的关键字:goto const
有特殊含义的关键字:null true false
在jdk1.4之后增加了一个assert关键字
在jdk1.5后增加了一个enum关键字
在java中一下不属于保留字,但是有意义的名称
true 、false、null
在java中,一个小数的默认值类型是double
byte-short-int-long
int-float-double   double是数据类型长度最大的
左移位:<< 有符号的移位操作
右移位:>> 有符号的移位操作
无符号的右移操作 >>>
任何语言的循环控制是一样的。
4. Java的新特性:对数组的支持
Foreach 可变参数
for(数据类型 变量:数组){
操作
} 在声明方法参数的时间加了可变参数
public static 返回值类型(数据类型 …..参数名称)
这样一来,在传入参数的时间就可以任意多个了,而且全部的参数是以数组形式就收的
5. 构造方法
构造方法的目的是为类中的属性初始化,构造方法定义与类名相同,但是没有返回值类型。在使用关键字new实例化对象的时间调用。若类中没有明确定义一个构造方法的话。则会自动生成一个无参:什么都不做的构造方法。也就是类中至少有一个构造方法存在。构造方法的本身也是可以进行方法重载的。只要参数的类型或个数不同,就可以完成重载。
6. 匿名对象:只使用一次的对象,使用一次之后将被垃圾收集。
7. (1)String 类及String类的相关操作方法
(2)this关键字
   (3)static关键字
   (4)内部类
1)两种实例化的方式
String str = “hello”; //通过直接赋值的方式完成
String str = new String(“aaa”);//通过构造方法完成
“==”实际上对于”==”比较的是地址是否相等,因为地址是以数值形式存在。
如果字符串比较的话,比较的不是地址的值,而是两个字符串的内容。所以在现在就需要使用String类中的equals()方法来完成比较
2)一个字符串实际上就是一个String的匿名对象,一个字符串是使用“”括起来的,那么一个字符串的常量实际上本身就属于匿名对象。
3)String两种实例化的区别
String str = new String(“”);
可以发现,程序开辟了两个空间,与直接赋值方式相比,肯定直接赋值的方式更为方便,所以在开发中,绝对不能使用new调用String类的String(String org)的构造方法
而且,使用直接赋值的方式也可以减少堆内存的开销。对于String类型来讲,使用直接赋值的方式会在字符串池中,保存内容。若之后再声明字符串的时间发现内容一样了,则不会重新开辟空间,而是从内存池中取出数据继续使用。
String的特点
(1) 字符串的内容一旦确定,则不能修改:实际来讲,字符串变量的改变是内存空间地址的指向,而本身的字符串内容并没有任何的变化。因此在开发中要避免。
(2) String类的常用操作方法
•字符串变为字符数组:public char[] toCharArray()
`将全部字符数组变为字符串:public String (char[] value)
`将部分的字符数组变为String类型 public String (char[] value,int offset,int count);//后两个参数分别代表起始位置和长度。
   判断是否以指定的字符串开头或者结尾
•判断以指定的字符串开头:public boolean startwith(String prefix);
`判断以指定的字符串结尾:public boolean endwith(String prefix);
`替换操作:public String replace
`字符串截取,使用以下的两个方法
•全部截取:public String subString(int length)
`部分截取:public String subString(int begin,int endIndex)
字符串的拆分操作
可以将字符串按照指定的内容进行拆分操作
• public String[] split(String prefix);
字符串的查找
如果在一个字符串中查找指定的内容,可以使用以下方法
取其位置 public int indexOf(String string)有的话,返回其位置,没有则返回-1;
是否包含public boolean contains(String str);
字符串的其他操作
去掉左右空格:public String trim();
去掉字符串的长度:public int length();
转大写:public String toUpCase();
转小写:public String toLowCase();
引用传递:String的内容不可改变,改变的只是其内存的地址的指向。
8. this在关键字中表示一下的概念
(1) 调用类中的属性,this.属性;  (2)调用类中的方法,this.方法()
(3)  调用类中的构造,this.();     (3)表示当前概念
*所有的构造方法应该是对象操作前最早调用的,所以使用this调用构造方法的时间,所有代码必须放在构造方法的首行。
*在使用this调用构造方法的时间至少有一个构造方法,是没有使用this调用的,而此构造方法将作为调用的出口。一般这个出口都会使用无参构造方法来完成。(this使用最多的两种情况)
*this的最重要概念表示当前对象,当前正在调用类中的方法的对象,成为当前对象
9.static关键字
(1)将一个属性设置为公共属性,则使用static关键字声明。一般情况下,对于使用static关键字声明的属性,都使用类名直接调用。例如 :类名称.static 属性
(2)static除了声明属性之外,还可以定义方法,使用static定的方法可以由类名称直接调用。
•而类中的普通方法和普通属性,只有在对象实例化后才可能调用。
(2) 主方法上也存在static关键字,那么主方法的含义是什么?
public static void main(Sting[] args){}
•public —》说明访问权限为最大,所有人都能用
• static—》因为执行的就是类名称,所以表示可以由类名称直接调用。
• void —》因为主方法是一切的起点,所以表示没有返回值
• main —》系统内建的方法名称
• String  args[]:表示字符串数组,用于接收参数static 的区域为公共的全局数据区。
• 程序的内存划分
(1) 栈内存:对象名称,实际上是对象对堆的引用地址
(2) 全局代码区:保存所有的操作方法
(3) 堆内存:属性
(4) 全局数据区:保存所有的static属性
对象数组:
对象名称[] 对象数组名称 = new 类名称(长度)
但这样开辟之后,数组中的每个内容都是null值,需要进行单独实例化操作。
5.static的相关应用
(1)使用static可以统计一个产生了多少个实例化对象
   •因为static的属性是所有对象共享的
(2)在研发中还可以使用static进行自动的命名操作。
6.String类的特点
   (1)不可改变
(2)使用直接赋值方式完成
(3)一个字符串就是一个String匿名对象
7.代码块,代码块可分为四种:
(1)普通代码块
(2)构造块
(3)静态块:使用static关键字声明的代码块,称为静态块
(4)同步代码块:多线程
构造块会优先于构造方法执行的,静态块是为静态属性初始化的。静态块优先于主方法执行的,静态块优先于构造方法执行的,而且只有一次。
9. 内部类:
(1) 缺点:从代码块中可以发现内部类的缺点,程序结构混乱
(2) 优点:(唯一优点)在于可以方便的访问外部类中的私有成员。
如果在外部类直接使用内部类的实例化对象
外部类.内部类 内部类对象 = 外部类对象. new 内部类实例
10. 内部类
若一个内部类使用static关键字声明的话,则此内部类将成为外部类。可以直接通过外部类.内部类的形式访问。内部类可以在任意位置使用
11. 继承
(1) 继承的基本概念
(2) 方法的覆写
(3) Super关键字
(4) 抽象类和接口的基本概念
(5) 对象的多态性
(6) 抽象类和接口的实际应用
1) 继承就是扩展自己已有类的功能,继承的限制:在java中不允许多重继承,一个子类只能继承一个父类,不能继承多个父类。但是在java 中允许多层继承
Eg.
Class A{}
Class B extends  A{}
Class C extends B{}
在继承中访问父类的私有操作,而只能继承全部的公共操作,对于私有内容是不能直接访问的,但是可通过其他途径访问。
2) 子类的实例过程
•在实例化为子类对象的时间,首先实例化父类中的内容,为父类初始化。实际对于子类的构造方法而言而实际上就隐藏了一个super()的语句
3) 在使用this调用构造方法的时间,至少留有一个构造方法,是没有使用this调用作为统一的出口。
4) 方法的覆写
(1) 是发生在继承关系之中,子类覆写了父类中的相关方法。
(2) 限制:子类定义了与父类同名的方法,称为方法的覆写,在方法覆写的时间一定要注意访问权限的问题。被覆写的方法不能拥有比子类更严格的访问权限。
(3) 在使用子类实例化对象调用类中被覆写方法时,调用的永远是被覆写过的操作。
(4) 原则:只要使用子类的实例化对象,调用的方法也被子类覆写过的话,则永远调用的是覆写过的操作。
(5) 如果希望调用父类中被覆写过的方法,则只能通过super.方法()的形式调用。
5) 属性的覆写
子类中声明了父类中同在的属性,称为覆盖。但从实际的开发来讲,属性基本上都属于private 类型的,所以属性的覆写基本上不存在。
6) 两个重要的对比
No 比较点 重载 覆写
1 英文单词 Overload Override
2 概念 方法名相同,参数的个数或类型不同 方法的名称,参数的个数和类型完全相同
3 注意点 无 访问权限不能变小
4 范围 在一个类中发生 在继承中发生
7) this与super的区别
No 比较点 重载 覆写
1 概念 this.属性表示本类中的属性 Super.属性直接找到父类中的属性
2 方法 this.方法表示调用本类中的方法 Super.方法表示直接调用父类中的方法
3 构造 可以调用本类中的其他构造方法,但是要求至少有一个构造方法没有this(),调用构造方法时间,this要放在构造方法首行。 从子类中调用父类中的构造方法,无论子类怎么编写代码,总先调用父类中的构造方法。调用构造方法时,要放在子类方法的首行。
4 特殊点 this表示当前对象 无此概念

7)final关键字
(1) 使用final可用于一下声明
(1.1) 声明类,声明的类不能有子类
(1.2) 声明方法,声明的方法不能被子类所覆写
(1.3) 声明变量,声明的变量就成为常量,常量是不能修改的
  *用final声明的类实际上就断子绝孙,也可以成为太监类
  *使用final声明的方法不能被子类覆写
  *使用final声明的变量叫常量
在java 中若使用final声明常量,则常量的标识全部大写。在final中存在一个概念:全局常量,使用public static final声明的常量成为全局常量。
                          泛型
1. 在jdk1.5之后,提供了泛型技术的支持,也是一个java的新特性。
•掌握泛型的基本作用
•掌握泛型通配符的使用
•掌握泛型和泛型接口的操作
Jdk1.5的新特性——泛型,此技术的最大特点是类中的属性的类型可以由外部决定,而且在声明类的时候应该采用如下格式:
class 类名称<泛型类型,泛型类型> {}
2. 泛型的其他注意点
在使用泛型操作时间,有很多注意点,例如:构造方法,依然可以使用泛型或者一种称为泛型的擦除。
3. 擦除泛型
如果在使用的时候没有指定泛型类型的话,则表示擦除泛型,泛型一旦擦除之后,将进行Object进行接收,以保证程序部出现任何错误。
4. 泛型的通配符
在泛型的操作中通配符使用较多,而且在日后的系统类库中有很多地方要使用这写操作。
Eg .         Object obj = “hello”;
5. 在进行对象转型的时候,可以使用自动的向上转型,但是在使用泛型的时候却没此种操作。在程序中的问号,表示可以接收任意的泛型类型,但是只是接受输出,并不能修改。
6. 泛型的上限:上限就是指一个操作泛型最大的操作父类:
Eg 泛型的上限通过以下语法完成
? extends 类
Eg.public class Point<T extends Number>{   //表示最高只能是Number
}
7. 泛型的下限:
泛型的下限指的是只能设置具体的类或父类,设置如下
? super 类
Eg.定义一个类,此方法只能接收String或Object类型的泛型的对象。
8. 泛型的接口
泛型不光可以在类中定义使用,还可以在接口中进行定义。操作语法如下:
Interface 接口名称 <泛型类型>{}
9. 泛型方法
泛型除在定义之外,还可以在方法中定义,而且在方法上使用泛型,此方法所在的类不一定是泛型所操作的类。
反射
1. 了解反射的作用
2. 掌握class类的操作及使用
3. 可以通过反射取得一个类的实例化
4. 可通过反射取得类的结构,可通过反射进行属性方法的调用
1.1认识反射
在Object存在以下一个方法
public final class<?> get class();
所有类的对象都可以使用getClass()方法完成操作,那么此方法返回的是一个class,那么通过class就可完成反射操作。
1.2 认识class类
   在反射中class类是一个操作源头,所有的反射操作从此类展开,但是如果想实例化磁力对象可以通过以下三种途径完成。
•通过Object类中的getClass()方法
•通过类.class的形式 eg  Person.class
•通过class类的静态方法,class.forName(“”)方法,最常用的是forName(“”)方法,其次是类.class形式。
1.3 通过class类实例化对象,而且日后所有框实现原理都是依靠class类完成的。
(1.3.1)实例化无参构造的类
     所以个类中存在一个无参构造方法,那么可直接通过class类进行实例化。
•根据包.类名称实例化class对象
通过class类中的以下方法 newInstance()
1.4通过class类取得完整结构
通过class类的很多方法,可以轻易的取得一个类中定义的全部构造方法、普通方法、常量、变量等。
(1) public class<?> getInterfaces() 取得实现的全部接口,接口本身就是一个特殊的类,所以会以class对象数组形式返回。
(2) 取得全部的构造方法
public Constructor <?>[] getConstructors() throws SecurityException,只能取得构造方法的名称
•得到访问修饰符:public int getModifers();
•得到全部的参数:public Class<?> getParamTypes()
在实际的开发中,所有的访问权限基本都是以数字的形式出现的。这样的程序较好些,对于public ,private 而言本身也是对应一个数字。而对于public static final ,实际上是属于三个值相加的结果。
所以要想正确的还原一个访问修饰符,则必须使用一个Modify的类进行还原。
Public static String toString()来还原修饰符
(3) 得到一个类的全部属性
Public Field[] getFields() throws SecurityException
异常
1.只要是RuntimeException的异常对象,虽然使用了throws,但是在程序中也可以不使用try……catch进行处理
2自定义异常
一个类继承了Exception类,则表示一个自定义异常。当发现系统中提供了异常类不够的时候就可以如此。
assert关键字作用(表示断言)
表示断言,就是表示程序执行到某条之后,其结果肯定是固定值。从实际开发而言,断言是很少用的。
小结
1. Java使用单继承,即一个子类只能继承一个父类
2. 接口相关的设计模式,工厂和代理
3. toString()用于对象的打印
4. equals()用于对象的比较。
5. 对象的转型
•向上转型:自动完成(一般情况下,向上转型的操作居多)
•向下转型:强制转换
6. 匿名内部类
内部类,在一个类的内部含有另外一个类,就是内部类。匿名内部类是在抽象类和接口的基础上发展起来的。
7. 在开发中匿名内部类的开发较少,只有两种情况不会见到:(1)Java图形界面上(2)Spring开发框架上。
8. 包
(8.1)包,实际上就是一个文件夹,可以在不同的文件夹下面定义同名文件,在Java中使用package来定义它。
(8.2)在进行包导入操作的时间,所有类必须放在包中,没有包的类是不存在的。
    9.静态导入
如果一个包的某个类的方法全都是static类型的,则就可以使用静态导入。
(10)系统常用包
(10.1)Java.lang此包属于自动导入,但在jdk1.0时需要手工导入
(10.2)java.lang.reflect此包为反射机制包,是Java乃至整个java世界中最重要的包,此包可以完成大量的底层操作。
(10.3)java.util 包,工具包。若将此包掌握清楚,则可以方便的做各种设计,各种开发
(10.4)java.io   IO操作
(10.5)java.net 网络编程
(10.6)java.sql 数据库编程
(10.7)java.text 国际化程序的应用
包装类
在Java中有一切皆对象的说法,但是在Java中的数据分为基本数据类型和引用数据类型。而基本数据类型是类吗?为了解决这个矛盾,java中针对这八种基本类型,设置了包装类,用于以类的形式表示数据类型。
八种包装类实际包含以下两种
(1) 数值型:Integer 、Byte 、short 、Float 、Double、Long
<都是Number的子类>
(2) 其他类型Character、Boolean
(3) 在包装类中,存在装箱与拆箱操作。
•装箱操作:将基本数据类型改为包装类,称为装箱操作。
•拆箱操作:将包装类变为基本数据类型,称为拆箱操作。
*在jdk1.5之前,所有的数据必须经过手工的装箱与拆箱操作,而且包装不能进行任何的运算。但在jdk1.5之后,for-each,可变参数,自动进行装箱和拆箱。
   (4)包装类也可以取得最大值与最小值
(5)可以将字符串变为基本数据类型,但需要注意的是该字符串必须由数字组成。如果非数字则会出现代码错误
Eclispe简介:
1.JDT是Java的开发环境,可以方便的对代码进行开发与调试
2.Junit的使用
(1)黑盒测试:测试功能的
(2)白盒测试:测试性能的
在Java中有很多开发工具,但是Junit的使用较为广泛。对测试而言,主要测试的理论以及选用的测试用例<Test Case>
克隆对象
克隆就是复制,可以将一个类的内容完整的复制下来。
接口的两个作用
(1) 表示一种能力(例如克隆接口)
(2) 说明其作用 (只定义方法)
Stack栈
特点:先进后出,所有的内容将从栈顶取出,每次新增内容都保存在栈顶之中。
(1) public class Stack<E> extends Vector<E>实际上属于比较古老的类。
栈的操作:
(1) 入栈:public E push(E item)
(2) 出栈:public E pop();
栈的属性操作,在java之前的国际程序中,提出了一种属性文件的概念。属性文件的后缀是“*.properties”.在java中提供一个专门的属性操作类:Properties。
public class Properties extends HashTable<Object,Object>;此类是HashTable的子类,所有的属性都是以字符串的形式出现。所以不能加入其他非字符串(String)对象
(2) 可以将属性文件保存在一个xml格式文件之中
(3) 可以将xml文件中读取属性
类集操作
枚举
1. enum
2. enum关键字与Enum类的关系
3. 类集与枚举的支持
4. 使用枚举实现一个接口或在枚举中定义抽象方法。
1.枚举的作用:
(1) 在jdk1.5之前,Java并不存在枚举类型
(2) enum关键字
在jdk1.5之后,可以直接使用enum关键字定义一个枚举类型
Eg.
Public enum Color{
    RED,GREEEN,BLUE;
}
而且枚举在jdk1.5之后也可以直接在switch语句中使用,switch判断的时候只能判断字符或数字,但是在jdk1.5之后,却可以判断枚举类型。
2.Enum与enum的区别是什么?
(1)使用emun可以定义一个枚举类型,那么实际上就相当定义一个类,即此类继承了Enum类而已。
(2)在Enum类的构造方法中是受保护的,实际上对于每一个枚举。对象一旦声明之后,就表示自动调用了此构造方法。所有的编号采用自动编号的方式进行。
3.还可以通过此类找到枚举中的一个指定的内容使用valusof()方法
4.类集对枚举的支持
在jdk1.5之后,增加了两个类集的操作类:EnumSet、EnumMap
(1) EnumMap:EnumMap是Map的子类,与Map的操作是一致的
(2) EnumSet:本身是Set接口的子类,但是在此类中没有任何构造方法定义,表示构造方法被私有化了。此类的方法都是静态的操作。
5. 枚举深入
(1) 定义构造方法:枚举的使用非常灵活,可以在枚举中直接定义构造方法,但是一旦构造方法定义之后,则所有的枚举对象都必须明确的调用此构造方法。
(2) 枚举中的构造方法不能声明为public 的,因为外部是不能调用枚举的构造方法。
6. 在枚举中定义抽象方法
在枚举中可以定义多个抽象方法,那么这样一来,枚举中的每个对象都必须单独实现此方法。
多线程(并发)
1. 掌握多线程的两种手段
2. 了解多线程的基本操作方法
3. 理解同步及死锁的概念
1. 线程是进程基础上的进一步划分
多线程实现的两种方式:(1)一种是继承Thread类(2)一种是实现Runnable接口。
Thread类:一个类只要继承了Thread类,同事覆写了run()方法,则就可以实现多线程操作了。
Runnable接口:
在实际的开发中,很少使用Thread来完成,而是通过Runnable接口来完成。
public interface Runnable{
    public void run();
}
所以一个类要是实现此接口,并要实现run()方法。
2两种实现多线程方式的区别以及联系?
在实际的开发中,永远以实现Runnable接口相比Thread有以下好处
(1) 避免单继承的局限,因为一个类可实现多个接口;
(2) 适合资源的共享
Thead和Runnable之间还是存在联系的,哪些联系?
public class Thread extends Object implements Runnable;
多线程设置和取得名字
1. 在线程的操作中因为操作的不确定性,所以提供了一个方法,可以取得当前的操作线程。
public static Thread currentThread();
对于线程的名字一般是在启动前进行设置,最好不要设置相同名字,最好不要为一个线程改名字。
(1) 设置名字:
|- Set public final void setName(String name);
|- 构造
   |- public Thread (Runnable target String name);
|- public Thread (String name);
(2) 取得名字:
|- public final String getName();
得出结论,在程序运行时间。主方法实际上就是一个主线程。实际上对于java来讲,每一次执行java命令对于操作系统来讲都将启动一个Java的进程。那么主方法实际上只是这个进程的进一步划分。
问题:在Java程序执行中的一个程序至少启动几个线程?
至少启动两个:main,gc(垃圾收集器)
2. 线程的休眠
让一个线程小小休息一下,之后起来继续工作,称为休眠。
Public static void sleep (long miss) throws Interrupted Exception
在使用此方法时,需要进行try……catch.
3. 线程的中断
在sleep()方法中存在interruptException,那么会造成异常的方法就是中断。
public void interrupt();
4. 线程的优先级,在线程中使用以下方式设置
(1)public final void setPriority(int newPriority)
5. 对于优先级来在线程中有三种
•最高:public static final int MAX_PRIORITY;
•中等:public static final int NORM_PRIRITY;
•最低:public static final int MIN_PRIORITY;
问题:各个线程可设置优先级,那么主方法的优先级是什么?
通过程序可知主方法的优先级是NOR_PROPERTY;
同步与死锁
同步
在Java中可通过同步代码的方式进行代码的加锁方式,同步的方式有两种
(1) 同步代码块
(2) 同步方法
同步代码块:synchronized关键字进行代码块的声明,但是在使用此操作时,必须明确的指出到底要锁定的是哪个对象,一般都是以锁定当前对象为主。格式如下:
Synchronized(对象){}                   //表示锁定某个对象
一般将this进行锁定。
同步方法:

通过以上两种可以给出Java中方法定义的完整格式:
[访问权限(public |protected|defaukt|private)] [static ][final][synchronized][niative]
返回值类型或void
方法名称([参数列表])[throws 异常1,异常2]
发现同步可以保证资源的完整性,但是过多的同步,程序依然保证完整性,但是性能会降低。
死锁
在程序中过多的使用同步会产生死锁问题,那么死锁属于程序运行时间发生的一种特殊状态
*多个线程共享一个资源的时间需要进行同步,但是过度的同步会造成死锁。
对象的克隆
Object类中有一个clone()方法,完成对象的克隆。
如果希望对象能被克隆,那么其所在的类必须实现Cloneable接口。此接口未定义任何方法,表示它有这种能力。
对象的多肽 :
1. 方法的重载和覆写是多肽的一种体现
2. 真正的多太性还包括了一种称为对象的多肽性的概念。
|对象的多肽性指的是,子类和父类之间的相互转换关系
|向上转型:父类. 父类对象 = 类实例          —自然完成
|向下转型:子类.子类对象 = (子类)父类实例 —强制转换
*为了保证对象向下转型操作正确,在操作前最好加上instanceof关键字进行判断。
*在设计中父类的设计较为重要,只要父类设计合理了,则代码开发就非常的简便。
一、 抽象类(重点)
抽象类,包含一个抽象方法的类称为抽象类,抽象方法则是只声明而未实现的方法。所有的抽象方法用abstract 所有的类也是一样的。
对于抽象类来讲,不能实例化操作。但是可以声明,如果要想使用抽象类,则必须依靠子类。抽象类必须被子类继承的。而且被继承的子类必须实现抽象类中的所有抽象方法。
思考:1.抽象类能否使用abstract声明呢?
(1) 抽象类必须被子类继承
(2) 被finnal声明的类不能有子类
2.抽象类中能不能不存在构造方法?
抽象类中允许有构造方法,但是此构造方法不能直接调用的,是交给子类去调用的。子类对象的实例化过程,永远是先调用父类中的构造方法。
实际上来讲,抽象类比普通类就是多一个抽象方法而已。
抽象类中的属性要想初始化,则肯定还是依赖于构造方法。
二、 接口(重点)
1. 接口是一个特殊的类,在Java中接口是有抽象方法和全局常量组成。在java是使用interface来定义一个接口。
interface A{
public static final String INFO = "CHINA";  //全局常量
public abstract void print();  //抽象方法
public abstract void fun();    //抽象方法
}
在此接口中,定义了一个全局常量两个抽象方法。那么接口与抽象类一样。需要有子类,那么子类此时不再成为继承类。而是实现接口,通过关键字implements完成。
interface A{
public static final String INFO = "CHINA";  //全局常量
public abstract void print();  //抽象方法
public abstract void fun();    //抽象方法
}
class B implements A{    //子类B实现接口A

@Override
public void print() { //实现抽象方法
System.out.println("Hello world........");
}
@Override
public void fun() { //输出全局常量
System.out.println(INFO);
}

}

public class InterfaceDemo01 {
public static void main(String[] args) {
B b = new B();
b.print();
b.fun();
}
}
进一步研究以上的程序
•既然接口已经明确的要求是由抽象方法和全局常量组成。那么在接口定义的时间,就可以简化操作。
interface A{
//public static final String INFO = "CHINA";  //全局常量
final String INFO = "CHINA";  //全局常量
//public abstract void print();  //抽象方法
void print();  //抽象方法
//public abstract void fun();    //抽象方法
void fun();    //抽象方法
}

•一个类虽然只能继承一个父类,但是同时可以继承多个接口。使用接口可以实现多继承的能力。
如果一个类既要实现接口,又要继承抽象类的话,则必须按照以下方式完成。
class 子类 extends 抽象类 extends 接口A,接口B,…{}
interface D{
public void printD();
}
interface F{
public void printF();
}
abstract class E{
public abstract void printE();
}
class X extends E implements D,F{

@Override
public void printD() {
// TODO Auto-generated method stub

}

@Override
public void printE() {
// TODO Auto-generated method stub

}

@Override
public void printF() {
// TODO Auto-generated method stub

}

}
public class InterfaceDemo02 {
public static void main(String[] args) {

}
}
一个抽象类可以实现多个接口,但是一个接口不能继承一个抽象类。一个接口不能继承一个抽象类,但是一个接口可以继承多个接口。
•这一点在以后的开发中会用到。
三、 多态性
使整个java中最重要的部分,因为有多态性的存在,才是程序变得更加灵活。是面向对象的最后一个特征。
•方法的重载和方法的复写都是多肽性的体现,
•真正的多态性还包含一种对象多肽性的概念
|对象多态性主要指的是子父类相互转换的关系。
|向上转型 父类 父类对象 = 子类实例          ->自动完成
  |向下转型 子类 子类对象 = (子类)父类实例        -> 强制完成
四、抽象类和接口的应用
1.抽象类的最大用处就是模板设计
2.接口的最大用处是
抽象类用于定义模板操作,但是接口呢?
接口实际上作为标准存在的,例如:
四、 抽象类与接口的区别是什么?
1. 通常情况下,一个接口的子类实现其全部的抽象方法。但是在一般的开发中,可以根据自己的需要选择性的覆写,那么该怎么实现呢?用一个类先将接口实现了,但是所有的方法都属于空实现,之后再继承此类。应该使用抽象类,因为抽象类也不能直接使用。
2. 抽象类与接口的区别(绝对重点)
No 比较点 抽象类 接口
1 组成 抽象方法、普通方法、常量、变量、构造方法、全局常量 抽象方法、全局常量
2 定义 abstract interface
3 子类 通过extends继承抽象类 通过implements实现接口
4 限制 一个子类只能实现一个抽象类 一个子类可以同时实现多个接口
5 关系 一个抽象类可以实现多个接口 一个接口不能继承一个抽象类,但是可以实现多个接口
一个抽象类中可以包含多个接口 一个接口中可以包含多个抽象类
6 设计模式 模板设计 工厂设计、代理设计
两个一起操作可以完成适配器操作
7 实例化 都是通过对象的多态性,通过子类完成子类的实例化操作
8 实现限制 存在单继承局限 不存在此类局限
9 特性 表示一个标准,一种能力
从以上的表格来看,在抽象类和接口同时使用的话,优先使用接口,因为接口可以避免单继承的局限。
一个抽象类中允许包含一个接口
1.适配器设计模式
interface Window{
public abstract void open();    //打开操作
public abstract void close();   //关闭操作
public abstract void icon();    //最小化
public abstract void unicon();  //最大化
}
abstract class WindowAdapter implements Window{
public void open(){}
public void close(){}
public void icon(){}
public void unicon(){}
}
class MyWindow extends WindowAdapter{
public void open(){
System.out.println("打开窗口");
}
}
public class AppAdapterDemo {
public static void main(String[] args) {
Window win = new MyWindow();
win.open();
}
}
2.工厂设计模式

interface Fruit{
public void eat();
}
class Apple implements Fruit{
@Override
public void eat() {
System.out.println("吃苹果。。。。。");
}

}
class Orange implements Fruit{

@Override
public void eat() {
System.out.println("吃橘子。。。。。。");
}

}
//增加一个过渡类,该类成为工厂类
class Factory {
public static Fruit getFruit(String className){
Fruit fru = null;
if("apple".equals(className)){
fru = new Apple();
}
if("orange".equals(className)){
fru = new Orange();
}
return fru;
}
}
public class Interdemo {
public static void main(String[] args) {
Fruit f = Factory.getFruit(args[0]);
if(f != null){
f.eat();
}
}
}
以前讲的所有的实例化对象,都是通过工厂取得的。那么客户端调用的时间,根据传入的值不同,完成的功能也不同。
if("orange".equals(className)){
fru = new Orange();
}
以上代码将字符串写在前面,通过字符串的匿名对象调用方法。将字符串写在前面,有效的避免空指向异常。
3.代理设计模式
有如下情景,
•张某属于老好人,也特别有银子,然后马某向张某借了很多1000000钱.说一年后还钱
•但是一年之后张某向马某讨债时间,马某说没钱。但是张某知道马某有钱不还
•张某在无奈之下,找到了讨债公司范某。基本手法就是
•范某为了把钱讨回来,准备了:绳索、钢筋、钢锯
•马某害怕了然后还钱
•马某销毁罪证
张某—》范某——》马某

interface Give{
public void  giveMoney();
}
class RealGive implements Give{

@Override
public void giveMoney() {
System.out.println("把钱给我。。。。。。。。。。。");
}
}
class ProxyGive implements Give{
private Give give = null;
public ProxyGive(Give give){
this.give = give;
}
public void before(){
System.out.println("绳索、钢筋、钢锯");
}
@Override
public void giveMoney() {
this.before();
this.give.giveMoney();
this.after();
}
public void after(){
System.out.println("销毁所有的罪证");
}

}
public class StringDemo {
public static void main(String[] args) {
Give give = new ProxyGive(new RealGive());
give.giveMoney();
}
}

一、 日期操作类(重点)
在java中对日期的显示,有很好的支持。Date、DateFormat、SimpleDateFormat、Calendar。等都可以取得日期。
1. Date(重点)



IO 部分:
1.在Java Io操作中,文件的分隔符是不一样的。
•windows:  \
•linux   :   /
2.Java本身属于跨平台性,那么应该可以适应不同的平台要求。那么为了解决可以自动适应不同系统的分隔符要求,所以File 类中提供了以下的2个变量
•路径分隔符:public static final String path(String separator,”;”);
•分隔符   :public static final String(String separator,”\”或”/”);
3.判断文件是否存在
提供了以下的方法:public boolean exist();
4.在File类中提供了以下两个方法进行目录列表的操作
•public String [] list();                //返回字符串数组
•public  File[] listFile();       //返回文件数组
5.创建目录 mkdir();
6.判断是否是文件夹,public boolean isDirectory();
判断是否是文件 public boolean isFile();
7.System类对IO的支持;
(1)System类中存在三个变量
No 常量 描述
1 public static final PrintStream out 输出
2 Public static final PrintStream err 错误
3 …………        InputStream in 输入
(2)System.out是PrintStream的实例,常用的方法就是向屏幕上打印信息,当然若使用System out的话也可以直接为outPutStream实例化。
(3)输出、输入重定向
System.out ,System.err都有固定的输出目标,都是屏幕。
System in 有固定的输出目标,都是键盘。但是System类中提供了一系列的输入输出重定向的方法,可以改变System out  ,System err ,System in的输入输出位置。
System out重定向      public static void setOut();
System err重定向      ………………………….setErr();
2.BufferedReader
实际上表示的是缓冲区读取,可以一次性的将内容全部读取出来.
(1) InputStreamRead:表示将输入字节流变为字符流
(2) OutputStreamwrite:表示将字符的输出流变为字节的输出流
字符编码
在程序中如果字符编码没有完成则会出现乱码,常见的乱码
•UTF:包含了以下编码
• 8859-1:包含全部的英文编码
•GBK /GBK2312 GBK表示简体中文和繁体中文
GB2312只表示简体中文。
2.造成乱码的根本原因就在于程序与本机环境的编码不一致
3.对象序列化
对象序列化,就是将一个对象转化为二进制的数据流。如果一个类的对象要想实现对象序列化,则对象所在的类必须实现Serializable接口。此接口中没有任何的方法,此接口只是作为一个标识,表示本类的对象具备了序列化的能力而已。
3.ObjectOutputStream类和ObjectInputStream前者属于序列化操作,而后者属于饭序列化操作。对象进行序列化之后,就可以通过ObjectInputStream进行及序列化操作。若假设类中的某个属性不希望被序列化的话,则要使用transient关键字声明。
4.Runtime类
每一个JVM启动的时候都对应了一个Runtime实例,表示运行时
Public class Runtime extends Object
但此类的构造方法私有化
功能:
(1) 运行本机程序
(2) 使用Runtime取得系统信息。
在Runtime类中可以通过maxMemory() freeMemory(),totalMemory()取得系统内存信息,之后也可以通过gc()方法强制性的让程序改掉所有的垃圾空间。

Str.split(“|”);应该为str.split(“\\|”);
Systime类是一个系统类,是陪伴我们最常的一个类。此类可以取得程序的花费时间
执行前startTIme public static long currentTimeMills();
执行后endTime public static long currentTimeMills();
执行时间(endTime - startTIme)
(3) System与垃圾回收
public static void gcc();
调用此方法实际上就是调用Runtime类中的gcc()方法
若一个对象不用的话,则就可能进行垃圾回收。在Object类中存在一个方法,此方法将在对象被回收前调用。
Protected void finalized() throws Throwable
但从一般的开发来看,很少说有专门的开发在对象回收前进行操作。所以此操作理解即可。
字节流与字符流
1. 在整个IO包中,流的操作分为两种
(1)字节流:(1)字节输出流:OutputStream;(2)字节输入流:InputStream
(2)字符流:(1)字符数出流:Writer;(2)字符输入流:Reader
        2.IO操作的基本步骤
           在Java中使用IO操作必须按照以下的步骤完成
(1) 使用File找到一个文件
(2) 使用字节流或字符流的子类OutputStream,InputStream,Writer,Reade进行实例化
(3) 进行读或写操作
(4) 关闭close方法,在流的操作中最终必须进行关闭
1.字节输出流
在java.io包中OutputStream是字节输出流的最大父类,此类是抽象类,所以在使用时间,需要子类实例化操作,若此时要完成文件的数出操作,则使用FileOutputStream为OutSttream进行实例化操作。
OutputStream提供了以下的数据导入方法
(1) 写入全部的字节数组 public void writed(byte[] b) throws IOException
(2) 写入部分的字节数组 public void write(byte[] b,int offset,int length) throws IOException
(3) 写入一个数据:public FileOutputStream (File file,boolean append) 若将append的内容设置为true,则表示增加内容
2. 字节输入流
使用InputStream可以读取输入流的内容,那此类定义如下
•将内容读入到字节数组之中,public int read (byte[] b[]) throw Exception
•每次读一个数据 public abstract int read () throw IOException
4.字符数出流Writer
          Writer是在io包中操作字符的最大父类,主要功能是完成字符流的数出。
5.字符输入流 Reader  
字符输入流与字节输入流不同的地方在于,使用的是char数组。
IO小结;
1. 字节流与字符流的区别?
(1) 字节流操作的时间是直接与文件本身相关联,不使用缓冲区;
(2) 字符流在操作的时间是通过缓冲区与文件操作的。
  即:(1)字节—》文件
   (2)字符—》缓冲—》文件
在综合的比较来说,在传输或者在硬盘上保存的内容都是以字节形式存在的,所以字节流的操作比较多,但是在操作中文的时候,字符流比较好使。
2. 在Java中所有的IO操作都定义在java.io包中。
3. File 类表示与平台无关的平台操作,只负责文件本身,而不负责文件的内容。
4. OutputStream与InputStream字节的输出、输入流,通过FileXXX实例化。
5. Writer和Read是字符的输出、输入流,通过FileXXX实例化。
6. 字节流是直接操作文件本身的,而字符流是需要缓存操作文件的。
流还分为以下几种:
1. 内存操作流
2. 管直流
3. 字节—字符转换流
4. 字符编码问题
5. 打印流
6. 对象序列化
内存操作流
   IO提供了一个内存操作流,通过内存操作流输入和数出的目的是内存
使用ByteArrayOutputStream和ByteArrayInputStream完成内存的操作流
在内存流中,所有的输入和数出都是以内存为操作的源头。
ByteArrayOutputStream是内存向程序数出的。
ByteArrayInputStream是用于程序内存写入的
管道流
   管道流是两个线程间的通讯,PipedOutputStream和PipedInputStream两个类完成的,但是这两个类使用的时候基本都跟OutputStream和InputStream类似。唯一的区别是在于连接管道的操作上。



    


集合
一、 集合
1. Collection接口、List接口、Set接口的作用及关系
2. Map接口的作用
3. 类集的四种方式及使用区别
4. 类集的常用操作
(1) 单值操作接口:Collection、List、Set
|- List和Set是Collection接口的子接口
(2) 一对值的操作接口:Map
(3) 排序的操作接口:sortedMap,SortedSet
(4) 输出接口Iterator、ListIterator 、Enumeration
(5) 队列:Queue
1) Collection 接口是最重要的操作接口,其中规定了一个集合的基本操作方法,此接口下有两个接口,这两个接口又分别有着各自的特点,在使用上完全不一样。
Collection定义了如下的方法:
Public interface Collection<E>extends Iterable<E>
在JDK1.5之后,Collection接口使用了泛型技术。这样接口中操作的内容更加安全
Collection定义了如下的方法
No 方法 类型 作用
1 Public boolean add(E e) 普通 向集合中添加元素
2 Public boolean addAll(Collection<? Extends E> c) 普通 向集合中添加一组元素,泛型指定了上限
3 Public void clear(); 普通 清空所有内容
4 Public Boolean contains() 普通 判断是否有指定内容
5 public boolean containsAll(); 普通 查找一组数据是否存在
6 Public Boolean equals(Object obj) 普通 对象的比较
7 Int hashCode() 普通 返回hash码
8 Public Boolean Isempty() 普通 判断集合内容是否为空
9 Public Iterator<E> iterator() 普通 为Iterator接口实例化,迭代输出
10 Public Boolean remove() 普通 删除指定的对象
11 Public Boolean removeAll(Collection<?> c ) 普通 从集合中删除一组对象
12 Public Boolean retainAll(Collection<?> c) 普通 保留集合中指定的内容
13 Public int size() 普通 取集合的长度
14 Public Object <T>[] toArray(T[] a) 普通 取得全部内容
2) 从现代的开发中,在集合操作中已经很少使用Collection完成功能了,基本上都使用了其子类接口,List,Set
• List接口的最大特点是里面的内容都可以重复,但是此接口比Collection接口扩充了很多方法。
以下的方法是新增的方法
No 方法 类型 描述
1 Public void add(int index E element) 普通 在指定位置加入元素
2 Public Boolean addAll(int index Collection<?>) 普通 在指定位置加入一组元素
3 E get(int index) 普通 根据索引位置可以去除每一个元素
4 Public ListIterator <E> ListIterator() 普通 为ListIterator接口实例化
5 Public E remove (int index); 普通 删除指定位置的内容
6 Pubic E set(int index) 普通 设置指定位置内容
7 Public List<E> sublist (int formIndex,int toIndex); 普通 截取子集合
若想使用List接口,则要通过其子类。常用的子类有如下几种:
(1)ArrayList;(2)Vector;(3) LinkedList
2)新的子类ArrayList
ArrayList是List接口最常用的一个子类,其定义如下。
Public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess,Cloneable,Serizable实例化
完成增加数据的操作
在使用remove(Object obj)的时间,操作使用的是String,所以可以删除掉。如果现在是自定义的匿名对象,则可能无法删除。
2.完成输出数据的操作
在Collection接口中实际上也规定了两个可以将集合变为对象数组的操作。
3.也可以在输出的时候指定泛型的类型,这样操作起来比较方便。
4.集合的其他操作
(1)判断元素是否存在
(2)List接口中定义的subList()方法
3)旧的子类Vector
Vector类是一个元老级的操作类,在jdk1.0之后推出的时候就有了,ArrayList类在jdk1.2之后才定义新的操作类。但是因为考虑到一部分人已经习惯于使用Vector类,所以Java的开发者在定义类集的时候又让Vector类多实现了一个List接口
,所以此类可以直接为List接口实例化
需要说明的是,在Vector类因为一个比较老的类,所以里面也定义了自己的增加数据的操作。
 ArrayList 与Vector的区别
ArrayList与Vector类都是List接口的子类,既然是List接口的子类,那么两个类有什么区别呢?
No 区别点 ArrayList Vector
1 推出时间 Jdk1.2之后推出的 Jdk1.0时推出的
2 操作 异步 同步
3 性能 高 相对较低
4 安全 非线程安全 线程安全
5 输出 Iterator、ListIterator、LinkedList和foreach Iterator、ListIterator、foreach和Enumeration

Queue接口(了解)
LinkedList完成的是一个链表操作,可以方便的找到表头之类的具体操作,此类定义如下
Public class LinkedList<E> extends AbstractList<E> implements List<E>,Deque<E>,Cloneable,Serializable 此类提供的方法就是链表提供的方法。
3) Set接口
Set接口也是Collection接口的子接口,最大特点是里面没有重复元素。在Set接口中有两个子类是常用的
•TreeSet:有序列的
•HashSet:散序列存放
(1)散列存放的HashSet接口本身并没有对Collection接口做任何扩充,是完全一样的。
HashSet子类的内容是没有顺序的。
(2)有序存放的TreeSet
Treeset是可以进行排序的操作接口
(3)关于重复的说明
在程序中是通过Object类中的HashCode()和equals()方法来完成重复元素的验证,所以一个完整的类必须复写Object类中的HashCode()和equals()方法就在这里。
4) 集合输出
在Java类集合的输出有以下四种
• Iterator  `ListIterator `foreach `Enumeration
在开发之前给一个标准的开发模式:只要碰到了集合输出,想都不用想就使用Iterator接口。
Iterator 表示迭代接口,Iterator接口中定义了如下方法
No 方法 类型 描述
1 Public boolea hasNext() 普通 将指针向下移动判断是否有内容
2 Public E next() 普通 取出内容
3 Public Void remove() 普通 删除当前指针的内容
如果想为Iterator接口实例化,则必须使用Collection接口的如下方法
• public Iterator<T> iterator()
但是在Iterator接口中存在一个删除的方法,在使用此方法时一定要注意因为所谓的Iterator实际上只是将一个集合的内容交给了Iterator输出而已,而如果直接使用了集合中的remove()方法,删除的话,则会破坏整个集合的内容,所以输出会出现问题。而在实际的开发中很少使用Iterator进行删除的操作,只是判断是否有并且将内容输出。
5)ListIterator接口
ListIterator是Iterator接口的字接口。Iterator接口的最大特点是能从前向后迭代输出,如果现在想执行双向输出,则只能使用ListIterator接口。但是此接口使用时有一个要求,即只能输出List接口的内容。要依靠如下的方法
Public ListIterator<E> listIterator()
此接口的操作方法如下
No 方法 类型 描述
1 public void add(E e) 普通 增加数据
2 public boolean hasNext() 普通 从Iterator继承而来
3 public E next() 普通 从Iterator继承而来
4 public void remove() 普通 从Iterator继承而来
5 public boolean hasPrevious() 普通 判断有前一个元素
6 public boolean previous() 普通 取前一元素
6 public void set() 普通 修改元素
可实现双向的输出,但是要执行由后向前输出,首先执行由前向后输出,否则无效。
Foreach输出方法
    在数组的输出上,则可以使用foreach,在集合的输出上,也同样可以使用(在jdk1.5之后增加的)
5) 废弃的接口 Enumeration
Enumeration最古老的输出接口,支持此种输出类只有Vector接口
在Vector存在以下的方法
Public Enumeretion<E> elements()通过此种方法Enumeretion接口进行实例化的操作。
Enumeretion接口定义了如下方法
•判断是否有内容: Boolean hasNextElements()
`取出内容 E nextElement()
可以发现此接口定义的方法功能与Iterator功能类似,而且单词比Iterator长很多,况且记得费劲,所以基本上不使用
当然对于一些旧的操作类中依然支持Enumeration,这一点在日后的Java Web开发当中,可以见到,掌握此接口也是很有必要的。
Iteration 、Set  、List、 Collection 、Enumeretion
在jdk1.5之后对打印流进行了更新,可以使用格式化输出。
在打印流中一定要记住以下原则,根据其实例化子类的不同,完成的打印输出功能也不同。


3.Map接口及其子类

Collection接口是保存单值最大的父接口,那么Map接口保存的是一对值。所有的内容都是以key->形式存在的。
Map接口本身有三个常用的子类
   Hashmap 、Hashtable、TreeMap
Map接口的常用方法如下
                                                            
NO 方法 类型 描述
1 V put(K key,V value); 普通 增加内容
2 V get(Object key) 普通 取得设置的内容,根据key取得
3 boolean contiansKey(Object key) 普通 查找指定的key是否存在
4 boolean contiansVlaue(Object value) 普通 查找指定的value是否存在
5 boolean isEmpty() 普通 判断集合是否为空
6 Set<K> keySet() 普通 将全部的key变为Set集合
7 Collection<V> value() 普通 将全部的value变为Collection集合
8 V remove(Object key) 普通 根据key删除内容
9 void putAllMap(? Extends key,? extends value) 普通 增加一组数据
3.1 新的子类HashMap
HashMap是一个新的操作类,其本身可以直接为Map接口实例化操作。Map中的key不能重复的,如果重复则视为覆盖。Map最大的特点是查找功能,如果查找到了则返回内容,否则返回null。
还可以将Map中的全部key一集合的形式返回。
从程序可以看出,HashMap本身也属于无需操作。
3.2 旧的子类 Hashtable
Hashtable实际上与Vector产生的时代是一样的,都属于最早的集合操作类。之后只是扩展了其应用实现的Map接口而已。
3.3 HashMap与Hashtable的区别是什么?
HashMap与Hashtable的都是Map接口的子类,既然是Map接口的子类,那么两个类的区别是什么呢?
NO 区别 HashMap Hashtable
1 推出时间 是在jdk1.2之后推出的,属于新的类 是在jdk1.0推出的,属于旧的类
2 性能 性能高 性能低
3 安全 非线程安全操作 线程安全
从实际的开发来讲,Map接口使用最多的子类就是hashMap。
3.4 按序排列的类 TreeMap
   TreeMap使用的时候可以按照key的方式进行排序。
3.5 注意事项一: Map不能使用Iterator输出
在集合的标准操作中,所有的集合内容最好都使用Iterator集合输出,但是在Map的接口中并没有名曲的定义这样的操作。如果,没有的话,则必须了解Map的存储形式。
在Map中虽然是以一对值出现的,但是真正保存的还是一个单独的对象。即程序将key->value 放在一个对象之中,之后将此对象放到了集合里。
Map Entry,Map实体
下面就可以给出Map接口使用Iterator输出的标准操作
1.通过接口中的,Set<Map.Entry<K,V> >entrySet()取得Set集合
2.通过Set接口为Iterator进行初始化操作
3.通过Iterator取出每一个Map
4.通过Map.Entry进行Key与value 的分离
* 在jdk1.5之后,可以使用foreahc输出全部的内容
3.5 注意事项二: 使用非系统类作为key




分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics