JAVA学习第七天之面向对象深入

学习目的

掌握Object类需重写的方法
掌握包机制引入的概念及用法
掌握Java的访问控制权限
了解Java内部类的概念及用法

一.Object类

概念
Object 类是所有Java类的根基类，每个类都默认继承 Object类作为超类<父类>。所有的对象，包括数组，都实现这个Object类的方法。
常见方法

Object clone();//返回该对象的一个副本；
boolean equals(Object obj);//判断该对象与指定对象obj 是否相等；
final 类<?> getClass()**;//返回该对象的运行时类<返回字节码的类名>；
int hashCode();//返回对象在堆内存中的哈希码值；
String toString();//返回对象的字符串表示形式；
void finalize();//启动垃圾收集器，回收堆内存对象，释放内存。

1.1 toSring()方法

方法说明
toSring()方法返回该对象的字符串表示，建议每个类都重写toString()方法。未重写时返回对象的哈希码地址的无符号十六进制，重写后返回一个以文本方式表示此对象的字符串。
特点

未重写：每次输出引用时，默认调用，返回该对象的由** 类名@ 和此对象哈希码的无符号十六进制**组成的字符串；
重写后：由对象调用，输出该对象的文本表示，一般为输出该对象的各个属性。

原理

//Object源码：未重写toString()时的原理
 public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
//Integer源码：toHexString()方法，将hashCode() = i 转换成十六进制表示
public static String toHexString(int i) {
        return toUnsignedString0(i, 4);
    }

println(A.toString());//未重写：arrays.Person@7f31245a
println(A.toString());//重写：name=
class A{
    String name;
    public String toString() {
        return "Person{" + "name='" + name + '\'' + '}';
    }
}

1.2 equals()方法

方法说明
equals()方法是用于判断两个对象是否相等的一个方法。判断两个基本类型数值可以用==号，但用==号判断两个引用类型时，只是判断他们的地址是否相等，并不能判断两个引用类型的所有数值相等（地址及属性）。
特点
未重写Object本身的equals()方法时，equals()底层也是使用"==号"进行"=="比较，不能满足现实中的要求。
重写equals()的实质

类型转换：将两个引用类型对象转换成相同类型的对象才可以比较，可能需要使用instanceof转换符；
对象转型：将参与比较的对象（引用类型）转换为可直接比较的"基本数据类型"，暨将对象比较转成属性比较；
对象属性比较：对于两个相同类型的对象，使用==号逐一比较它们各个属性是否相等，从而得出两个对象是否相等。

重写原则
equals()重写时必须彻底，即一个对象中有n个属性，重写时也必须比较n个属性；若属性也是引用类型（对象相关），那么在每个引用类型属性中也要进行equals()重写。
重写模板

 public boolean equals(Object o) {
        if (this == o) return true;
        //判断"参与比较的引用类型"是否为空，或是相同的数据类型
        if (o == null || getClass() != o.getClass()) return false;
        //对"参与比较的引用类型"进行类型转换
        AutoString  as = (AutoString) o;
        // ==比较两个对象的每一个属性是否相等
        return this.属性1 == as.属性1 &&
                this.属性2 == as.属性2 &&
                this.属性3 == as.属性3;
    }
//重写示例
public class MyTime {
    private int year;
    private int month;
    private String day;

    public boolean equals(Object o) {
        if (this == o) return true;//内存地址若相同，直接返回true
        if (o == null || getClass() != o.getClass()) return false;
        MyTime myTime = (MyTime) o;
        return year == myTime.year && 
               month == myTime.month &&
               day.equals(myTime.day);//day属性为String引用类型，在day类中也要重写equals()
    }
}

equals()方法与==号比较图解

equals()方法与 ==号的内存模型分析图.png

1.3 finalize()方法

方法说明
finalize()方法是Object提高的用于回收垃圾对象的方法，以释放对象所占用的堆内存。当垃圾收集器将要收集某个垃圾对象时，JVM的GC回收器将会自动调用 finalize()方法。
垃圾对象
当一个对象不再有局部变量或引用保存其地址时，该对象成为垃圾对象，即对象 = null。
特点

finalize()不一定会调用：当垃圾对象数量过少时，垃圾回收器可能调用finalize()方法（jdk8可允许存在的垃圾对象数量在1千万个以上）；
垃圾回收器未启动则未调用：当垃圾回收器未启动时，也不会调用finalize()方法（在jdk9以后finalize()已失效）；
finalize()由System.gc()启动垃圾回收器后调用，不是Object子类对象调用，子类对象可以重写finalize()，但不会调用。

特殊点
finalize()方法在Object 类底层使用protected 修饰，并不是 public公开的。因此一个类不显式的去重写finalize()时，gc默认调用的是Object的finalize()，除了释放内存没有其他实际意义。
重写finalize()

所有对象在JVM中被释放的时候，请记录对象被释放的时间点

class A{
    // 重写finalize()方法，当A类型的对象被gc回收时
    //gc负责调用重写的finalize()，记录对象释放的时间点，配合输出流将释放记录 输出为日志文件
    protected void finalize() throws Throwable {
        // this代表当前对象
        System.out.println(this + "即将被销毁！");
    }
}

1.4 clone()方法

方法说明
clone() 方法是 Object 类中使用protected 修饰的方法，它实现的是对一个对象的复制，返回的是一个新的对象，而不是一个引用(变量)。
特点

不公开：clone() 方法protected 修饰的，因此一个类不显式的去重写 clone()方法时，其它类不能直接去调用该类的clone() 方法；
返回对象：clone()实现的是对对象的复制，返回也是一个对象。

使用条件

实现Cloneable接口：重写clone()方法的类必须实现Cloneable接口，Cloneable接口只是规定，该接口内并无任何可实现的方法。若一个类没有实现 Cloneable接口又调用了 clone()方法，就会抛出CloneNotSupportedException；
重写的访问控制权限为public：重写clone()方法是为了可以给别人调用，因此必须是公开的（访问权限比Object类高）。

//实现 Cloneable 接口
public class Myclone implements Cloneable{
    int a;
    int b;
//重写Object类的clone()方法，访问控制权限为public
    @Override
    public Object clone() throws CloneNotSupportedException {
        //return (Myclone)super.clone();
        return super.clone();
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
        Myclone mc = new Myclone();
        //Myclone mc1 = mc.clone();
        Myclone mc1 = (Myclone) mc.clone();
        System.out.println(mc == mc1);//false
        System.out.println(mc.a == mc1.a);//true
    }

1.4 .1 深克隆

概念
深克隆指的是创建一个新对象，属性中引用的其他对象也会被复制克隆，不再指向原有对象地址。

public class DeepCloneExample implements Cloneable { 
          private int[] arr;
          //重写clone()方法
          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

1.4 .2 浅克隆

概念
浅克隆指的是创建一个新对象，新对象的属性和原对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象内存地址。即新对象和原对象共享引用数据类型属性的对象地址。

public class ShallowCloneExample implements Cloneable { 
          private int[] arr;
          //重写clone()方法 
          protected ShallowCloneExample clone() throws CloneNotSupportedException { 
                return (ShallowCloneExample) super.clone(); 
          } 
}

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

1.5 hashCode()方法

方法说明
hashCode()方法是一个可以得到对象在堆内存地址的方法。未重写时，直接调用Object的hashCode()得到对象的哈希地址。重写后，在重写的hashCode()底部，使用Objects类的hash()方法对该对象的各个属性进行计算得到哈希码值。
特点
重写hashCode()后，得到的是对象在堆内存中存储的数组下标（若对象是以HashSet集合存储的话）。
原理

未重写：未重写的hashCode()在Object底层是调用c++程序完成计算得出对象的内存地址；
重写：重写的hashCode()在底层是调用Objects类的hash()方法将重写对象的每个属性值存储到Arrays数组中，再调用Arrays数组的hashCode()方法将每一个属性值通过计算得出最终的对象地址；而在Arrays数组的hashCode()内部求属性的hashCode时，调用的还是Object的hashCode()；
重写：Object.hashCode() → 子类.hashCode() → Objects.hash(elements) → Arrays.hashCode(elements) → elements.hashCode() → Object.hashCode()

执行原理

class User{
    String name;
    int age;
    //hashCode()一般与equals()同时重写
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }
    //重写hashCode()
    public int hashCode() {
        return Objects.hash(name, age);//name和age都是values
    }
}
//Objects类底层的hash()原理
public static int hash(Object... values) {
        return Arrays.hashCode(values);
    }
//Arrays工具类底层的hashCode(values)
public static int hashCode(Object a[]) {
        if (a == null)  return 0;
        int result = 1;
        for (Object element : a){
            result = 31 * result + (element == null ? 0 : element.hashCode());//element调用的还是object的hashCode()
        }
        return result;
    }

二.包和import机制

2.1 包

常规编程存在问题

类名混乱：在编程开发中需要定义的类很多，每个类的功能作用也不一样，全都放在一块易混乱，可读性差，不方便查找；
绝对路径与相对路径：javac编译源程序时，是编译当前路径下的文件，采用的是相对路径，若想要编译另一处（另一个包下）的文件，则出现找不到文件错误；
编译：javac编译命令后面编写的类名不是原始类名，原始类名是包形式的类名；

包原理
包相当于目录，用于项目比较大、文件特别多、类特别多的环境中，采用分包目录管理，不仅方便快速查找每一个类，可读性也很强。
分类

自定义包：自定义包就是开发人员编写项目时的项目目录；
本地包：本地包是java语言开发者已经编写好的各种包，存放于jdk的jre目录下。

包命名规则

包名通常全部采用小写；
命名不能重复，一般采用公司网站逆序，如：域名.公司名.项目名.模块名。

2.2 import引入机制

概念
包定义好后，包在项目中的使用主要采用import package 包名的方式引入包或类。
使用规则

package 必须放到所有语句的第一行<顶头>，注释除外；
采用 import 通配符<全类名>引入需要使用的类；
可以采用星号<*>通配符引入包下的所有类。

常用包

java.lang：此包 Java 语言标准包，使用此包时无需 import 引入；
java.sql：提供了 JDBC 接口类；
java.util：提供了常用工具类；
java.io：提供了各种输入输出流；
详情请见java常用包的使用

三.访问控制权限

概念
访问控制权限是java提高的，用于控制各个类或对象访问其他类的属性和方法的一种权限。因为包机制的引入，开发者可以调用其他包或类的方法，但是为了安全性考虑，java提供了访问权限来修饰类，从而控制调用者的访问。
分类

public：public声明的变量或方法是完全公开的，在任意地方都可以使用；
private：private声明的变量或方法，只能在同一个类中使用；
protected ：protected声明的变量或方法，只有子类或同一个包下的类可以调用；
默认不写：若一个类既不采用 public修饰也没有采用其他修饰符修饰，则该类只有在同一个类中或在同一个包下才可以访问，在子类中也不能访问；
default：JDK8以后提供的关键字，是接口中默认的方法实现。

访问控制权限.png

使用位置

类、接口：修饰类或者接口的控制权限只能是public 和 default；
方法：private、protected、default、public都可以使用修饰；
属性、变量：private、protected、default、public都可以使用修饰。

四.内部类

概念
内部类指的是在一个已定义好的类内部，再次定义的类。
分类
成员内部类、局部内部类、静态内部类。
缺点
可读性差，不建议使用。

4.1 实例内部类

定义
实例内部类是以类的形式作为外部类的实例变量<实例属性>来定义的一个类。
位置
类体中，属于类级别，与实例变量（成员变量）同位。
创建条件

外部类的实例变量必须已经创建，即外部属性要比内部类先定义创建；
实例内部类的内部不能采用 static 声明，即不能定义static成员，只能定义实例成员；
实例内部类可以持有或访问外部类的引用。

使用方式
外部类.内部类引用 = new 外部类(参数列表).new 内部类();
代码示例

public class InnerTest {
    //静态变量
    static int Inner_i ;
    //非静态变量
    int Inner_j;
    //实例内部类
    class Inner2{
        //static int k;//不能定义static静态的属性或方法
        int k;
        public void getInner(){
            System.out.println(Inner_i);//可以访问外部类的静态变量
            System.out.println(Inner_j);//可以访问外部类的非静态变量
        }
    }

    public static void main(String[] args) {
        //创建实例内部类Inner2对象
        InnerTest.Inner2 inner = new InnerTest().new Inner2();
        System.out.println(inner.k);//访问内部类的实例变量
    }
}

4.2 局部内部类

定义
局部内部类是 以类的形式作为外部类方法的局部变量<参数类型>来定义的一个类。和局部变量一样有局限性，生命周期与方法一起结束，局部内部类不能创建对象。
位置
在外部类的方法内部，作为外部类方法的局部变量，或方法的参数列表。
创建条件

局部内部类在方法中定义，因此外部类必须先创建出方法；
只能在当前方法中使用<生命周期同局部变量>；
内部不能采用 static 声明，即不能定义static成员，只能定义实例成员；
局部变量在内部类中使用时，必须采用 final 修饰。

作用
通常作为方法的参数，取代一个接口的实现类，让参数 = 内部类 = 接口实现类。
使用方式

public class InnerTest {
    //静态变量
    static int Inner_i ;
    //非静态变量
    private int Inner_j;

    //实例内部类
    class Inner2{
        int k;
        public void getInner(){ }
    }

    //成员方法（实例方法）
    public void add(){
        //局部变量
        int g = 100;
        //局部内部类
        final class Inner3{
            int e;//局部内部类的实例变量，不需要初始化
            public void getInner(){
                System.out.println(Inner_i);//可以访问外部类的静态变量
                System.out.println(Inner_j);//可以访问外部类的非静态变量(包括私有的)
                System.out.println(new InnerTest().new Inner2());//可以访问创建实例内部类
            }
        }

    public static void main(String[] args) {
        InnerTest inner = new InnerTest();
       //inner.add().new Inner3();//局部内部类不能创建对象
    }
}

4.3 静态内部类

定义
静态内部类是在已定义好的类体中，使用static关键字修饰的一个类。
位置
static属性都是类级别的，静态内部类和类的成员变量处于同等位置<静态的不可定义在方法内部>。
创建条件
静态内部类参照静态代码块，静态的内部不会也不能持有外部的非静态属性或方法。
使用方式
静态内部类可以访问外部的静态变量，但访问外部类的成员变量必须通过外部类的实例<对象>访问。

public class InnerTest {
    //非静态-成员方法
    public void sum() { }
    //静态变量
    static int Inner_i ;

    //静态内部类
    static class Inner1{
        //静态内部类的构造方法
        public Inner1() { }

        public void getInner(){
            System.out.println(Inner_i);//可以访问外部类的静态变量
            //System.out.println(new InnerTest().sum());//不能访问外部类的非静态成员方法
        }
    }

    public static void main(String[] args) {
        //静态内部类不能使用new，直接使用类名即可
        //InnerTest.Inner1 inner = new InnerTest().new Inner1();
    }
}

4.4 匿名内部类

定义
匿名内部类是一种特殊的、没有名字或标识符的内部类，是局部内部类的一种。
位置
方法体内，与局部变量同一位置。
实质
匿名内类提供了一个选择，当接口没有实现类时，却又想使用接口的方法。接口作为完全抽象的类，不能直接new接口，只能new接口的实现类，然后通过new接口实现类的对象去覆盖接口的方法。
使用格式

在一个与接口毫无关联的类中，把接口作为该类方法的参数，利用该方法的形参去调用目标接口的方法；
创建该类的对象，使用对象.方法( new 接口(){ 接口方法(){} };)；
即在方法的参数列表里new 接口的具体实现，从而取代接口的实现类。

代码示例
正常的接口实现类格式：

public class InnerTest2 {
    public static void main(String[] args) {
        MyMath mm = new MyMath();
        //接口实现类-实现接口方法格式
        mm.mySum(new MathImpl(),10,20);
    }
}

interface Math{
    public int sum(int a,int b);
}
class MathImpl implements  Math{
    public int sum(int a, int b) {
        return a + b;
    }
}

class MyMath{
   //此处Math m使用多态，运行时会创建Math的实现类对象，调用实现类对象重写后的sum()方法
    public void mySum(Math m,int x,int y){
        int result =  m.sum(x,y);
        System.out.println(x + "+" + y + "=" + result);
    }
}

匿名内部类的使用格式：以匿名内部类取代传统的实现类-重写接口的方法

public class InnerTest2 {
    public static void main(String[] args) {
        MyMath mm = new MyMath();
        //匿名内部类："虚假的 new 接口(){ 并重写接口方法() }"
        mm.mySum(new Math() {
            public int sum(int a, int b) {
                return a + b;
            }
        },100,200);
    }
}

interface Math{
    public int sum(int a,int b);
}
//匿名内部类 取代 接口的实现类
//class MathImpl implements  Math{   }
class MyMath{
    //将接口作为参数，调用时使用多态
    public void mySum(Math m,int x,int y){
        int result =  m.sum(x,y);
        System.out.println(x + "+" + y + "=" + result);
    }
}

常见面试题

深克隆和浅克隆的区别和实现方式？
答：