抽象类
抽象类：如果一个类含有抽象方法，则这个类为抽象类，用关键字abstract声明，并且一定要写，不可省略。
抽象方法：只有声明而没有实现的方法为抽象方法，用abstract声明，不可省略。
public abstract class Animal {
String color;
double weight;
public Animal(String color, double weight) {
super();
this.color = color;
this.weight = weight;
}
public abstract void cry();
public void display(){
System.out.println("颜色是："+color+"体重是："+weight);
}
}
此处cry()为抽象方法， Animal为抽象类。
抽象类的使用规则：
- 抽象类与抽象方法必须都用abstract关键字声明，不可省略。
- 抽象方法只有方法的声明而没有方法的实现。
- 抽象方法必须为public或protected，不能为private，否则不能被子类继承，实现不了该方法。
- 抽象类不能实例化，它的子类必须重写抽象类中的全部抽象方法。
- 抽象类中可以定义抽象方法也可以定义普通方法，但普通类中只能定义普通方法。
- 抽象类不能用final修饰，因为被final修饰的类不能被继承。
- 允许在抽象类中定义构造方法，也可以在子类中用super调用父类的构造方法。
- 抽象类使用的时候一定要有子类，子类用extends关键字来继承，一个类不能同时继承多个抽象类。
下面给出一个例子
//抽象类Animal
public abstract class Animal {
String color;
double weight;
public Animal(String color, double weight) {
super();
this.color = color;
this.weight = weight;
}
public abstract void cry();
public void display(){
System.out.println("颜色是："+color+"体重是："+weight);
}
}
//子类Cat
public class Cat extends Animal{
public Cat(String color, double weight) {
super(color, weight);
}
public void cry(){
System.out.println("喵喵喵");
}
}
//子类Dog
public class Dog extends Animal {
public Dog(String color, double weight) {
super(color, weight);
}
@Override
public void cry() {
System.out.println("汪汪汪");
}
}
//实现类Test
public class Test {
public static void main(String[] args) {
Cat cat=new Cat("red",90);
cat.cry();
cat.display();
Dog dog=new Dog("green",100);
dog.cry();
dog.display();
}
}
接口
接口：如果一个类中完全由静态常量（用static,final修饰）和抽象方法组成，则该类可以设计为一个接口。
接口三部曲：
- 定义接口
- 实现接口
- 使用接口
//定义接口
public interface Human {
//静态常量
public static final String TYPE="haha";
//抽象方法
public abstract void run();
public abstract void say();
}
由于接口就是定义常量和抽象方法的，所以可以简写：
//定义接口
public interface Human {
//静态常量
String TYPE="haha";
//抽象方法
void run();
void say();
}
接口与抽象类一样不能会直接实例化，需要通过实现类来实现（implements）接口中的抽象方法，实现类中也可以定义自己的属性和方法。
//实现Human接口
public class Person implements Human {
double height;
double weight;
public Person(double height, double weight) {
super();
this.height = height;
this.weight = weight;
}
//实现接口的抽象方法
public void run() {
System.out.println("我跑了两万米");
}
public void say() {
System.out.println("Hello World!");
}
//定义自己的抽象方法
public void display(){
System.out.println("我的身高是:"+height+"我的体重是："+weight);
}
}
另外定义一个类来使用该接口
//使用接口
public class Test2 {
public static void main(String[] args) {
Person person1=new Person(155.0,95);
person1.display();
person1.run();
person1.say();
Person person2=new Person(160.0,99);
person2.display();
person2.run();
person2.say();
}
}
运行结果：
我的身高是:155.0我的体重是：95.0
我跑了两万米
Hello World!
我的身高是:160.0我的体重是：99.0
我跑了两万米
Hello World!
接口的使用规则：
- 接口与抽象类一样不能会直接实例化，需要通过实现类来实现（implements）接口中的抽象方法，实现类中也可以定义自己的属性和方法。
- 实现类可以同时使用多个接口，接口用逗号隔开
public class A implement B,C,D{} - 实现类同时共享多个接口中的常量，且必须实现接口中的多个方法。
- 若实现类中仍然有未实现的抽象方法，则它仍然为抽象类。
5.接口是一种约定，一种能力：接口中规定了实现类必须实现的所有方法，且要求实现类必须有能力提供每个方法的具体实现。 - 一个类可以只能继承一个父类，但是可以实现多个接口。
- 一个接口可以同时继承多个接口，实现接口的多继承，但不能继承抽象类。
