文章目录
- java的命名规范
- Java的基本命令
- java基础
- 标识符
- 关键字
- java的基本数据类型
- 变量
- 变量的声明
- 变量作用域
- 变量的初始值
- 常量和字面量
- 常量
- 字面量
- 基本数据类型的转换
- 类和对象
- 对象
- 类
- 消息
- 面向对象的特性
- 封装
- 继承
- 多态
- 类的简介
- 类的逻辑结构
- 访问控制修饰符
- 类的定义
- 限定符
- 接口
- 接口的基本概念
- 接口的声明（定义）
- 接口的实现
- 包
- 数组
- 一维数组
- 一维数组的声明
- 定义数组的大小
- 数组的初始化
- 一维数组的长度及引用
- foreach循环
- 二维数组
- 集合
- List接口
- ArrayList
- LinkedList
- Map接口
- 迭代器Iterator
java的命名规范
所有的变量、方法、类名：见名知意
类成员变量、局部变量、方法名采用首字母小写和驼峰原则，eg：monthSalary、runRun()
常量使用大写字母和下划线，eg：MAX_VALUE
类名使用大写字母和驼峰原则，eg：GoodMan
Java的基本命令
- java编译器：javac.exe
javac用于将源程序代码“.Java”文件编译成字节码“.class”文件。对源文件中的每一个类均生成对应的类文件
命令格式为Javac sourceFileName.Java注意在编译的时候不要忘记了.Java后缀 - java解释器：java.exe
运行编译后的程序，其实就是运行.class的程序，
命令格式为java classFileName，注意这里不需要带.class后缀
java基础
java的符号集采用Unicode字符集。java符号分为5类：标识符、关键字、字面量、分隔符
标识符
标识符是指标明程序中元素的名字，如类名，方法名和变量名。标识符需要遵守以下命名规则：
标识符是由字母、数字、下划线和美元符号($)构成的字母序列
必须以字母、下划线或美元符号开头，不能以数字开头
长度没有限制，但不能包含空格，不能是java关键字
标识符不能是true、false或null关键字
关键字 | 含义 |
abstract | 表明类或者成员方法具有抽象属性 |
assert | 断言，用来进行程序调试 |
boolean | 基本数据类型之一，声明布尔类型的关键字 |
break | 提前跳出一个块 |
byte | 基本数据类型之一，字节类型 |
case | 用在switch语句之中，表示其中的一个分支 |
catch | 用在异常处理中，用来捕捉异常 |
char | 基本数据类型之一，字符类型 |
class | 声明一个类 |
const | 保留关键字，没有具体含义 |
continue | 回到一个块的开始处 |
default | 默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现 |
do | 用在do-while循环结构中 |
double | 基本数据类型之一，双精度浮点数类型 |
else | 用在条件语句中，表明当条件不成立时的分支 |
enum | 枚举 |
extends | 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口 |
final | 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量 |
finally | 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块 |
float | 基本数据类型之一，单精度浮点数类型 |
for | 一种循环结构的引导词 |
goto | 保留关键字，没有具体含义 |
if | 条件语句的引导词 |
implements | 表明一个类实现了给定的接口 |
import | 表明要访问指定的类或包 |
instanceof | 用来测试一个对象是否是指定类型的实例对象 |
int | 基本数据类型之一，整数类型 |
interface | 接口 |
long | 基本数据类型之一，长整数类型 |
native | 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的 |
new | 用来创建新实例对象 |
package | 包 |
private | 一种访问控制方式：私用模式 |
protected | 一种访问控制方式：保护模式 |
public | 一种访问控制方式：共用模式 |
return | 从成员方法中返回数据 |
short | 基本数据类型之一,短整数类型 |
static | 表明具有静态属性 |
strictfp | 用来声明FP_strict（单精度或双精度浮点数）表达式遵循[IEEE 754](https://baike.baidu.com/item/IEEE 754)算术规范 |
super | 表明当前对象的父类型的引用或者父类型的构造方法 |
switch | 分支语句结构的引导词 |
synchronized | 表明一段代码需要同步执行 |
this | 指向当前实例对象的引用 |
throw | 抛出一个异常 |
throws | 声明在当前定义的成员方法中所有需要抛出的异常 |
transient | 声明不用序列化的成员域 |
try | 尝试一个可能抛出异常的程序块 |
void | 声明当前成员方法没有返回值 |
volatile | 表明两个或者多个变量必须同步地发生变化 |
while | 用在循环结构中 |
🔔：java中所有关键字都是小写的，所以对于TRUE、FALSE、NULL都不是java的关键字
java的基本数据类型
名称 | 占用字节数 | 名称 | 占用字节数 |
boolean（布尔型） | 1B | int（整型） | 4B |
byte（字节型） | 1B | long（长整型） | 8B |
char（字符型） | 2B | float（浮点型） | 4B |
short（短整型） | 2B | double（双精度型） | 8B |
🔔：在计算机中：位是bite，用b表示，字节是Byte，用B表示，1字节 = 8位，即1B = 8b。
还有各次方的记忆口诀，32 = 2的5次方，64=2的6次方，128，7；256，8；512，9
408中的计组知识哦，别忘了哦。
变量
变量的声明
在java中，可以变化的量就叫做变量，它用于暂存中间结果。定义变量即位变量分配内存。
变量在使用前应进行定义或者声明，声明时还需要指定数据类型，其声明格式如下：
[各种限定符] dataType variableName [= value];其中限定符就是指public、static等，数据类型就是2.3中所介绍的八大数据类型，
变量名就是符合2.1中介绍的标识符命名规则的名称。对于[ … ]中的内容表示可选内容
换句话说，在变量声明时候，可以对他赋予初值，也可以只是声明。
变量作用域
变量作用域是指，从变量开始到它所在的块结束为止的程序的某一部分有效。
其中块的意思是由“{}”确定的程序段
public class MyTest{
public int a;//该类中都有效的变量
public void test(){
int b;//仅在该方法中有效的变量
}
}变量的初始值
数据类型 | 默认值 | 数据类型 | 默认值 |
boolean | false | int | 0 |
byte | 0 | long | 0L |
char | “\u0000”,空Unicode中的0 | float | 0.0f |
short | 0 | double | 0.0 |
常量和字面量
常量
常量是指一直保持不变的量。其声明格式如下
final dataType constantName = value;其中声明常量的final是关键字，dataType是基本数据类型之一，constantName一般全为大写字母
字面量
字面量就是指那些字面上的量，比如整型的100、浮点型的2.7f、布尔型的true等
但这里需要注意的是对于字符型的字面量，需要用单引号引起来，比如‘c’
字符串型的字面量需要用双引号引起来，比如“cym”。
所以对于‘b’和”b“的含义是不同的，前者代表的是字符b，后者代表的是字符串b
基本数据类型的转换
在进行基本的数据运算时，如果遇到多种数据类型在一个式子中参与了运算，
那这时候java就会进行隐式转换，会让精度低的往精度高的转
精度低的想精度高的转换时，不会导致信息的丢失，但精度高的往精度低的就可能会。
那什么是精度高的呢？就是说该类型所表示的数值范围更大
但有的时候我们又需要把精度高的往精度低的方向转，那这时候怎么办呢？
这里就需要用到强制转换了，其强制转换的命名格式如下：
(精度低的数据类型) 精度高的数据类型
double d = 1.0;
float f = (float) d;注意，这里不要被这个数据类型给限制了思维，其实也可以对对象进行强转
类和对象
对象
什么是对象呢？对象就是属性和操作相关属性的行为的集合，是类的具体化，是类的实例化
类
类又是什么呢？简单的来说，类其实就是同种对象的集合与抽象。
分类的原则是抽象，其主要是由属性和方法组成
消息
消息就是俩个对象之间通过消息机制进行交互
面向对象的特性
封装
所谓封装，就是指利用抽象数据类型，把数据和基于数据的方法包装起来，
把对象的属性和方法结合成一个独立的单位，并尽可能隐蔽对象的内部细节，
也就是将一些复杂的处理细节、私有数据封装在类里，使类容易被使用，且更加安全，
不会破坏类内部的数据，保障了数据的安全性和严密性。
封装包含俩个含义：把对象的全部属性和全部动作结合在一起，形成一个不可分割的独立单位，
即对象；隐蔽信息，即尽可能隐蔽对象的内部细节，对外形成一个边界，或者说是一道屏障，
只保留有限的对外接口使之与外部发生联系。
继承
当一个类拥有另外一个属性和行为时，就称这个类是继承过来的类。其中被继承的类称为父类，
也叫超类，而继承过来的类称为父类的子类，也叫派生类。
对于子类继承父类，那么子类就拥有父类中的一些属性和方法（具体有哪些，这需要看修饰符，即public和private等）。同时子类还可以定义属于自己的方法和属性。但注意，在java中只有单继承，没有多继承（C++中有多继承），这是为了让java变得简单。不过可以通过接口实现多继承的功能，关于接口以后还会详说。
多态
多态就是指在一般类中定义的属性或方法被特殊类继承之后，可以具有不同的数据类型或者是方法体的执行内容不同。这使得同一个属性或方法在各个特殊类中具有不同的语义。
多态的实现方法有俩种
- 通过子类对父类方法的重写（override）来实现多态
父类中的方法和子类中可以同名，并重新编写代码。而子类中与父类同名的方法，功能却完全不一样。
区分调用的是子类还是父类中同名方法，办法就是在调用时指明哪个类的方法即可。 - 同一类中定义同名方法即重载（overload）实现多态
在一个类中，可以定义多个同名的方法，这些方法的最终目的基本或者完全相同，
只不过会根据具体的情况来确定使用哪个方法。那区分同一类汇总同名的方法，靠的是参数。
在同名的不同方法中，要求参数列表不同，这就包括参数个数、参数数据类型、排列顺序。
而对于返回值类型可以不同，也可以相同
类的简介
类的逻辑结构
在java中，所有类都有一个共同的父类（直接或间接）–Object类，在Java中称为基类。
因此，Object也是唯一一个没有父类的类。
访问控制修饰符
访问控制修饰符可以限定类、属性或方法被程序里其他类访问和调用的权限，
即是否可以被其他程序中的类所访问（access）。访问控制修饰符总是放在类、方法、属性的最前面。
但无论如何，一个类总是可以访问和调用它自己的属性和方法，无论这些属性和方法用什么修饰符修饰。
对于各种修饰符的限定范围见下表：
类型 | private | 无修饰或friendly | protected | public |
同一类 | √ | √ | √ | √ |
同一包中的子类 | √ | √ | √ | |
同一包中的非子类 | √ | √ | √ | |
不同包中的子类 | √ | √ | ||
不同包中的非子类 | √ |
🔔:1.对于被private修饰的属性或方法，只有同一类中可以访问，其他的无论是子类还什么，都不可以访问
2.对于被public修饰的属性或方法，所有的类都可以访问，只需要通过对象.属性或对象.方法来调用
3.在同一类中，无论是哪种修饰符修饰，都可以访问该类中所有的属性和方法
4.对于被protected修饰的属性或方法，其可以让同一个包中子类和非子类访问，也可以让不同包中的
子类访问，但不会让不同包中的非子类访问
5.对于被friendly或者没有修饰（其实是被default修饰）的属性和方法，只能让同一包中的子类和非子类
访问，不同包中的是访问不了。
6.对于同一包中的子类或非子类，只要不是被private修饰的属性和方法，都是可以被访问的。
7.而如果想让不同包中的子类访问，只有用protected或public来修饰属性或者方法，
想让不同包中的非子类访问，只有用public来修饰属性或者是方法
8.关于类及权限定义还有一些特殊的要求。首先，一个源文件最多只能有一个标记为public的类
这类的名字也是源文件的文件名。一个源文件中也可以不含有公有类，此时的文件名可以随意取
其次，除内部类以外（定义在类中的类），一个类是不能私有的，私有类是不能被其他类访问的，
在一般情况下，类不定义为保护的，所以一个类的访问权限常用public或者是friendly
类的定义
定义一个类时，应该包含俩部分：类的声明和类的实现（类的主体，即类体）。
主体部分是有关类的属性的声明和方法的定义，一般格式如下：
[public] [abstract | final] class ClassName [extends SuperClassName] [implements InterfaceNameList]{
//成员变量的声明
//成员方法的声明
}其中class是关键字，定义类的标志，表示一个类的开始
ClassName是定义类的名字，首字母大写，采用驼峰命名规则
SuperClassName是被继承的类，其跟在extends后面，指明当前定义的类是已存在的某个类的派生类
限定符
也称修饰符（identifier），它说明类的特殊性质。限定符包括三部分
- 访问控制符–说明类的访问特性，public或者是friendly（默认）
- 抽象类说明符–abstract修饰类，说明类的抽象性。抽象类不能直接生成对象，
且如果一个非抽象的子类，继承了一个抽象父类，那它一定要重写父类的抽象方法。
抽象类中可以有0个或多个抽象方法，也可以有非抽象的方法。但是如果有抽象方法了，
那么该类就一定要是抽象类 - 终极类说明符–final，说明类的非继承性，终极类是不能被继承的。
- InterfaceNameList 是要实现的接口列表，跟在关键字implements后，指明当前定义的类是实现
某个或某些接口，有多个接口的时用逗号隔开。
接口
接口是用来实现类间多继承功能的结构。接口使抽象的概念更加深入了，
我们可以把接口看成是一种特殊的抽象类，接口用来表明一个类必须做什么，而不是规定它如何去做，
因此常常使用接口来指定类的协议。
接口的基本概念
java规定：为了与类的继承区分，对接口的继承称为实现。接口中没有可以变动的数据成员（变量），
只能有final类型的数据成员（常量）；接口是一个抽象类，接口中的方法都是抽象方法，
方法仅用来指明需要做什么，但不需要明确该怎么做
接口的声明（定义）
接口的结构与定义和类相似，只是定义接口的时候使用interface而不是class。
接口在实现之前也应该先声明。接口声明格式如下：
[public] interface interfaceName [extends 父接口名列表]{
//以下是接口体
[static] [final] (常量) 数据类型的声明
[public] [static] final dataType variableName = Value;
//以下是抽象方法的声明
[public] [abstract] [native] returnDataType methodName(paramentersList)[throwsexceptionList];
}
//举个栗子
interface Son extends Father{
int add(int a,int b);
}接口的访问控制符只有一个，那就是public。如果使用public修饰符，则可以被所有类和接口使用，
不加时为缺省，表示只能在同一个包中的其它类和接口使用。
extends指明当前接口是某个父类接口的派生接口。一个接口可以同时实现若干个接口，
即有多个父接口（实现多继承），多个接口之间用“，”分开。
如果接口本身是public的，则接口的属性系统默认为public static final，
即使声明都不写，接口的方法系统默认为public abstract。
接口的实现
接口是对一系列方法的声明，而接口的具体实现通过类来完成，在定义类时使用“implements 接口名列表”
要实现接口所规定的功能时，则需要在某个类中为接口中的抽象方法些代码，这个过程称为接口的实现（implement）。接口和实现类之间的关系实质上是继承的关系，一个类可以实现多个接口，从而实现多继承。
具体格式如下：
public class A implements Son,Father{
//实现（重写）接口中的方法
@override
... //被重写的方法
}包
包（package）是一种松散的类的集合，它可以将各种类文件组织在一起，就像磁盘的文件夹一样。
一般包名为小写单词。同一个包下的类不要求有关系，但在实际中，一般会把有关系的类放到同一个包中。
其实包就相当于一个命名空间，不同包中的类是可以同名的。
其中最常用的包如下：
包名 | 作用 |
java.lang | 该包存放了java最基础的类，如Math类。该类不需要使用import语句导入即可在程序中使用 |
java.io | 该包存放了支持输入/输出操作的类 |
java.awt | 该包存放了支持图形化用户界面（GUI）的类 |
javax.swing | 该包存放支持SwingGUI组件的类，它比java.awt相关的组件更加灵活易用 |
java.applet | 该包存放了支持编写applet（小程序）的类 |
java.util | 该包存放了一系列标准操作以管理数据集、访问时间和日期信息 |
java.sql | 该包中存放了支持使用标准SQL方式访问数据库的类 |
java.net | 该包中存放了支持网络编程的类 |
数组
一维数组
只有一个下标的数组称为一维数组。在java中，数组是作为对象被处理的，所以在使用数组之前，
必须初始化。所谓初始化，就是为数组分配内存空间，并为每个数组元素赋予初值。
一维数组的声明
声明数组 的目的在于说明数组变量名和数组元素的数据类型，具体格式如下：
dataType arrayName[];//第一种声明方式，这是为了迎合c的
dataType[] arrayName;//第二种，更加符合java格式定义数组的大小
数组的声明仅说明了数组变量的名称和数据类型，但存放数组元素的内存空间并不存在，还必须为其申请
内存空间即定义数组的大小。申请内存空间就是指定数组长度，即数组中存放元素的个数，格式如下：
arrayName = new dataType[numberOfArrayElement];
//其中arrayName是数组名，numberOfArrayElement为数组元素的个数
//也可以将数组的声明和定义数组大小合在一起
dataType[] arrayName = new dataType[numberOfArrayElement]数组的初始化
所谓初始化就是定义数组时，为每个元素赋初值。一旦数组被定义后，系统就给每个元素赋予默认的初值
有时候我们希望在声明数组时用指定的一组值对它进行初始化，同时也确定了数组的大小，即静态初始化。
如果在数组定义后，再给数组元素赋初始值，称为动态初始化。
- 静态初始化：在声明和定义数组的同时，给数组元素赋初值。初始化时，由我们显式指定每个数组元素
的初始值，由系统决定数组的长度。格式如下：
dataType[] arrayName = {value1,value2,value3,....}
//比如
int[] array = {1,2,3};- 动态初始化：先声明和定义数组，然后再赋值。再初始化时，只需要指定数组的长度，由系统为数组
元素分配初始值。格式如下：
//简单类型的数组，如
int[] a = new int[5];
//复合类型的数组，如
String str = new String[5];一维数组的长度及引用
在java中数组其实是作为对象来使用的，所有的数组对象都有一个length属性，用来记录数组中元素的个数，
这里需要注意，数组的大小为length，但引用数组元素的最大下标为length-1。其引用方式为arrayName[index]
foreach循环
从java5之后，java就提供了一种更为简单的循环：foreach循环，这种循环遍历数组和集合更加简洁，
使用foreach循环无需获得数组和集合长度，无需根据索引来访问数组元素和集合元素，foreach循环会
自动遍历数组元素。但其不能改变数组元素的值。格式如下：
for(type variableName:array|collection){
//variableName自动迭代访问每个元素
}
//举个栗子
public class LearnArray {
public static void main(String[] args) {
int[] array = new int[10];
//初始化
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
//利用foreach遍历数组
for(int a:array){
a=1;
System.out.print(a);
}
System.out.println();
//在foreach中貌似改变数组中元素的值，但实际上并没有
System.out.print(array[0]);
System.out.print(array[1]);
System.out.print(array[2]);
}
}
//运行结果如下
1111111111
012二维数组
带有俩个下标的数组称为二维数组，和一维数组一样，可以先声明后定义，也可以声明和定义合在一起。
推荐使用如下格式：
dataType[][] arrayName = new dataType[arrayLength1][arrayLength2];
//举个栗子，声明并定义一个2行3列的二维数组
int[][] array = new array[2][3];
//对二维数组的静态初始化如下
int[][] a = {{1,2,3},{2,3,4}};集合
java集合框架有三大类接口，Collection、Map和Iterator。Iterator叫迭代器，是专门为集合接口和类提供遍
历方法的。Collection又有俩个子接口List和Set，所以通常说java集合框架共有三大接口：List、Set和Map，他
们共同特点在于都是集合接口，都可以用来存储很多对象。区别如下表
是否有序 | 是否允许元素重复 | |
List | 是 | 是 |
Set | 否 | 否 |
Map | 否 | 用键值对来存储，键不可以重复，值可以重复 |
List接口
实现List接口常用的类有：ArrayList和LinkedList，他们都可以容纳所有类型的对象包括null，允许重复，且
保证元素的存储顺序。List接口中定义的各种常用方法：
返回类型 | 方法名 | 说明 |
boolean | add(Object obj) | 加入元素，返回是否添加成功 |
void | add(int index,Object obj) | 在指定的索引位置添加元素 |
boolean | clear() | 清除集合中的元素 |
boolean | contains(Object obj) | 查找集合中是否存在传入的元素 |
Object | get(int index) | 获取指定位置的元素 |
boolean | isEmpty() | 判断集合是否为空 |
Object | remove(int index ) | 删除指定位置的元素，并返回该元素 |
boolean | remove(Object obj) | 从列表中删除元素 |
int | size() | 获取集合大小 |
Object[] | toArray() | 将集合转换成一个数组 |
ArrayList
ArrayList是对数组进行了封装，实现了长度可变的数组，和数组采用相同的存储方式，在内存中分配连续的空
间，其优点和数组一样，在于遍历元素和随机访问元素的效率比较高。集体操作如下：
package com.cym.base;
import java.util.ArrayList;
import java.util.List;
public class LearnList {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student("cym",18));
list.add(new Student("oyz",80));
list.add(new Student("lyz",22));
System.out.println("一共有"+list.size()+"个学生。分别是：");
for (int i = 0; i <list.size() ; i++) {
Student temp = (Student) list.get(i);
System.out.println("姓名："+temp.getName()+" 年龄："+temp.getAge());
}
}
}
class Student{
private String name;
private int age;
public Student(String str,int age){
this.name = str;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}🔔：List接口的add(Objdect o)方法的参数类型是Object，即使在调用时实参是Student类型，但系统认为是
Object，所以在通过get(int index)方法获取元素时，必须进行强制类型转换，Student temp = (Student)
list.get(i);否则会出现编译错误。同时使用remove、contains、indexOf等方法时，应该重写类的equals方
法，如果为重写，则默认的是按引用地址去比较，而每个对象的地址不一样，所以会出现删不掉、查不到等现象
所以这时候我们应该给Student类添加equals方法可以解决这个问题
class Student{
//省略了一些无关代码
public boolean equals(Object obj){
if(obj == null) return false;
if(!(obj instanceof Student)) return false;
Student stu = (Student) obj;
return stu.name.equals(this.name) && stu.age ==this.age;
}
}LinkedList
LinkedList采用链表存储方式，其优缺点和链表存储一样，插入删除元素效率比较高，且它提供了额外的addFirst()、addLast()、removeFirst()、removeLast()等方法。
Map接口
Map中可以存储多个元素，每个元素都由俩个对象组成，一个键对象，一个值对象。可以根据键实现对应值
的映射。Map中的key不要求有序，不允许重复。value不要求有序，但允许重复。最常见的Map实现类是
HashMap，它的存储方式是哈希表，优点是查询指定元素效率高。Map接口定义的各种常用方法如下：
返回类型 | 方法 | 说明 |
Object | put(Object key,Object value) | 以键值对的方式进行存储，这里面如果添加了重复的键， 那么最后加入的键值对将替换掉原先的键值对 |
Object | get(Object key) | 根据键key去找值，如果没有就返回null |
Object | remove(Object key) | 删除指定的键映射的键值对 |
Int | size() | 返回元素个数 |
Set | keySet() | 返回键的集合 |
Collection | values() | 返回值的集合 |
boolean | containsKey(Object key) | 如果存在键映射的键值对则返回true，否之false |
迭代器Iterator
所有集合接口和类都没有提供相应的遍历方法，而是把遍历交给了迭代器Iterator完成。Iterator为集合而生
专门实现集合的遍历。它隐藏了集合实现类的内部细节，提供了遍历集合的统一编程接口。Collection接口的
iterate()方法返回一个迭代器，然后通过Iterator接口的如下俩个方法来实现遍历：
- boolean hasNext()：判断是否存在另外一个可访问的元素
- Object next()：返回要访问的下一个元素。
package com.cym.base;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class LearnList {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student("cym",18));
list.add(new Student("oyz",80));
list.add(new Student("lyz",22));
System.out.println("一共有"+list.size()+"个学生。分别是：");
//迭代器实现遍历集合
Iterator it = list.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println("姓名："+s.getName()+" 年龄："+s.getAge());
}
}
}
class Student{
private String name;
private int age;
public Student(String str,int age){
this.name = str;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
