包、包的使用方式，Object类，Object类中的常见的重要方法以及代码演示

- 日理万妓 2022-12-02 00:56 87阅读 0赞

## 1. 包 ##

**1.1使用方式**

1.声明包----package  告知程序当前定义类/接口所在的位置   只能出现一次且出现在首行
    2.导入包----import    把和当前位置不在一个包下的类/接口的位置告知程序   可以出现多次且不在首行

\*（通配符——可以把当前包下的所有的类/接口都能匹配过来）

**1.2 提供包**

java（源生包）
    lang包：当程序启动时必须加载的信息（核心类库）
    util包：提供大量的信息来操作类/接口（工具包）
    io包：做数据传输
    math包：提供简单的数学运算
    net包：网络
    nio包：高并发
    security包：安全
    sql包：操作数据库
    text包：格式化（2.567 保留两位小数）
    time包：时间和日期
    javax（扩展包）
    org（第三方厂商提供的包）

**API——Application Programming Interfaces（提供一系列的接口以及接口下的类）  
API里提供的所有方法要么是被protected修饰，要么就是不写（public）。**

## 2. Object ##

**Object类是java的顶级父类，每个类默认继承Object类。**

**2.1 重要方法**  
1.clone()：克隆方法,把原对象的属性值赋值到新对象中，并且把新对象进行返回  
类实现Cloneable接口产生对象才能支持克隆操作

package cn.tedu.object;
    //当类实现Cloneable接口，产生的对象就能支持克隆操作
    //Cloneable接口是空接口，没有内容
    //当类实现接口时会给类添加一个标记，类产生的每个对象都会有这个标记
    //当做克隆操作时检测出对象有标记就可以进行正常的克隆操作
    public class ObjectDemo1 implements Cloneable{
        
        int i=1;
        public static void main(String[] args) throws CloneNotSupportedException {
        
            //创建对象(Object类的子类对象)
            ObjectDemo1 od=new ObjectDemo1();
            //调用父类Object类里的clone方法
            //Alt+回车——提示键
            //CloneNotSupportedException——克隆不支持异常
            ObjectDemo1 od1= (ObjectDemo1) od.clone();
            //克隆对象属性值和原对象的属性值一致
            System.out.println(od1.i);
            //false 把原对象的属性值赋值到新对象中
            System.out.println(od==od1);
        }
    }

2.finalize()：通知系统进行垃圾回收  
3.getClass()：返回的Object的实际创建类的类型（包名+类名）

//创建对象
     ObjectDemo2 od=new ObjectDemo2();
     Object od1=new ObjectDemo2();
     //包名+类名
     System.out.println(od.getClass());//class cn.tedu.object.ObjectDemo2
     //Object的实际创建类类型
     System.out.println(od1.getClass());//class cn.tedu.object.ObjectDemo2

4.hashcode()：返回对象的哈希码值  
哈希码值（1.取值范围广、2.散列分布——不会出现重复）

//不同对象的哈希码值不一样
    //哈希码值特点（1.取值范围广（41亿左右）   2.散列分布（均匀分布））
    //哈希码值不会重复———内存地址值唯一 ——— 用哈希码值代表地址值
    System.out.println(new Object().hashCode());
    //把十进制转成十六进制
    System.out.println(Integer.toHexString(new Object().hashCode()));

5.toString()：拼接对象地址值  
为了获取的是对象的属性值需要重写toString

package cn.tedu.object;
    
    public class ObjectDemo3 {
        
        public static void main(String[] args) {
        
            /*//创建对象
            ObjectDemo3 od=new ObjectDemo3();
            //od对象传入到底层valueOf()中要去调用Object类里的toString()
            //Object类里的toString方法默认给对象来拼接地址值
            System.out.println(od);
            //od对象直接调用Object类里的toString()来拼接地址值
            System.out.println(od.toString());*/
    
            //
            Person p=new Person();
            p.name="豆豆";
            p.gender='男';
            p.age=10;
    
            //调用Person类重写的toString方法来输出对象属性值
            System.out.println(p);
    
    
        }
    }
    
    //
    class Person{
        
        String name;
        char gender;
        int age;
    
        //重写Object类里的toString方法，为了获取对象的属性值
        //Ctrl+O --- 展示出可以重写的方法
       /* @Override 
        public String toString() {
            return this.name+","+this.gender+","+this.age;
        }*/
    
    
        //java自动生成
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", gender=" + gender +
                    ", age=" + age +
                    '}';
        }
    }

6.equals()：根据对象地址值来判断对象是否相等  
为了更加全面的来判断对象是否相等，根据对象地址值以及对象属性值来综合判断。需要重写equals方法（1.对象地址值，2.参数对象是否为null，3.两个对象的类型，4.比较属性值）

package cn.tedu.object;
    
    import java.util.Objects;
    
    public class ObjectDemo4 {
        
        public static void main(String[] args) {
        
            //创建对象
            Student s1=new Student();
            s1.name=null;
            s1.age=10;
            s1.gender='男';
            Student s2=new Student();
            s2.name=new String("张三");
            s2.age=10;
            s2.gender='男';
            //Student s2=s1;
    
            //Object类里的equals方法是根据对象地址值来判断对象是否相等
            System.out.println(s1.equals(s2));
    
        }
    }
    class Student{
        
        //属性
        String name;
        int age;
        char gender;
    
        //根据对象地址值和属性值来综合判断对象是否相等
        //需要重写equals方法
    
    /*    @Override
        public boolean equals(Object obj) {
            //1.判断对象地址值是否相等
            if(this==obj){
                return true;
            }
            //2.判断参数对象是否为null
            if(obj==null){
                return false;
            }
            //3.判断两个对象的类型是否一致
            //把所有类型不同的情况都排除掉
            if(this.getClass()!=obj.getClass()){
                return false;
            }
            //当代码执行到此行就表明从逻辑上两个对象的类型一致
            //但是从语法上而言两个对象的类型不一致
            Student s=(Student)obj;
    
            //4.比较对象属性值
            //比较两个对象的年龄
            if(this.age !=s.age){
                return false;
            }
            //比较两个对象的性别
            if (this.gender!=s.gender){
                return false;
            }
            //比较两个对象的姓名
            //根据两个name对象的地址值来判断name对象相等
            //name对象是String类型，调用的是String类型，重写的是equals方法
            //重写的方法——先比较对象地址值再比较对象的内容
            if (this.name==s.name||this.name!=null&&this.name.equals(s.name)){
                return true;
            }
            //两个对象的name属性不相等
            return false;
        }*/
        
        //java自动生成内容
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age &&
                    gender == student.gender &&
                    Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(name, age, gender);
        }
    }