抽象类：
将共性的方法抽取到父类之后。由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
而为什么不直接在子类中定义方法：项目的完成不是一个人，如果有时忘记写方法重写，抽象类就会报错，没有抽象类不会报错
抽象方法的定义格式:
public abstract 返回值类型 方法名(参数列表);
抽象类的定义格式:
public abstract class 类名{}
抽象类练习：
练习思路：定义父类Animal，青蛙，狗，山羊的属性：名字，年龄，行为：喝水都可以继承于父类Animal,行为吃的内容都不相同，在父类定义抽象类，子类中写出个子吃的行为
package demo7test;
public abstract class Animal { //有抽象方法的类一定是抽象类,不是抽象会报错
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void drink(){
System.out.println("动物在喝水");
}
public abstract void eat(); //父类吃为抽象类
}
package demo7test;
public class Dog extends Animal{
//抽象类的子类
//1.要么重写抽象类的所有抽象方法(一般用这个)
//2.要么是抽象类(因为抽象类不能创建对象，要想创建只能再弄一个子类所以一般都用方法一)
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() { //重写抽象类的所有方法
System.out.println("狗在吃骨头");
}
}
package demo7test;
public class Frog extends Animal{
public Frog() {
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
}
package demo7test;
public class Sheep extends Animal{
public Sheep() {
}
public Sheep(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("山羊在吃草");
}
}
测试类：
package demo7test;
public class test {
public static void main(String[] args) {
Dog dog = new Dog("小黑", 5);
System.out.println(dog.getName() + ", " + dog.getAge());
dog.eat();
dog.drink();
Frog frog = new Frog("小蛙", 3);
System.out.println(frog.getName() + ", " + frog.getAge());
frog.eat();
frog.drink();
}
}
代码输出：
接口：
有多个处于继承中子类的类里有共性行为却不是所有子类都有时就需要接口,如果只是在子类中写的话会不统一方法名所以就要用接口来统一
接口的定义和使用:
接口用关键字interface来定义 public interface 接口名 {}
接口不能实例化
接口和类之间是实现关系，通过implements关键字表示 public class 类名 implements 接口名 {}
注意1:接口和类的实现关系，可以单实现，也可以多实现:
public class 类名 implements 接口名1，接口名2 {}
注意2:实现类还可以在继承一个类的同时实现多个接口:
public class 类名 extends 父类 implements 接口名1，接口名2 {}
接口练习：
练习思路：可以看到三种动物的行为中并不是所有类都会游泳这种行为，因为拥有行为的类不止一个所以要定义一个游泳接口
package demo7test;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat(); //对于吃行为抽象化
}
package demo7test;
public class Dog extends Animal implements Swim{ //狗需要游泳接口
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙吃虫子");
}
@Override
public void swim() {
System.out.println("狗在狗刨");
}
}
package demo7test;
public class Frog extends Animal implements Swim{ //青蛙需要游泳接口
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
@Override
public void swim() {
System.out.println("青蛙在蛙泳");
}
}
package demo7test;
public class Rabbit extends Animal{
public Rabbit() {
}
public Rabbit(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("兔子在吃胡萝卜");
}
}
package demo7test;
public interface Swim { //接口
//成员方法:可以是抽象方法（目前只知道这个）(默认修饰符：public abstract(你不写也可以因为是默认的,两个混合))，有方法体的方法，私有方法
public abstract void swim();
}
测试类：
package demo7test;
public class test {
public static void main(String[] args) {
Dog dog = new Dog("小黑", 3);
System.out.println(dog.getName() + ", " + dog.getAge());
dog.eat();
dog.swim();
Rabbit rabbit = new Rabbit("小白",2);
System.out.println(rabbit.getName()+", "+rabbit.getAge());
rabbit.eat();
}
}
可以看到兔子并没有游泳行为
输出结果：
