Java中API概述以及Object类的概述

API概述以及Object类的概述

API（Appliaction programming Interface) 应用程序编程接口。Java API，就是java提供给我们使用的类，这些类在底层被封装起来，我们不需要知道他是如何实现的，我们只要学会使用就好。object类是类层次的根类，所有的类，直接或间接继承该类。他的构造方法是 public object();

Object类的hashCode()方法

1，我们可以直接调用此方法，不用导包，因为他在java.lang包下，他是返回该对象的哈希码值，默认情况下，该方法会根据该对象的地址值计算。
2.不同的对象的哈希码值也是不一样的，同一对象的hashcode()值肯定相同，
3.hashCode不是对象的实际地址值，可以理解为逻辑地址值，
例如：下面代码

public class MyTest {
    public static void main(String[] args) {
        Object o = new Object();
        int i = o.hashCode();
        Object o1 = new Object();
        int i1 = o1.hashCode();
        System.out.println(i);
        System.out.println(i1);
            }
}
输出结果：
356573597
1735600054

Object类的getClass方法

1.getClass()返回该类的字节码文件对象，
2.可以通过Class类中的一个方法，获取对象的真实类的全名称 public String getName()
例如：下面代码

public class MyTest {
    public static void main(String[] args) {
        Object o = new Object();
        Class<?> aClass = o.getClass();
        Object o1 = new Object();
        Class<?> aClass1 = o1.getClass();
        System.out.println(aClass);
        System.out.println(aClass1);
        System.out.println(o==o1);
        System.out.println(aClass==aClass1);
    }
}
输出结果：
class java.lang.Object
class java.lang.Object
false
true

Object类的toString()方法

1.返回该对象的字符串表示
2.他打印出的数据，对我们来说，没有意义，所以我们会重写，返回该对象的所有的成员变量
例如：

public class MyTest {
    public static void main(String[] args) {
        Object o = new Object();
        String string = o.toString();
        System.out.println(string);
    }
输出结果：java.lang.Object@1540e19d//我们要这个结果没有意义，我们要对其重写
例：
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
       return "年龄"+this.name+"年龄"+this.age;
    }
}
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student("张三",20);
        String string = student.toString();
        System.out.println(string);
    }
}
输出结果：年龄张三年龄20

Object类的equals()的方法

1指示其他对象某个对象是否与此对象“相等”，默认情况下，比较的是对象的引用是否相同
2.我们一般要比对象的成员变量就要重写此方法
3.重写的方法，提高了效率，提高了健壮性

例：

public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("张麻子",30);
        Teacher teacher2 = new Teacher("张麻子",30);
        System.out.println(teacher==teacher2);
        boolean equals = teacher.equals(teacher2);
        System.out.println(equals);
        System.out.println("----------------");
        boolean equals1 = teacher.equals(teacher2);
        System.out.println(equals1);


    }
}
class Teacher{
    private String name;
    private int age;

    public Teacher() {
    }

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

    @Override
    public boolean equals(Object obj) {
        if (this==obj){//自己先和自己比
            return true;
        }else if (!(obj instanceof Teacher)){
            return false;
        }else {
            Teacher ter=(Teacher)obj;//向下转型
            return this.name.equals(ter.name)&&this.age==ter.age;
        }
    }
}
输出结果：
false
true
----------------
true
注意：instanceof 判断一个引用，是否是，该类型的一个引用

==和equals的区别
== 比较的是值是否相等，如果比较的基本数据类型的变量，比较的是其存储的“值”是否相等。如果比较的是，引用数据类型，则比较的是所指向的地址值是否相等。
equals equals不能比较基本数据类型的变量，equals继承object类，比较的是是否是同一个类。如果对equals方法没有重写，则比较的是引用类型的变量所指向的对象的地址。诸如：String Date等类对equals方法进行了重写，比较的是所指向的内容是否相等。

Object类的clone（）方法

浅克隆：

1.被复制的类需要实现Cloneable接口（不实现的话在调用clone方法会抛出，CloneNotSupportedExcetion异常），该接口为标记接口，不含任何方法。
2.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另一个类的对象，这时只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
3.对象的浅克隆不会调用到构造方法。

例：

public class MyTest2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("兰博基尼");
        Drive drive = new Drive("张麻子",20,car);
        drive.car.name="宝马";
        Drive drive1= (Drive) drive.clone();
        drive1.car.name="奔驰";
        System.out.println(drive.car.name);
        System.out.println(drive1.car.name);


    }
}
    class Drive implements Cloneable {
    public String name;
    public int age;
    public Car car;

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

        }

        public Drive(String name, int age, Car car) {
            this.name = name;
            this.age = age;
            this.car = car;
        }


    }
class Car{
    public String name;

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

}
输出结果：
奔驰
奔驰

Scanner的概述

static InputStream in “标准”输入流。

public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入Scanner(InputStream source) 构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

hasNextXxx（）判断下一个是否是某种类型的元素，其中Xxx可以是Int，Double等。
如果需要判断是否包含下一个字符串，则可以省略Xxx
nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同

public class MyTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数");
        int i = scanner.nextInt();
        System.out.println(i);
        System.out.println("请输入字符串");
        scanner=new Scanner(System.in);
        String s = scanner.next();//遇到空格就停止打印
        System.out.println(s);
    }
}
判断你输入的类型是否符合要求

public class MyTest2 {
    public static void main(String[] args) {
        Scanner scanner1 = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String getnumber = Utils.getnumber(scanner1);
        System.out.println("你输入的字符串是"+getnumber);
    }

}
class Utils{
    private Utils() {
    }
    public static String getnumber(Scanner scanner1){
        String num;
        while (true){
            Scanner scanner = new Scanner(System.in);
            boolean b = scanner.hasNextLine();
            if (b){
                num= scanner.nextLine();
                break;
            }else {
                System.out.println("你输入的类型不正确");
            }
        }
        return num;
    }
}