java基础篇之-----------抽象类 、最终类、接口

一、抽象类：
我们把一类事物抽象出来，类中只声明方法，不实现，这就是抽象类存在的意义；

抽象类： 含有抽象方法的类，被abstract 关键字修饰；
抽象方法：只有方法声明没有方法实体，被abstract关键字修饰；

注意要点：
1、抽象类没有实例对象，只能通过别的类继承实现抽象方法；
2、抽象类可以含有普通方法，但是只要包含一个抽象方法，此类就是抽象类；
3、抽象方法需要通过继承来实现，所以抽象方法不能被private关键字所修饰；
4、继承了抽象类的类必须实现抽象类里面提供的所有抽象方法，不然这个子类依然是一个抽象类，需要被abstract所修饰；
5、一个子类只能继承一个抽象类；

abstract class testAbstract {   //   定义了一个抽象类；
    public abstract void bark();   //   声明了一个抽象方法；
}

class Dog extends testAbstract {   //  子类继承了这个抽象类；就要实现抽象类的所有方法；
    @Override
    public void bark() {				//    实现了抽象类中的抽象方法，不然会报错；如果不实现这个抽象方法，这个类依然是抽象类，需要abstract修饰
        System.out.println("汪汪汪");
    }
}

二、最终类（密封类）
1：被final关键字修饰；
2：表示不能被继承，防止有意的派生；

final class plan{
	void fly() {
	System.out.println("fly fly fly");
	}
}

三、接口
对接口的理解：接口就是将某个功能抽象出来，如果某个类需要，调用接口，实现接口中的方法；
interface 关键字： 用于定义接口，
implements 关键字:实现接口；
1、接口中只有方法声明，没有方法实现；
2、接口中定义的变量都默认为public static final;
3、接口中的方法类型默认abstract类型；
4、接口也可以向上转型，相当于多态；
5、接口可以继承，而且也可以多继承，而且不用实现父类接口的方法；
6、类实现多个接口，必须重写接口中所有的方法；
7、接口的出现就是为了解决抽象类只能被单继承的短板；

interface InterfaceFun1 {			//  定义了一个接口
	void fun1(); //   只有方法的声明，没有实现；
}
class gun  implements {		//  此类调用了接口，就必须实现接口里面的方法； 
	 public void fun1(){
	 	Syste.out.println("枪可以用来射击！");
	 }
}

练习： 一个门有开和关两个行为，并且有的门有警报功能，现在使用所学知识实现这个类；
1、所有的门都有开和关这两个行为，但是不一定都可以报警；
2、以此可以设计一个门的抽象类，定义一个开门行为和关门行为；
3、单独设计一个报警的接口，定义一个报警的方法；

interface InterfaceAlarm {    //   报警接口
    void alarm();    //   方法声明
}

abstract class doorFun {       //   抽象类
    abstract void open();		

    abstract void close();
}

class door extends doorFun implements InterfaceAlarm {  //   继承了抽象类并且调用了接口

    void open() {
        System.out.println("开门");
    }

    void close() {
        System.out.println("关门");
    }

     public void alarm() {
        System.out.println("具有报警功能！！");
    }
}

标记接口：
1 Cloneable ： 此接口是个空接口，目的是为了标记当前类可以实现克隆（在类中得自己重写object的clone方法，不然，jvm 不会识别）

 *   @Modified By:  此类是为了测试三个标记接口，关于接口的内容在testDemo_oop3_abstract类中；
 *   第一个标记接口： Cloneable；
 *   面试问题：
     Cloneable 接口是空的吗？  设计这个接口的目的是什么？
     标记接口：

     Cloneable ： 空的，目的是为了标记当前类可以克隆（实现：重写object的clone方法），如果不实现jvm不能识别
 *
 */
class car implements Cloneable {   //  调用了cloneable接口，必须自己在类中重现clone方法
    int prise = 10;
    protected Object clone() throws CloneNotSupportedException {   //   重写object的clone方法,并抛出异常
        return super.clone();
    }
}
class people implements Cloneable {         //  调用了cloneable接口，必须自己在类中重现clone方法
    private String name;
    car jeep;
    public people(String name) {
        this.name = name;
        jeep = new car();
    }
    protected Object clone() throws CloneNotSupportedException {     //   重写object的clone方法,并抛出异常
        people businessman = (people) super.clone();    //  将 object类型返回值强转成people类型
        businessman.jeep = (car) this.jeep.clone();   //  将 object类型返回值强转成car类型
        return businessman;
    }
}
public class testDemo_oop3_interface  {
    public static void main(String[] args) throws CloneNotSupportedException {
        people man = new people("mayun");// 创建对象
      people superman= (people) man.clone();  //   将man的对象地址赋值给super，
        System.out.println(man.jeep.prise);   // 输出man对象中jeep的价格
        System.out.println(superman.jeep.prise);   //  输出引用对象jeep的价格
        System.out.println("======================");
        man.jeep.prise=263000;          // 将原对象的价格修改
        System.out.println(man.jeep.prise);         
        System.out.println(superman.jeep.prise);

    }
}

2、Comparable

*          Comparable: (用于比较)有一个ComparTo <T O>泛型方法声明，实现此接口后需要实现此方法
 *           想对引用类型的对象进行排序
 */


import java.util.Arrays;
import java.util.Comparator;

class students implements Comparable<students> {  //  一个泛型新接口
    private int age;
    private String name;
    private int score;

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

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(students o) {
        // 以姓名排序
        //return name.compareTo(o.name);
        // 以成绩排序：
        return  score-o.score;
    }
}

public class testDemo8_oop3_interface2 {
    public static void main(String[] args) {
        students[] stu = new students[4];
        stu[0] = new students(18, "awhvo", 89);
        stu[1] = new students(24, "bliming", 81);
        stu[2] = new students(28, "cxingling", 74);
        stu[3] = new students(26, "dhuzi", 99);
        Arrays.sort(stu);
        System.out.println(Arrays.deepToString(stu));
        Arrays.sort(stu,new Comparator<students> () {    
            @Override
            public int compare(students o1, students o2) {
                //return o1.getAge()-o2.getAge();
                return o1.getName().compareTo(o2.getName()); //  以姓名排序
            }
        });
        System.out.println(Arrays.deepToString(stu));  //输出以姓名排序
    }
}