JavaSE-抽象类和接口

抽象类

在Java中使用abstract关键字定义抽象方法，且抽象方法所在的类一定是抽象类，抽象方法没有方法体

抽象类无法直接实例化子类，子类继承抽象类必须覆写所有抽象类中的抽象方法。

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

class Rect extends Shape{

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

1、抽象类无法直接实例化对象，可以通过向上转型进行实例化

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

class Rect extends Shape{

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

public class Demo1 {
    public static void main(String[] args) {
        Shape shape=new Rect();
    }
}

2、抽象类中可以没有抽象方法，只要一个类中定义了抽象方法，则这个类一定是抽象类

3、抽象方法不能是private的，而且不能被final和static修饰

被final修饰的方法不能被重写，抽象方法子类必须重写

被final修饰的类不能继承，抽象类必须有子类

4、抽象类是普通类的超集，仍存在普通方法和构造方法，且子类实例化时仍满足继承的原则，先调用父类的构造方法，在调用子类的构造方法

 接口

更纯粹的抽象类

public  class  类名称  implements  接口名称{

//...

}

1、在Java中，使用interface关键字来定义接口，接口中只有全局常量和抽象方法

interface USB{
    public static final String MSG="全局常量";
    public abstract void plugIn();
    public abstract void work();
}

在Java中，子类使用implements表示来实现一个接口，必须覆写接口中所有的抽象方法

class Mouse implements USB{

    @Override
    public void plugIn() {
        System.out.println("鼠标安装驱动中......");
    }

    @Override
    public void work() {
        System.out.println("鼠标可以正常开始工作了......");
    }
}

2、接口中只存在全局常量和抽象方法，所以接口中public  abstract  static  final可以省略不写

3、接口无法实例化对象，必须通过子类向上转型为其实例化

public static void main(String[] args) {
    USB usb=new Mouse();
    usb.plugIn();
    usb.work();
}

4、接口中也允许存在普通方法，接口中的普通方法使用default关键字来定义，有方法体，子类实现接口后可以直接使用接口中的普通方法

5、一个子类可以使用implements关键字实现多个父接口

接口和类之间的关系

若有子类同时需要继承一个抽象类，实现父接口，先用extends继承一个父类，再用implements实现接口。

class Animal{
    public String name;

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

    public void eat(){
        System.out.println(name+"正在吃饭");
    }
}

interface IRun{
    void run();
}

interface ISwim{
    void swim();
}

class Dog extends Animal implements IRun,ISwim{
    public Dog(String name) {
        super(name);
    }

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

    @Override
    public void run() {
        System.out.println(name+"在用四条腿跑");
    }

    @Override
    public void swim() {
        System.out.println(name+"在狗刨");
    }
}

class Duck extends Animal implements IRun,ISwim{

    public Duck(String name) {
        super(name);
    }

    public void eat(){
        System.out.println(name+"正在吃虫子");
    }

    @Override
    public void run() {
        System.out.println(name+"在用两条腿走");
    }

    @Override
    public void swim() {
        System.out.println(name+"在用脚掌游");
    }
}

class Fish extends Animal implements ISwim{

    public Fish(String name) {
        super(name);
    }

    public void eat(){
        System.out.println(name+"正在吃鱼食");
    }

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

public class Demo3 {
    public static void run(IRun iRun){
        iRun.run();
    }

    public static void swim(ISwim iSwim){
        iSwim.swim();
    }

    public static void main(String[] args) {
        run(new Dog("小狗"));
        run(new Duck("小鸭子"));

        swim(new Dog("小狗"));
        swim(new Duck("小鸭子"));
        swim(new Fish("小鱼"));

        Animal animal=new Dog("11");
        animal.eat();
        Animal animal1=new Duck("22");
        animal1.eat();
        Animal animal2=new Fish("33");
        animal2.eat();
    }

}

JDK中常用的两大接口

1、Comparable接口

表示当前类具备了比较的能力

只看compareTo方法的返回值，返回<0就认为小，返回>0就认为大，否则认为相等

class Student /*implements Comparable<Student>*/{
    public String name;
    public int age;
    public int score;

    public Student(String name, int age, int 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(Student o) {
//        return this.age-o.age;
//    }

}

class AgeComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}

class ScoreComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.score-o2.score;
    }
}

public class Demo4 {
    public static void main(String[] args) {
        Student s1=new Student("11",16,98);
        Student s2=new Student("22",19,34);
        AgeComparator ageComparator=new AgeComparator();
        int ret=ageComparator.compare(s1,s2);
        System.out.println(ret);
        ScoreComparator scoreComparator=new ScoreComparator();
        int ret1=scoreComparator.compare(s1,s2);
        System.out.println(ret1);
    }

//    public static void main1(String[] args) {
//        Student s1=new Student("11",16,98);
//        Student s2=new Student("22",19,34);
//        if (s1.compareTo(s2)<0){
//            System.out.println("s1小于s2");
//        }else if (s1.compareTo(s2)==0){
//            System.out.println("s1等于s2");
//        }else {
//            System.out.println("s1大于s2");
//        }
//    }
}

 2、Clonable接口

具备克隆的能力

class Person implements Cloneable{
    public int age=10;

    public Person() {
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

public class Demo5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person=new Person();
        Person person1=(Person) person.clone();
    }
}

Object类

方法参数若需要接收所有的类对象，可以用object类来接收（除了可以接收所有类的对象外，还可以接收所有的引用数据类型（数组，接口））

class Person{
    public String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Stedent{
    public String name;

    public Stedent(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Stedent{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Demo1 {
    public static void fun(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        fun(new Person("11"));
        fun(new Stedent("22"));
    }
}

//接口引用
Comparable comparable=new Student("haha");
//数组引用
int[] data=new int[]{1,2,3};
fun(data);
fun(comparable);

toString方法：获取一个对象的具体信息

equals：对象比较相等时用equals方法，在引用数据类型进行数据比较时，用equals（对象的内容）

若要进行同一个类的两个不同对象属性值的比较相等，覆写equals方法

public boolean equals(Object obj){
    //1.判断obj和当前对象的关系
    if (this == obj){
        return true;
    }
    //2.脱掉obj的外衣
    if(!(obj instanceof Student)){
        return false;
    }
    //3.obj是student类型的对象且和this当前对象不是同一对象
    Student stu=(Student) obj;
    return this.name.equals(stu.name)  &&  this.score==stu.score;
}

“==”和equals的区别：

1、==比较的是两个变量的数值是否相等，对于基本类型，比较的就是具体保存的数值，对于引用数据类型比较的是两个引用类型的地址是否相同；

2、equals方法是Object类的默认方法，自定义类型覆写equals方法可以按照属性值来比较两个对象的内容是否相等

String类

1、字符串的对象创建方式

//通过字符串常量进行赋值
String s1="hello,baekhyun!";
//通过构造方法产生对象
String s2=new String("krystal");
//通过字符数组产生对象
char[] chars={'d','d','0'};
String s3=new String(chars);
//通过字符串的静态方法
String s4=String.valueOf("balabalabala");

2、两个字符串的比较

通过==比较（比较的是两个字符串的地址，不看内容）

通过equals方法来比较两个字符串对象的内容是否相等（大小写敏感）

通过equalsIgnoreCase比较两个字符串对象的内容是否相等（大小写不敏感）

通过compareTo方法来比较两个字符串对象的大小关系

3、字符串内容的查找

在字符串中查找指定的字符

char  charAt(int  index)

4、字符串的转化

其他类型转为字符串，valueOf方法

字符串转大写  toUpperCase（）

字符串转小写  toLowerCase（）

字符串转为数组  toCharArray（）

字符串转为字节数组  getBytes（）

字符串的替换  replaceAll（）

字符串的拆分  split（）

异常

try{

        //所有可能产生异常的代码块

}catch（要捕获的异常类型）{

        //出现异常之后执行的代码

}[finally{

        //无论是否产生异常，一定会执行的代码块

}]——可选代码块

代码示例：

public class Demo1 {
    public static void main(String[] args) {
        try{
            int[] array=null;
            System.out.println(array.length);
        }catch (NullPointerException e){
            e.printStackTrace();
            System.out.println("捕获到了一个空指针异常！");
        }
    }
}