《Thinking in Java》 10~

最新推荐文章于 2022-05-19 18:08:14 发布

weixin_30849591

最新推荐文章于 2022-05-19 18:08:14 发布

阅读量94

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/mryangbo/p/10157021.html

版权

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 持有对象

泛型和类型安全的容器

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

基本概念

Collection （List Set Queue）
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);
    }
}