Java Learning(7)

接口

Tips:

不是类，是对类的需求描述。

如果类遵从某个特定接口，就履行某服务。

实现一个接口: 实现接口中定义的方法均为public，并且需要在实现类中注明public，以避免编译器试图改变为更弱的访问权限而带来的警告。

特性：

接口不能实例化，但却可以声明接口变量且该变量必须引用实现了对应接口的类的对象。

接口可以通过instanceof来检查某对象是否实现了某个特定的接口。

接口可以扩展已有接口。

接口中可以定义常量(public static final)。

单继承但可以实现多个接口。所以如果一个类在继承的时候只能extends一个抽象类但却可以实现多个接口。变相的实现多继承的功能，去除了多继承带来的复杂性和低效率。

多继承表明继承类可以扮演多个角色，而实现多个接口可以说实现类可以具有多个角色的功能。

对象拷贝和克隆：

变量拷贝是引用的拷贝。

在对象拷贝过程中，被拷贝对象如果有第三方引用，则拷贝者只拷贝当前对象，而被被拷贝者所引用的部分不进行拷贝（浅拷贝），仍然是公用，以引用的方式存在。但这会造成很多问题，因此需要重新定义clone方法达到对引用对象的克隆（深拷贝）。运用clone方法需要实现Cloneable接口，否则会产生checked exception。

注意：必须实现Cloneable，否则会抛出CloneNotSupportedException。

Demo:

class entry:

public class Entry {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        eggSample es = CloneSample.es;
        es.setFrom(new factory("factory1","Shanghai PudongStrict NO.1"));

        try {
            eggSample es1 = es.deepclone();
            es1.getfrom().setName("factory2");

            System.out.println(es.getfrom().getName());
            
            eggSample es2 = es.shallowclone();
            es2.getfrom().setName("factory2");
            
            System.out.println(es.getfrom().getName());
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }        
    }
}

class eggsample:

public class eggSample implements Cloneable {
    private String color;
    private String name;
    private String data;
    private factory from;

    public eggSample(String color, String name, String data) {
        this.color = color;
        this.name = name;
        this.data = data;
    }

    public String getColor() {
        return this.color;
    }

    public String getName() {
        return this.name;
    }

    public String getdata() {
        return this.data;
    }

    public factory getfrom() {
        return this.from;
    }

    public eggSample shallowclone() throws CloneNotSupportedException {
        return (eggSample) super.clone();
    }

    // deep copy
    public eggSample deepclone() throws CloneNotSupportedException {
        eggSample estempt = (eggSample) super.clone();
        estempt.from = (factory) from.clone();
        return estempt;
    }

    public void setInfo(String colorS, String nameS, String dataS) {
        this.color = colorS;
        this.name = nameS;
        this.data = dataS;
    }

    public void setFrom(factory factoryS) {
        this.from = factoryS;
    }

    public String toString() {
        return "egg is coming from : " + from.toString() + "\n\tProperties:"
                + "\n\t Color: " + this.color + "\n\t Name: " + this.name
                + "\n\t Data: " + this.data;
    }
}

class factory:

public class factory implements Cloneable{
    
    String factoryname;
    String factorylocation;
    
    public factory(String name, String location){
        this.factorylocation = location;
        this.factoryname = name;
    }
    
    public String getName(){
        return this.factoryname;
    }
    
    public String getLocation(){
        return this.factorylocation;
    }
    
    public String toString(){
        return "Factory :" + this.factoryname + "\t" + this.factorylocation ; 
    }
    
    public void setName(String name){
        this.factoryname = name;
    }
    
    public void setLocation(String Location){
        this.factorylocation = Location;
    }
    
    public factory clone() throws CloneNotSupportedException {
        return (factory) super.clone();
    }
}
class clone Sample:

public class CloneSample implements Cloneable {
    public static eggSample es = new eggSample("red", "egg1", "20150930");    
}

Result:

factory1
factory2

接口和回调：
特定情况下传对象优于传递函数，因为对象作为传递对象可以携带很多其他相关信息，比方法传递要灵活。

System.exit(int status) --> Runtime.exit(int status):

0 - 将虚拟机中的所有内容都停掉，内存清空，JVM停止；

1 or <>0 - 非正常退出，通常放在catch模块中用于终止当前程序；

但后期需要进一步学习关于exist本身发生的时候JVM层面上的事情。

和Return的区别，Return是返回上一层，二exist则是放回到最外层；

CallBack && Hook：

回调： 程序设计模式，指出某个特定事件发生时应该采取的动作。个人感觉Hook也是这么回事，就是在特定事件出发时候关联某些行为的设计方法。

比如说在程序执行到需要shutdown之前弹出对话框什么之类的。
内部类：

原因：某类的内部类可以访问该类中所有的作用域中的数据；其次内部类可以通过权限控制只对该类可见；还有就是在该类中需要定义一个回调函数但是不想便携大量的代码时，可以使用匿名内部类。

Demo：

public class TalkingClock {
	
	private int interval;
	private boolean beep;

	public TalkingClock(int interval, boolean beep){
		this.interval = interval;
		this.beep = beep;
	}
	public void start(){
		ActionListener listener = new TimePrinter();
		Timer t = new Timer(interval, listener);
		t.start();
	}
	
	public class TimePrinter implements ActionListener{
		
		@Override
		public void actionPerformed(ActionEvent event) {
			// TODO Auto-generated method stub
			Date now = new Date();
			System.out.println("At the tone, the time is " + now);
			if(beep)
				Toolkit.getDefaultToolkit().beep();
		}
		
	}

内部类中的beep是默认从主类中读取的。

内部匿名类：直接创建实现某个接口或者继承某个父类的类的实例。ActionListener是一个接口。匿名类不能有构造器，构造器需要的参数传递给父类的构造器。

ActionListener al = new ActionListener(){
     public void actionPerformed(ActionEvent envent){
        .......
     }
};
//format type: SuperType can be class or interface
new SuperType(constructor parameter){
     innerClass's method or data.
}