《Thinking in Java》 10~

chapter 10 内部类（P191）

创建内部类

链接到外部类

　　内部类能访问器外围对象的所有成员，而不需要任何特殊条件。

使用.this与.new

package cn.test;

public class DotThis {
    void f() {
        System.out.println("DotThis.f()");
    }
    public class Inner{
        public DotThis outer() {
            return DotThis.this;
        }
    }
    public Inner inner() {
        return new Inner();
    }
    public static void main(String[] args) {
        DotThis dt = new DotThis();
        DotThis.Inner dti=dt.inner();
        dti.outer().f();
    }
}

package cn.test;

public class DotNew {
    public class Inner{}
    public static void main(String[] args) {
        DotNew dn = new DotNew();
        DotNew.Inner dni = dn.new Inner();
    }
}

为什么需要内部类

为了实现多重继承。

情形1：必须在一个类中以某种方式事项两个接口。由于接口的灵活性，有两种选择：使用单一类，或使用内部类。

package cn.test;
interface A {}
interface B {}
class X implements A,B{}
class Y implements A{
    B makeB() {
        return new B() {};
    }
}
public class MultiInterfaces {
    static void takesA(A a) {}
    static void takesB(B b) {}
    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();
        takesA(x);
        takesA(y);
        takesB(x);
        takesB(y.makeB());
    }
}

package cn.test;
class D{}
abstract class E{}
class Z extends D{
    E makeE() {
        return new E() {};
    }
}
public class MultilImplementation {
    static void takesD(D d) {}
    static void takesE(E e) {}
    public static void main(String[] args) {
        Z z = new Z();
        takesD(z);
        takesE(z.makeE());
    }
}

闭包与回调

内部类标识符

　　

　　外围类的名字，加上“$”，再加上内部类的名字。

chapter 11 持有对象

泛型和类型安全的容器

　　通过使用泛型 ，可以在编译期防止将错误类型的对象放置到容器中（报编译期错误）。

基本概念

1. Collection （List Set Queue）
2. Map

迭代器

　　Iterator

　　ListIterator

Stack

　　"栈"是“先进后出”的容器。

　　LinkedList具有能够直接实现栈功能的方法。

Queue

　　队列是先进先出的容器。

Foreach 与 迭代器

chapter 12 通过异常处理错误

栈轨迹

Java 标准异常

chapter 13 字符串

不可变String

　　String对象是不可变的。

重载 "+" 与 StringBuilder

　　对String的“+”操作，是通过中间对象StringBuilder的append方法，String引用最终执行操作后的字符串对象。

package cn.test;
public class WhitherStringBuilder {
    public String implicit(String[] fields) {
        String result="";
        for(int i=0;i<fields.length;i++)
            result+=fields[i];
        return result;
    }
    public String explicit(String[] fields) {
        StringBuilder result=new StringBuilder();
        for(int i=0;i<fields.length;i++)
            result.append(fields[i]);
        return result.toString();
    }
}

反编译：

public class WhitherStringBuilder
{

    public WhitherStringBuilder()
    {
    }

    public String implicit(String fields[])
    {
        String result = "";
        for (int i = 0; i < fields.length; i++)
            result = (new StringBuilder(String.valueOf(result))).append(fields[i]).toString();
　　　　　　　//在for循环内创建StringBuilder对象；
        return result;
    }

    public String explicit(String fields[])
    {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < fields.length; i++)
            result.append(fields[i]);

        return result.toString();
    }
}

格式化输出

package cn.test;

public class SimpleFormat {
    public static void main(String[] args) {
        int x=5;
        double y=4.333333;
        System.out.printf("Row 1:[%d,%f]\n",x,y);
        System.out.format("Row 1:[%d,%f]\n",x,y);
    }
}

正则表达式

　　API：boolean matches(String string)

chapter 14 类型信息

在运行时识别对象和类的信息：

　　1.RTTI，编译时知道所有的类型

　　2.反射机制，在运行时发现和使用类的信息

理解动态绑定。

package cn.test;

import java.util.Arrays;
import java.util.List;

abstract class Shape{
    void draw() {
        System.out.println(this+".draw()");
    }
    abstract public String toString();
}
class Circle extends Shape{
    public String toString() {
        return "Circle";
    }
}
class Square extends Shape{
    public String toString() {
        return "Square";
    }
}
class Triangle extends Shape{
    public String toString() {
        return "Triangle";
    }
}
public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapeList=Arrays.asList(new Circle(),new Square(),new Triangle());
        for(Shape shape:shapeList) {
            shape.draw();
        }
    }
}

源码：

public class Shapes
{

    public Shapes()
    {
    }

    public static void main(String args[])
    {
        List shapeList = Arrays.asList(new Shape[] {
            new Circle(), new Square(), new Triangle()
        });
        Shape shape;
        for (Iterator iterator = shapeList.iterator(); iterator.hasNext(); shape.draw())
            shape = (Shape)iterator.next();

    }
}

Class 对象

类字面常量

动态的instanceof

注册工厂

反射：运行时的内信息

　　

类方法提取器

动态代理

　　代理模式案例：

package cn.test;
interface Interface{
    void doSomething();
    void somethingElse(String arg);
}
class RealObject implements Interface{
    public void doSomething() {
        System.out.println("doSomething!");
    }
    public void somethingElse(String arg) {
        System.out.println("somethingElse"+arg);
    }
}
class SimpleProxy implements Interface{
    private Interface proxied;
    public SimpleProxy(Interface proxied) {
        this.proxied=proxied;
    }
    @Override
    public void doSomething() {
        System.out.println("doSomething!");
        proxied.doSomething();
    }
    @Override
    public void somethingElse(String arg) {
        System.out.println("SimpleProxy somethingElse"+arg);
        proxied.somethingElse(arg);
    }
}
public class SimpleProxyDemo {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }
    public static void main(String[] args) {
    //    consumer(new RealObject());
        consumer(new SimpleProxy(new RealObject()));
    }
}

　　动态代理：

package cn.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class DynamicProxyHandler implements InvocationHandler{
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        super();
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("**** proxy: "+proxy.getClass()+",method: "+method +". args: "+args);
        if(args != null) {
            for(Object arg : args) {
                System.out.println(" "+arg);
            }
        }
        return method.invoke(proxied, args);//反射
    }

}
public class SimpleDynamicProxy {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }
    public static void main(String[] args) {
        RealObject real = new RealObject();
//        consumer(real);
        Interface proxy = (Interface)Proxy
                .newProxyInstance(Interface.class.getClassLoader(),new Class[] {Interface.class}, new DynamicProxyHandler(real));
     // Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h);
　　　　　consumer(proxy);
    }
}

空对象

chapter 15 泛型

一个元组内库

泛型方法

　　定义泛型方法，需要将泛型参数列表置于返回值之前：

public class GenericMethods {
    public <A,B> void f(A a,B b) {
        System.out.println(a.getClass().getName()+","+b.getClass().getName());
    }
    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("",1);
        gm.f(1,12);
        gm.f(1.0,1);
        gm.f(1.0F,1);
        gm.f('c',1);
        gm.f(gm,1);
    }
}