public class MyTest extends Object{
public static void main(String[] args) {
//Object 是我们所有类的顶层父类，所有类都是直接或间接继承自他
//创建Object类的对象
Object obj = new Object();
//Object类中常用的方法
//hashCode() 返回一个对象的哈希码值
int code = obj.hashCode(); //把对象的地址值换算成一个整数值
System.out.println(code);
Object obj2 = new Object();
int i = obj2.hashCode();
System.out.println(i);
//不同的对象的哈希码值不一样
}
}

equals（）方法

方法概述

指示其他某个对象是否与此对象“相等”
默认情况下比较的是对象的引用是否相同。
由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等

代码演示

public class MyTest2 {
public static void main(String[] args) {
//  boolean equals (Object obj) 比较两个对象的地址值是否相等
Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1==obj2);
boolean equals = obj1.equals(obj2);
System.out.println(equals);

//public boolean equals (Object obj){
//    return (this == obj);
//}
}
}

equals（）方法代码优化

优点

提高效率提高健壮性(instanceof)

代码演示

ublic class MyTest {
public static void main(String[] args) {
//Student student = new Student();
//Student student1 = new Student();
//System.out.println(student==student1);
////我们认为equals方法的默认实现，去比较两个对象的地址值是否相同，这个比较方式，我们认为不够好
////我们想要按照自己的比较方式，去比较
//
//student.equals(student1);

System.out.println("-----------------------");
//我们想要按照自己的比较方式，去比较 我认为只要两个对象的成员变量值一样，我就认为两个对象一样
Student student3 = new Student("张三", 23);
Student student4 = new Student("张三", 23);

System.out.println(student3.equals(student4));
}
}

class Dog {
}
-----------------
public class Student {
String name;
int age;

public Student() {
}

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

@Override
public boolean equals(Object obj) {
//instanceof 可以判断一个引用或者对象，是不是该类型的一个引用
//我认为，两个对象的成员变量一摸一样，我就认为两个对象一样
//向下转型
//优化比较效率
if(this==obj){
return true;
}

if(!(obj instanceof Student)){
return false;
}
Student stu= (Student) obj;
//"张三"=="张三" 有肯能 false  String 类认为父类Object中的 equals默认比较方式意义不大，String类 他重写了equals方法，去比较两个字符串字面内容是否相同
return this.name.equals(stu.name)&&this.age==stu.age;

}
}

getClass（）方法

概述

返回此 Object 的运行时类
可以通过Class类中的一个方法，获取对象的真实类的全名称

代码演示

public class MyTest {
public static void main(String[] args) {
//  Class<?> getClass () 按Java万物皆对象的思想，那么他会把 .class 文件看做一个对象

//Student.class 加载进内存后，JVM 就会为 Student.class文件创建一个对象
//我们可以把这个对象获取出来用，怎么获取，getClass（）这个方法可以获取
Student student1 = new Student("张三",23);
Student student2 = new Student("张三", 23);
Class aClass = student1.getClass(); //Student.class--->对象
Class aClass1 = student2.getClass();
System.out.println(student1==student2);//false

System.out.println(aClass==aClass1);//true

System.out.println("-----------------------------------------");
System.out.println(student1.equals(student1));//false
}
}

to String()方法

概述

由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
怎么重写, 一般是将该类的所有的成员变量组成返回即可

代码演示

public class MyTest {
public static void main(String[] args) {
//String toString ()
//返回该对象的字符串表示。
Object obj= new Object();
String s = obj.toString();
System.out.println(s);

Student student = new Student();
System.out.println(student.toString());

//public String toString () {
//    return getClass().getName() + "@" + Integer.toHexString(this.hashCode());
//}
//

System.out.println("------------------------");
Student student1 = new Student("张三", 24);
String s1 = student1.toString();
System.out.println(s1);

4000
// System.out.println(student1.getName()+"==="+student1.getAge());

Scanner scanner = new Scanner(System.in);
System.out.println(scanner.toString());

//如果我们以后直接打印一个对象名的时候，如果输出的不是地址值，说明该类重写了Object类中的toString()方法
}
}

class Student{
private String name;
private int age;

public Student() {
}

public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

//@Override
//public String toString() {
//    return "[姓名"+this.name+",年龄"+this.age+"]";
//}
}

clone（）方法

概述

clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
使用clone()方法采用的是浅克隆的方式
如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
Cloneable接口只不过是一个标识接口而已，没有任何方法
对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
对象的浅克隆也不会调用到构造方法的。

浅克隆

代码演示

public class MyTest {
public static void main(String[] args) throws CloneNotSupportedException {
//  protected Object clone () 创建并返回此对象的一个副本。
Dog dog = new Dog();
Object clone = dog.clone(); //克隆对象时不会执行构造方法

Dog dog1= (Dog) clone;
dog1.eat();
}
}

//Cloneable 里面没有任何抽象方法，这种接口，我们称之为标记即可，作用就是让JVM知道，我要克隆
class Dog implements Cloneable{
public Dog() {
System.out.println("构造方法执行了");
}

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

public void eat(){
System.out.println("狗吃肉");
}
}

浅克隆2

代码演示

public class MyTest {
public static void main(String[] args) throws CloneNotSupportedException {
//Dog dog = new Dog();
//dog.name="旺财";
//dog.age=3;
//Dog dog1= (Dog) dog.clone();
//dog1.name="赛虎";
//dog1.age=4;
//System.out.println(dog.name+"==="+dog.age);
//System.out.println(dog1.name + "===" + dog1.age);
DogFood dogFood = new DogFood("王中王");
Dog dog1 = new Dog("旺财", 2, dogFood);
dog1.food.name="双汇";
Dog dog2 = (Dog) dog1.clone();
dog2.name="赛虎";
dog2.age=34;
dog2.food.name="金锣";
System.out.println(dog1.name + "==" + dog1.age + "===" + dog1.food.name);//金锣
System.out.println(dog2.name + "==" + dog2.age + "===" + dog2.food.name);//金锣

}
}

class Dog implements Cloneable{
String name;
int age;
DogFood food;

public Dog() {
}

public Dog(String name, int age, DogFood food) {
this.name = name;
this.age = age;
this.food = food;
}

public void show(){
System.out.println(name+"==="+age);
}

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

class DogFood{
String name;

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

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

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航