今天逛贴吧的时候偶然发现吧友的一个有趣例子。

public class Demo{

    public static void main(String[]args){
        System.out.println(24/0);  //会抛byzero异常
        System.out.println(24.0/0.0) //可以输出，输出为Infinity；
    }

}

原因补充20160805：

查阅了Double包装类的源码，发现：

 /**
     * A constant holding the smallest positive nonzero value of type
     * {@code double}, 2<sup>-1074</sup>. It is equal to the
     * hexadecimal floating-point literal
     * {@code 0x0.0000000000001P-1022} and also equal to
     * {@code Double.longBitsToDouble(0x1L)}.
     */
    public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324

这句话的意思是定义一个最小的非零常数，意思就是说我们定义double类型的0.0时其值是4.9e-324（十进制）,即4.9乘以10的负324次方。想象得到非常接近于零了，但并非零，这样进行除法，那结果肯定就是无限大了（Infinity）。

关于java类的继承协变返回类型的例子

栽自《java编程思想第八章8.4节》

package com.wwp.abc;

/**
 * 
 * 1 子类完全拥有父类的方法，且具体子类必须实现父类的抽象方法。
 * 2 子类中可以增加自己的方法.
 * 3 当子类覆盖或实现父类的方法时，方法的形参要比父类方法的更为宽松。（逆变）
 * 4 当子类覆盖或实现父类的方法时，方法的返回值要比父类更严格（协变）
 * 
 * 
 * 
 * ***/

public class Test1 {
	public static void main(String []args){
		//int c=a.age;
		Mill m=new Mill();
		Grain g=m.process();
		System.out.println(g);
		 m=new WheatMill();
		 g=m.process();
		System.out.println(g);
		
		
	}
}
class Grain{
	@Override
	public String toString(){
		return "Grain";
	}
}
class Wheat extends Grain{
	
	@Override
	public String toString(){
		return "Wheat";
	}
}
class Mill{
	public Grain process(){
		return new Grain();
	}
}
class WheatMill extends Mill{
	@Override
	public Wheat process(){
		return new Wheat();
	}
}

输出结果为

Grain

Wheat


java接口之再学习

在《thinking in java》里的第九章接口讲解中，讲到了策略模式和适配器模式。于是自己联系生活中的电脑与USB连接手机的例子。进行理解。

package com.wwp.abc;

/**
 * 
 *接口的适配器功能及策略模式Demo
 * 
 * 
 * 
 * ***/


public class Test1 {

	
	
	
	public static void main(String []args){
	Computer computer=new Computer(new Androidphone());
	computer.conectionWrite();	
	computer.connectionRead();
	computer=new Computer(new Iphone());
	computer.conectionWrite();	
	computer.connectionRead();
	}

	
	
}
interface USB{
	public void write();//写
	public void read();//读
}
class Androidphone implements USB{
	public void write(){
		System.out.println("安卓手机在写数据");
	}
	public void read(){
		System.out.println("安卓手机在读数据");
	}
}
class Iphone implements USB{

	public void read() {
		// TODO Auto-generated method stub
		System.out.println("苹果手机在读数据");
	}

	public void write() {
		// TODO Auto-generated method stub
		System.out.println("苹果手机在写数据");
	}
	
}

class Computer{
	 public Computer(USB usb){
		this.usb=usb;
	}
	private USB usb;
	private String name;
	public USB getUsb() {
		return usb;
	}
	public void setUsb(USB usb) {
		this.usb = usb;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void connectionRead(){
		
		usb.read();
	}
	public void conectionWrite(){
		usb.write();
	}
	
}

结果为wKioL1ej-aGDFQjHAAAmFUkI7TM632.png


从上面的例子可以看出接口的灵活性，当想和电脑连接时，必须实现USB接口里的方法,即某些协议你必须遵守。至于你是谁，并不是电脑关心的。而这里的接口就起到了一个桥梁的作用，它建立了设备与电脑间的联系，同样别的类型设备想要连接电脑，那它实现该接口即可。这就是所谓的适配器模式。接口就是一个适配器。而电脑内部则是采用策略模式，根据不同的接口实现类，调用不同的实现方法。这样使代码更加简洁，同时增加了代码的扩展性。