java抽象、多态、接口学习笔记(一)

抽象、多态、接口(一)

抽象类

abstract class Shape {
    public  abstract void draw();
}

• 一个不能具体描述对象的类

• 方法被abstract修饰，代表这个方法不可以进行实现，成为抽象方法

• 如果一个类中包含抽象方法，该类必须是抽象类。没有抽象方法该类也可以被写为抽象类（抽象方法不能是private、final、static)

• 抽象类当中的成员和普通类没区别

  abstract class Shape {
     public String name;
     public int age;
     public static void func() {
      }
     public  abstract void draw();
  }
  

• 抽象类不可以被实例化！只是为了被继承！！

• 当一个普通类继承这个抽象类后，必须重写抽象类中的抽象方法

  class Rect extends Shape {
      @Override
      public void draw() {
          System.out.println("画一个矩形！");
      }
  }
  

• 否则子类也改为抽象类，用abstract修饰，该子类A再被继承后，继承的子类B必须重写父类和子类A的抽象方法

  abstract class A extends Shape {
      public abstract void testA();
  }
  class B extends A {
      @Override
      public void draw() {
      }
      @Override
      public void testA() {
      }//重写两个抽象方法
  }
  

• 抽象类可以向上转型、动态绑定、多态

• 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

抽象类的作用

• 多了一层编译器的校验

接口

• 接口是公共的行为规范，只要符合规范规范就可以通用，在java中可以看成是多个类的公共规范，是一种引用数据类型。

语法规范

public interface ITestInterFace {
}

• 关键字interface

• 命名以I开头，一般使用形容词性的单词，会生成单独的文件

• 接口中的成员变量必须初始化，默认为public static final修饰

• 接口中方法默认是public abstract 修饰，不能有具体实现

• 接口中的方法和属性不要加任何修饰符号，保持代码的简洁性

  interface IShape {
      int AGE = 10;
      void draw();
      /*default void func() {
          System.out.println("default!");
      }
      public static void staticFunc() {
          System.out.println("staticFunc()");
      }*//只有被defult、static修饰的方法可以有具体实现
  }
  

• 接口不能有具体实现

• 接口需要被类实现，关键字implements来实现

  class Rect implements IShape {
      @Override
      public void draw() {
          System.out.println("画一个矩形！");
      }
  }
  

• 当一个类实现了一个接口，必须重写这个方法

• 可以发生多态,向上转型，动态绑定

  public class Test {
      public static void drawMap(IShape iShape) {
          iShape.draw();
      }
      public static void main(String[] args) {
          //IShape iShape = new IShape();
          drawMap(new Rect());
          drawMap(new Triangle());
      }
  }
  

接口的使用

public interface IUSB {
    void openDevice();
    void closeDevice();
}

public class Mouse implements IUSB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
    public void click() {
        System.out.println("点击鼠标！");
    }//子类自己的方法
}

public class KeyBoard implements IUSB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘！");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘！");
    }
    public void input() {
        System.out.println("键盘输入");
    }//子类特有的方法
}

public class Computer {
    public void powerOff() {
        System.out.println("关闭电脑");
    }

    public void powerOn() {
        System.out.println("打开电脑");
    }

    public void useDevice(IUSB usb) {

        usb.openDevice();//发生了动态绑定（多态）
        //这里的问题 区分 到底USB引用了哪个对象
        if(usb instanceof Mouse) {
            Mouse mouse = (Mouse)usb;//强转，向下转型
            mouse.click();//子类特有的方法
        }

        if(usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.input();
        }

        usb.closeDevice();//发生了动态绑定（多态）
    }


    public static void main(String[] args) {
        Computer computer = new Computer();//实例化一个对象
        computer.powerOn();

        computer.useDevice(new KeyBoard());
        computer.useDevice(new Mouse());

        computer.powerOff();
    }
}

接口的特性

• 可以实现多个接口，解决了不能多继承的问题

class Test03 implements IA,IB{
    @Override
    public void testA() {
        System.out.println("teatA(");
    }

    @Override
    public void testB() {
        System.out.println("testB()");

    }
}

• 解决了多继承问题

public class fish extends Animal implements ISwimming，Ifly{
    public fish(String name, int age) {
        super(name,age);
    }
   	@Override
    public void eat() {
        System.out.println(this.name+"吃鱼食");

    }

    @Override
    public void swim() {
        System.out.println("游泳");

    }

    @Override
    public void fly() {
         System.out.println("飞"); 
    }
}

• 普通类可以继承类实现接口

• 所有方法都要重写

• 可以发生动态绑定

  public class test {
  //    public static void eatFunc(Animal animal){
  //        animal.eat();
  //    }
      public static void swimFunc(ISwimming swimming){
          swimming.swim();
      }
      public static void main(String[] args) {
          swimFunc((new fish("surat",24)));
      }
  //    public static void main(String[] args) {
  //        eatFunc((new fish("surat",24)));
  //
  //    }
  }
  

接口与接口间的继承

interface IA{
    void a();
}
interface IB{
    void b();
}
interface IC extends IA,IB{
    void c();//IC扩展了IA,IB

}
class testDemo implements IC{
    public testDemo() {
        super();
    }

    @Override
    public void a() {
        System.out.println("a()");

    }

    @Override
    public void b() {
        System.out.println("b()");

    }

    @Override
    public void c() {
        System.out.println("c()");
        
    }
}
public class test2 {
    public static void main(String[] args) {

    }
}

• 接口间的继承相当于把多个接口合并在一起

接口使用实例

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
          return this.age - o.age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class test {
    public static void main(String[] args) {
        Student s1 = new Student("小白", 15);
        Student s2 = new Student("surat", 20);
        if (s1.compareTo(s2) > 0) {
            System.out.println(" s1 > s2");
        } else {
            System.out.println("s1 <= s2");

        }
    }
}

• String比较大小

  @Override
  public int compareTo(Student o) {
      if(this.name.compareTo(o.name) < 0){
          return 1;
      }else if(this.name.compareTo(o.name) == 0){
          return 0;
      }else{
          return -1;
      }
  

  • Comparable接口有局限性，后期不能随便更改比较方式
  • 借助compareTo接口实现排序

  public class test {
      public static void main(String[] args) {
          Student[]students = new Student[3];
          students[0] = new Student("wang",22);
          students[1] = new Student("li",20);
          students[2] = new Student("zhao",19);
    	    System.out.println(Arrays.toString(students));
          Arrays.sort(students);
          System.out.println(Arrays.toString(students));
  
      }