Java学习----接口、常用类

接口

        我们今天接着昨天的学习接口，接口可以继承其他多个接口，一个类如果实现一个接口（通过implemes来继承实现），要么重写接口中的抽象方法，要么将此类声明为一个抽象类（是不是很想继承一个抽象类，这也侧向说明了接口其实是一种更为彻底的抽象），不一样的是一个类只能继承一个类，简介多层继承多个类，而一个类可以直接继承多个接口，下面我们看代码：

public interface Run {
    //主要用来定义方法，不能实例化对象
    void run();
}
public interface Swim {
    void swim();
}
public interface Fly {
    void fly();
}
import java.security.PrivateKey;

public abstract class Animals {
    private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    public abstract void eat();
}
public class Bird extends Animals implements Fly{

    @Override
    public void eat() {
        System.out.println("鸟吃饭");
    }

    @Override
    public void fly() {
        System.out.println("飞行");
    }
}
public class Dog extends Animals implements Run{

    @Override
    public void run() {
        System.out.println("跑步");
    }

    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
}
public class Fish extends Animals implements Swim,Fly{

    @Override
    public void eat() {
        System.out.println("鱼吃饭");
    }

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

    @Override
    public void fly() {
        System.out.println("飞鱼飞");
    }
}
public class Test {
    public static void main(String[] args) {
        Animals dog=new Dog();
        Animals fish=new Fish();
        Animals bird=new Bird();

        //类和接口之间存在多态关系

        //一个接口可以被多个类实现，同时一个类也可以继承多个接口
        Fly fly=new Bird();
        Fly fly1=new Fish();
        Swim swim=new Fish();
        Run run=new Dog();
    }
    void test(Fly fly){
        fly.fly();
    }
}

        从上我们再总结一下：接口和抽象类的区别：

                抽象类可以包含非抽象方法，而接口里面只能包含抽象方法

                类只能继承一个抽象类，但是可以继承多种接口

                抽象类可以有构造方法，接口不能有构造方法

                抽象类可以有成员变量，接口只能有常量

                接口的访问权限修饰符只能使用public

常用类/API

        常用类:Java系统中提供使用频率较高的类;

        API:应用程序编程接口,Java系统中所提供的一系列类和接口

                api文档:官方给广大Java开发者和学习者的对类和接口功能的说明文档

Object类

        Object:Java.Object 是Java类体系中最顶级的类

        toString():

                当我们要输出一个对象的时候,会默认调用toString()方法,把对象以字符串的形式输出,类中如果没有toString()方法,则会调用父类中的同String()方法:

//源代码中的toStirng()方法:
    public String toString() {
//返回值为地址
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

        当然我们可以通过在子类中重写的方式来改变toString()的返回值:

public class ObjectStu extends Object{
    String name;
    int age;
//构造方法,将传入的值赋给ObjectStu类型的成员
    public ObjectStu(String name, int age){
        this.age=age;
        this.name=name;
    }
//创建一个成员
    public static void main(String[] args) {
        ObjectStu objectStu=new ObjectStu("Gouku",77);
    }
//重写toString()方法改变返回值
    @Override
    public String toString() {
        return "ObjectStu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

        Equals():一般我们再资料中看到的Equals()方法都告诉我们Equals()方法经常用来比较对象中的内容,那么现在我们来看一下Object类中的方法是怎么实现的:

    public boolean equals(Object obj) {
        return (this == obj);
    }

        这里可以看出来equals方法似乎跟平常我们进行比较直接使用==来比较并没有什么区别,在这里我们不得不先提一下==在比较不同类型的数据的时候是怎么运行的了:

        当==比较基本数据类型的时候,直接比较两边的值是否相等,当==比较引用类型的值的时候,将会比较两边所引用的地址.

public class ObjectStu extends Object{
    String name;
    int age;

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

    public static void main(String[] args) {
        ObjectStu objectStu=new ObjectStu("Gouku",77);
    }

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

    @Override
    public boolean equals(Object obj) {
//重写之后的equals方法:先创建一个对象
        ObjectStu objectStu=(ObjectStu)obj;
//通过比较引用类型的地址,与对象里面的值,这个才是我们常说的比较对象的内容
        return this.name.equals(objectStu.name) && this.age==objectStu.age;
    }
}
public class TestEquals {
    public static void main(String[] args) {
        ObjectStu o1=new ObjectStu("ErGou",13);
        ObjectStu o2=new ObjectStu("ErGou",13);
        System.out.println(o1==o2);
        //重写之后的equals方法,注:equals方法是ObjectStu类的方法要写再ObjectStu类之下
        System.out.println(o1.equals(o2));
    }
}

        Arrays:Arrays是我们用于操作数组的工具类,一般不与成员变量有关像之前有写的找出最大值的哪个类一样,全部定义成静态变量一样,只用直接赋值即可,这些一般我们称之为工具类.

        这里我们测试:二分法查找,copyOf方法,还有比较数组这三种方法:

import java.lang.reflect.Array;
import java.util.Arrays;

public class BinnarySearch {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8};
        //调用binarySearch方法
        /*
            public static int binarySearch(int[] a, int fromIndex, int toIndex,int key) {
                rangeCheck(a.length, fromIndex, toIndex);
                return binarySearch0(a, fromIndex, toIndex, key);
            }
         */
        System.out.println(Arrays.binarySearch(arr,3,3,5));
        /*
            public static int binarySearch(int[] a, int key) {
                return binarySearch0(a, 0, a.length, key);
            }
        */
        //这是已经写好的方法,只需要调用即可
        System.out.println(Arrays.binarySearch(arr,4));
        //调用copyOf方法,
        /*
            public static int[] copyOf(int[] original, int newLength) {
                int[] copy = new int[newLength];
                System.arraycopy(original, 0, copy, 0,
                          Math.min(original.length, newLength));
                return copy;
            }
         */
        //注意这里返回值是copy是数组,直接输出输出的是地址
        System.out.println(Arrays.toString(Arrays.copyOf(arr,10)));
        //比较两个数组是否一样
        /*
            public static boolean equals(int[] a, int[] a2) {
               if (a==a2)
                 return true;
               if (a==null || a2==null)
                 return false;

                int length = a.length;
                if (a2.length != length)
                    return false;

            for (int i=0; i<length; i++)
                if (a[i] != a2[i])
                    return false;

            return true;
            }
         */
        int[] arr2={1,23,4,5,3,6};
        System.out.println(Arrays.equals(arr,arr2));
    }
}

        通过上面代码可以看出来,之所以称为面向对象思想,就是在于这里我们不用考虑我们该怎么实现二分查找比较复制数组,只用考虑我们要干什么即可,至于怎么实现已经有人帮你完成了(直接用就是爽)