Java常用类及其方法（一）Object

（一）：类Object:

    类Object是类层次结构的根类，每个类都使用Object作为根类。所有对象包括数组都实现这个类的方法
 A:常用的方法：
 1）public int hashCode();返回该对象的哈希码值
 2）public final Class getClass();返回此Object的运行时类
 3）public String toString();返回该对象的字符串表示
 4）public boonlean equals(Object obj):指示其他某个对象是否与此对象相等
 5）public Object clone():创建并返回此对象的一个副本，返回值是Object类型
 6）protected void finalize();当垃圾回收器确定不存在该对象的更多引用时，由对象的垃圾回收器调用此方法
 7）Scanner:简单的文本扫描器。jdk5.0以后用来获取键盘录入对象的
     B：
  1）public int hashCode()
  i:返回的是该对象的哈希码值哈希码值在底层通过哈希表进行的一个哈希算法算出来的，哈希码值不是实际地址值，可以理解为地址值（整数）
  2)public final Class getClass()
  i：返回此Object正在运行的类
  ii:可以通过Class类中的一个方法，获取对象的真实类的全名称
  publlic String getName();以String的形式返回此Class对象所表示的实体
  代码
  package Object类;

public class Student extends Object {
}
  public class StudentDemo {
public static void main(String[] args) {
 //创建学生类对象
 Student s=new Student();
 System.out.println(s.hashCode());
 Student s2=new Student();
 System.out.println(s2.hashCode());
 //Class类表示Java应用程序正在运行的类或者接口（类对象）：反射机制中讲
 Class c=s.getClass();//返回当前正在运行的类
 System.out.println(c);//class Object类.Student
 String str=c.getName();
 System.out.println(str);//全路径名称：Object类.Student:包名.类名
 //直接走，链式编程
 String str2=s.getClass().getName();
 System.out.println(str);
}
}
     3）public String toString()
  i:返回该对象的字符串表示
  通常toString()方法会返回一个”以文本方式表示“此对象的字符串
  ii:toString()相当于：s.getClass.s.getName()+"@"+该方法所在的；类名.toHexString(int ）
  iii:Interger类：是int类型的包装类型
  从一个基本类型---->提升了Integer类型（JDK5.0以后特性：
  int类型---->自动装箱Integer类型
  Integer类型----->自动拆箱int)
  iiii:public static String toHexString(int i)
  以16进制（基数16）无符号整数形式返回一个整数参数字符串表示形式
  注意：
  创建对象，直接输出对象名称，其实是调用了toString()方法，打印出来的是一个全路径名称的一个地址值：包名.类名@16进制数据
  在一个类中重写toString()是不需要手动建立的，自动生成
代码
//学生类
public class Student extends Object{
private String name;
private int age;
public Student() {
 super();

}
public Student( 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;
}
//自动生成toString
//Alt+shift+s--->s
@Override
public String toString() {
 return "Student [name=" + name + ", age=" + age + "]";
}
//手动重写
public String toString1(){
 return "姓名"+"小米"+",年龄"+66;
}
}
另一个类中的代码
public class StudentTest {
public static void main(String[] args) {
 //创建学生类对象
 Student s=new Student();
 System.out.println(s.hashCode());
 System.out.println(s.getClass().getName());
 System.out.println(s.toString1());
 /*
  * ToString()的方法：等价于：
  * s.getClass().getName()+'@'+Integer.toHexString(s.hashCode())
  * toString 的原码：
  * public String toString(){
  * return getClass().getName()+'@'+Integer.toHexString(s.hashCode())
  * }
  */
 System.out.println(s.getClass().getName()+'@'+Integer.toHexString(s.hashCode()));
 Student s1=new Student("小红",17);
 System.out.println(s1);
}
}
    4）public boolean equals(Object obj)
 i:指示其他某个对象是否与此对象相等
 ii：equals()方法默认的比较的是两个对象的地址值是否相等，如果要比较的是他们的内容（成员变量）是否相同，那么就必须要重写equals()
 iii:怎么重写equals()？
 自动生成：重写的目的：更加了可以优化代码，提高代码的复用性
 iiii:注意
 equals和==的区别？
 ==：在String类：直接是两个对象的地址值是否相同
 equals()：默认的比较的是地址值，如果重写了Object中的equals()方法，那么就比较两个对象的内容是否相同
 equals的原码：
 public boolean equals(Object obj){
 return(this==obj)
 }
代码：
//学生类
public class Student {
private String name;
private int age;
public Student() {
 super();
}
public Student(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;
}
@Override
public String toString() {
 return "Student [name=" + name + ", age=" + age + "]";
}
//equals的原码：
//public boolean equals(Object obj){
//return(this==obj);
@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;
 Student other = (Student) 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;
}

}
//测试类
public class StudentTest {
public static void main(String[] args) {
 Student s1=new Student("修奥",18);
 System.out.println(s1);//相当于调用了toString全路径名称@16进制
 System.out.println(s1.getClass().getName()+'@'+Integer.toHexString(s1.hashCode()));
 Student s2=new Student("修奥",18);
 System.out.println(s2);
 System.out.println(s1.equals(s2));//fause
 Student s3=s1;
 System.out.println(s1.equals(s3));
 Demo d=new Demo();//连这个类型都不一样
 System.out.println(s1.equals(d));
 String str1="hello";
 String str2="world";
 System.out.println("str1:"+str1);
 System.out.println("str2:"+str2);
// change(str1,str2);
// System.out.println("str1:"+str1);
// System.out.println("str2:"+str2);
// private static void change(String str1,String str2);
// s2=s1;
// s2=s2+s1;
}
}
class Demo{
 
}
    5）protected Object clone(){}
 i:表示创建一个对象的副本：复制操作，返回的值是Object类型
 ii:Object类的clone方法执行特定的复制操作。首先，如果此对象的类不能实现接口Cloneable，则会抛出CloneNotSupportedException异常
 iii:自定义实现克隆步骤：
 A:自定义实现cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆
 B:自定义类中重写Object类的clone方法
 C：重写clone方法时通过super.clone()调用Object中的clone()方法来得到该对象的副本，并且返回该副本
代码：
public class Student {
private String name;
private int age;
 public Student() {
  super();
 }
 public Student(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;
}
 @Override
 protected Object clone() throws CloneNotSupportedException {
  return super.clone();
 }
 
}
//测试类
public class StudentTest {
public static void main(String[] args) throws CloneNotSupportedException {
 Student s=new Student();
 s.setName("小红");
 s.setAge(23);
 System.out.println(s.getName()+","+s.getAge());
System.out.println("--------");
//创建副本
Object obj=s.clone(); 
//向下转型，将obj强制转换成Student类型
Student s2=(Student) obj;
System.out.println(s2.getName()+","+s2.getAge());
System.out.println("........");
//之前的操作
Student s3=new Student();//在堆内存中重新开辟一个空间
s3.setName("小明");
s3.setAge(33);
Student s4=new Student();//将一个地址值赋值给s4对象
System.out.println(s4.getName()+","+s4.getAge());

}
}
    6）Scanner:简单的文本扫描器。jdk5.0以后用来获取键盘录入对象的
 i:创建键盘录入对象
 Scanner sc=new Scanner(System.in);
 构造方法：Scanner(InputStream is)
 InputStream:抽象类：抽象类不能直接实例化：字节输入(IO流）
 InputStream is=System.in;标准输入流：抽象类多态
 int a=sc.nextInt();
 ii:Scanner类中常用的；两个方法:
 sc.nextInt();接受的是一个整数类型
 sc.nexLine();接收的是一个字符串类型
 发现细节问题：先接收一个int类型，再去接收一个字符串类型，发现字符串类型的值会遗漏掉，而是直接输出int类型的值，字符串是空的，没有值，为什么？
 跟回车换行符有关系，如何解决？
 在输入字符串之前，在创建一个键盘录入对象
代码：
 import java.util.Scanner;

public class ScannerDemo {
public static void main(String[] args) {
 //需求：输入两个int类型的数据
 Scanner sc=new Scanner(System.in);
 int a=sc.nextInt();
 int b=sc.nextInt();
 System.out.println(3+","+4);
 //需求：输入两个String类型的数据
 String s1=sc.nextLine();
 String s2=sc.nextLine();
 System.out.println(a+","+b);
 //需求:先输入一个int类型，在输入一个字符串类型
 Scanner sc1=new Scanner(System.in);
 int c=sc1.nextInt();
 //因为先是int类型，防止出现遗漏值，所以重新创建一个新的键盘录入对象
 Scanner sc2=new Scanner(System.in);
 String d=sc2.nextLine();
 System.out.println(6);
 System.out.println(d);
}
}