疯狂JAVA讲义---第六章（上）：面向对象二

最新推荐文章于 2024-10-25 21:30:51 发布

原创最新推荐文章于 2024-10-25 21:30:51 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #string #cache #设计模式 #equals #null

J2SE 专栏收录该内容

64 篇文章

订阅专栏

面向对象是java的重点，所以也是这本书的重点。这章延续上章，我粗略数了下，这两张加起来竟然达到这本书的四分之一。这章刚开始讲了包装类，由于jdk1.5以后引入了自动装箱和拆箱，基本类型和包装类转化就方便了。包装类有很多方法用起来很方便大家要熟悉下，eg

public class Primitive2String
{
    public static void main(String[] args) 
    {
        String intStr = "123";
        //把一个特定字符串转换成int变量 
        int it = Integer.parseInt(intStr);
        System.out.println(it);
        String floatStr = "4.56";
        //把一个特定字符串转换成float变量 
        float ft = Float.parseFloat(floatStr);
        System.out.println(ft);
        //把一个float变量转换成String变量 
        String ftStr = String.valueOf(2.345f);
        System.out.println(ftStr);
        //把一个double变量转换成String变量 
        String dbStr = String.valueOf(3.344);
        System.out.println(dbStr);
        //把一个boolean变量转换成String变量 
        String boolStr = String.valueOf(true);
        System.out.println(boolStr.toUpperCase());
    }
}

网上说的很多关于==和equals的区别，误导了一大片人，看了李刚的书，然后我也研究了下jdk的源码。发现对object来说这两者是一样的。下面看源码

 public boolean equals(Object obj) {
    return (this == obj);
    }

网上说了很多他们之间的不同是由于（我们那String来做例子）equals被重写过，eg

  public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }

然后讲了设计模式中的单例模式（具体我会在以后的设计模式中讲）现在先举个例子，eg

class Singleton
{
    //使用一个变量来缓存曾经创建的实例 
    private static Singleton instance;
    //将构造器使用private修饰，隐藏该构造器 
    private Singleton(){}
    //提供一个静态方法，用于返回Singleton实例 
    //该方法可以加入自定义的控制，保证只产生一个Singleton对象 
    public static Singleton getInstance()
    {
        //如果instance为null，表明还不曾创建Singleton对象 
        //如果instance不为null，则表明已经创建了Singleton对象，将不会执行该方法 
        if (instance == null)
        {
            //创建一个Singleton对象，并将其缓存起来 
            instance = new Singleton();
        }
        return instance;
    }
}
public class TestSingleton
{
    public static void main(String[] args)
    {
        //创建Singleton对象不能通过构造器，只能通过getInstance方法 
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        //将输出true 
        System.out.println(s1 == s2);
    }
}

不可变类的设计，注意引用变量的问题。eg

class Name
{
    private String firstName;
    private String lastName;
    public Name(){}
    public Name(String firstName , String lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public void setFirstName(String firstName)
    {
        this.firstName = firstName;
    }
    public String getFirstName()
    {
         return this.firstName;
    }
    public void setLastName(String lastName)
    {
        this.lastName = lastName;
    }
    public String getLastName()
    {
         return this.lastName;
    }
}

这里虽然没改person对象，但其实改name对象的时候，由于name对person是引用对象，所以person中的name其实也是改变了，为了解决这个问题，使用以下方法。eg

public class Person
{
    private final Name name;
    public Person(Name name)
    {
        //this.name = name;
        this.name = new Name(name.getFirstName(), name.getLastName());
    }
    public Name getName()
    {
        //return name;
        return new Name(name.getFirstName(), name.getLastName());
    }
    public static void main(String[] args)
    {
        Name n = new Name("悟空", "孙");
        Person p = new Person(n);
        //如果没有保护：Person对象的Name属性的firstName属性值为"悟空"
        System.out.println(p.getName().getFirstName());
        //改变Person对象Name属性的firstName属性值
        n.setFirstName("八戒");
        //如果没有保护：Person对象的Name属性的firstName属性值为"八戒"
        System.out.println(p.getName().getFirstName());
    }
}

虽说还是引用对象但这个name对象别人访问不到了，这样就实现了不可变类。

最后讲个用缓存来实现不可变类，eg

public class CacheImmutale
{
    private final String name;
    private static CacheImmutale[] cache = new CacheImmutale[10];
    //记录缓存实例在缓存中的位置,cache[pos-1]是最新缓存的实例
    private static int pos = 0;
    public CacheImmutale(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public static CacheImmutale valueOf(String name)
    {
        //遍历已缓存的对象，
        for (int i = 0 ; i < pos; i++)
        {
            //如果已有相同实例，直接返回该缓存的实例
            if (cache[i] != null && cache[i].getName().equals(name))
            {
                return cache[i];
            }
        }
        //如果缓存池已满
        if (pos == 10)
        {
            //把缓存的第一个对象覆盖
            cache[0] = new CacheImmutale(name);
            //把pos设为1
            pos = 1;
            return cache[0];
        }
        else
        {
            //把新创建的对象缓存起来，pos加1
            cache[pos++] = new CacheImmutale(name);
            return cache[pos - 1];
        }
    }
    public boolean equals(Object obj)
    {
        if (obj instanceof CacheImmutale)
        {
            CacheImmutale ci = (CacheImmutale)obj;
            if (name.equals(ci.getName()))
            {
                return true;
            }
        }
        return false;
    }
    public int hashCode()
    {
        return name.hashCode();
    }
    public static void main(String[] args)
    {
        CacheImmutale c1 = CacheImmutale.valueOf("hello");
        CacheImmutale c2 = CacheImmutale.valueOf("hello");
        //下面代码将输出true
        System.out.println(c1 == c2);
    }
}