Java基础-抽象和接口

1.抽象方法

概念：将共性的行为抽取到父类，由于每个子类执行的内容是不一样的，所以在父类中不能确定具体的方法体。

关键字 ： abstract

  1.1 注意事项

1. 抽象类 可以有构造方法，但是不能实例化
2. 抽象类 中不一定有抽象方法，但是有抽象方法的一定是抽象类
3. 抽象类 的子类，要么重写抽象类中所有抽象方法，要么是抽象类

 1.2 抽象类的构造方法的作用

1. 当子类创建对象的时候，给属性赋值
2. 案例解析：创建一个抽象的父类（Person）,一个子类（Studnet）继承父类并实现里面的方法

   package cn.sxau.抽象;
   
   public abstract class Person {
       private String name;
       private String age;
   
       public Person() {
       }
   
       public Person(String name, String age) {
           this.name = name;
           this.age = age;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public String getAge() {
           return age;
       }
   
       public void setAge(String age) {
           this.age = age;
       }
       public abstract void work();
   }
   
   
   
   package cn.sxau.抽象;
   
   
   public class Student extends Person{
       public Student(){
   
       }
       public Student(String name ,String age){
               super(name,age);
       }
   
       @Override
       public void work() {
           System.out.println("学生的工作是学习");
       }
   }
   
   
   
   package cn.sxau.抽象;
   
   public class Test {
       public static void main(String[] args) {
           Student s = new Student("张三","18");
           System.out.println(s.getName()+"，"+s.getAge());
           s.work();
       }
   }
   

    

 2.接口

概念：是建立类与类之间的协议，它所提供的只是一种形式，并没有具体的实现方法。

关键字 ： interface

  2.1 注意事项

1. 接口 没有构造方法，不能实例化
2. 接口和类之间是实现关系 ，关键字 ： implements
3. 接口的子类，要么重写接口的所有抽象方法，要么是抽象类
4. 接口可以多实现

  2.2 接口中成员的特点

1.  成员变量：只能是常量（public static final）

2. 构造方法：没有

3. 成员方法：只能是抽象方法,(JDK7)；

  2.3 接口的新特性（Java 1.8） 

1. 接口里可以用default关键字修饰默认方法，方法可以有方法体

   public interface Test1{
       default  void print1(){
           System.out.println("Test1接口中的默认方法");
       }
       
   }

2.  一个类实现接口后，不必重写接口里的默认方法
3. 默认方法可以被继承，类的实例对象可以直接调用接口中的默认方法

   public static void main(String[] args) {
       Put put = new Put();
       put.print1();
   }

4. 如果一个类实现了多个接口，多个接口中都定义了一个相同方法名的默认方法，实现类需要重写接口中的默认方法。
5. 如果一个类继承了一个抽象类，实现了一个接口，抽象类和接口中存在相同的方法，采取类优先的原则，优先继承抽象类中的方法
6. 接口中可以声明静态方法，可以为静态方法提供实现。接口中的静态方法必须是public的，public修饰符可以省略，静态方法不能被继承和覆盖，只能在其所在的接口被调用。

  2.3 案例实现

1.  创建一个实体类（animal），和1个接口（swing）和2个实现类（狗，兔子）和一个测试类（Test）

2. package cn.sxau.接口;
   
   public abstract class Animal {
       private String name;
   
       public Animal() {
       }
   
       public Animal(String name) {
           this.name = name;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
       //吃东西
       public abstract void eat();
   }
   
   
   package cn.sxau.接口;
   
   
   public interface swing {
       public abstract void swing();
   }
   
   
   package cn.sxau.接口;
   
   public class Dog extends Animal implements swing{
       public Dog() {
       }
   
       public Dog(String name) {
           super(name);
       }
   
       @Override
       public void eat() {
           System.out.println("吃骨头");
       }
   
       @Override
       public void swing() {
           System.out.println("游泳");
       }
   }
   
   
   package cn.sxau.接口;
   
   public class tuzi extends Animal{
       public tuzi() {
       }
   
       public tuzi(String name) {
           super(name);
       }
   
       @Override
       public void eat() {
           System.out.println("吃胡萝卜");
       }
   }
   
   
   package cn.sxau.接口;
   
   public class Test {
       public static void main(String[] args) {
           Dog d = new Dog("小狗");
           d.swing();
           d.eat();
           tuzi t = new tuzi("兔子");
           t.eat();
       }
   }