【原】Java学习笔记021

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        // 类 Object：是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 
        
        Person person = new Person();
        System.out.println(person);            // cn.temptation.Person@15db9742
        
        // Object类的成员方法：
        // int hashCode() ：返回该对象的哈希码值。
        // hashCode 和 对象在内存中的地址值有关，可以理解为对象在内存中的地址值
        System.out.println(person.hashCode());        // 366712642（十进制值）-----> 15db9742（十六进制值）
        System.out.println(Integer.toHexString(person.hashCode()));        // 15db9742
    }
}

// 显式的描述该类继承自Object类（平时写代码时都省略了这个继承）
class Person extends Object {
    
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // Objec类的常用成员方法：
        // Class<?> getClass() ：返回此 Object 的运行时类。 
        
        // Class类：Class类的实例表示正在运行的 Java 应用程序中的类和接口。
        // Class类的常用成员方法：
        // String getName() ：以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。 
        
        Human human = new Human();
        
        Class clazz = human.getClass();
        System.out.println(clazz);            // class cn.temptation.Human
        System.out.println(clazz.getName());    // cn.temptation.Human
        
        // 链式编程
        System.out.println(human.getClass().getName());        // cn.temptation.Human
    }
}

class Human {
    
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        // Object类的常用成员方法：
        // String toString() ：返回该对象的字符串表示。 
        
//        Animal animal = new Animal();
//        System.out.println(animal);                    // cn.temptation.Animal@15db9742
//        System.out.println(animal.toString());        // cn.temptation.Animal@15db9742
        
        // 通过观察，发现直接打印对象  和  使用对象从Object类继承而来的toString()方法打印出的结果是一致
        
        // 对比JDK中Object类的源码，其实toString方法就是这样的实现
//        System.out.println(animal.getClass().getName() + "@" + Integer.toHexString(animal.hashCode()));        // cn.temptation.Animal@15db9742
        
        // 既然做了重写，那么就不再使用Object中的toString方法，使用子类重写的toString方法
        Animal animal = new Animal("张三", 20);
        System.out.println(animal);
        System.out.println(animal.toString());
    }
}

class Animal extends Object {
    // 成员变量
    private String name;
    private int age;

    // 构造函数
    public Animal() {
        super();
    }

    public Animal(String name, int age) {
        super();
        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;
    }
    
    // 重写从Object类中继承而来的toString方法
//    @Override
//    public String toString() {
//        return "Animal [name=" + this.name + ", age=" + this.age + "]";
//    }
    
    // 使用alt+shift+s，alt+shift+s可以自动生成toString方法
    @Override
    public String toString() {
        return "Animal [name=" + name + ", age=" + age + "]";
    }
}
// Object类中的toString()方法源码
//public String toString() {
//    return getClass().getName() + "@" + Integer.toHexString(hashCode());
//}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        // 基本数据类型 使用 == 判断值是否相等
//        int i = 2;
//        int j = 3;
//        System.out.println(i == j); // false

        // 引用数据类型，使用 == 判断地址值是否相同
        Man man1 = new Man("张三", 20);
        Man man2 = new Man("张三", 20);
        System.out.println(man1);                // cn.temptation.Man@15db9742
        System.out.println(man2);                // cn.temptation.Man@6d06d69c
        System.out.println(man1 == man2);        // false
        
        Man man3 = man1;
        System.out.println(man3);                // cn.temptation.Man@15db9742
        System.out.println(man1 == man3);        // true
        System.out.println(man2 == man3);        // false
        
        System.out.println("--------------------------------------------");
        
        
        // Object类的常用成员方法：
        // boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。
        
//        System.out.println(man1.equals(man2));    // false
//        System.out.println(man1.equals(man3));    // true
//        System.out.println(man2.equals(man3));    // false
        
        // 首先直接使用Object类的equals方法，其实还是使用  == 进行比较，不符合要求（我们希望比较对象们的特征是否相同）
        // 所以，考虑重写继承过来的equals方法
        
        System.out.println(man1.equals(man2));    // true
        System.out.println(man1.equals(man3));    // true
        System.out.println(man2.equals(man3));    // true
        
        
        // 注意：== 就可以判断基本数据类型的值是否相等；需要重写equals方法来判断引用数据类型的内容是否相等
    }
}

class Man extends Object {
    // 成员变量
    private String name;
    private int age;

    // 构造函数
    public Man() {
        super();
    }

    public Man(String name, int age) {
        super();
        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;
    }
    
    // 从equals方法的说明，看到要重写equals方法，需要先重写hashCode方法
//    @Override
//    public int hashCode() {
//        int temp = 123;
//        int result = 1;
//        
//        result = temp * result + age;
//        result = temp * result + ((name == null) ? 0 : name.hashCode());
//        
//        return result;
//    }
    
    // 重写从Object类中继承而来的equals方法
//    @Override
//    public boolean equals(Object obj) {
//        // 情况1、如果传入的对象是自身，不用比较了，空间是同一块空间，返回true
//        if (this == obj) {
//            return true;
//        }
//        
//        // 情况2、如果传入的对象是null值，那也不用比较了，直接返回false
//        if (obj == null) {
//            return false;
//        }
//        
//        // 情况3、比较当前对象 和 传入对象的运行时类是否相同，如果类类型都不相同，那也不用比较了，直接返回false
//        if (this.getClass() != obj.getClass()) {
//            return false;
//        }
//        
//        // 情况4、equals方法传入的参数类型是Object类型，但是拿来比较的对象本质是Man类型的，是有name属性和age属性的，所以需要进行向下转型
//        Man temp = (Man) obj;
//        
//        // 对基本数据类型的age属性进行比较
//        if (this.age != temp.age) {
//            return false;
//        }
//        
//        // 对引用数据类型的name属性进行比较
//        // String 类代表字符串。
//        // String类的常用成员方法：
//        // boolean equals(Object anObject) ：将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。
//        if (this.name == null || temp.name == null) {
//            return false;
//        } else if (!this.name.equals(temp.name)) {
//            return false;
//        }
//        
//        return true;
//    }
    
    // 使用alt+shift+s，alt+shift+h进行hashCode方法和equals方法的重写
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Man other = (Man) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}
// Object类中的equals方法源码
//public boolean equals(Object obj) {
//    return (this == obj);
//}

package cn.temptation;

import java.util.Scanner;

public class Sample05 {
    public static void main(String[] args) {
        // 类 Scanner：一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。 
        
        // Scanner类的构造函数：
        // Scanner(InputStream source) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
        
        // Scanner类的常用成员方法：
        // void close() ：关闭此扫描器。
        
        // 类 InputStream：此抽象类是表示字节输入流的所有类的超类。 
        // 类 System：System 类包含一些有用的类字段和方法。它不能被实例化。 
        // System类的字段：
        // static InputStream in ：“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。  
        
        System.out.println("输入数字：");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        scanner.close();
        
        System.out.println("i:" + i);
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample06 {
    public static void main(String[] args) {
        // Scanner类的常用成员方法：
        // 1、void close() ：关闭此扫描器。
        // 2、next()方法和nextXXX()方法：获取扫描器扫描的内容
        // 3、hasNext()和hasNextXXX()方法：在获取扫描器扫描的内容之前，先判断一下扫描的内容是否是指定的数据类型
        
        System.out.println("输入数字：");
        Scanner scanner = new Scanner(System.in);
        
        // 虽然要求用户输入数字，但是用户的输入是具有未知性的，输入的不是数字时，可能会产生异常：java.util.InputMismatchException
//        int i = scanner.nextInt();
        
        // 改进方案：先使用hasNext()方法 和  hasNextXXX()方法进行操作前的检查工作
        if (scanner.hasNextInt()) {
            int i = scanner.nextInt();
            System.out.println("i:" + i);
        } else {
            System.out.println("输入的不是int类型的数据");
        }
        
        scanner.close();
    }
}