



















































简单总结,需要重写的有:
普通类继承抽象类,重写所有抽象类方法;(不包括普通方法)
普通类继承接口,重写所有接口方法。(不包括default关键字修饰的方法)
详解见下:
1. 普通类继承,并非一定要重写父类方法。
2. 抽象类继承,如果子类也是一个抽象类,并不要求一定重写父类方法。如果子类不是抽象类,则要求子类一定要实现父类中的抽象方法。
3. 接口类继承。如果是一个子接口,可以扩展父接口的方法;如果是一个子抽象类,可以部分或全部实现父接口的方法;如果子类不是抽象类,则要求子类一定要实现父接口中定义的所有方法。
不一定,关键要看子类是否是抽象类。
如果子类是非抽象类,则必须实现接口中的所有方法;
如果子类是抽象类,则可以不实现接口中的所有方法,因为抽象类中允许有抽象方法的存在!
1、抽象类定义
抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。通常在编程语句中用 abstract 修饰的类是抽象类。在C++中,含有纯虚拟函数的类称为抽象类,它不能生成对象;在java中,含有抽象方法的类称为抽象类,同样不能生成对象。抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。
2、抽象类特点
1)抽象类不能实例化。
2)抽象类可以包含抽象方法和抽象访问器。
3)不能用 sealed 修饰符修饰抽象类,因为这两个修饰符的含义是相反的。 采用 sealed 修饰符的类无法继承,而 abstract 修饰符要求对类进行继承。
4)从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。
3、与具体类的比较
1)抽象类不能直接实例化,并且对抽象类使用 new 运算符会导致编译时错误。虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为 null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)。
2)允许(但不要求)抽象类包含抽象成员。
3)抽象类不能被密封。
4、与接口的比较
1)相同点
a、不能实例化;
b、包含未实现的方法声明;
c、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员)
2)不同点
a、类可以实现无限个接口,但仅能从一个抽象(或任何其他类型)类继承,从抽象类派生的类仍可实现接口,从而得出接口是用来解决多重继承问题的。
b、抽象类当中可以存在非抽象的方法,可接口不能,且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。
c、抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量默认的都是静态常量(static final)。
d、抽象类是对象的抽象,然而接口是一种行为规范。
------------------------------------------------------
上面是转载的,下面是自己的补充哈~
首先创建接口ClassA,创建抽象类ClassB,创建类ClassC,
关系:ClassA是基类接口,ClassB实现了ClassA,ClassC继承了ClassB
public interface ClassA { void a(); void aa(); }
public abstract class ClassB implements ClassA{ @Override public void a() { Log.d("chenhua","我是B,实现了A中的a方法"); } @Override public void aa() { Log.d("chenhua","我是B,实现了A中的aa方法"); } }
public class ClassC extends ClassB { }
在activity中编写:
ClassA classA = new ClassC(); classA.a(); classA.aa();
得到输出:
CassB实现了ClassA,对于抽象类实现接口类,不一定要重写他的全部方法,但是!!但是如果一个类继承了抽象类,比如ClassC继承了ClassB,那么ClassC必须重写ClassB中没有重写的ClassA的方法!这句好好理解下哦~
看图示意:ClassA不变,ClassB不实现aa方法
public abstract class ClassB implements ClassA{ @Override public void a() { Log.d("chenhua","我是B,实现了A中的a方法"); } }
那么在ClassC中报红
提示说,ClassC要么声明成抽象类,要么就实现aa()方法!
首先要知道,一个类必须继承接口中的所有方法吗
答案是:不一定的。如果子类是非抽象类,则必须实现接口中的所有方法,因为非抽象函把抽象方法继承过来了 这肯定是不规范的;
如果子类是抽象类,则可以不实现接口中的所有方法,因为抽象类中允许有抽象方法的存在!我们再回过头看这个错误,大概就能恍然大悟了,首先你这个类是非抽象的,你还没把接口的方法全部重写。
如果你知道上面那个知识点的话,还出现这个错误,大概率是向我一样把函数名写错了(笑
大话设计模式第一章之:工厂模式客套话:程序能运行不一定是最优的。可维护,可扩展,可复用,灵活性好,避免重复(可以多一个环节来排除重复)业务逻辑与界面逻辑的分开类与对象抽象类,虚方法实现不同功能如调用不同功能,要使用不同类吗,只要使用一个基类,用swicth判断要使用什么功能,然后用子类初始化基类,就可以了。一个最基础的类,继承会让所有的子类都拥有某种特性,为了实现一些可有可无的特性,可以使用接口。原则:尽可能的避免重复只有分离才可以更好的维护和复用。要复用,不复制要松耦合不要紧耦合UML图:单向关联用箭头,双向不用。+public-private#protected直线加空白三角形:继承了,箭头指向为被继承的虚线加空白三角形:实现了,箭头指向为被实现的箭头:某个类实现某个类,类含有某个类空菱形加箭头:聚合,包含,反过来不成,不是整体的部分,及可有可无实体菱形加箭头:合成,包含,整体的部分,不可分离,不能没有,两端会有数字,如一只鸟有2个翅膀虚线箭头:依赖,人要依赖空气等大话设计模式第二章之:策略模式算法之间可以互相调用策略模式就是用来封装算法的。大话设计模式第三章之:单一职责原则单一职责原则:就一个类而言,应该仅有一个引起它变化的原因类承担的职责不能过多,因为有时,完成一个职责,会影响到其他职责的,手机只用来接电话,相机只用来拍照,功能才强大,集成太多了,其他功能就弱化了。对应一些问题,要方法化,要类分离化大话设计模式第四章之:开放-封闭原则开放-封闭原则:是说软件实体(类、模块、函数等等)应该可以扩展,但是不可修改。OCP扩展是开放的,修改是封闭的。软件要容易维护,不容易出问题,就是要多扩展,少修改。要做到,面对需求是,对程序的改动是通过增加新代码,而不是修改原有的代码大话设计模式第五章之:依赖倒转原则依赖倒转原则:1、高层模块不应该依赖低层模块,两个都依赖于抽象2、抽象不应该依赖细节,细节应该依赖抽像李氏代换原则:子类型必须能够替换掉它们的父类型,参数为父类,子类就可以传入替代。所有的依赖关系都是取决于接口和抽象类。大话设计模式第六章之:装饰者模式继承之间可能没有多大关系。如饮料和调味料,人和服饰。大话设计模式第七章之:代理模式代理模式:为其他对象提供一种代理,以控制对这个对象的访问模版代码abstract class Subject{public abstract void Request();}class RealSubject extends Subject{public void Request(){System.out.println("真实的请求");}}class Proxy extends Subject{RealSubject realSubject;public void Request(){if (realSubject == null){realSubject = new RealSubject();}realSubject.Request();}}static void Main(String args[]){Proxy proxy = new Proxy();proxy.Request();}远程代理:也就是为了一个对象在不同的地址空间提供局部代表,这样可以隐藏一个对象存在于不同地址空间的事实虚拟代理:根据需要创建开销很大的对象,通过它来存放实例化需要很长时间的真实对象。安全代理:用来控制真实对象访问时的权限智能指引:是指当调用真实对象时,对象处理另外一些事。大话设计模式第八章之:工厂方法模式工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。简单工厂模式:最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了具体产品的依赖。工厂方法模式实现时,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行,你想要加功能,本来是修改工厂类,现在是修改客户端。大话设计模式第九章之:原型模式原型模式:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。其实就是从一个对象再创建另外一个可定制的对象,而且不需要知道任何创建的细节。优点:一般在初始化的信息不发生变化的情况下,克隆是最好的办法,这既隐藏了对象创建的细节,又对性能是大大的提高。不用重新初始化对象,而是动态的获取对象运行时的状态。浅复制:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用都仍然指向原来的对象。深复制:深复制把引用对象的变量指向复制过的新对象,而不是原有的被引用的对象。// 原型类abstractclass Prototype{private String id;public Prototype(String id){this.id = id;}public String getId(){return id;}public abstract Prototype clone();}// 具体原型类class ConcretePrototype1 extends Prototype{public ConcretePrototype1(String id){super(id);}@Overridepublic Prototype clone(){return (Prototype)this;}}// 客户端staticvoid main(String args[]){ConcretePrototype1 p1 = new ConcretePrototype1("I");ConcretePrototype1 c1 = (ConcretePrototype1)p1.clone();}大话设计模式第十章之:模版方法模式用继承,并且肯定这个继承有意义,就应该要成为子类的模版,所有重复的代码都应该要上升到父类去,而不是让每个子类都去重复。使用场合:我们要完成在某一细节层次一致的过程或一系列步骤,但个别步骤在更详细的层次上的实现可能不同时,我们通常考虑用模版方法模式处理。我们遇到由一系列步骤构成的过程需要执行,这个过程从高层次上看是相同的,但有些步骤的实现可能不同。模版方法模式:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,模版方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。AbstractClass是抽象类,定义并实现一个模版方法,这个模版方法一般是一个具体方法,它给出了一个顶级逻辑骨架。而逻辑的组成步骤在相应的抽象方法中,推迟到子类实现。顶级逻辑也可能调用一些具体的方法。特征:通过把不变行为搬到超类。去除子类中的重复代码。// 模版代码publicclass Client{//public static void main(String[] args){AbstractClass c;c = new ConcreteClassA();c.templateMethod();c = new ConcreteClassB();c.templateMethod();}}// 抽象模版类abstractclass AbstractClass{public abstract void primitiveOperation1();public abstract void primitiveOperation2();public void templateMethod(){primitiveOperation1();primitiveOperation2();System.out.println("");}}// 具体类实现class ConcreteClassA extends AbstractClass{@Overridepublic void primitiveOperation1(){System.out.println("具体类A方法1实现");}@Overridepublic void primitiveOperation2(){System.out.println("具体类A方法2实现");}}// 具体类实现class ConcreteClassB extends AbstractClass{@Overridepublic void primitiveOperation1(){System.out.println("具体类B方法1实现");}@Overridepublic void primitiveOperation2(){System.out.println("具体类B方法2实现");}}大话设计模式第十一章之:迪米特法则迪米特法则:如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某个方法的话,。可通过第三者转发这个调用。根本思想:强调类之间的松耦合,类之间的耦合越弱,越有利复用,一个类的修改不会波及其他类。大话设计模式第十二章之:外观模式外观模式:为子系统中的一组接口提供一个一致的界面,此模式定义一个高层接口,这个接口使得这一子系统更加容易使用。使用场合:大话设计模式第十三章之:建造者模式建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。使用场合:当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时使用。大话设计模式第十四章之:观测者模式观察者模式:定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,这个主题对象在状态发生变化时,会通知所有观察者对象。使它们能够自动更新自己。实际工作:解除耦合,让耦合的双方都依赖于抽象,而不是依赖于具体,从而使得各自的变化不会影响另一边的变化缺点:方法名必须一样,java中也许有一种EventHandler处理机制,批量调用函数。就是委托,可以看作是对函数的抽象,不过搭载的方法必须必须同参数列表,同返回值,可以不同名。大话设计模式第十五章之:抽象工厂模式提供一个创建一系列相关或互相依赖对象的接口,无需指定它们具体的类。优点:便于交换产品系列让具体的创建实例过程与客户端分离,客户端是通过他们的抽象接口操作实例,产品的具体类名也被具体工厂的实现分离。大话设计模式第十六章之:状态模式状态模式:当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类。解决问题:当控制一个对象状态转换的条件表达式过于复杂时的情况,把状态的判断逻辑转移到表示不同状态的一系列类当中。可以把复杂的判断逻辑简化。使用场合:将特定的状态相关的行为都放入一个对象中,由于所有与状态大话设计模式第十七章之:适配器模式适配器模式:将一个类的接口转换成客户希望的另外一个接口,Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。使用场合:系统的数据和行为都正确,但接口不符时,我们应该考虑用适配器,目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类,但是接口又与复用环境要求不一致的情况。使用一个已经存在的类,如果它的接口,也就是它的方法和你的要求不相同时。两个类所做的事情相同或相似,但是具有不同的接口时要使用它,大话设计模式第十八章之:备忘录模式备忘录模式:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象恢复到原先保存的状态。适用场合:Memento模式适用于功能比较复杂的,但需要维护或记录属性历史的类,或者需要保存的属性是众多属性中的小部分时,Originator可以根据保存的Memento信息还原到前一状态。自己的理解:备忘录模式,就是一个被保存的对象,这个对象由很多参数描述,如Originator,它可以恢复自己的状态,改变自己的状态。这些状态参数由独立出来的Memento描述,Caretaker管理者才是拥有保存了数据的幕后者,Originator要恢复数据,要通过Caretaker内保存的Memento来恢复。其实有时由于要保存的状态有多种,这时就可以抽象出Memento抽象类来,根据实际继承Memento。大话设计模式第十九章之:组合模式组合模式:将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。组合对象也可以被组合,树叶和非树叶大话设计模式第二十章之:迭代器模式迭代器模式:提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示。就是分离了集合对象的遍历行为,抽象出一个迭代器类来负责适用场合:当你需要访问一个聚集对象,而且不管这些对象是什么都需要遍历是,遍历方式不同。大话设计模式第二十一章之:单例模式单例模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个最好的办法就是,让类自身负责保存它的唯一实例,这个类可以保证没有可以被创建,并且它可以提供一个访问该实例的方法。将构造函数声明为private,通过其他内部方法,调用它,返回new的类对象,不过要先判断是否类为空。// 防止派生publicfinalclass Singleton{private static Singleton instance;private static Object object = new Object();private Singleton(){}public static Singleton getInstance(){// 单锁// synchronized (object)// {// if (instance == null)// {// instance = new Singleton();// }// }if (instance == null){synchronized (object){if (instance == null){instance = new Singleton();}}}return instance;}}publicclass Client{public static void main(String[] args){Singleton s1 = Singleton.getInstance();Singleton s2 = Singleton.getInstance();if (s1 == s2){System.out.println("两个对象相同");}}}大话设计模式第二十二章之:桥接模式桥接模式:将抽象部分与它的实现部分分离,使它们都可以独立地变化。像手机的,实现方式多种,桥接模式就可以把这些实现独立出来,让它们各自地变化,不影响其他变化。合成/聚合复用原则:尽量使用合成/聚合,尽量不要使用类继承。聚合表示一种弱拥有关系,合成表示强拥有关系,体现了严格的部分和整体关系。大话设计模式第二十三章之:命令模式命令模式:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。执行与请求分离大话设计模式第二十四章之:职责链模式职责链模式:使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。优点:当客户提交一个请求时,请求是沿链传递直至一个ConcreteHandler对象负责处理它为止。实现:处理者,继承统一的处理接口,然后继承者又持有下一个处理者的变量,无法处理就交给下一个处理者。大话设计模式第二十五章之:中介模式降低了colleague之间的耦合大话设计模式第二十六章之:享元模式享元模式:运用共享技术有效地支持大量细粒度的对象。对象太多时,找出对象相同的为内部,不同的为外部。减少对象的实例。大话设计模式第二十七章之:解释器模式解释器模式:给定一个语言,定义他的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。大话设计模式第二十八章之:访问者模式转载于:https://www.cnblogs.com/itc0z0sti/p/3309584.html