《Thinking in Java》 10~

二次信任 提交于 2020-05-07 18:24:53

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);
    }
}

 

 

 

 

 

 

 

 

 

 

 

  

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!