初始Java6-优快云博客

本文链接：https://blog.youkuaiyun.com/pingwenqi/article/details/145227030

一.Cloneable接口和深拷贝

1.克隆Cloneable

定义：clone就是拷贝对象使用的。

格式：

class Animal implements Cloneable {
private String name;
@Override
public Animal clone() {
Animal o = null;
try {
o = (Animal)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Animal animal2 = animal.clone();
System.out.println(animal == animal2);
}
}
// 输出结果
// false

首先在主方法内进行克隆操作：Animal animal2 = animal.clone(); clone是object内部的方法所以要进行重写（其中要进行异常抛出CloneNotSupportedException）。与此同时在要进行克隆的对象其创建的时候进行实现Cloneable接口class Animal implements Cloneable。

2.深拷贝与浅拷贝

区别：

当进行对象新属性添加后，改变原对象该属性的值，浅拷贝中的克隆会改变（因为对于新属性的引用，原对象与新对象使用的是同一块地址），而深拷贝中的克隆不会改变（其中克隆了新属性并放到另一地址中，两个地址不会有影响）。

所以深拷贝与浅拷贝的关键在于对新属性是否再克隆，表现是对对象新属性添加后，改变原对象该属性的值，克隆对象是否改变。

实例：

class Money {
public double m = 99.99;
}
class Person implements Cloneable{
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo3 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person();
Person person2 = (Person) person.clone();
System.out.println("通过person2修改前的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
person2.money.m = 13.6;
System.out.println("通过person2修改后的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
}
}
// 执行结果
//通过person2修改前的结果
//99.99
//99.99
//通过person2修改后的结果
//13.6
//13.6

二.object类

1.定义：

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

class Person{}
class Student{}
public class Test {
public static void main(String[] args) {
function(new Person());
function(new Student());
}
public static void function(Object obj) {
System.out.println(obj);
}
}
//执行结果：
Person@1b6d3586
Student@4554617c

自定义方法传参的时候可以进行传入Object类。

2.获取对象：ToString

打印对象中的内容，可以直接重写 Object 类中的 toString() 方法

// Object类中的toString()方法实现：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

3.对象比较：equal（）

在 Java 中， == 进行比较时：

a. 如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同

b. 如果 == 左右两侧是引用类型变量，比较的是引用变量地址是否相同

c. 如果要比较对象中内容，必须重写 Object 中的 equals 方法，因为 equals 方法默认也是按照地址比较的：

// Object类中的equals方法
//public boolean equals(Object obj) {
//return (this == obj); // 使用引用中的地址直接来进行比较
//}  // 不重写的时候
//重写时
public boolean equals(Object obj) {
if (obj == null) {
return false ;
}
if(this == obj) {
return true ;
}
// 不是Person类对象
if (!(obj instanceof Person)) {
return false ;
}
Person person = (Person) obj ; // 向下转型，比较属性值
return this.name.equals(person.name) && this.age==person.age ;
}
}//
class Person{
private String name ;
private int age ;
public Person(String name, int age) {
this.age = age ;
this.name = name ;
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person("gaobo", 20) ;
Person p2 = new Person("gaobo", 20) ;
int a = 10;
int b = 10;
System.out.println(a == b); // 输出true
System.out.println(p1 == p2); // 输出false
System.out.println(p1.equals(p2)); // 输出false
}
}

结论：比较对象中内容是否相同的时候，一定要重写 equals 方法。

4.hashcode（）方法：public native int hashCode();

用处：我算了一个具体的对象位置，

因为是native类型（底层c/c++写的代码）所以看不到

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写 hashcode() 方法，我们可以来看示例

代码：

class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
//执行结果
460141958
1163157884

注意事项：两个对象的 hash 值不一样。

像重写 equals 方法一样，我们也可以重写 hashcode() 方法。此时我们再来看看。

class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode())；
System.out.println(per2.hashCode());
}
}
//执行结果
//460141958
//460141958//哈希值一样

结论：

1 、 hashcode 方法用来确定对象在内存中存储的位置是否相同（一般重写）

2 、事实上 hashCode() 在散列表中才有用，在其它情况下没用。在散列表中 hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

三.内部类

1.定义：

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在 Java 中， 可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类 。内部类也是封装的一种体现。

public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类
//    定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
//    内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件
public class A{
}
class B{
}
// A 和 B是两个独立的类，彼此之前没有关系

2.分类：

内部类因为在一个类的不同位置进行定义

public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类
public class InnerClass1{
}
// 成员位置定义：被static修饰 ---> 静态内部类
static class InnerClass2{
}
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
class InnerClass5{
}
}
}

（1）.实例内部类

内部类中不能声明static静态变量，后加final变成常量可以

内部类不能直接在其他类中进行实例化，需要外部类名.内部类名it=new 外部类（）.new 内部类名（）

内部类访问外部类时，内部与外部类名不同可直接访问，当相同时：this.it访问的时内部类变量，外部类.this.it访问的是外部类。

其字节码文件命名为需要外部类名$内部类名

外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

public class OutClass {
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 实例内部类：未被static修饰
class InnerClass{
int c;
public void methodInner(){
// 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
a = 100;
b =200;
methodA();
methodB();
// 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
c = 300;
System.out.println(c);
// 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
OutClass.this.c = 400;
System.out.println(OutClass.this.c);
}
}
public static void main(String[] args) {
// 外部类：对象创建 以及 成员访问
OutClass outClass = new OutClass();
System.out.println(outClass.a);
System.out.println(OutClass.b);
System.out.println(outClass.c);
outClass.methodA();
outClass.methodB();
System.out.println("=============实例内部类的访问=============");
// 要访问实例内部类中成员，必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodInner();
}}

（2）.静态内部类

创建静态内部类对象时，不需要先创建外部类对象，内部类不能直接在其他类中进行实例化，需要外部类名.内部类名it=new 外部类名.内部类名（）

在静态内部类中只能访问外部类中的静态成员内部类访问外部类变量外部类名.变量名。

public class OutClass {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 静态内部类：被static修饰的成员内部类
static class InnerClass{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
// a = 100; // 编译失败，因为a不是类成员变量
b =200;
// methodA(); // 编译失败，因为methodB()不是类成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.methodInner();
}
}

（3）.局部内部类

局部内部类只能在所定义的方法体内部使用

不能被 public 、 static 等修饰符修饰

编译器也有自己独立的字节码文件，命名格式：外部类名字 $ 数字内部类名字 .class

几乎不会使用

public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}