- 抽象类
- 抽象类的使用原则如下:
(1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public;
(2)抽象类不能直接实例化,需要依靠子类采用向上转型的方式处理;
(3)抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
(4)子类(如果不是抽象类)则必须覆写抽象类之中的全部抽象方法(如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。); - 抽象类的特点
- 抽象类依然有构造方法,用于其成员变量与成员方法的初始化
- 抽象类不能被abstract所修饰 , 因为冲突
- 外部抽象类不能被static修饰, 内部抽象类可以.
- 抽象类其他方面,与普通类一样. 静态成员变量也可以使用类名进行调用.
- 抽象类的应用 –模板设计模式 – 参考链接 : http://blog.csdn.net/wei_zhi/article/details/52736350
- 接口与抽象类或者普通类相比的优势 : 接口可以多实现, 更容易扩展. 接口内是由抽象方法组成,没有方法体,对外提供服务更加方便.. 而且更容易实现松耦合
- 抽象类的使用原则如下:
- 接口
- 组成
- 接口时由抽象方法与全局常量组成的特殊的类,连构造方法都没有.
- 使用原则
(1)接口必须要有子类,但此时一个子类可以使用implements关键字实现多个接口;
(2)接口的子类(如果不是抽象类),那么必须要覆写接口中的全部抽象方法;
(3)接口的对象可以利用子类对象的向上转型进行实例化。
(4) 接口中的访问权限只有一种:public
(5) 静态final成员变量和成员抽象方法的修饰词统统可以省略 - 继承关系
(1)一个抽象类只能继承一个抽象父类,而接口可以继承多个接口;
(2)一个子类只能继承一个抽象类,却可以实现多个接口(在Java中,接口的主要功能是解决单继承局限问题) - 利用接口对外提供规则.
- 自定义可供外使用的接口
如果要进行开发,要先开发出USB接口标准,然后设备厂商才可以设计出USB设备。
现在假设每一个USB设备只有两个功能:安装驱动程序、工作。
定义一个USB的标准:
- 自定义可供外使用的接口
- 组成
interface USB { // 操作标准
public void install() ;
public void work() ;
}
在电脑上应用此接口:
class Computer {
public void plugin(USB usb) {
usb.install() ;
usb.work() ;
}
}
然后接口实现者 可以根据自己的需要自定义接口实现.
- 完全解耦
1. 方法在指定接收参数为类时, 本质上已经限制了该方法接收的类只能是该类或者该类的子类. 反而如果接收参数是接口, 那么则不存在该限制. 具有良好的扩展性.
2. 情况
1.情况可控时
package org.interfaces;
import java.util.Arrays;
class Processor {
public String name() {
return getClass().getName();
}
Object process(Object input) {
return input;
}
}
class Upcase extends Processor{
String process(Object input){
return ((String)input).toUpperCase();
}
}
class Downcase extends Processor{
String process(Object input){
return ((String)input).toLowerCase();
}
}
class Splitter extends Processor{
String process(Object input){
return Arrays.toString(((String)input).split(" "));
}
}
// 多态,实现了代码的复用性. 但是在 Apply类中的通用处理器,只是针对Processor的通用处理器类,并不能实现扩展.
// 也就是说, Apply与Processor并没有实现真正的解耦
class Apply{
public static void process(Processor p,Object s){
System.out.println("Using Processor"+p.name());
System.out.println(p.process(s));
}
public static String s="this is a Sup--Sub Coupling";
public static void main(String[] args){
process(new Upcase(),s);
process(new Downcase(),s);
process(new Splitter(),s);
}
}
- 改进后
package org.interfaces.interfaceprocess;
// 接口处理器
public interface Processor {
String name();
Object process(Object input);
}
package org.interfaces.interfaceprocess;
public abstract class StringProcessor implements Processor{
@Override
public String name() {
return getClass().getName();
}
@Override
public abstract Object process(Object input);
}
class Upcase extends StringProcessor{
public String process(Object input) {
return "1";
}
}
class Downcase extends StringProcessor{
public String process(Object input) {
return "2";
}
}
class Splitter extends StringProcessor{
public String process(Object input) {
return "3";
}
}
// 此种, 以接口为参数,就可以实现更好的扩展.
// 同时, 其他各种具体扩展器实现继承接口的抽象子类, 既复用代码,又约定了规则.
class Apply {
public static void process(Processor p,Object s){
System.out.println("Using Processor"+p.name());
System.out.println(p.process(s));
}
public static String s="this is a Sup--Sub Coupling";
public static void main(String[] args){
process(new Upcase(),s);
process(new Downcase(),s);
process(new Splitter(),s);
}
}
- 适配器模式实现完全解耦 ->
- 改造前
package org.interfaces.filter;
// 波形 ->处理对象
public class Waveform {
private static long counter; //计数
private final long id = counter++; //ID
public String toString() {return "Waveform:" +id;}
}
// 过滤器基类
public class Filter {
public String name() {
return getClass().getName();
}
}
// 过滤器实现
public class LowPass extends Filter{
double cutoff; //截止值
public LowPass(double cutoff) {
this.cutoff = cutoff;
}
// 这种方式只针对Waveform类, 依赖性太强. 毫无扩展性
public Waveform process(Waveform input) {
return input;
}
}
public class HighPass extends Filter{
double cutoff; //截止值
public HighPass(double cutoff) {
this.cutoff = cutoff;
}
public Waveform process(Waveform input) {
return input;
}
}
public class BandPass extends Filter{
double lowcutoff,highcutoff; // 底截止, 高截止
public BandPass(double lowcutoff, double highcutoff) {
super();
this.lowcutoff = lowcutoff;
this.highcutoff = highcutoff;
}
public Waveform process(Waveform input) {
return input;
}
}
// 此代码复用性极差, 只对一种对象做处理. 而且假设该对象是别人提供代码, 不能修改或者修改会引发隐患.
// 改造后
上方代码不变
增加了一个适配器,如下代码所示
package org.interfaces.filter.adaper;
import org.interfaces.filter.Filter;
import org.interfaces.filter.Waveform;
import org.interfaces.interfaceprocess.Processor;
// 适配器 -> 对过滤器进行包装
// 所以,要有被包装的对象.->其基类即可
// processor -> 通用的实现可扩展的过滤器类
// 通过适配器包装其他不通用的过滤器,其实内部还是调用了该过滤器的具体方法.从而实现了过滤器的完全耦合.
public class FilterAdapter implements Processor{
Filter filter;
public FilterAdapter(Filter filter) {
// 传进来过滤器,对其进行包装
this.filter = filter;
}
@Override
public String name() {
return filter.name();
}
// 利用协变返回方式 窄化返回值
@Override
public Waveform process(Object input) {
return filter.process((Waveform)input);
}
}
// 接口的完全解耦经验总结 : 为实现可扩展,定义为以接口为参数的方式.
- Java的多重继承
- 多重继承指的是接口的多重继承. 对于普通类或者抽象类,Java只能单继承.
- 项目在其包时,不得携带Java关键字或敏感子. 如Java
- Java多重继承实现更好扩展性的实例
package think;
/**
* @Description TODO
* @author Cai
* @date 2018年1月19日 上午9:31:51
* @version V1.0
*/
public interface CanFly{
void fly();
}
interface CanSwim{
void swim();
}
interface CanSing{
void sing();
}
class Hero implements CanFly,CanSing,CanSwim {
@Override
public void swim() {
System.out.println("swim");
}
@Override
public void sing() {
System.out.println("sing");
}
@Override
public void fly() {
System.out.println("fly");
}
}
class DiaoYong {
/*public static void swim(Filter filter) {
// 此种方式,需要向下转型,不易于扩展,
}*/
public static void swim(CanSwim swim) {
swim.swim();
}
public static void sing(CanSing sing) {
sing.sing();
}
public static void fly(CanFly fly) {
fly.fly();
}
public static void main(String[] args) {
Hero hero = new Hero();
swim(hero);
}
}
// 注释: 每个接口都去实现一个空的接口, 用以增强代码的复用性. 因为超类作为参数,Java有一种参数绑定机制,前期绑定与后期绑定. 其会自动定位到其引用的子类并调用其子类的重写的方法.
// 2. 如果需要对该接口进行扩展,不建议对该接口进行增加方法,因为可能对其已经使用的子类产生印象. 只需重新创建一个接口,对该接口进行实现然后进行开发即可.
- 继承的缺点
- 如果父类有私有的成员变量, 那么其子类不能继承, 且不能重写该方法.
- 关于类的域的问题(域,即是成员变量)
- 如果基类与其子类有同样的公有的成员变量. 会出现如下的情况
public class Father {
String id = "father";
public String getId() {
return id;
}
public static void main(String[] args) {
Father father = new son();
System.out.println("father.id="+father.id+";getId="+father.getId());
son son = new son();
System.out.println("son.id="+son.id+";getId="+son.getId());
System.out.println("getSuperId="+son.getSuperId());
}
}
class son extends Father {
String id = "son";
public String getId() {return id;}
public String getSuperId() {return super.id;}
}
运行结果
father.id=father;getId=son
son.id=son;getId=son
getSuperId=father
// 总结:
1. 由于域不是多态. 所以,如果是父类引用, 则如果访问该变量, 则访问的域是父类变量. 如果创建的是子类引用, 访问域, 则访问的是子类的变量
2. 由于方法时多态的. 所以, 访问的终究是子类的方法.
- 接口与工厂模式
// 工厂模式
interface ServiceFactory{
Service getService();
}
class Implemention1Factory implements ServiceFactory {
public Service getService() {
return new Implemention1();
}
}
class Implemention2Factory implements ServiceFactory {
public Service getService() {
return new Implemention2();
}
}
interface Service {
void method1();
void method2();
}
// 实现服务
class Implemention1 implements Service {
public void method1() {
System.out.println("Implemention1.method1");
}
public void method2() {
System.out.println("Implemention1.method2");
}
}
class Implemention2 implements Service {
public void method1() {
System.out.println("Implemention2.method1");
}
public void method2() {
System.out.println("Implemention2.method2");
}
}
public class Factories {
// 工厂模式.
// 通过具体服务实现继承该模块实现服务接口. 便于定义规则统一管理.且易于扩展
// 调用该工厂
// 服务消费端口.接收工厂
// 此模式有一个弊端. 那就是每次出现一个新的工厂需求.就需要添加一个新的工厂与工厂实现.
public static void serviceConsumer(ServiceFactory fact) {
Service service = fact.getService();
service.method1();
service.method2();
// 对于方法内部实现,并不清楚. 实现了服务与实现的完全分离.
}
public static void main(String[] args) {
serviceConsumer(new Implemention1Factory());
serviceConsumer(new Implemention2Factory());
}
}