【oo面向对象基础】抽象方法、抽象类、接口、引用类型数组（package、import、封装、static、final、枚举详解）

目录

        1、抽象方法：

        2、抽象类：

        3、接口：

        4、引用类型数组：                ​​​​​​​------ 记住它和基本类型数组的两种区别即可

补充：

1、设计规则：-----------适合初学者

2、类间关系：

3、null：表示空，没有指向任何对象。

---

• 1、抽象方法：

  • 由 abstract 修饰

  • 只有方法的定义，没有具体的实现 ( 连 { } 都没有 )

• 2、抽象类：

  • 由abstract修饰

  • 包含抽象方法的类必须是抽象类，但不包含抽象方法的类也可以声明为抽象类

  • 抽象类不能被实例化(new对象)

  • 抽象类是需要被继承的，派生类：

    • 必须重写所有抽象方法------------------变不完整为完整

    • 也声明为抽象类----------------------------一般不这么用

  • 抽象类的意义：

    • 封装共有的属性和行为------------------代码复用

    • 可以包含抽象方法，为所有派生类统一入口(名字统一)，强制必须重写

  public abstract class Animal {
      String name;
      int age;
      String color;
      Animal(String name,int age,String color){
          this.name = name;
          this.age = age;
          this.color = color;
      }
  
      void drink(){
          System.out.println(color+"色的"+age+"岁的"+name+"正在喝水...");
      }
      abstract void eat();
  }
  
  public class Dog extends Animal{
      Dog(String name,int age,String color){
          super(name,age,color);
      }
  
      void lookHome(){
          System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在看家...");
      }
      void eat(){
          System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在吃肯头...");
      }
  }
  
  public class Chick extends Animal {
      Chick(String name,int age,String color){
          super(name,age,color);
      }
      void layEggs(){
          System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在下蛋...");
      }
      void eat(){
          System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在吃小米...");
      }
  }
  
  public class Fish extends Animal {
      Fish(String name,int age,String color){
          super(name,age,color);
      }
  
      void eat(){
          System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在吃小虾...");
      }
  }

• 3、接口：

  • 是一种引用数据类型

  • 由interface定义

  • 只能包含抽象方法(常量、默认方法、静态方法、私有方法------暂时搁置)

    interface Inter{
        public abstract void show(); //完整写法
        void test(); //默认public abstract
        //void say(){} //编译错误，抽象方法不能有方法体
    }

  • 不能被实例化

    public class InterfaceDemo {
        public static void main(String[] args) {
            //Inter o = new Inter(); //编译错误，接口不能被实例化
        }
    }

  • 接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法

    • 注意：重写接口中的方法时，必须加public(先记住)

      interface Inter1{
          void show();
          void test();
      }
      class Aoo implements Inter1{
          public void show(){} //重写接口中的方法时，必须加public
          public void test(){}
      }

  • 一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现

    //演示接口的多实现
    interface Inter2{
        void show();
    }
    interface Inter3{
        void test();
    }
    abstract class Boo{
        abstract void say();
    }
    class Coo extends Boo implements Inter2,Inter3{
        public void show(){}
        public void test(){}
        void say(){}
    }

  • 接口可以继承接口

    //演示接口继承接口
    interface Inter4{
        void show();
    }
    interface Inter5 extends Inter4{
        void test();
    }
    class Doo implements Inter5{
        public void test(){}
        public void show(){}
    }

  public abstract class Animal {
      String name;
      int age;
      String color;
      Animal(String name,int age,String color){
          this.name = name;
          this.age = age;
          this.color = color;
      }
  
      void drink(){
          System.out.println(color+"色的"+age+"岁的"+name+"正在喝水...");
      }
      abstract void eat();
  }
  
  public interface Swim {
      /** 游泳 */
      void swim();
  }
  
  public class Dog extends Animal implements Swim {
      Dog(String name,int age,String color){
          super(name,age,color);
      }
  
      void lookHome(){
          System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在看家...");
      }
      void eat(){
          System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在吃肯头...");
      }
      public void swim(){
          System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在游泳...");
      }
  }
  
  public class Fish extends Animal implements Swim {
      Fish(String name,int age,String color){
          super(name,age,color);
      }
  
      void eat(){
          System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在吃小虾...");
      }
      public void swim(){
          System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在游泳...");
      }
  }
  
  public class Chick extends Animal {
      Chick(String name,int age,String color){
          super(name,age,color);
      }
      void layEggs(){
          System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在下蛋...");
      }
      void eat(){
          System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在吃小米...");
      }
  }

• 4、引用类型数组：
  ​​​​​​​​​​​​​​        ​​​​​​​        ​​​​​​​------记住它和基本类型数组的两种区别即可

  • 区别1：给引用类型数组的元素赋值时，需要new个对象

  • 区别2：访问引用类型数组的元素的属性/行为时，需要打点访问

  public class Test {
      public static void main(String[] args) {
          Dog dog = new Dog("小黑",2,"黑");
          System.out.println(dog.name);
          dog = null; //表示空，没有指向任何对象
          System.out.println(dog.name);
  
          //- 区别1：给引用类型数组的元素赋值时，需要new个对象
          //- 区别2：访问引用类型数组的元素的属性/行为时，需要打点访问
          Dog[] dogs = new Dog[3];
          dogs[0] = new Dog("小黑",2,"黑");
          dogs[1] = new Dog("小白",1,"白");
          dogs[2] = new Dog("小灰",3,"灰");
          System.out.println(dogs[0].name); //输出第1只狗狗的名字
          dogs[1].age = 4; //修改第2个狗狗的年龄为4岁
          dogs[2].swim(); //第3只狗狗在游泳
          for(int i=0;i<dogs.length;i++){ //遍历dogs数组
              System.out.println(dogs[i].name); //输出每只狗狗的名字
              dogs[i].eat(); //每只狗狗吃饭
          }
  
          Chick[] chicks = new Chick[2];
          chicks[0] = new Chick("小花",1,"花");
          chicks[1] = new Chick("大花",3,"白");
          for(int i=0;i<chicks.length;i++){ //遍历chickes数组
              System.out.println(chicks[i].name);
              chicks[i].eat();
          }
  
          Fish[] fish = new Fish[4];
          fish[0] = new Fish("小金",2,"金");
          fish[1] = new Fish("大金",4,"白");
          fish[2] = new Fish("小绿",1,"绿");
          fish[3] = new Fish("大绿",3,"白");
          for(int i=0;i<fish.length;i++){ //遍历fish数组
              System.out.println(fish[i].name);
              fish[i].eat();
          }
      }
  }

补充：

1、设计规则：-----------适合初学者

• 将所有派生类共有的属性和行为，抽到超类中-------------抽共性

• 若派生类的行为/代码都一样，设计普通方法

  若派生类的行为/代码不一样，设计抽象方法

• 将部分派生类共有的行为，抽到接口中

  • 接口对继承单根性的扩展------------------------实现多继承

  • 接口是一种标准、规范，若实现了某接口就具备某个的功能，若不实现接口就不具备那个功能----------后期才能理解得更好

2、类间关系：

• 类和类-------------------------------继承

• 接口和接口-------------------------继承

• 类和接口----------------------------实现

3、null：表示空，没有指向任何对象。

• 若引用的值为null，则该引用不能再进行任何操作了，若操作则发生NullPointerException空指针异常。