一、抽象类
1、抽象方法
抽象方法只有声明，而没有具体的实现。也就是说没有{}。
抽象方法的声明格式为：abstract void 方法名();
2、抽象类
包含一个抽象方法的类就是抽象类 使用abstract类就是抽象类
3、特点
1.抽象类与抽象方法必须使用abstract修饰
2.抽象类不允许创建对象
3.抽象类总可以有抽象方法也可以没有抽象方法.如果抽象类中有带主体方法子类继承也可以直直接用
4.抽象类的子类使用
a.继承抽象类,重写抽象方法
b.抽象类的子类也可是抽象类
4.格式
public abstract class People { //关键词abstract，声明该类为抽象类
public int age;
public void Num() {
}
public abstract Name(); //声明该方法为抽象方法
}
注意:
abstract不能与final并列修饰同一个类
abstract 不能与private、static、final或native并列修饰同一个方法。
5.使用
在下面这个例子中，把打印机类封装成抽象类，把print定义成抽象类，当HPPrinter和CannonPrinter要继承printer类的时候，必须重写print函数。这样写的好处是，每个打印机都有自己打印方式，此举可以防止子类没有写明打印方式。
public abstract void Printer() {
public void open() {
system.out.print("打印机开启");
}
public void close() {
system.out.print("打印机关闭");
}
abstract void print(); //把print方法定义为抽象方法
}
public HPPrinter extends Printer {
void print(){ //必须重写抽象方法print()
system.out.print("惠普打印机开始打印");
};
}
public CanonPrinter extends Printer {
void print(){ //必须重写抽象方法print()
system.out.print("佳能打印机开始打印");
};
}
接口
接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法组成
1.格式
public interface interface 接口名称{
全局常量
抽象方法
}
2.特点
1.使用关键字interface
2.接口的实现也必须通过子类，使用关键字implements，而且接口是可以多实现的
class A implements Inter1,Inter2{ //Inter1和Inter2是接口
...
}
3.一个类可以同时继承抽象类和接口
class A extends Abs implements Inter1,Inter2{ //Abs是一个抽象类
...
}
4.一个接口不能继承普通的类，但可以通过extends关键字继承多个接口，实现接口的多继承
interface Inter extends Inter1,Inter2{ //Inter、Inter1、Inter2都为接口
...
}
5.接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误）
6.无构造方法
抽象类和接口的区别
一、语义层次
public abstract class People { //关键词abstract，声明该类为抽象类
void Num();
abstract void Name(); //声明该方法为抽象方法
}
Interface Person {
void Num();
void Name();
}
一、抽象类方式中，抽象类可以拥有任意范围的成员数据，同时也可以拥有自己的非抽象方法，但是接口方式中，它仅能够有静态、不能修改的成员数据（但是我们一般是不会在接口中使用成员数据），同时它所有的方法都必须是抽象的。
二、在某种程度上来说，接口是抽象类的特殊化。
三、对子类而言，它只能继承一个抽象类（这是java为了数据安全而考虑的），但是却可以实现多个接口。
二、设计层次
1、 抽象层次不同
抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
2、 跨域不同
抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机可以实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a" 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。
3、 设计层次不同
对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。
实例:
现在有个鸟类，鸟的属性有种类，颜色，重量等，鸟的行为有吃，飞。但是有的鸟类只会奔跑不会飞(鸵鸟)。这时如果我们在一个Birds类中去定义飞和奔跑的行为，分别让只会飞的鸟和只会奔跑的鸟都去继承这个类，好像有些不太妥当。我们可以这样解决：定义一个抽象类，属性包括种类、颜色、重量，行为包括吃。在定义一个Fly接口，包含一个方法fly()。在定义一个Run接口，包含一个run()方法。如果只是会飞的鸟我们就继承Birds类，实现Fly接口。如果只是会奔跑的鸟我们就实现Birds类，实现Run接口。如果继承Birds类，实现了Fly和Run接口，那就是又会飞又会奔跑的鸟。实现代码如下：
定义鸟的抽象类其中用3个成员变量一个eat的抽象方法,一个print方法
public abstract class Birds {
private String type;
private String color;
private double weight;public Birds(String type, String color, double weight){
this.setType(type);
this.setColor(color);
this.setWeight(weight);
}public abstract void eat();
public void print(){
System.out.println("种类："+this.getType());
System.out.println("颜色："+this.getColor());
System.out.println("重量:"+this.getWeight());
}public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
}
定义飞的接口
public interface Fly {
void fly();
}
定义跑的接口
public interface Run {
void run();
}
/**
* 蜂鸟 继承抽象类,实现Fly的接口
*/
public class HummingBird extends Birds implements Fly {
public HummingBird(String type, String color, double weight){
super(type, color, weight);
}@Override
public void fly() {
//实现飞接口中的方法
System.out.println("我是"+this.getType()+",我会fly。");
}@Override
public void eat() {
//实现抽象类中的抽象方法
System.out.print("我是"+this.getType()+",我吃花蜜。");
}
}
/**
* 鸵鸟
*/public class OstrichBirds extends Birds implements Run {
public OstrichBirds(String type, String color, double weight) {
super(type, color, weight);
}@Override
public void run() {
System.out.println("我是"+this.getType()+",我会奔跑。");
}@Override
public void eat() {
System.out.println("我是"+this.getType()+",我吃草。");
}
}
public class Test {
public static void main(String [] args){
//蜂鸟
Birds hummingBirds =new HummingBird("蜂鸟", "彩虹色", 2.3);
hummingBirds.print();
hummingBirds.eat();
Fly f = (Fly) hummingBirds;
f.fly();//鸵鸟
OstrichBirds ostrichBirds =new OstrichBirds("鸵鸟", "灰色", 200.2);
ostrichBirds.print();
ostrichBirds.eat();
ostrichBirds.run();System.out.println("是否会飞=>"+(hummingBirds instanceof Fly));
}
}
