Java基础——面向对象编程（补充）

对象数组：

定义：

数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用类型中的类时，称为对象数组。

标红：

对象数组，首先要创建数组对象本身，即确定数组的长度，然后再创建每一个元素对象，如果不创建，数组的元素的默认值就是null，所以很容易出现空指针异常NullPointerException。

举例：

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。其中为20个学生创建数组，数组的元素是学生。学生是类。所以就构成对象数组。

类中属性赋值：

在类的属性中，可以有哪些位置给属性赋值？

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过"对象.属性"或"对象.方法"的方式，给属性赋值

这些位置执行的先后顺序是怎样？

顺序：① - ② - ③ - ④

说明：

上述中的①、②、③在对象创建过程中，只执行一次。

④ 是在对象创建后执行的，可以根据需求多次执行。

JavaBean:

JavaBean是一种Java语言写成的可重用组件。

• • 好比你做了一个扳手，这个扳手会在很多地方被拿去用。这个扳手也提供多种功能(你可以拿这个扳手扳、锤、撬等等)，而这个扳手就是一个组件。

所谓JavaBean，是指符合如下标准的Java类：

• • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的get、set方法
• 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
• 《Think in Java》中提到，JavaBean最初是为Java GUI的可视化编程实现的。你拖动IDE构建工具创建一个GUI 组件（如多选框），其实是工具给你创建Java类，并提供将类的属性暴露出来给你修改调整，将事件监听器暴露出来。

UNL类图：

UML（Unified Modeling Language，统一建模语言），用来描述软件模型和架构的图形化语言。

• 常用的UML工具软件有PowerDesinger、Rose和Enterprise Architect。
• UML工具软件不仅可以绘制软件开发中所需的各种图表，还可以生成对应的源代码。
• 在软件开发中，使用UML类图可以更加直观地描述类内部结构（类的属性和操作）以及类之间的关系（如关联、依赖、聚合等）。
  • +表示 public 类型， - 表示 private 类型，#表示protected类型
  • 方法的写法:  方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型
  • 斜体表示抽象方法或类。

 

Object类的使用：

如何理解根父类：

类 java.lang.Object是类层次结构的根类，即所有其它类的父类。每个类都使用 Object 作为超类。

• Object类型的变量与除Object以外的任意引用数据类型的对象都存在多态引用

1. (Object obj){…} //可以接收任何类作为其参数
   
   Person o = new Person(); 
   method(o);

• 所有对象（包括数组）都实现这个类的方法。
• 如果一个类没有特别指定父类，那么默认则继承自Object类。例如：

1. class Person {
   ...
   }
   //等价于：
   public class Person extends Object {
   ...
   }

 

Object类的方法：

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。这里我们主要关注其中的6个：

1、(重点)equals()

= =：

• 基本类型比较值:只要两个变量的值相等，即为true。

1. a=5;
   if(a==6){…}

• 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。

1. p1=new ();      
   Person p2=new Person();
   if (p1==p2){…}
   • 用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错

equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。

• 只能比较引用类型，Object类源码中equals()的作用与“==”相同：比较是否指向同一个对象。 

• 格式:obj1.equals(obj2)
• 特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
  • 原因：在这些类中重写了Object类的equals()方法。
• 当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等
• 重写equals()方法的原则
  • 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
  • 自反性：x.equals(x)必须返回是“true”。
  • 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
  • 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
  • 任何情况下，x.equals(null)，永远返回是“false”；

• •  x.equals(和x不同类型的对象)永远返回是“false”。

2、(重点)toString()

方法签名：public String toString()

① 默认情况下，toString()返回的是“对象的运行时类型 @ 对象的hashCode值的十六进制形式"

② 在进行String与其它类型数据的连接操作时，自动调用toString()方法

Date now=new Date();
System.out.println(“now=”+now);  //相当于
System.out.println(“now=”+now.toString());

③ 如果我们直接System.out.println(对象)，默认会自动调用这个对象的toString()

因为Java的引用数据类型的变量中存储的实际上时对象的内存地址，但是Java对程序员隐藏内存地址信息，所以不能直接将内存地址显示出来，所以当你打印对象时，JVM帮你调用了对象的toString()。

④ 可以根据需要在用户自定义类型中重写toString()方法  如String 类重写了toString()方法，返回字符串的值。

 3、clone()

//Object类的clone()的使用
public class CloneTest {
	public static void main(String[] args) {
		Animal a1 = new Animal("花花");
		try {
			Animal a2 = (Animal) a1.clone();
			System.out.println("原始对象：" + a1);
			a2.setName("毛毛");
			System.out.println("clone之后的对象：" + a2);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

class Animal implements Cloneable{
	private String name;

	public Animal() {
		super();
	}

	public Animal(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Animal [name=" + name + "]";
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
	
}

4、finalize()

• 当对象被回收时，系统自动调用该对象的 finalize() 方法。（不是垃圾回收器调用的，是本类对象调用的）
  • 永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。
• 什么时候被回收：当某个对象没有任何引用时，JVM就认为这个对象是垃圾对象，就会在之后不确定的时间使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize()方法。
• 子类可以重写该方法，目的是在对象被清理之前执行必要的清理操作。比如，在方法内断开相关连接资源。
  • 如果重写该方法，让一个新的引用变量重新引用该对象，则会重新激活对象。

在JDK 9中此方法已经被标记为过时的。

5、getClass()

public final Class<?> getClass()：获取对象的运行时类型

因为Java有多态现象，所以一个引用数据类型的变量的编译时类型与运行时类型可能不一致，因此如果需要查看这个变量实际指向的对象的类型，需要用getClass()方法

public static void main(String[] args) {
    Object obj = new Person();
    System.out.println(obj.getClass());//运行时类型
}

结果：

class com.atguigu.java.Person

6、hashCode()

public int hashCode()：返回每个对象的hash值。(后续在集合框架章节重点讲解)

public static void main(String[] args) {
    System.out.println("AA".hashCode());//2080
    System.out.println("BB".hashCode());//2112
}

 native关键字的理解：

使用native关键字说明这个方法是原生函数，也就是这个方法是用C/C++等非Java语言实现的，并且被编译成了DLL，由Java去调用。

• 本地方法是有方法体的，用c语言编写。由于本地方法的方法体源码没有对我们开源，所以我们看不到方法体
• 在Java中定义一个native方法时，并不提供实现体。

1. 为什么要用native方法

Java使用起来非常方便，然而有些层次的任务用java实现起来不容易，或者我们对程序的效率很在意时，例如：Java需要与一些底层操作系统或某些硬件交换信息时的情况。native方法正是这样一种交流机制：它为我们提供了一个非常简洁的接口，而且我们无需去了解Java应用之外的繁琐的细节。

2. native声明的方法，对于调用者，可以当做和其他Java方法一样使用

native method的存在并不会对其他类调用这些本地方法产生任何影响，实际上调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM将控制调用本地方法的所有细节。

单例设计模式：

设计模式概述：

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。"套路"

经典的设计模式共有23种。每个设计模式均是特定环境下特定问题的处理方法。

简单工厂模式并不是23中经典模式的一种，是其中工厂方法模式的简化版 

何为单例模式：

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

实现思路：

如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例模式两种实现方式：

饿汉式：

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();

    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}

懒汉式：

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }
}

饿汉式vs懒汉式：

饿汉式：

• 特点：立即加载，即在使用类的时候已经将对象创建完毕。
• 优点：实现起来简单；没有多线程安全问题。
• 缺点：当类被加载的时候，会初始化static的实例，静态变量被创建并分配内存空间，从这以后，这个static的实例便一直占着这块内存，直到类被卸载时，静态变量被摧毁，并释放所占有的内存。因此在某些特定条件下会耗费内存。

懒汉式：

• 特点：延迟加载，即在调用静态方法时实例才被创建。
• 优点：实现起来比较简单；当类被加载的时候，static的实例未被创建并分配内存空间，当静态方法第一次被调用时，初始化实例变量，并分配内存，因此在某些特定条件下会节约内存。
• 缺点：在多线程环境中，这种实现方法是完全错误的，线程不安全，根本不能保证单例的唯一性。
  • 说明：在多线程章节，会将懒汉式改造成线程安全的模式。

单例模式的优点及应用场景：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

应用场景：

• Windows的Task Manager (任务管理器)就是很典型的单例模式
• Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
• Application 也是单例的典型应用
• 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只

• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

理解main方法的语句：

由于JVM需要调用类的main()方法，所以该方法的访问权限必须是public，又因为JVM在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。

又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。