Java 抽象类与接口

1.抽象类

1.1抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，一个类中没有包含足够的信息来描绘一个具体的对象，这个类就是抽象类

比如：Animal是动物类 具有叫的方法 但是因为Animal不是一个具体的动物 因此其bark()方法就无法具体实现 因此应该把Animal设置为抽象类

1.2抽象类语法

abstract class shape{
    public static  int b;
    public int a;
    public  void functionA()

    {
        System.out.println("A-Function");
    }
    //抽象类可以 定义普通方法 属性等
    public abstract void draw();//抽象方法
}

抽象类语法比较简单 就是class前加了abstract关键字‘

1.3抽象类的一些属性

//Shape shape = new Shape()  会报错 抽象类是不可以实例化的

abstract class Shape{
    abstract private void draw();
}
//编译出错
Error:(4,27)java:非法的修饰符组合:abstract和private

抽象方法亦不可被final 和 static修饰  因为抽象方法要被子类重写的

抽象类必须被继承 并且继承后子类要重写父类中的所有抽象方法 否则子类也必须是抽象类

一个例子

​
abstract class shape{
    public static  int b;
    public int a;
    public  void functionA()

    {
        System.out.println("A-Function");
    }
    //抽象类可以 定义普通方法 属性等
    public abstract void draw();//抽象方法
}
class Rect extends shape{
    @Override
    public void draw(){
        System.out.println("画一个矩形");
    }
}
class Flower extends shape{
    @Override
    public void draw() {
        System.out.println("画一朵❀");
    }
}
public class Test {
    //Shape shape = new Shape()  会报错 抽象类是不可以实例化的
    public static void drawMap(shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Rect());
        drawMap(new Flower());
    }
}

​

1.4抽象类作用

多了一层编译器的校验 且有利于代码的可读性 等

2.接口

2.1接口的概念

直观地理解接口 可以理解为 统一的规范 比如

无论是笔记本上的Usb接口 或者是插孔上的接口 都是符合人为规定的一个规范  

接口就是公共的行为规范标准 大家在实现时 只要符合规范标准就可以通用 

在Java中 接口可以看成时 多个类的公共规范 是一种引用数据类型

--使用 interface 修饰接口

--在接口中可以定义成员变量 且默认为被 public static final 修饰

--接口中的成员方法 默认被 public abstract 修饰

--接口本身不可实例化

--类和接口的关系是使用 implements 来关联的 意为当前类实现了接口

 2.2语法

package IntefercrTest;
interface Shape{
    void draw();
}
class Rect implements Shape{

    @Override
    public void draw() {
        System.out.println("画矩形");
    }
}

class Flower implements Shape{

    @Override
    public void draw() {
        System.out.println("画❀");
    }
}

public class Test {
    public static void drawMap(Shape shape){
        shape.draw();
    }

    public static void main(String[] args) {
        drawMap(new Flower());
        drawMap(new Rect());//向上转型
        Shape shape = new Flower();
        shape.draw();
    }
}

 

--接口可以引用 具体实现类 相当于向上转型

2.3例子

  一个例子

package Test;
abstract class Animal{               //抽象类Animal
    public String name;
    public int age;

    public Animal(String name , int age){
        this.age=age;
        this.name=name;
    }

    public abstract void eat();//抽象方法 eat()
}
interface Irunning{
    void run();
}

class Dog extends Animal implements Irunning{
    public Dog(String name , int age){
        super(name,age);
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃狗粮");
    }

    @Override
    public void run() {
        System.out.println(name+"正在摇着尾巴跑");
    }
}

public class Test {
    public static void func(Animal animal){
        animal.eat();
    }

    public static void main(String[] args) {
        func(new Dog("二哈",3));
    }
}

 

一个例子

​
package Test02;
class Student implements Comparable{      //实现了Comparable接口
    String name;
    int age;
    double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Object o) {          //重写了compareTo方法

       if (this.age>((Student) o).age){
           return 1;
       }else if (this.age==((Student) o).age){
           return 0;
       }else {
           return -1;
       }
    }


}
public class Test01 {
    public static void main(String[] args) {
        Student student1 = new Student("x",18,87);
        Student student2 = new Student("y",28,67);
        if (student1.compareTo(student2)>0){
            System.out.println(student1.name+"年长于"+student2.name);
        }else if (student1.compareTo(student2)==0){
            System.out.println("二人同岁");
        }else {
            System.out.println(student2.name+"年长于"+student1.name);
        }
    }
}

​

 一个例子

public class Test01 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0]= new Student("Eric",18,66);
        students[1]= new Student("Hoke",15,66);
        students[2]= new Student("Joe",32,66);
        System.out.println("排序前"+Arrays.toString(students));

        Arrays.sort(students);

        System.out.println("排序后"+Arrays.toString(students));
    }
}

 总结一下：

 后期Java的学习在很多方面也会使用接口 有一种说法是 面向接口编程 在工作中 会大量使用

 未完待续。。。