抽象类和接口

抽象类

1.特点

（1）一个方法只有声明，没有实现时，该方法就是抽象方法；需要被abstract修饰。
抽象方法必须定义在抽象类里面，该类也必须用abstract修饰；
（2）抽象类不可以被实例化，因为调用抽象方法没有意义；
（3）抽象类必须有其子类覆盖了所有的抽象方法后，该类才可以被实例化。否则这个子类还是抽象类；

2.细节问题

（1）抽象类中有构造函数吗？
答：有，用于给子类对象进行初始化；
（2）抽象类可以不定义抽象方法吗？
答：可以，（但是很少见），目的是不让该类创建对象，AWT的适配器对象就是这类，通常这种类有方法体，但是么有内容；
（3）抽象关键字abstract不可以和哪些关键字共存？
答：
1. private不行（抽象方法被覆盖，而子类无法覆盖）；
2. static不行（成员变静态，不需要new对象，但是抽象方法运行无意义）；
3. final不行；
（4）抽象类和一般类的异同点？
答：
1.相同点：
–抽象类和类都是用来描述事务
–都在内部定义了成员
2.不同点：
—-一般类有足够信息描述事务，抽象类描述信息有可能不足
—-一般类中不能定义抽象方法，抽象类可以定义抽象方法和非抽象方法
—-一般类可以被实例化，抽象类不可以被实例化
（5）抽象类一定是父类吗？
答：是的，需要子类覆盖其方法后才可以对子类实例化；

public abstract class Animals {

    public String name;
    public int age;
    public String sex;
    public final String area = "地球";

    public void fn(){
        System.out.println("abstract--fn---");
    }
    public abstract void eat();
    public abstract String Sleep(String sleep);
}
----------
public class Dog  extends Animals{

    public void eat(){
        System.out.println("dog eat-------");
    }

    public  String Sleep(String sleep){
        System.out.println(sleep);
        return sleep;

    }
}
----------
public class Cat extends Animals {

    public void eat() {

        System.out.println("cat eat------");

    }

    public String Sleep(String sleep) {

        return sleep;
    }
}
----------
public class Text {

    public static void main(String[] args) {

        Dog d = new Dog();
        Cat c = new Cat();
        d.eat();
        c.eat();
        d.Sleep("Dog sleep---");
        System.out.println(c.Sleep("catcat"));

    }

}
/*
dog eat-------
cat eat------
Dog sleep---
catcat
*/

---

接口

当一个类中的方法都是抽象的时候，这时可以将抽象类用另一种形式定义和表示，这就是接口（interface）
对于接口中常见的成员：
1.全局常量：public static final—-
2.抽象方法：public abstract—-
即接口中的成员都是公共的权限
接口可以多继承，且接口不可以被实例化
一个类在继承另外一个类的同时，还可以实现多个接口
接口的特点：
1.接口是对外暴露的原则
2.接口是程序的功能扩展
3.接口的出现降低了耦合性
4.接口可以多实现
5.接口只能定义抽相方法

接口里面可以定义：
1.常量 可以省去final关键字
2.抽象方法 可以省去abstract关键字

public interface InterfaceA {
     //1.常量  可以省去final关键字
     //2.抽象方法 可以省去abstract关键字
    public static final String name="Jerry";
    public abstract  void fn1();
    public String getStr(String s);

}
----------
public class MyClass implements InterfaceA {

    public void fn1() {
        System.out.println("fn1");

    }

    public String getStr(String s) {
        System.out.println(s);
        return s;
    }

}


----------
public class Text {
    public static void main(String[] args){

        MyClass m = new MyClass();
        m.fn1();
        m.getStr("abc");

        InterfaceA ia = new MyClass();
        ia.fn1();
        ia.getStr("123");

    }


}
/*
fn1
abc
fn1
123
*/