day-21 常用类

转载

mb5fed6ec4336ce 2021-10-08 22:24:00

文章标签 字符串 ide 自动生成数据 java 文章分类 代码人生

API概述（Application Programming Interface）：应用程序编程接口，本节涉及API指的就是JDK中提供的各种功能的Java类

一、Object类

　　1.概述:Class Object是类Object结构的根。每个class都有Object作为超类。所有对象（包括数组）都实现了这个类的方法

　　2.构造方法： public Object()

　　3.成员方法：

day-21 常用类_数据

　　　　1. public int hashCode()
　　　　　　返回对象的哈希码值。支持这种方法是为了散列表，如HashMap提供的那样。

　　　　　　该方法的默认实现通过将对象的内存地址转换为整数来计算对象的哈希码　　

　　　　2. public final Class getClass()

　　　　　　表示类对象的运行时类的Class对象。

class Student extends Object {
}

public class StudentTxet {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        /*
        public int hashCode()
        返回对象的哈希码值,支持这种方法是为了散列表，如HashMap提供的那样。
        该方法的默认实现通过将对象的内存地址转换为整数来计算对象的哈希码
        */
        System.out.println(s1.hashCode());//1163157884
        System.out.println(s2.hashCode());//1956725890
        System.out.println(s3.hashCode());//356573597
        System.out.println("==========================");

        /*
        public final Class getClass()
        表示 类对象的运行时类的Class对象。
        */
        System.out.println(s1.getClass());//class shujia.day1.day10.Student
        System.out.println(s2.getClass());//class shujia.day1.day10.Student
        System.out.println("==========================");
        /*Class类中的方法：

        public String getName()
        返回由类对象表示的实体的名称（类，接口，数组类，原始类型或void），作为String 。
        */
        Class aClass = s1.getClass();
        System.out.println(aClass.getName());//shujia.day1.day10.Student

        //使用链式编程
        System.out.println(s2.getClass().getName());//shujia.day1.day10.Student


//        System.out.println(s1.equals(s2));//false
//        System.out.println(s1.equals(s3));//false
//        System.out.println(s1.equals(s1));//true
    }
}

　　　　3. public String toString()返回对象的字符串表示形式

　　　　一般来说。toSting()返回的是一个对象的字符串。

/*
public String toString()返回对象的字符串表示形式
        一般来说。toSting()返回的是一个对象的字符串。

toString()方法等价于以下内容：
        getClass().getName() + '@' + Integer.toHexString(hashCode())

Integer类中提供了一个静态的方法：
public static String toHexString(int i)：
        返回整数参数的字符串表示形式，作为16位中的无符号整数。
*/

public class StudentText1 {
    public static void main(String[] args) {
//        toString()方法覆盖前
        Student1 s1 = new Student1();
        System.out.println(s1.getClass().getName());//shujia.day1.day10.Student1    重写后 shujia.day1.day10.Student1
        System.out.println(s1.toString());//shujia.day1.day10.Student1@4554617c      重写后  Student{name='null', age=0}
//        toString()方法等价于以下内容：
//        getClass().getName() + '@' + Integer.toHexString(hashCode())
        System.out.println(s1.getClass().getName() + '@' + Integer.toHexString(s1.hashCode()));
        //shujia.day1.day10.Student1@4554617c
        System.out.println("===========tostring()方法覆盖后===========");
        s1.setName("张三");
        s1.setAge(11);
        System.out.println(s1.toString());//shujia.day1.day10.Student1@4554617c    重写后 Student{name='张三', age=11}
        //打印对象本身，默认调用toString()方法
        System.out.println(s1);//shujia.day1.day10.Student1@4554617c    重写后 Student{name='张三', age=11}

    }
}

public class Student1 {
    private String name;
    private int age;

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

    public Student1() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

//重写方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

　　　　4.public boolean equals(Object obj)　　　　　

　　　　　　指示一些其他对象是否等于此。这个方法默认比较的是地址值，默认情况下比较的是地址值，需要根据情况去重写，而重写的时候不需要我们自己去重写可以自动生成,可以自动生成,只重写equals（）方法，里面的实现逻辑需要自己去写，也可以和hashCode一起自动生成重写

/*
        public boolean equals(Object obj)指示一些其他对象是否等于此。
        这个方法默认比较的是地址值。通过观察源码发现，底层默认调用的是==比较两个对象，
        而==比较的是地址值是否相同，所以System.out.println(s1.equals(s2)); //false

        但是呢，比较地址值是没有任何意义的，更多情况下，我们应该比较的是对象中成员变量
        的值是否一样。

        ==:
           基本数据类型：比较的是值是否相同
           引用数据类型：比较的是地址值是否相同

       equals:
        因为equals是属于Object类中的方法，只有对象可以去调用，而基本数据类型不属于对象
        引用类型：默认情况下比较的是地址值，需要根据情况去重写，而重写的时候不需要我们自己去重写
        可以自动生成,但是里面的实现逻辑需要自己去写
 */

public class StudentText3 {
    public static void main(String[] args) {
        Student1 s1 = new Student1("路哥", 18);
        Student1 s2 = new Student1("路哥", 18);
        Student1 s4 = new Student1("K", 18);
        Student1 s3 = s1;
        //equals()方法重写前
//        System.out.println(s1==s2);//false
//        System.out.println(s1.equals(s1));//true
//        System.out.println(s1.equals(s2));//false
//        System.out.println(s1.equals(s3));//true
//        System.out.println(s1.equals(s4));//false

        //equals()重写后
        System.out.println(s1==s2);//false
        System.out.println(s1.equals(s1));//true
        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s3));//true
        System.out.println(s1.equals(s4));//false
    }
}




//import java.util.Objects;  equals方法和hashCode方法一起重写需要导包
public class Student1 {
    private String name;
    private int age;

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

    public Student1() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

    @Override
    public boolean equals(Object o) {
        //和hashCode()方法一起自动重写
//        if (this == o) return true;
//        if (!(o instanceof Student1)) return false;
//        Student1 student1 = (Student1) o;
//        return age == student1.age &&
//                Objects.equals(name, student1.name);
        //Object obj = new Student3();
//        return true;


        //单独重写equals()方法
        //s1 -- this
        //s4 -- o
       //判断两个对象是否同一对象
        if (this == o){
            return true;
        }
        //Object o = new Student1();多态
        //想要访问子类中成员，就要向下转型
        Student1 s = (Student1)o;
        return this.name.equals(s.getName()) && this.age == s.getAge();//字符串中equals自动重写比较值
      
    }

//    @Override
//    public int hashCode() {
//
//        return Objects.hash(name, age);
//    }
}

　　　　5. protected void finalize() //作为了解即可

　　　　　　throws Throwable

　　　　　　当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。简单来说，它就是用于垃圾回收的。什么时候回收不确定。

　　　　6. protected Object clone()

　　　　　　throws CloneNotSupportedException

　　　　　　创建并返回此对象的副本。返回的是这个实例的一个克隆，被Object类接收，clone会创建一个新的对象出来。

　　　　注意事项；

　　　　　　Interface Cloneable使用clone方法必须实现这个接口,但是我们通过观察API发现，该接口没有任何抽象方法，那么实现这个接口有什么意义呢？
　　　　　　如果没有重写该接口就直接调用，会报错CloneNotSupportedException,像这样没有任何方法的接口我们称之为标记接口

//protected Object clone()
//        throws CloneNotSupportedException创建并返回此对象的副本。
//        返回的是这个实例的一个克隆，被Object类接收
//
//        clone会创建一个新的对象出来。
//
//
//        Interface Cloneable使用clone方法必须实现这个接口
//        但是我们通过观察API发现，该接口没有任何抽象方法，那么实现这个接口有什么意义呢？
//        如果没有重写该接口就直接调用，会报错CloneNotSupportedException
//        像这样没有任何方法的接口我们称之为标记接口
public class StudentText4 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Student2 s1 = new Student2();
        s1.setName("god");
        s1.setAge(18);
        System.out.println(s1);//Student2{name='god', age=18}
        Object s1Clone = s1.clone();//多态
        System.out.println(s1Clone);//Student2{name='god', age=18}
        Student2 sClone  = (Student2)s1Clone;
        System.out.println(s1.getName()+"---"+s1.getAge());//god---18
        System.out.println(sClone.getName()+"---"+sClone.getAge());//god---18

        Student2 s2 = s1;//堆内存中始终只有一个对象
        s2.setAge(19);
        s2.setName("tt");
        System.out.println(s2.getName() + "---" + s2.getAge());//tt---19
        System.out.println(sClone.getName() + "---" + sClone.getAge());//god---18
        System.out.println(s1.getName() + "---" + s1.getAge());//tt---19
    }
}



public class Student2 implements Cloneable {
    private String name;
    private int age;

    public Student2() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

二.Scanner类（JDK5以后用于获取用户的键盘输入）

　　1.构造方法

　　　　 public Scanner(InputStream source)

　　2.成员方法

day-21 常用类_自动生成_02

/*
        public int nextInt()
        public String nextLine()

 */
import java.util.Scanner;
public class ScannerTest {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
//        int i = sc.nextInt();
//        System.out.println(i);
        //判断输入的数据是否符合接收的数据类型
//        if(sc.hasNextInt()){
//            int i = sc.nextInt();
//            System.out.println(i);
//        }else {
//            System.out.println("输入的数据不是int类型");
//        }
//        System.out.println("asda");

//        int i = sc.nextInt();
//        int j = sc.nextInt();
//        System.out.println("i: "+i+",j: "+j);

//        String s = sc.nextLine();
//        String s2 = sc.nextLine();
//        System.out.println("s: "+s+",s2: "+s2);

        //先输入字符串再输入int类型
//        String s = sc.nextLine();
//        int i = sc.nextInt();
//        System.out.println("s: "+s+",i: "+i);

        //先输入int类型再输入字符串类型
        //这里会出现问题：输入完int类型的数据之后，就自动输出了，还没来得及出入字符串
        //为什么呢？
        //nextLine()将我们的换行符给接收到了

        //怎么解决呢？
        //方式1：创建另一个新的Scanner对象
        int i = sc.nextInt();
        Scanner sc2 = new Scanner(System.in);
        String s = sc2.nextLine();
        System.out.println("s: "+s+",i: "+i);

        //方式2：输入一个东西就去判断一下是否符合类型 （开发中使用方式2去解决这个问题）
    }
}