JAVA基础--IDE&Object类、常用API-String类、常用API-Arrays、System、StringBuffer&Integer类和Date类、对象数组

一、IDE&Object类

Eclipse

1:Eclipse的概述

(1)eclipse的由来

A：由IBM一个小组开发。(4000万$ 免费就是最大回馈)

SUN,IBM,微软,Oracle,惠普,谷歌...

(2)eclipse的特点

A：完全由Java语言编写的工具。

B：不需要安装

C：免费的，eclipse.org

D：开源的

E：扩展性非常强

(3)eclipse和MyEclipse的区别

A：MyEclipse是基于eclipse加入了一些用于开发Web的插件

并对这些自己开发的插件进行收费。

B：特点 MyEclipse集成性很好。

(4)在使用eclipse之前，系统中必须要先有JDK或者JRE。

因为eclipse就是用Java语言编写的程序，所以需要jvm的解释执行。

A：对于高版本的MyEclipse，内部已经集成了JDK。

所以安装后，它会用自己的JDK来执行MyEclipse。

2:Eclipse安装

A：解压Eclipse压缩包

B：复制到制定的目录（不要有中文，和其他非法字符）

3:Eclipse的使用

A:打开软件的界面

B:新建一个项目(工程)

C:在项目下的src(源码包)下建立包

D:在包下建立类

E:在类里边写代码

F:编译源文件(代码写完保存的时候会自动生成class文件，在项目的bin目录下。)

G:执行class文件(右键 -- Run As -- Java Application)

H:结果显示在Console控制台上

4:Eclipse的基本设置

A:在代码最左侧前面，右键
- Show Line Numbers，如何取消?再次选择

B:java代码字体,Window -- Preferences -- Appearance -- Colors and Fonts -- Java-- Java Editor-- 选择右边的Edit进行修改即可。

C:如果不小心把界面给弄没了不要担心有复位操作,window -- reset ...

5:Eclipse的内容辅助键

Alt+/

main方法：先写main然后alt+/最后Enter

输出语句：先写syso然后alt+/最后Enter

for循环： 先写for然后alt+/最后Enter

6:Eclipse的快捷键

(A,E,F必须掌握)

A：alt+/ 内容辅助键 这个功能很酷啊."酷就一个字，我只说一次"

补充类或者接口名，帮我们起变量名，new 后面直接提示等。

B：ctrl+/ 单行注释，在按一次，取消单行注释

C：ctrl+shift+/ 对选中的区域进行多行注释的封装

D：ctrl+shift+\ 用于取消多行注释，只要光标在多行注释中即可

E：ctrl+shift+o 对使用了其他包中的类或者接口进行自动导入

F：ctrl+shift+f 对代码进行格式化

G：alt+上键 向上移动当前行或者选中行

H：alt+下键 向下移动当前行或者选中行

I：ctrl+d 删除当前行，或者删除选中行

J：ctrl+shift+x 将选中部分的字母大写

K：ctrl+shift+y 将选中部分的字母小写

L：ctrl+1 光标放在编译中出现红色波浪线提示的内容上，

在该快捷键可以获取建议的处理方式

M：F3 可以查看类或者方法的源码，前提是，该原码已经关联。

7:Eclipse的自动给出set，get方法

右键--source--（set，get方法）Generate Setters and Getters

（有参构造）Generate Constructor using Fields...

（无参构造）Generate Constructors form Superclass..

8:Eclipse删除和导入项目

删除：

选中项目 -- 右键delete ...

A:从工作台中删除

B:从硬盘删除

导入：

在项目所在位置的空白处右键 --》 Import --》 General --》 Existing Project...（最长的那个）

9:Eclipse的debug调试

A:如何加断点

在你想看从哪里执行的程序的左边双击即可。(不要在注释上做)

在哪里加?

哪里不会加哪里。

最好在每个方法的第一条语句上加。

B:如何使用

右键 -- Debug As -- Java Application

弹出一个界面问你：

是否打开调试界面。yes

是否记住我的选择。选中框框即可

C:查看哪里

左边：

程序运行到哪里了

右边：

变量的变化过程

D:怎么继续

F6 执行一行。

E:去除断点

方式1：在点击的那个地方再次点击

方式2：在debug调试界面--BreakPoints -- remove All...

F：补充：

F5跳入

F8跳到下一个断点

演示创建对象的整个过程

Object类的方法

1：创建Student对象并打印效果

A：打印他的时候，默认调用的他的toString方法

B：Student没有toString方法，调用的是Object的toString方法

C：object的toString方法 返回值是 包名...类名+@+16进制地址值 ，我们一般使用toString方法都要重写他

2:关于==做比较的问题

A:基本类型的比较： 比较的是值

B:引用类型的比较： 比较的是引用类型所指向的地址值

3:自己实现对象的成员变量数据的比较

“2”，“3”目的是为了引出Object中的equals方法

4:Object中的equals方法

源码其实就是用“==”比较的两个变量

我们一般需要重写，如何重写？

1）：如果是这个对象

2）：如果不是这个对象，而又不是这一类对象

3）：如果他是这一类对象，那就好说了，强转，然后比较每个变量的值

代码实现：

[java] view
plain copy

public boolean equals(Object obj)

{

//为了提高代码的效率

if( this == obj)

{

return true;

}

//为了提高代码的健壮性

if( !( obj instanceof Student) )

{

return false;

}

Student s = (Student)obj; //向下转型

return this.age == s.age;

}

5:String类中的equals方法

理解就ok！

[java] view
plain copy

public boolean equals(Object anObject)

{

//如果两个对象是同一个对象，直接返回True

if(this == anObject) { return true; }

//如果 s2 是String类的对象，就进去

if(anObject instanceof String)

{

//对anObject进行向下转型，假设为（s2）

//value在String中的定义

//private final char[] value

//字符串 --》 底层将该字符串转成了字符数组

//s1.toCharArray()方法

int n = value.lenght; //字符串s1的长度

//然后将字符串s2（也就是anObject）也转成字符数组

//首先先来比较这两个字符数组的长度，

//如果长度一样就继续执行，否则直接返回false

//然后依次来比较两个字符数组中的各个元素

//如果都相等，则返回true；

}

//情况都不满足，直接返回false

return false;

}

二、常用API-String类

1: Scanner注意事项

存在的问题：当录入数据依次是int String，并且分别使用nextInt()和nextLine()方法获取数据的时候，会接受不到String数据。

解决办法：

1). 在录入完int后重新创建一个新的Scanner对象

2). 用字符串接受，然后把字符串转成int类型

2:数据结构思想：拿时间换空间，拿空间换时间

例子：需求：一个网站有一个功能，当你填入你的年龄的时候，我就能自动判断你是哪个年龄段

0-9岁，儿童

10-19岁，少年

20-29岁，青年

30-39岁，壮年

40-49岁，中年

50-59岁，中老年

60岁以上，老年

代码实现例子：

String[] ages = {"儿童","少年","青年","中年","中老年","老年"};

System.out.println(ages[age/10]);

2：String类(掌握)

(1)字符串：多个字符组成的一串数据。

(2)构造方法：

A:String s = new String();

B:String s = new String(byte[] bys);

C:String s = new String(byte[] bys,int index,int length);

D:String s = new String(char[] chs);

E:String s = new String(char[] chs,int index,int length);

F:String s = new String(String str);

G:String s = "hello";

(3)字符串的特点及面试题

A:字符串一旦被赋值，就不能改变。

注意：字符串的值不能改变，没有说引用变量不能改变。

B:面试题：

a:String s = new String("hello")和String s = "hello"的区别。

b:请写出结果:

String s1 = new String("hello");

String s2 = new String("hello");

System.out.println(s1==s2);//false

System.out.println(s1.equals(s2));//true

String s3 = new String("hello");

String s4 = "hello";

System.out.println(s3==s4);//false

System.out.println(s3.equals(s4));//true

String s5 = "hello";

String s6 = "hello";

System.out.println(s5==s6);//true

System.out.println(s5.equals(s6));//true

(4)成员方法

A:判断功能

boolean equals(Object obj)：判断字符串的内容是否相同,区分大小写。

boolean equalsIgnoreCase(String str):判断字符串的内容是否相同,不区分大小写。

boolean contains(String str):判断字符串对象是否包含给定的字符串。

boolean startsWith(String str):判断字符串对象是否以给定的字符串开始。

boolean endsWith(String str):判断字符串对象是否以给定的字符串结束。

boolean isEmpty():判断字符串对象是否为空。数据是否为空。

B:获取功能

int length():获取字符串的长度

char charAt(int index):返回字符串中给定索引处的字符

int indexOf(int ch):返回指定字符在此字符串中第一次出现的索引

int indexOf(String str):返回指定字符串在此字符串中第一次出现的索引

int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符的索引，从指定的索引开始搜索。

int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串的索引，从指定的索引开始搜索。

String substring(int start):截取字符串。返回从指定位置开始截取后的字符串。

String substring(int start,int end):截取字符串。返回从指定位置开始到指定位置结束截取后的字符串。

C:转换功能

byte[] getBytes():把字符串转换成字节数组。

char[] toCharArray()：把字符串转换成字符数组。

static String copyValueOf(char[] chs):把字符数组转换成字符串

static String valueOf(char[] chs):把字符数组转换成字符串。

static String valueOf(int i):基本类型：把int（基本类型）转换成字符串。

String toLowerCase()：把字符串变成小写

String toUpperCase():把字符串变成大写

String concat(String str):拼接字符串。

D:其他功能

a:替换功能

String replace(char oldChar,char newChar)：用新的字符去替换指定的旧字符

String replace(String oldString,String newString)：用新的字符串去替换指定的旧字符串

b:切割功能

String[] split(String regex):按照规定的格式切割字符串成字符串数组

c:去除两端空格功能

String trim()：去除字符串两端空格

d:字典顺序比较功能

int compareTo(String str)：按字典顺序（Unicode编码顺序），如果第一个相同比较第二个，依次类推

int compareToIgnoreCase(String str) ：按字典顺序（Unicode编码顺序），如果第一个相同比较第二个，依次类推，不区分大小写

(5)案例：

A:模拟用户登录 （用到了 判断equals 功能，如果有的用户名不区分大小写 还可以用equalsIgnorCase）

[java] view
plain copy

String username = "admin";

String password = "admin";

// 三次机会

for (int x = 0; x < 3; x++) {

// x 0,1,2

// 键盘录入数据：用户名和密码。

Scanner sc = new Scanner(System.in);

System.out.println("请输入用户名：");

String name = sc.nextLine();

System.out.println("请输入密码：");

String pwd = sc.nextLine();

// 把数据进行比较。

if (username.equals(name) && password.equals(pwd)) {

System.out.println("恭喜你,登录成功");

// 引入曾经的猜数字小游戏。

break;

} else {

if ((2 - x) == 0) {

System.out.println("账号被锁定,请与林青霞联系");

} else {

// 2,1,0

System.out.println("登录失败,你还有" + (2 - x) + "次机会");

}

}

}

B:字符串遍历 （用到了 charAt 功能）

[java] view
plain copy

for (int x = 0; x < s.length(); x++) {

char ch = s.charAt(x);

System.out.println(ch);

}

C:统计字符串中大写，小写，数字字符出现的次数 （用到了 charAt 功能）

[java] view
plain copy

String s = "Hello12345World";

// 定义三个统计变量

int bigCount = 0;

int smallCount = 0;

int numberCount = 0;

// 遍历字符串。

for (int x = 0; x < s.length(); x++) {

char ch = s.charAt(x);

// 判断是属于哪种范围

if (ch >= 'A' && ch <= 'Z') {

bigCount++;

} else if (ch >= 'a' && ch <= 'z') {

smallCount++;

} else if (ch >= '0' && ch <= '9') {

numberCount++;

}

}

D:把字符串的首字母大写，其他小写（用到了 截取 、 连接 、 转大小写 功能）

[java] view
plain copy

String str2 = str.substring(0,1).toUpperCase().concat(str.substring(1).toLowerCase());

E:大串中小串出现的次数（用到了 截取 、 indexOf 功能，）

[java] view
plain copy

public int getCount(String maxString, String minString) {

// 定义统计变量

int count = 0;

// 在大串中查找小串一次

int index = 0;

// 如果返回值不是-1，说明小串在大串中是存在的。

// 判断

while ((index = maxString.indexOf(minString)) != -1) {

// 统计变量++

count++;

// 把查找过的数据给截取掉,重新赋值给大串

maxString = maxString.substring(index + minString.length());

}

return count;

}

：学习indexOf过程中，我们发现contains()的底层就是用的indexOf()

public boolean contains(CharSequence s) {

return indexOf(s.toString()) > -1;

}

三、常用API-Arrays、System、StringBuffer&Integer类

1：数组操作(理解原理，并要求会写该算法的代码)

1):冒泡排序原理：相邻元素两两比较，大的往后走，第一次完毕后，最大值就在最大索引处。

2):冒泡排序代码

[java] view
plain copy

public static void bubbleSort(int[] arr) {

// 外循环控制次数

for (int x = 0; x < arr.length - 1; x++) {

// 内循环控制每一次的比较过程

/*

* 第一次，所有元素都参与比较，也就是0个元素不参与。

* 第二次,有1个元素不用参与。

* 第三次，有2个元素不用参与。 ...

*/

// -1是为了防止索引越界

// -x是为了减少比较的次数

for (int y = 0; y < arr.length - 1 - x; y++) {

if (arr[y] > arr[y + 1]) {

// 数据交换

int temp = arr[y];

arr[y] = arr[y + 1];

arr[y + 1] = temp;

}

}

}

}

3):查找

--普通查找:数组无序

--二分查找(折半查找):数组有序

4):代码：

[java] view
plain copy

public static int getIndex(int[] arr,int value)

{

int maxIndex = arr.length-1;

int minIndex = 0;

int midIndex = (maxIndex+minIndex)/2;

while(arr[midIndex]!=value)

{

if(arr[midIndex]>value)

{

maxIndex = midIndex - 1;

}

else if(arr[midIndex]<value)

{

minIndex = midIndex + 1;

}

if(minIndex > maxIndex)

{

return -1;

}

midIndex = (maxIndex+minIndex)/2;

}

return midIndex;

}

2：Arrays工具类的使用

(1)Arrays是针对数组操作的工具类。

(2)成员方法：

public static String toString(数组):把数组变成字符串。

public static void sort(数组):对数组进行排序(升序)。

public static int binarySearch(int[] arr,int value):二分查找

3：System的方法

(1)系统类，提供了静态的变量和方法供我们使用。

(2)成员方法：

public static void exit(int value):退出jvm，非0表示异常退出。

public static long currentTimeMillis():返回当前系统时间的毫秒值。（一般用来测试一个程序执行的快慢）

和1970 年 1 月 1 日午夜之间的时间差

public static void arraycopy(Object src,int srcPos,Object dest,int
destPos,int length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。（了解String的的方法底层都是用的此方法即可）

4：StringBuffer

(1)字符个数可以发生改变的字符串类。字符串缓冲区类。

(2)构造方法：

A:StringBuffer()：默认容量16

B:StringBuffer(int capacity)：指定容量

C:StringBuffer(String str)：把字符串转换成StringBuffer

(3)成员方法：

A:添加功能

public StringBuffer append(int i):在末尾追加元素

public
StringBuffer insert(int index,int i):在指定位置添加元素

B:删除功能

StringBuffer deleteCharAt(int index):删除指定位置字符

StringBuffer delete(int start, int end):删除指定开始位置和结束位置间的字符

C:替换功能

StringBuffer replace(int start, int end, String str)：把开始到结束位置的字符用一个新的字符串给替换。

D:截取功能

String substring(int start):从指定位置到末尾截取

String substring(int start, int end): 从指定位置到结束位置截取

E:反转功能

StringBuffer reverse():字符串反转

(4)案例：

字符串反转。

StringBuffer sb = new StringBuffer("abc");

sb.reverse();

String result = new String(sb);

System.out.println(result);//cba

5：基本类型包装类

(1)基本类型的数据我们只能使用值，不能做更多的操作。为了方便我们操作，java就把每种基本类型进行了包装。提供方法供我们使用。

(2)基本类型和包装类的对应关系

byteByte

shortShort

int Integer

longLong

floatFloat

double Double

char
Character

boolean Boolean

(3)Integer构造方法

A:Integer i = new Integer(int num);

B:Integer i = new Integer(String s);

注意：s必须是一个由数字字符组成的字符串。

(4)String和int类型的转换

A:String -- int

Integer:

public static int parseInt(String s)

B:int -- String

Integer:

public static String toString(int i)

String:

public static String valueOf(int i)

(5)JDK5以后的新特性

A:自动装箱 基本类型--引用类型

B:自动拆箱 引用类型--基本类型

举例：

Integer i = 100;// 默认相当于new Integer(100)

i += 200;// 等价于ii = new Integer(ii.intValue()+200);

//因为i += 200底层调用的是intValue()方法，所以我们要加一层判断,防止报空指针异常

if (i != null) {

i += 200;

System.out.println(i);

}

(6经典题：byte常量池

Integer i1 = new Integer(127);

Integer i2 = new Integer(127);

System.out.println(i1 == i2);// false

System.out.println(i1.equals(i2));// true

Integer i3 = new Integer(128);

Integer i4 = new Integer(128);

System.out.println(i3 == i4);// false

System.out.println(i3.equals(i4));// true

Integer i5 = 128;

Integer i6 = 128;

System.out.println(i5 == i6);// false

System.out.println(i5.equals(i6));// true

//byte常量池。 byte范围内的值，直接赋值给Integer，是从常量池里面获取的。

Integer i7 = 127;

Integer i8 = 127;

System.out.println(i7 == i8);// true

System.out.println(i7.equals(i8));// true

(7)案例：

把字符串中的数字字符排序。

需求："23 98 16 38 42"

结果："16 23 38 42 98"

代码：

[java] view
plain copy

String s = "23 98 71 54 60";

// 字符串 -- 字符串数组

String[] strArray = s.split(" ");

// 字符串数组 -- int数组

int[] arr = new int[strArray.length];

// 循环遍历赋值

for (int x = 0; x < arr.length; x++) {

arr[x] = Integer.parseInt(strArray[x]);

}

//int[]排序

Arrays.sort(arr);

//把排序后的int[] -- String

StringBuffer sb = new StringBuffer();

for(int x=0; x<arr.length ;x++){

sb.append(arr[x]).append(" ");

}

String result = sb.toString().trim();

System.out.println(result);

四、Date类、对象数组

1：选择排序

先拿第一个与后面的每个元素比，小的放前面，这样最小的就到最前面来了

再拿第二个与后面.....这样次小的就到第二个位置了，依次类推...

[java] view
plain copy

for(int x=0; x<arr.length-1; x++)

{

for(int y=x+1; y<arr.length; y++)

{

if(arr[y]<arr[x])

{

int temp = arr[x];

arr[x] = arr[y];

arr[y] = temp;

}

}

}

2：经典题：随机给出一个数组，要求你把越靠近50的数往左排;

[java] view
plain copy

public static void main(String[] args) {

int[] arr = { 1, 2, 4, 7, 9, 12, 2, 3, 4, 89, 100, 105, 88, 50, 49, 48,

48, 47, 99, 60, 40, 30, 70 };

// int[] arr= {1,4,5,7,8,22,44};

arr = sort50(arr);

System.out.println(Arrays.toString(arr));

}

public static int[] sort50(int[] arr) {

// 从小到大排

Arrays.sort(arr);

/*

* 如果数组里面所有的数都大于50

*/

if (arr[1] >= 50) {

return arr;

/*

* 如果数组里面所有的数都小于50

*/

} else if (arr[arr.length - 1] <= 50) {

int[] arrtemp = new int[arr.length];

for (int i = 0; i < arr.length; i++) {

arrtemp[arr.length - 1 - i] = arr[i];

}

return arrtemp;

/*

* 如果数组里面有大于50的也有小于50的

*/

} else {

// 外循环控制次数

for (int x = 0; x < arr.length - 1; x++) {

// 内循环控制每一次的比较过程

/*

* 第一次，所有元素都参与比较，也就是0个元素不参与。 第二次,有1个元素不用参与。 第三次，有2个元素不用参与。 ...

*/

// -1是为了防止索引越界

// -x是为了减少比较的次数

for (int y = 0; y < arr.length - 1 - x; y++) {

if (Math.abs(arr[y] - 50) > Math.abs(arr[y + 1] - 50)) {

// 数据交换

int temp = arr[y];

arr[y] = arr[y + 1];

arr[y + 1] = temp;

}

}

}

[java] view
plain copy

/*// 选择排序法

for (int i = 0; i < arr.length - 1; i++) {

for (int j = i + 1; j < arr.length; j++) {

if (Math.abs(arr[i] - 50) > Math.abs(arr[j] - 50)) {

int temp = arr[j];

arr[j] = arr[i];

arr[i] = temp;

}

}

}*/

}

return arr;

}

1：“时间”在项目中的运用

2：Date

(1)日期类。

构造方法：

Date():默认指当前系统时间。

Date(long
time):根据给定的毫秒值生成一个时间。

(2)完成如下操作(日期和毫秒值的转换)

Date --> long

Date d = new Date();

long
time = d.getTime();

long --> Date

long time = ???;

Date
d = new Date(time);

或

Date
d2 = new Date();

d2.setTime(time);

(3)DateFormat类(日期和字符串的转换)

String --> Date

public Date parse(String source)

注意：如果是字符串到日期，你指定的格式必须和字符串的格式匹配。

2013-12-12

yyyy-MM-dd

2013/11/11

yyyy/MM/dd

Date --> String

public final String format(Date date)

需要自己指定格式，常见的格式：

yyyy年MM月dd日
HH:mm:ss

yyyy年MM月dd日

HH:mm:ss

yyyy-MM-dd HH:mm:ss

2：Calendar

(1)Calendar是日历类，它可以获取任意指定日历值，然后自由组合。

Calendar是抽象类不能实例化，但是他提供了获取其实例的方法

Calendar c = Calendar.getInstance();// 多态

(2)成员方法：

get(日历字段):根据给定的日历字段获取值

int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH);

int date = c.get(Calendar.DATE);

int hour = c.get(Calendar.HOUR_OF_DAY);

int minute = c.get(Calendar.MINUTE);

int second = c.get(Calendar.SECOND);

String s = year + "年" + (month + 1) + "月" + date + "日" + "
" + hour

+ ":" + minute + ":" + ((second>9)?second:"0"+second);

set(年,月,日):给日历设定指定的年，月，日

add(日历字段,值):给指定的日历字段添加或者减去给定的值。取决于值的正负。

(3)案例：请说出任意一年的2月份是多少天。

Calendar c = Calendar.getInstance();

Scanner sc = new Scanner(System.in);

int year = sc.nextInt();

c.set(year, 2, 1);// 把日期设置为2013年3月1日

c.add(Calendar.DATE, -1);// 把日期往前推1日

System.out.println(c.get(Calendar.DATE));

3：对象数组

学生数组的引入，是为了引入即将学习的集合，（学生数组是不是只能存学生啊？数组是不是必须固定长度啊？那么打破这些规则的话，需要用什么存呢？答案：集合

4：案例：对象数组改进登陆注册

分包： cn.itcast.dao

-UserDao.java

cn.itcast.dao.impl

-UserDaoImple.java

cn.itcast.pojo

-User.java

cn.itcast.test

-UserTest.java

UserDao:操作接口（这儿有人不理解为啥要写个这个接口呢？是因为有好多的大公司里面，这种设计架构的工作已经由架构师做好了他规定了这个操作类里面就这增删改查四个方法，并规定了方法的名字怎么写，

他就分配给专门的人员A来做test类，调用的时候就让A调用写架构师说的几个方法

又由专门的人B来做操作类，那么万一做操作类的人写一个方法的时候写错了其中一个方法名字，自己又没意识到，那么这时候A调用方法的时候，报错了

公司这么大，沟通成本很高，那么这时候就需要架构师提供一个借口给A和B，B呢你就给我实现这个接口，A呢你就调用接口的方法，那么这时候还会发生上面的情况吗？）

（在这儿，如果大家还不理解，也没有关系，不必太纠结，以后我还会给大家提，就业班的时候也会天天做这个）

UserDaoImpl：操作类实现操作接口

User：存储学生数据的对象（可以存储 用户名，密码，邮箱等等）

UserTest：测试类

代码：只给大家写一个UserDaoImpl和UserTest,其他的比较简单

[java] view
plain copy

package cn.itcast.dao.impl;

import cn.itcast.dao.UserDao;

import cn.itcast.pojo.User;

/**

* 用户操作实现类

*

* @author itcast 如何实现呢? 如果是注册一个用户，用User保存即可。 但是，注册肯定不止一个用户，所以我们得想想用什么存储?

* 目前我们学过的能够存储的：对象，对象数组。 通过分析，我们最终选择对象数组。 问题：用对象数组，就得定义数组，定义数组，就得知道长度。

* 不知道，我也不知道。所以，对象数组不够好。最终选择集合。 不过，集合还没学呢，所以，我们还是只能使用对象数组。 自己给一个固定长度：5

*/

public class UserDaoImpl implements UserDao {

// 定义成员变量的数组

private static User[] users = new User[5];

private static int index = 0;

@Override

public boolean isLogin(String username, String password) {

/*

* 遍历数组，获取到每一个对象，然后再拿对象的用户名和密码和传递过来的用户名和密码进行比较

*/

boolean flag = false;

for (int x = 0; x < users.length; x++) {

User user = users[x];

// 判断用户是否为null

if (user != null) {

if (user.getUsername().equals(username)

&& user.getPassword().equals(password)) {

flag = true;

break;

}

}

}

return flag;

}

@Override

public void regist(User user) {

users[index++] = user;

}

}

----------------------------------------------------------------

package cn.itcast.test;

import java.util.Scanner;

import cn.itcast.dao.UserDao;

import cn.itcast.dao.impl.UserDaoImpl;

import cn.itcast.pojo.User;

public class UserTest {

public static void main(String[] args) {

while (true) {

System.out.println("欢迎来到itcast");

System.out.println("1:登录");

System.out.println("2:注册");

System.out.println("3:退出");

System.out.println("请选择：");

Scanner sc = new Scanner(System.in);

String line = sc.nextLine();

switch (line) {

case "1":

System.out.println("欢迎来到登录界面");

System.out.println("请输入用户名：");

String username = sc.nextLine();

System.out.println("请输入密码：");

String password = sc.nextLine();

// 多态用法

// UserDao ud = new UserDaoImpl();

// 具体类用法

UserDaoImpl udi = new UserDaoImpl();

boolean flag = udi.isLogin(username, password);

if (flag) {

System.out.println("开始玩游戏吧");

System.exit(0);

} else {

System.out.println("登录失败,返回主界面");

}

break;

case "2":

System.out.println("欢迎来到注册界面");

// 键盘录入用户信息

System.out.println("请输入用户名：");

String newUsername = sc.nextLine();

System.out.println("请输入密码：");

String newPassword = sc.nextLine();

System.out.println("请输入邮箱：");

String newEmail = sc.nextLine();

System.out.println("请输入电话：");

String newPhone = sc.nextLine();

// 把数据用对象进行封装

User user = new User();

user.setUsername(newUsername);

user.setPassword(newPassword);

user.setEmail(newEmail);

user.setPhone(newPhone);

// 创建用户操作类对象

UserDaoImpl newUdi = new UserDaoImpl();

// 调用注册方法

newUdi.regist(user);

System.out.println("注册成功");

break;

case "3":

// System.out.println("谢谢你的使用");

// System.exit(0);

// break;

default:

System.out.println("谢谢你的使用");

System.exit(0);

break;

}

}

}

}