• 推荐！搬瓦工官方代理，自动更换被封IP：Just My Socks

ad

第9章 接口

2018年4月11日 0条评论 0人点赞
  • 9.1 抽象类和抽象方法
    1. 抽象类可以没有任何抽象方法，但是包含一个或多个抽象方法的类必须被限定为抽象的。
    2. 抽象类不能实例化。
    3. 如果从一个抽象类继承，并想创建该新类的对象，那么必须为基类中的所有抽象方法提供定义。如果不这么做，那么导出类也是抽象类，并且必须用abstract修饰。
  • 9.2 接口
    1. interface是一个完全抽象的类，只提供了形式，不会提供任何具体实现。
    2. 接口中的所有方法都是public的，实现接口的类中定义的相应方法也必须是public的；接口中的域都被隐式的定义成static和final的。
    3. 将一个导出类向上转型为普通类、抽象类或者是接口，都不会有问题。
  • 9.2 完全解耦
    1. 如果一个方法操作的是类（参数），那么只能使用这个类或者是子类。这样的设计耦合性比较高，例如两个基类，一个Processor，一个Filter，它们内部的方法都一样，但是如果某个方法操作的是Processor，就不能传递Filter的子类进去。
    2. 策略设计模式：方法包含所要执行的算法中固定不变的部分，而“策略”包含变化的部分。例如process(Processor p, Object s)，这里Processor就是一个策略。
    3. 适配器模式：适配器中的代码接受已有的接口，并产生所需要的接口（自己加代码）。

方法操作的是类：

class Processor{
	public String name(){
		return getClass().getSimpleName();
	}
	Object process(Object input){
		return input;
	}
}

class Upcase extends Processor{

	@Override
	public String process(Object input) {
		// TODO Auto-generated method stub
		return ((String)input).toUpperCase();
	}

	@Override
	public String name() {
		// TODO Auto-generated method stub
		return getClass().getSimpleName();
	}
	
}

class Downcase extends Processor{
	
	public String process(Object input){
		return ((String)input).toLowerCase();
	}
	
	public String name() {
		// TODO Auto-generated method stub
		return getClass().getSimpleName();
	}
}
class Filter{
	public String name(){
		return getClass().getSimpleName();
	}
	public Waveform process(Waveform input){
		return input;
	}
}

public class test{
	
	public static void process(Processor p, Object s){
		System.out.println("Using Processor " + p.name());
		System.out.println(p.process(s));
	}
	
	public static String string = "This is a test String";
	
	public static void main(String args[]){
	    //process(new Filter(), string)//No way
		process(new Upcase(), string);
		process(new Downcase(), string);
	}
}

方法操作的是接口：

interface AllInUse{
	String name();
	Object process(Object input);
}
class Upcase implements AllInUse{

	@Override
	public String process(Object input) {
		// TODO Auto-generated method stub
		return ((String)input).toUpperCase();
	}

	@Override
	public String name() {
		// TODO Auto-generated method stub
		return getClass().getSimpleName();
	}
	
}

class Downcase implements AllInUse{
	
	public String process(Object input){
		return ((String)input).toLowerCase();
	}
	
	public String name() {
		// TODO Auto-generated method stub
		return getClass().getSimpleName();
	}
}


/*--------------------------------------------------- */

class Waveform{
	private static long counter;
	private final long id = counter++;
	public String toString(){
		return "Waveform "+ id;
	}
}


class LowPass implements AllInUse{
	double cutoff;
	public LowPass(double cutoff){
		this.cutoff = cutoff;
	}
	public Waveform process(Object input){
		return (Waveform)input;
	}
	@Override
	public String name() {
		// TODO Auto-generated method stub
		return getClass().getSimpleName();
	}

}
class HighPass implements AllInUse{
	double cutoff;
	
	public HighPass(double cutoff){
		this.cutoff = cutoff;
	}
	
	public Waveform process(Object input){
		return (Waveform)input;
	}
	
	public String name() {
		// TODO Auto-generated method stub
		return getClass().getSimpleName();
	}
}

public class test{
	public static void process(AllInUse p, Object s){
		System.out.println("Using AllInUse " + p.name());
		System.out.println(p.process(s));
	}
	
	public static String string = "This is a test String";
	
	public static void main(String args[]){
		process(new HighPass(0.5), new Waveform());
		process(new LowPass(0.5), new Waveform());
		process(new LowPass(0.5), new Waveform());
		process(new Upcase(), string);
		process(new Downcase(), string);
	}

适配器：

class FilterAdapter implements AllInUse{
	
	AllInUse allInUse;
	
	public FilterAdapter(AllInUse allInUse) {
		// TODO Auto-generated constructor stub
		this.allInUse = allInUse;
	}

	@Override
	public String name() {
		// TODO Auto-generated method stub
		return allInUse.name();
	}

	@Override
	public Object process(Object input) {
		// TODO Auto-generated method stub
		return allInUse.process(input);
	}
	
}
  • 9.4 Java中的多重继承
    1. Java中只能继承一个类，但是可以实现多个接口，并且可以向上转型成每个接口，因为每个接口都是一个独立类型。
    2. 使用接口的核心原因：1.为了能够向上转型成多个基类型（以及由此而带来的灵活性）；2.防止客户端程序员创建该类的对象。
  • 9.5 通过继承来扩展接口
    1. 通过继承可以很容易的在接口添加新的方法声明，还可以通过继承在新的接口中组合多个接口（只允许用在接口继承中）。
interface a{
	void aPlay();
}
interface b extends a{
	void bPlay();
}

interface c extends a, b{
	void cPaly();
}

class interf implements c{

	@Override
	public void aPlay() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void bPlay() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void cPaly() {
		// TODO Auto-generated method stub
		
	}
	
}
  • 9.6 适配接口
    1. 接口最吸引人的原因之一就是允许同一个接口具有多个不同的具体实现。在简单的情况中，它的体现形式通常是一个接口接口类型的方法，而该接口的实现和向该方法传递的对象则取决于方法的使用者。（即前文中的策略模式）
  • 9.7 接口中的域
    1. 方法接口中的任何域都是自动是static和fianl的，在Java SE5前，这是产生C或C++中的enum具有相同效果的类型的唯一途径。
    2. 接口的域自动是public的。
    3. 在接口中定义的域不能是空final。
  • 9.8 嵌套接口
    1. 接口可以嵌套在类或者其他接口中。
    2. 在类中定义的接口可以试private类型的。
    3. 当实现某个接口时，并不需要实现嵌套在其内部的任何接口。
  • 9.9 接口与工厂
    1. 工厂方法设计模式：生成遵循某个接口的对象的典型方式，这与直接条用构造器不同，我们在工厂对象上调用的是创建方法，而该工厂对象将产生接口的某个实现的对象。
interface Service{
	void method1();
	void method2();
		
}
interface ServiceFactory{
	Service getService();
}

class class1 implements Service{
	@Override
	public void method1() {
		// TODO Auto-generated method stub
		System.out.println("class1 method1");
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		System.out.println("class1 method2");
	}
	
}

class factory1 implements ServiceFactory{

	public factory1() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public Service getService() {
		// TODO Auto-generated method stub
		return new class1();
	}
	
}

class class2 implements Service{

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		System.out.println("class2 method1");
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		System.out.println("class2 method2");
	}
	
}

class factory2 implements ServiceFactory{

	public factory2() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public Service getService() {
		// TODO Auto-generated method stub
		return new class2();
	}
	
}

public class test{
	public static void serviceConsumer(ServiceFactory factory){
		factory.getService().method1();
		factory.getService().method2();
	}
	public static void main(String args[]){
		serviceConsumer(new factory1());
		serviceConsumer(new factory2());
	}
}

原创声明

该日志由 flyzy小站 于2018年04月11日发表在《Java编程思想》笔记分类下，
转载请注明: 第9章 接口 | flyzy小站
weinxin
我的微信公众号
"flyzy小站"：关注VPS测评与优惠，玩机教程，技术分享，留言及时回复
点赞

相关文章