(三)Java类特性 & 设计模式初窥

一、Object类

Object类是一切类的源头，是所有类的父类。因为它是所有类的父类，那么它体现了所有类的共性。
通过查看Object类，可以看到Java中的类都有哪些共性。

• .equals()方法
  
  • Object类中为比较两个对象的首地址值（其实现就是使用了”==”号），这里注意，基本数据类型不是对象。
  • 子类一般要重写此方法以用来比较两个类的内容。
• .toString();
  
  • Object类中为返回对象的特征值(类名+hash code)
  • 打印一个对象时，默认调用toString()方法，所以没有重写toString的类会打印一个地址。
  • 子类一般重写将子类的属性返回显示在字符串中，如：String Date File 包装类中已经重写此方法。

public String toString(){
//返回类型加哈希值
return getClass().getName+"@"+Integer.toHexString(hashCode());
}

二、包装类(Wrapper)

由于基本数据类型不是对象，那么可以我们可以将其封装成对象。从而使基本数据类型具有对象的特性。

八种基本数据类型对应的封装类的转换：

1. 基本数据类型–>包装类（装箱）:调用包装类的构造器
   对于Boolean(),当形参是true时返回true如：Boolean(“true”)，其他false如：Boolean(trueabc)
2. 包装类–>基本数据类型（拆箱）：int i1=i.intValue();其他类似调用xxxValue方法
   对于以上的两种实现，JDK5.0后可实现自动装箱拆箱
3. 基本数据类型，包装类–>String:调用String类的静态重载的valueOf()方法
   String str = String.valueOf();
4. String–>基本数据类型，包装类：调用包装类的静态重载的parseXxx()方法
   int i=Integer.parseInt(String);
   总结：基本数据类型与包装类会进行自动转，而对于字符串与其他包装类的转换，从被转换的类中找方法。

三、接口(interface)

• 接口是与类并行的概念（面向接口的编程思想），它代表定义一个功能。一个类实现了一个接口，即表示一个类实现了此接口定义的功能。
• 接口中可以定义方法，常量。
• 介于纯抽象的接口与纯实体的实体类之间，有一种抽象类。
• 接口的实现可以是匿名类对象：new AA(){//此处为AA的方法重写};
  
  • 匿名类对象，匿名内部类对象，匿名接口类对象的实现：
  • 当只需要一次调用类的对象时使用，用完回收。

接口具有以下特征：

1. 特殊的抽象类(是常量与抽象方法的集合)
2. 接口定义的是一种功能，可以被类实现
3. 实现的类要重写所有的抽象方法
4. 类可以实现多个接口
5. 接口跟接口之间可以继承，且可以多继承
6. 接口与具体实现类之间存在多态性(类似父类)，在MVP设计模式中使用较多。

/*
定义：
interface AA{
    //public static final 为属性默认修饰
    public static final 属性
    //public abstract 为方法默认修饰
    public abstract 方法
}
实现：
class BB extends CC implements AA,MM{}
*/
interface Runner{
    run()
}
interface Swimmer{
    swim()
}
class Duck implements Runner,Swimmer{
    run(){//TODO}
    swim(){//TODO}
}
Runner r=new Duck();r.run();
Swimmer s=new Duck();s.swim();

四、设计模式：

4.1.单例设计模式

4.1.1 饿汉模式：(两个static:一个静态对象，一个获取静态对象的静态方法)

缺点是加载类的时候立即创建对象，有较大的内存开销

private Xxx(){};//私有化构造器
private static Xxx instance=new Xxx();//创建对象并私有化
pubic static Xxx getxxx(){//通过方法来调对象，由于外部不能创建对象，所以为静态
return xxx;
}

4.1.2 懒汉模式(可能存在线程安全问题)：

//创建对象时不new：
private static Xxx instance=null;
//使用时判断是否创建新对象：
public static Xxx getInstance(){
    if(instance==null)
        //这里可能存在线程安全，一个解决办法是使用synchronized包裹该代码块，但会影响性能。
        instance=new Xxx();
}
ruturn instance;

4.2 代理模式：

4.2.1 静态代理

Object接口+ProxyObject+ObjectImpl:代理类和被代理类都有Object接口的action()方法

public class TestProxy {
    public static void main(String[] args) {
        Object p=new ProxyObject();
        p.action();
    }
}
interface Object{
    void action();
}
class ProxyObject implements Object{
    Object obj;
    public ProxyObject(){
        obj=new ObjectImpl();
    }
    @Override
    public void action() {
        System.out.println("代理类执行开始");
        System.out.println("代理类的action方法执行的东西，其中包括被代理类的action方法体");
        obj.action();
        System.out.println("代理类执行结束");
    }

}
class ObjectImpl implements Object{

    @Override
    public void action() {
        System.out.println("被代理的类执行的东西");
    }
}

4.3 模板方法设计模式

抽象类作为模板，其中一部分方法抽象化，从而让子类来自定义实现。

4.4 工厂模式：

//工厂方法设计模式
public class TestFactoryMethod {
    public static void main(String[] args) {
        IWorkFactory i1=new StudentWorkFactory();//多态，创建一个学生工厂
        IWorkFactory i2=new TeacherWorkFactory();//多提，创建一个教师工厂
        i1.getWork().doWork();//从教师工厂生产一名教师，让教师工作
        i2.getWork().doWork();//从学生工厂生产一名学生，让学生工作
    }
}

class StudentWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new StudentWorker();
    }
}
class TeacherWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new TeacherWorker();
    }
}

class TeacherWorker implements Worker {
    @Override
    public void doWork() {
        System.out.println("老师批改作业");
    }
}
class StudentWorker implements Worker {
    @Override
    public void doWork() {
        System.out.println("学生做作业");
    }
}

interface IWorkFactory{
    Work getWork();
}
interface Work {
    void doWork();
}