*/
.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
color: #333;
background: #f8f8f8;
}
.hljs-comment,
.hljs-template_comment,
.diff .hljs-header,
.hljs-javadoc {
color: #998;
font-style: italic;
}
.hljs-keyword,
.css .rule .hljs-keyword,
.hljs-winutils,
.javascript .hljs-title,
.nginx .hljs-title,
.hljs-subst,
.hljs-request,
.hljs-status {
color: #333;
font-weight: bold;
}
.hljs-number,
.hljs-hexcolor,
.ruby .hljs-constant {
color: #099;
}
.hljs-string,
.hljs-tag .hljs-value,
.hljs-phpdoc,
.tex .hljs-formula {
color: #d14;
}
.hljs-title,
.hljs-id,
.coffeescript .hljs-params,
.scss .hljs-preprocessor {
color: #900;
font-weight: bold;
}
.javascript .hljs-title,
.lisp .hljs-title,
.clojure .hljs-title,
.hljs-subst {
font-weight: normal;
}
.hljs-class .hljs-title,
.haskell .hljs-type,
.vhdl .hljs-literal,
.tex .hljs-command {
color: #458;
font-weight: bold;
}
.hljs-tag,
.hljs-tag .hljs-title,
.hljs-rules .hljs-property,
.django .hljs-tag .hljs-keyword {
color: #000080;
font-weight: normal;
}
.hljs-attribute,
.hljs-variable,
.lisp .hljs-body {
color: #008080;
}
.hljs-regexp {
color: #009926;
}
.hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.lisp .hljs-keyword,
.tex .hljs-special,
.hljs-prompt {
color: #990073;
}
.hljs-built_in,
.lisp .hljs-title,
.clojure .hljs-built_in {
color: #0086b3;
}
.hljs-preprocessor,
.hljs-pragma,
.hljs-pi,
.hljs-doctype,
.hljs-shebang,
.hljs-cdata {
color: #999;
font-weight: bold;
}
.hljs-deletion {
background: #fdd;
}
.hljs-addition {
background: #dfd;
}
.diff .hljs-change {
background: #0086b3;
}
.hljs-chunk {
color: #aaa;
}
#container {
padding: 15px;
}
pre {
border: 1px solid #ccc;
border-radius: 4px;
display: block;
background-color: #f8f8f8;
}
pre code {
white-space: pre-wrap;
}
.hljs,
code {
font-family: Monaco, Menlo, Consolas, ‘Courier New‘, monospace;
}
:not(pre) > code {
padding: 2px 4px;
font-size: 90%;
color: #c7254e;
background-color: #f9f2f4;
white-space: nowrap;
border-radius: 4px;
}
-->
抽象类(abstract)
- 使用abstract关键字来修饰的类是抽象类。使用abstract修饰方法时这个方法称为抽象方法。
- 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
- 抽象类不能被实例化，即不能new该类对象。因为抽象类是比较抽象的类，是残缺不全的类。
- 抽象方法只需定义它的结构，不需写方法体。因为抽象方法最终都要被子类重写，即使定义抽象方法也是多余的。
- 抽象类中并非一定要包含抽象方法，也并非不能包含普通方法。
以下面多态的示例来说明：
class Animal {
private String name;
Animal(String name) {this.name = name;}
public void sing(){System.out.println("animal sing...");} //这是多余的方法
}
class Cat extends Animal {
private String eyeColor;
Cat(String n,String c) {super(n); eyeColor = c;}
public void sing() {System.out.println("cat sing...");}
}
class Dog extends Animal {
private String furColor;
Dog(String n,String c) {super(n); furColor = c;}
public void sing() {System.out.println("dog sing...");}
}
class Lady {
private String name;
private Animal pet;
Lady(String name,Animal pet) {this.name = name; this.pet = pet;}
public void myPetSing(){pet.sing();}
}
public class DuoTai {
public static void main(String args[]){
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname","black");
Lady l1 = new Lady("l1",c);
Lady l2 = new Lady("l2",d);
l1.myPetSing();
l2.myPetSing();
}
}
父类Animal中的sing()方法迟早要被子类Cat、Dog重写，而且在多态实现下，Animal的sing()完全是多余的。因此，可以将Animal的sing()方法的方法体删掉。
class Animal {
private String name;
Animal(String name) {this.name = name;}
public void sing() {}
}
更彻底一点，将sing()方法加上abstract关键字，这个方法变为抽象方法，抽象方法是不完整的方法，它必须被子类重写。抽象方法所在的类也必须加上abstract关键字变成抽象类。成了抽象类后这个类也是不完整的类，所以无法实例化new Animal。
abstract class Animal {
private String name;
Animal(String name) {this.name = name;}
public abstract void sing();
}
虽然Animal中的sing()用不上了，但它却必须要定义出来，因为它要被子类重写。另外，如果子类不想重写抽象方法，可以将这个子类也定义为抽象类，并让子子类去重写。
接口(interface)
接口定义的是一种具有某种能力的标准，通过接口实现的方式来体现如何具有该这些能力。说白了它就是能实现某些能力的标准。
例如定义一个USB接口的标准，各厂商如何去实现这个标准由各厂商自己去决定，但不管如何，各厂商实现的USB接口必须达到标准所要求具有的能力。
放在编程语言中来说，接口是一种特殊的抽象类，里面的方法必须全部是抽象方法且都是public的，里面的变量也必须都是"public static final"属性的。即使不写这些修饰关键字，默认也是这些属性，但如果写了，就绝对不能写错。
定义接口的方式是使用interface关键字替代class关键字。例如以下定义一个Singable接口，要求必须有喉咙，且能唱歌，能临时停止唱歌。
interface Singable {
public static final boolean houlong = true;
public void sing();
public void tmpStop();
}
既然接口是一种抽象类，那么就可以被继承，且里面的方法必须要重写以体现各子类独有的能力。通常接口都被命名为"XXXable"，因为接口一般体现的是具有某种能力。
继承接口这个特殊类的术语是"实现接口"，使用implement关键字。某个类可以实现多个接口，也就是"多重继承"。不仅如此，实现接口的同时还可以实现extends继承其他类。有以下几种写法：
class A implement intf1 {}
class A implement intf1,intf2 {}
class A extends ParentClass implement intf1,intf2 {}
以下是一个示例，定义了Singable和Paintable两个接口，还定义了两个实现这两接口的类Student和Teacher，它们分别有各自的方法study()和teach()。
interface Singable {
public void sing();
}
interface Paintable {
public void paint();
}
class Student implements Singable {
private String name;
Student(String name) {this.name = name;}
public void study() {System.out.println("Student studing...");}
// overwrite methods
public void sing() {System.out.println("Student singing...");}
}
class Teacher implements Singable,Paintable {
private String name;
Teacher(String name) {this.name = name;}
public void teach() {System.out.println("Teacher teaching...");}
// overwrite methods
public void sing() {System.out.println("Teacher singing...");}
public void paint() {System.out.println("Teacher painting...");}
}
public class Interface {
public static void main(String[] args) {
Singable s1 = new Student("Malongshuai");
s1.sing();
//s1.study(); //return error! because s1 upcasting from Student to Singable
Student s = (Student)s1;
s.study(); //return true
Singable t1 = new Teacher("Gaoxiaofang");
t1.sing();
//t1.paint(); //return error! t1 upcasting from Teacher to Singable,not Paintable
Paintable t = (Paintable)t1;
t.paint();
}
}
上面的示例中，Student类实现了Singable接口，所以它重写了sing()，Teacher类实现了Singable接口和Paintable接口，所以它重写了sing()和paint()。
需要注意的点在于接口和实现接口的类之间具有多态性。正如上面的Singable t1 = new Teacher("Gaoxiaofang");，此时t1虽然引用的是Teacher对象，但它能识别的数据只有Singable接口的成员sing()，而无法识别Teacher自身的方法teach()和Paintable接口的方法paint()，且因为子类Teacher重写了Singable中的sing()，所以多态性使得t1.sing()调用的是Teacher重写后的sing()。要访问paint()，需要将t1转型为Paintable类型或者Teacher类型，要访问teach()，就必须转型为Teacher类型。
注：若您觉得这篇文章还不错请点击右下角推荐，您的支持能激发作者更大的写作热情，非常感谢！
原文地址：https://www.cnblogs.com/f-ck-need-u/p/8127993.html