第一 静态导入
一、概述:
1、import语句:是导入一个类或某个包中的所有类。
2、import static语句:导入一个类中的某个静态方法或所有静态方法。
3、特点:简化了书写,但是代码的阅读性较差。
import static java.lang.Math.*;
/*
* 1.5新特性
* 静态导入
*/
public class StaticImport {
public static void main(String[] args) {
System.out.println(abs(3 - 6));
}
}
第二 增强for循环
一、概述
1、语法:for(可加修饰符 type 变量名 : 集合){statement}
2、注意:迭代变量必须定义在()中,集合必须是实现Iterable接口的集合类,变量类型前可加修饰符,如final(可被局部内部类访问到)。
/*
* 1.5新特性
*
* 增强for循环
* 格式:for(可以添加修饰符 type 变量名 :集合){}
* 这里的集合必须是实现了Iterable
*/
public class EnhanceFor {
public static void main(String[] args) {
System.out.println(variableParameter(1, 2, 5, 8, 6));
}
/*
* 可变参数的方法 可变参数只能放与最后
*/
public static int variableParameter(int x, int... arr) {
int sum = 0;
// 可变参数其实内部封装了数组,按照数组方式取值
for (int num : arr) {
sum += num;
}
return sum;
}
}
第三 可变参数
一、概述:所谓的可变参数就是参数个数不固定,就是方法的重载。
二、特点:
1、只能出现在参数列表的最后。
2、用…这三个点表示参数可以有很多,且这三个点位于变量类型和变量名之间,前后有无空格皆可。
3、调用可变参数的方法时,编译器为该可变参数隐含创建一个数组,在方法体中以数组的形式访问可变参数。
/*
* 1.5新特性
*
* 可变参数
*/
public class VariableParameter {
public static void main(String[] args) {
System.out.println(variableParameter(1, 2, 5, 8, 6));
}
/*
* 可变参数的方法
* 可变参数只能放与最后
*/
public static int variableParameter(int x, int... arr){
int sum = 0;
//可变参数其实内部封装了数组,按照数组方式取值
for(int i=0; i<arr.length; i++){
sum += arr[i];
}
return sum;
}
}
四 自动装箱拆箱
一、概述:
1、自动装箱:Integer i = 3;
2、自动拆箱:i + 2;
3、对于基本数据类型的说明:整数在-128 ~ 127之间的数,包装成Integer类型对象,会存入常量池中的缓存,再创建同一个对象的时候,会直接使用前一个已有的值,因为这些小数值使用的频率很高,所以这些数值需要如此的使用以优化内存。
/*
* 1.5新特性:
* 自动装箱和拆箱
*/
public class AutoBox {
public static void main(String[] args) {
Integer i = 123;//自动装箱
System.out.println(i);//自动拆箱
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1 == i2);
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3 == i4);
/*
* 享元模式:
* 就是将小的,经常用的放在常量池中,可供分享,这样就不用建立那么多对象,优化内存
* 如正数的-128~127
*/
Integer i5 = Integer.valueOf(50);
Integer i6 = Integer.valueOf(50);
System.out.println(i5 == i6);
Integer i7 = Integer.valueOf(-158);
Integer i8 = Integer.valueOf(-158);
System.out.println(i7 == i8);
}
}
4、享元模式(flyweight):
1)概述:如果很多很小的对象,他们有很多相同的属性,那么就可变为一个对象使用,这些属性称为内部状态,还有些不同的属性,作为方法参数植入,这些称为外部状态。这种优化内存,只创建一个对象的模式,称之为享元模式。
2)应用:
①、word中输入英文字母,可创建26对象,每个对象值是出现的位置不同(坐标),所以可用一个对象调用位置的方法:如,字母i:i.display(intx,int y),将高度重复使用的char类型的字母i封装成一个对象使用。
②、图标:window下的文件夹图标,只哟名称这个属性不同,包含了很多其他相同的属性,那么可以应用享元模式。
第五 枚举
一、概述:1、在实际编程中,往往存在着这样的“数据集”,它们的数值在程序中是稳定的,而且“数据集”中的元素是有限的。例如星期一到星期日七个数据元素组成了一周的“数据集”,春夏秋冬四个数据元素组成了四季的“数据集”。而在java中就是通过枚举对特定的"数据集"进行限定的。
2、枚举的作用:一些程序在运行时,它需要的数据不是任意的,而是必须在一定范围内的值举例说明,没有枚举的时候,就是通过自定义类来实现限定的,类似下面打印成绩的程序,但是成绩只有ABCDE五个等级,所以需要对其进行限定。
//没有枚举的时候:
class Demo{
public void test(){
print(Gread.B);
}
public void print(Gread g){
//打印成绩,只能接收ABCDE
}
}
class Gread{
private Gread(){}
public static final Gread A = new Gread();
public static final Gread B = new Gread();
public static final Gread C = new Gread();
public static final Gread D = new Gread();
public static final Gread E = new Gread();
}
有了枚举:
enum Gread{
A,B,C,D,E;
}
首先不明白不要紧,但是直观的效果就是简化了书写,让代码更加简单了。其实枚举简单的说就是限定条件,让特定的“数据集”不会超出预定的范围。
enum很像特殊的class,实际上enum声明定义的类型就是一个类,而且是一个不可被继承的final类,其中的元素都是类静态常量。而这些类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继承了这个Enum中的许多有用的方法
二、枚举的特征及用法:
public class EnumTest {
/**
* @param args
*/
public static void main(String[] args) {
WeekDay2 weekday2 = WeekDay2.MON;
System.out.println(weekday2.nextDay());
WeekDay weekday = WeekDay.FRI;
System.out.println(weekday);
System.out.println(weekday.name());
System.out.println(weekday.ordinal());
System.out.println(WeekDay.valueOf("SUN"));
System.out.println(WeekDay.values().length);// WeekDay.values(),返回数组
TrafficLamp tf = TrafficLamp.GREEN;
System.out.println(tf);
}
// (内部类)定义星期
public enum WeekDay {
SUN(1), MON(1, 1), TUE, WED, THL, FRI, SAT;// 元素列表
// 其他成员只能放于元素列表之后
private WeekDay() {
System.out.println("first");
}
private WeekDay(int day) {
System.out.println("second");
}
private WeekDay(int day, int d) {
System.out.println("third");
}
}
// 定义交通灯
public enum TrafficLamp {
// RED,GREEN,YELLOW;
// 子类实现父类的抽象方法
RED(30) {//调用构造函数,并覆盖父类中的抽象方法
@Override
public TrafficLamp nextLamp() {
return GREEN;
}
},
GREEN(40) {
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},
YELLOW(5) {
@Override
public TrafficLamp nextLamp() {
return RED;
}
};
private int time;
// 构造方法
private TrafficLamp(int time) {
this.time = time;
}
//抽象方法,子类必须实现
public abstract TrafficLamp nextLamp();
}
}
1、构造器:
1)构造器只是在构造枚举值的时候被调用。
2)构造器只有私有private,绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例,因为枚举值是public static final的常量,但是枚举类的方法和数据域是可以被外部访问的。
3)构造器可以有多个,调用哪个即初始化相应的值。
2、所有的枚举类都继承了Enum方法,方法如下:
1)toString() ---> 返回枚举量的名称
2)ordina() ---> 返回枚举值在枚举类中的顺序,按定义的顺序排
3)getClass() ---> 获取对应的类名
静态方法:
1)valueOf(String e) ---> 转为类中对应的对象,即将字符串转为对象
2)values() ---> 获取数组,将元素放入一个数组中。
三、注意:
1、元素列表即所有的元素项目,必须放在整个类的最前面。
2、元素列表后要可有可无分号,但是元素后面还有其他项目时,必须加上分号。
3、枚举类中的方法为private
4、在元素后跟上(),就可指定要使用的构造方法,含参数。
5、枚举类中的每个元素都是它的一个子类对象,当枚举类中存在abstract方法,须在子类后加{},并在其中实现此方法。
四、总结:
1、匿名内部类比较常用
2、类的方法返回的类型可以是类的类型
3、类中可定义静态常量,常量的结果就是自己这个类型的实例对象
4、如果枚举只有一个成员,就可以作为一种单例的实现方式,对象只有一个。