第18天 jdk5.0新特性及图书管理系统

 

1  JDK5特性

JDK5中新增了很多新的java特性，利用这些新语法可以帮助开发人员编写出更加清晰，安全，高效的代码。

静态导入

自动装箱/拆箱

增强for循环

可变参数

枚举

 

泛型

1.1 静态导入（了解）

JDK1.5 增加的静态导入语法用于导入类的某个静态属性或方法。使用静态导入可以简化程序对类静态属性和方法的调用。

语法：

importstatic 包名.类名.静态属性|静态方法|*

例如：

import static java.lang.System.out;
import static java.lang.Math.*;

public class Demo {

public static void main(String[] args) {
// 普通写法
System.out.println("hello world");
int max = Math.max(100, 200);
System.out.println(max);

// 静态导入
out.println("hello world");
int max2 = max(100, 200);
System.out.println(max2);
}

}

1.1 增强for循环

引入增强for循环的原因：在JDK5以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！

因此JDK5中定义了一种新的语法——增强for循环，以简化此类操作。增强for循环只能用在数组、或实现Iterable接口的集合类上

语法格式： 

for(变量类型变量　：需迭代的数组或集合){}

 

                                           

Foreach是为了让你的代码变得简捷、和容易维护。

 

增强for循环要注意的细节：

   1. 迭代器可以对遍历的元素进行操作，使用增强for循环时，不能对集合中的元素进行操作的。

2. 增加for循环与普通的for循环区别。

3. map的遍历。

1.2 可变参数

JDK中具有可变参数的类Arrays.asList()方法。

分别传多个参、传数组，传数组又传参的情况。

注意：传入基本数据类型数组的问题。

从JDK 5开始, Java 允许为方法定义长度可变的参数。

语法：数据类型…变量名。

可变长参数是Object[] 数组。（可变参数里存的是对象数组）

JDK中的典型应用：

     Arrays.asList(T…a)是jdk中的典型应用。

需求:对若干个整数进行求和

public static int sum1(int a,int b ) {
return a+b;
}

若干个整数求和如何解决？
可以使用数组接收整数。
public static int sum1(int[] numbers) {
if (numbers == null) {
return 0;
}

if (numbers.length == 0) {
return 0;
}

int sum = 0;
for (int num : numbers) {
sum += num;
}
return sum;
}

可以使用可变参数
public static int sum2(int... numbers) {
if (numbers == null) {
System.out.println("可变参数的值为null");
return 0;
}

if (numbers.length == 0) {
System.out.println("可变参数的值的长度为0");
return 0;
}

int sum = 0;
for (int num : numbers) {
sum += num;
}
return sum;
}

可变参数的使用
public static void main(String[] args) {
// int result = sum1(new int[] { 1, 3, 5, 7, 9 });
// System.out.println(result);

// // 使用了可变参数，传一个数组进去
// int result = sum2(new int[] { 1, 3, 5, 7, 9 });
// System.out.println(result);

// 使用了可变参数，不必声明数组，简化书写
// int result = sum2(2, 4, 6, 8, 10);
// int result = sum2(1);
int result = sum2();
System.out.println(result);
}

可变参数的细节

声明：

      在一个方法中，最多只能有一个可变参数。

      可变参数只能放在参数列表的最后面。

   调用：

      当使用可变参数时，可以传0或多个参数。

      当使用可变参数时，也可以传一个数组进去，就表示多个参数。

   使用：

      在方法内部使用时，就是在使用一个数组。

      当调用时没有传参数时（传了0个），这时在方法内部的参数数组是有值的（不为null），但长度为0.

1.1 自动装箱/拆箱

自动装箱：指开发人员可以把一个基本数据类型直接赋给对应的包装类。

自动拆箱：指开发人员可以把一个包装类对象直接赋给对应的基本数据类型。

典型应用：

List list = new ArrayList();
list.add(1);
//list.add(new Integer(1));
int i=list.get(0);
//int j = (Integer)list.get(0);

1.4.1 基本数据类型包装类

包装类 基本数据类型

Byte byte

Short short

Integer int

Long long

Boolean boolean

Float float

Double double

Character char

对象变基本数据类型:拆箱 基本数据类型包装为对象:装箱

为了使得java的基本类型有更多的功能，java为其所有的基本类型提供了包装类来封装常见的功能。如：最大值、数值转换等。

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

所属的包：java.lang.*

常见应用一:

获取最大最小值MAX_VALUE / MIN_VALUE 

整数类型最大值

Integer.MAX_VALUE

System.out.println(Integer.MIN_VALUE);// -2147483648

System.out.println(Integer.MAX_VALUE);// 2147483647

应用二:

基本数据类型和字符串之间的转换

例：Integer的parseInt方法，intValue方法

基本数据类型转换成字符串:

1:基本数据类型+””

2:基本数据类型.toString(基本数据类型值);

例如  Integer.toString(34); //将34变成了”34”

基本数据类型转字符串

int i=100;
String str=100+"";
String string = Integer.toString(100);

字符串变基本数据类型

基本数据类型 a=基本数据类型包装类.parse基本数据类型(String str);

str="123";
int parseInt = Integer.parseInt(str);
System.out.println(parseInt);

         

注意: 

public static int parseInt(String s)

Integer类中的parseInt方法是静态的 参数必须是数字格式

Double

str = "3.14";
double parseInt2 = Double.parseDouble(str);
System.out.println(parseInt2);

boolean b = Boolean.parseBoolean("true");

应用三:

进制转换:

 十进制转成其他进制.

toBinaryString(int i) 

          以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。 

toHexString(int i) 

          以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 

toOctalString(int i) 

          以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 

那么其他进制转成十进制

parseInt(String radix);

parseInt(String s, int radix) 

          使用第二个参数指定的基数，将字符串参数解析为有符号的整数。 

十进制转其他进制

十进制转其他进制
// 十进制转二进制
String binaryString = Integer.toBinaryString(100);
System.out.println(binaryString); // 1100100
// 十进制转十六进制
String hexString = Integer.toHexString(100);
System.out.println(hexString); // 64

// 十进制转八进制
String octalString = Integer.toOctalString(100);
System.out.println(octalString); // 144

其他进制转十进制
// 字符串转对应的进制
int parseInt3 = Integer.parseInt(octalString);
System.out.println(parseInt3);
// 二进制转十进制
int parseInt4 = Integer.parseInt(binaryString, 2);
System.out.println(parseInt4);
// 十六进制转十进制
int parseInt5 = Integer.parseInt(hexString, 16);
System.out.println(parseInt5);
// 八进制转十进制
int parseInt6 = Integer.parseInt(octalString,8);
System.out.println(parseInt6);

JDK5.0后出现了自动装箱和拆箱
JDK5.0以后，简化了定义方式。
Integer x = new Integer(5);//装箱
int intValue = x.intValue(); //拆箱

// 5.0简化书写
// 自动装箱。new Integer(5);
Integer y = 5;
// 对象加整数,x 进行了自动拆箱,变成了int 型 和5进行加法运算后再将和进行装箱赋给x。
y = y + 5; // 是通过Integer.intValue() 方法进行拆箱

练习:
public static void main(String[] args) {
Integer a = 127;
Integer b = 127;
System.out.println(a == b);

Integer c = 128;
Integer d = 128;
System.out.println(c == d);
}
请问结果?
a==b 为true 因为a和b指向了同一个Integer 对象.
Integer的缓存大小-128 ~127 之间也就是byte的范围。
1.5	枚举类
一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，此类问题在JDK5以前采用自定义带有枚举功能的类解决，Java5以后可以直接使用枚举予以解决。
例如: 交通灯(红、黄、绿)    性别(男、女)   星期(星期一、二、三…..)
分数等级(A、B、C、D、E)
JDK 5新增的 enum 关键字用于定义一个枚举类。
枚举的实现
使用enum定义枚举类
在枚举类中定义枚举值(大写)
enum Gender {
MALE, FEMALE;
}

发现其中每一个枚举值都是枚举类的具体实例对象.只不过是静态常量.

枚举类具有如下特性：

枚举类也是一种特殊形式的Java类。

枚举类中声明的每一个枚举值代表枚举类的一个实例对象。

与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数.

public class Demo1 {
public static void main(String[] args) {
Gender male = Gender.MALE;
System.out.println(male.getInfo());
}
}

enum Gender {
MALE("男"), FEMALE;

// 成员变量
private String info;

// 构造函数
private Gender() {

}

private Gender(String info) {
this.info = info;
}

// 成员方法
public String getInfo() {
return info;
}

}
枚举类可以声明抽象方法,但是要有具体的枚举值去实现.
public class Demo1 {
public static void main(String[] args) {
Gender male = Gender.MALE;
System.out.println(male.getInfo());
male.speak();
}
}

enum Gender {
MALE("男") {
@Override
public void speak() {
System.out.println("是男人");
}
},
FEMALE {
@Override
public void speak() {
System.out.println("是女人");
}
};

// 成员变量
private String info;

// 构造函数
private Gender() {

}

private Gender(String info) {
this.info = info;
}

// 成员方法
public String getInfo() {
return info;
}

public abstract void speak();

}

枚举类也可以实现接口(序列化)、或继承抽象类。

JDK5中扩展了swith语句，它除了可以接收int, byte, char, short外，还可以接收一个枚举类型(enum)。
public class Demo2 {
public static void main(String[] args) {
WeekDay mon = WeekDay.MON;
switch (mon) {
case MON:
System.out.println("星期一要上班...");
break;
case TUE:
System.out.println("星期二,继续上班...");
break;
}
}
}

enum WeekDay {
MON, TUE, WED, THU, FRI, SAT, SUN;
}

若枚举类只有一个枚举值，则可以当作单态设计模式使用。
练习：
请编写一个关于星期几的枚举WeekDay，要求：枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun 该枚举要有一个方法，调用该方法返回中文格式的星期。
enum WeekDay {
MON {

@Override
public String getInfo() {

return "星期一";
}

},
TUE {
@Override
public String getInfo() {

return "星期二";
}
},
WED {
@Override
public String getInfo() {

return "星期三";
}
},
THU {
@Override
public String getInfo() {

return "星期四";
}
},
FRI {
@Override
public String getInfo() {

return "星期五";
}
},
SAT {
@Override
public String getInfo() {

return "星期六";
}
},
SUN {
@Override
public String getInfo() {

return "星期天";
}
};

public abstract String getInfo();
}

2.图书管理系统
package cn.itcast.model;
//用户类
public class User {

private String userName;

private String password;
public User() {
super();
// TODO Auto-generated constructor stub
}

public User(String userName , String password) {
this.userName = userName;
this.password = password;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

@Override
public String toString() {
return "用户名"+ this.userName +" 密码："+ this.password;
}

}

package cn.itcast.model;

public class Book {

}

package cn.itcast.dao;

import java.util.ArrayList;
import java.util.Scanner;

import cn.itcast.model.User;

//该类是对用户数据增删查改的。
public class UserDao {

//用户的数据都存储到该集合中。
private static ArrayList<User> users = new ArrayList<User>();

//注册
public void reg(){
Scanner scanner = new Scanner(System.in);
String userName = null;
while(true){
System.out.println("请输入用户名:"); //用户名首位不能以数字开头， 6位英文字母与数组组成
userName = scanner.next();
if(userName.matches("[a-zA-Z][a-zA-Z0-9]{5}")){
break;
}else{
System.out.println("用户名不符合规则..");
}
}
String password =null;
while(true){
System.out.println("请输入密码:"); //用户名首位不能以数字开头， 6位英文字母与数组组成
password = scanner.next();
if(password.matches("\\d{6}")){
break;
}else{
System.out.println("密码不符合规则..");
}
}
//使用了新注册的信息生产一个用户对象。
User user = new User(userName,password);
users.add(user);
System.out.println("注册功能...");
System.out.println("当前用户有："+users );

}

}

package cn.itcast.main;

import java.util.Scanner;

import cn.itcast.dao.UserDao;

public class LibararyMain {

public static void main(String[] args) {
System.out.println("****************************************");
System.out.println("* *");
System.out.println("* *");
System.out.println("* *");
System.out.println("* *");
System.out.println("* 1208java基础班图书馆 *");
System.out.println("* *");
System.out.println("* *");
System.out.println("* *");
System.out.println("* *");
System.out.println("****************************************");
Scanner scanner = new Scanner(System.in);
UserDao userDao = new UserDao();

while(true){
System.out.println("请选择功能：A(用户登陆) B(注册用户) Q(退出系统)");
String option = scanner.next();

if("a".equalsIgnoreCase(option)){

}else if("b".equalsIgnoreCase(option)){
//注册
userDao.reg();

}else if("Q".equalsIgnoreCase(option)){
System.exit(0);
}else{
System.out.println("你的输入有误，请重新输入...");

}

}

}

}