黑马程序员--张孝祥Java高新技术-JDK1.5新特性（二）【基本数据类型的自动拆箱与装箱，枚举】以及享元设计模式

最新推荐文章于 2016-04-15 10:41:17 发布

HyoleeITBook

最新推荐文章于 2016-04-15 10:41:17 发布

阅读量1.2k

点赞数

分类专栏： javaEE

本文链接：https://blog.csdn.net/qq_19439251/article/details/39972639

版权

javaEE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ---

基本数据类型的自动拆箱与装箱

JDK 1.5的语法允许开发人员把一个基本数据类型直接赋给对应的包装类变量, 或者赋给 Object 类型的变量，这个过程称之为自动装箱。

自动拆箱与自动装箱与之相反，即把包装类对象直接赋给一个对应的基本类型变量。

package com.itheima.day1;

public class AutoBox {

public static void main(String[] args) {

Integer iObj = 3;// 装箱

System.out.println(iObj + 12);// 拆箱

String s1 = new String();

String s2 = new String();

// Integer i1 =13;

// Integer i2 =13;

Integer i1 = 137;

Integer i2 = 137;

// -128~127

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

// 这是一个设计模式：享元模式：flyweight

// 有很多个小的对象，他们有很多属性相同；把这些相同的属性变成一个对象.

// 哪些不同的对象，变成方法的参数。称为外部状态。相同的部分称为内部状态。

/*
* 享元模式在一般的项目开发中并不常用，而是常常应用于系统底层的开发，以便解决系统的性能问题。
*
* 比如：Java中的String类型就是使用了享元模式。
*
*
* 到底系统需要满足什么样的条件才能使用享元模式。对于这个问题，总结出以下几点：
*
* 1、一个系统中存在着大量的细粒度对象；
*
* 2、这些细粒度对象耗费了大量的内存。
*
* 3、这些细粒度对象的状态中的大部分都可以外部化；
*
* 4、这些细粒度对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除时，每一个组都可以仅用一个对象代替。
*
* 5、软件系统不依赖于这些对象的身份，换言之，这些对象可以是不可分辨的。
*
* 满足以上的这些条件的系统可以使用享元对象。
*
* 最后，使用享元模式需要维护一个记录了系统已有的所有享元的哈希表，也称之为对象池，而这也需要耗费一定的资源。
*
* 因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。
*/

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

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

Integer i3 = Integer.valueOf(213);

Integer i4 = Integer.valueOf(213);

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

}

}

枚举

为什么要有枚举？
问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。
枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

自定义类实现枚举功能
1、私有的构造方法。
2、每个元素分别用一个公有的静态成员变量表示。
3、可以自定义若干个公有方法或抽象方法。

代码体现：

package com.itheima.day1;

public abstract class WeekDay_1 {

private WeekDay_1(){}

public final static WeekDay_1 SUN = new WeekDay_1(){

//注意：可以采用抽象方法定义nextDay将大量的if...else语句转移到一个个独立的对象中实现。

public WeekDay_1 nextDay(){

return MON;

}

};

public final static WeekDay_1 MON = new WeekDay_1(){

public WeekDay_1 nextDay(){

return SUN;

}

};

public abstract WeekDay_1 nextDay();

/* public WeekDay nextDay(){

if(this==SUN){

return MON;

}else{

return SUN;

}

}*/

public String toString(){

return this ==SUN?"SUN":"MON";

}

}

package com.itheima.day1;

public class EnumTest {

public static void main(String[] args) {

WeekDay_1 weekDay = WeekDay_1.MON;

System.out.println(weekDay.nextDay());

}

}

枚举的基本应用以及

实现带有构造方法的枚举

代码体现：

package com.itheima.day1;

public class EnumTest {

public static void main(String[] args) {

WeekDay_1 weekDay = WeekDay_1.MON;

System.out.println(weekDay.nextDay());

WeekDay weekDay_2 =WeekDay.FRI;

System.out.println(weekDay_2.ordinal());

System.out.println(weekDay_2.name());

System.out.println(weekDay_2.getClass());

System.out.println(weekDay_2.valueOf("SUN").toString());

System.out.println(weekDay_2.values().length);//把枚举的元素转化为数组。

}

public enum WeekDay{

SUN(1),MON,TUE,WED,THL,FRI,SAT;

private WeekDay(){System.out.println("first");}

private WeekDay(int day){System.out.println("secod");}

}

}

总结：
枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，
例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。
注意：
最后一个枚举元素后面可以加分号，也可以不加分号。

实现带有构造方法的枚举
1 .枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。
2·枚举元素必须位于枚举体中的最开始部分，枚举元素列表的最后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器会报告错误。
3·带构造方法的枚举：
构造方法必须定义成私有的
如果有多个构造方法，将根据枚举元素创建时所带的参数决定选择哪个构造方法创建对象。
枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。

实现带有抽象方法的枚举
定义枚举TrafficLamp。（红，绿，灯系统）
实现抽象的nextTrafficLamp方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。
增加上表示时间的构造方法。

package com.itheima.day1;

public class EnumTest {

public static void main(String[] args) {

// 带有抽象方法的枚举：交通灯

public enum TrafficLamp {

RED(30) {

public TrafficLamp nextLamp() {

return GREEN;
}

},
GREEN(45) {

public TrafficLamp nextLamp() {

return YELLOW;

}

},
YELLOW(5) {

public TrafficLamp nextLamp() {

return RED;

}

};// 红，绿，黄。

// 定义下个灯的方法

public abstract TrafficLamp nextLamp();

// 定义一个成员变量时间（因为现实生活中每个灯都有时间的）

private int time;

private TrafficLamp(int time) {

this.time = time;

}

}

}

枚举类总结：

1、枚举类是一种特殊形式的Java类。
2、枚举类中声明的每一个枚举值代表枚举类的一个实例对象。
3、枚举类与Java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数。
但枚举类的构造函数必须为私有的（这点不难理解）。
4、枚举类也可以实现接口、或继承抽象类。
5、JDK 1.5 中扩展了switch语句，它除了可以接收int, byte, char, short,String外，还可以接收一个枚举类型。
6、若枚举类只有一个枚举值，则可以当作单例设计模式使用。
7、枚举类的实例变量是把所以的枚举实例都加载一次的。
如果调用了某个枚举类，那么该枚举类先把枚举类里面的所有元素都先加载一次。

注意：

1、枚举只有一个成员时，就可以作为一种单例的实现方式。
2、查看生成的class文件，可以看到内部类对应的class文件。
也就是枚举的元素都是一个内部类实例对象。

单例设计模式(Singleton)：

解决一个类在内存中只存在一个对象

比如对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

想要保证对象唯一：

为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象；

还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象；

为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式；

单例设计模式之饿汉式

Single类一进内存，就已经创建好了对象，简单的说就是一上来就吃。

思路：
将构造函数私有化；
在类中创建一个本类对象；
提供一个公共的访问方法，可以获取到该类对象；

代码体现：

package com.itheimaday06;

/*
 设计模式：解决某一类问题最行之有效的方法。

 java 中23中设计模式：

 单例设计模式：解决一个类中在内存在能存在一个对象


 想要保住对象的唯一。

 1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。

 2，还为了让其他程序还可以访问到该类对象。只好在本类中 ，自定义一个对象。

 3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

 这三不这么用代码体现呢？

 1，将构造函数私有化，

 2，在类中创建一个本类对象。

 3,提供一个方法可以获取到该对象。

对于事物该这么描述。还这么描述。

当需要将该事物的对象保证在内存中的唯一时。就就以上三步加上即可。

 */

//单例设计模式一

class Singele {

	private int num;

	public int getNum() {

		return num;

	}

	public void setNum(int num) {

		this.num = num;

	}

	private Singele() {
		
	}

	private static Singele s = new Singele();

	public static Singele getInstance() {

		return s;

	}

}

public class SingleDemo_09 {

	public static void main(String[] args) {

		Singele s1 = Singele.getInstance();

		Singele s2 = Singele.getInstance();

		s1.setNum(45);

		System.out.println(s2.getNum());

	}

}

class Student{
	
	private int age;
	
	private Student(){
		
		
	}
	
	private static Student s = new Student();
	
	public static Student getInstance(){
		
		return s;
		
	}

	public int getAge() {
		
		return age;
		
	}

	public void setAge(int age) {
		
		this.age = age;
		
	}
	
	
	
	
	
}

package com.itheimaday06;

/*

 */

//单例设计模式一：  先初始化   饿汉式

//Single类 一进内存 就已经创建好了对象。


/*class Sengle {

 private Sengle(){	}

 private static Sengle s = new Sengle();

 public static Sengle getInstance() {

 return s;

 }

 }*/

//单例设计模式二： 方法被调用式 才初始化 也叫对象的延迟加载。成为：懒汉式

//Single 类进内存，对象还没存在 ，只有调用了 getInstance 方法时，才建立对象。


class Single1 {

	private Single1() {
	};

	private static Single1 s = null;

	public static Single1 getInstance() {

		if (s == null) {

			s = new Single1();

		}

		return s;

	}

}

public class SengleDemoTwo_10 {

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

//记住原则：定义单例。建议使用 饿汉式！