JavaSE(3)关键字和Object

Xiao艾扶

墨衍会员 · AI 创作全网分发码龄7年

关注

原创 2022-03-17 16:36:10 411 阅读 AI 写同款· GEO 优化 ›

JavaSE中 this关键字的3种用法，你都知道吗？本篇博客浅浅来总结了在JavaSE中的this关键字的3种用法，并通过代码示例，希望让每一位铁汁们都把这个知识点弄懂弄透。阅读详情

JavaSE基础Day3部分—关键字、Object

前言

今天主要的是了解关键字，能够知道Object的基本内容和继承的部分。

1、关键字

1.1 final关键字

final是一个声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能够被改变的常量。

final可以用在修饰类、方法和变量（包括成员变量和局部变量）。

首先修饰类时，表明这个类不能被继承。并且在final类中修饰的所有成员方法都会被隐式地指定为final方法。
其次修饰方法时，通过final将方法锁定，以防任何继承类修改它的含义。
修饰变量是final用的最多的地方。对于基本类型，final 使数值不变；对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。

//举例
final int x=1;
x=2//这个是错误的
final A a = new A();
a.b=1;

1.2 static

static使用的地方应该会比final更多一些对于一般的程序员讲。

1、静态变量

静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。并且静态变量在内存中只存在一份。
实例变量：每创建一个实例就会产生一个实例变量，它与该实例具有一样的生命周期。

什么意思呢？看一下下面的举例：

public class A {

    private int x;         // 实例变量
    private static int y;  // 静态变量

    public static void main(String[] args) {
        int x = A.x; //错误写法 

        A a = new A();//正确写法
        int x = a.x;
        
        int y = A.y;
    }
}

2、静态方法

静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

public abstract class A {
    public static void func1(){
    }
    public abstract static void func2(){};  // 错误写法，abstract和static冲突
}

因为类所有的实例都共享静态变量，而且静态方法是实现的对象，意思就是静态方法是可以被静态变量所享受到共享的，而非静态就不能使用。当然这里的this和super也不能使用。

public class A {

    private static int x;
    private int y;

    public static void func1(){
        int a = x;
        int b = y;  // 错误
        int b = this.y;     // 错误
    }
}

3、静态语句块

静态语句块在类初始化时运行一次。

public class A {
    static {
        System.out.println("123456");
    }

    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

4、静态内部类

这个就比较有意思，因为非静态内部类依赖于外部类的实例(就是一个对象的创建就是创建一个对象实例)，也就是说需要先创建外部类实例，才能用这个实例去创建非静态内部类。而静态内部类不需要。

public class OuterClass {

    class InnerClass {
    }

    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass(); // 错误
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}

此时静态内部类不能访问外部类的非静态的变量和方法。

5、初始化顺序

静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。

public static String staticField = "静态变量";

static {
    System.out.println("静态语句块");
}

public String field = "实例变量";

{
    System.out.println("普通语句块");
}

最后才是构造函数的初始化。

public InitialOrderTest() {
    System.out.println("构造函数");
}

存在继承的情况下，初始化顺序为：

父类（静态变量、静态语句块）
子类（静态变量、静态语句块）
父类（实例变量、普通语句块）
父类（构造函数）
子类（实例变量、普通语句块）
子类（构造函数）

2、Object方法

2.1 equals()

1、等价关系

两个对象具有等价关系，需要满足以下五个条件：

自反性
x.equals(x); // true
对称性
x.equals(y) == y.equals(x); // true
传递性
if (x.equals(y) && y.equals(z))
    x.equals(z); // true;
一致性

多次调用 equals() 方法结果不变
x.equals(y) == x.equals(y); // true
equal与 null 的比较

对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
x.equals(null); // false;

2、等价与相等

对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。

Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y);      // false

2.2 hashCode()

hashCode() 返回哈希值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价，这是因为计算哈希值具有随机性，两个值不同的对象可能计算出相同的哈希值。

在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象哈希值也相等。

HashSet 和 HashMap 等集合类使用了 hashCode() 方法来计算对象应该存储的位置，因此要将对象添加到这些集合类中，需要让对应的类实现 hashCode() 方法。

下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象。但是 EqualExample 没有实现 hashCode() 方法，因此这两个对象的哈希值是不同的，最终导致集合添加了两个等价的对象。

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size());   // 2

当然理想的河西韩束总是存在均匀性，让不相等的对象应当均匀分布到所有可能的哈希值上。

2.3 toString()

默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。

public class ToStringExample {

    private int number;

    public ToStringExample(int number) {
        this.number = number;
    }
}

ToStringExample example = new ToStringExample(123);
System.out.println(example.toString());

ToStringExample@4554617c

2.4 clone()

1.cloneable

clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。

public class CloneExample {
    private int a;
    private int b;
}

CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'

重写 clone() 得到以下实现：

public class CloneExample {
    private int a;
    private int b;

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

CloneExample e1 = new CloneExample();
try {
    CloneExample e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

java.lang.CloneNotSupportedException: CloneExample

这是 CloneExample 没有实现 Cloneable 接口。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。

public class CloneExample implements Cloneable {
    private int a;
    private int b;

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

2. 浅拷贝

拷贝对象和原始对象的引用类型引用同一个对象。

public class ShallowCloneExample implements Cloneable {

    private int[] arr;

    public ShallowCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected ShallowCloneExample clone() throws CloneNotSupportedException {
        return (ShallowCloneExample) super.clone();
    }
}

ShallowCloneExample e1 = new ShallowCloneExample();
ShallowCloneExample e2 = null;
try {
    e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 222

3. 深拷贝

拷贝对象和原始对象的引用类型引用不同对象。

public class DeepCloneExample implements Cloneable {

    private int[] arr;

    public DeepCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected DeepCloneExample clone() throws CloneNotSupportedException {
        DeepCloneExample result = (DeepCloneExample) super.clone();
        result.arr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            result.arr[i] = arr[i];
        }
        return result;
    }
}

DeepCloneExample e1 = new DeepCloneExample();
DeepCloneExample e2 = null;
try {
    e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 2

4. clone() 的替代方案

使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。

public class CloneConstructorExample {

    private int[] arr;

    public CloneConstructorExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public CloneConstructorExample(CloneConstructorExample original) {
        arr = new int[original.arr.length];
        for (int i = 0; i < original.arr.length; i++) {
            arr[i] = original.arr[i];
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }
}